rust-filepatterns: export glob_to_re function

Making this function public should not risk freezing the internal API,
and it can be useful for all downstream code that needs to perform
glob matching against byte strings, such as RHGitaly where it will
be useful to match on branches and tags.

rust/hg-core/src/filepatterns.rs

@@ -1,874 +1,874 b''
 // filepatterns.rs
 //
 // Copyright 2019 Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Handling of Mercurial-specific patterns.
 
 use crate::{
     utils::{
         files::{canonical_path, get_bytes_from_path, get_path_from_bytes},
         hg_path::{path_to_hg_path_buf, HgPathBuf, HgPathError},
         SliceExt,
     },
     FastHashMap, PatternError,
 };
 use lazy_static::lazy_static;
 use regex::bytes::{NoExpand, Regex};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::vec::Vec;
 
 lazy_static! {
     static ref RE_ESCAPE: Vec<Vec<u8>> = {
         let mut v: Vec<Vec<u8>> = (0..=255).map(|byte| vec![byte]).collect();
         let to_escape = b"()[]{}?*+-|^$\\.&~#\t\n\r\x0b\x0c";
         for byte in to_escape {
             v[*byte as usize].insert(0, b'\\');
         }
         v
     };
 }
 
 /// These are matched in order
 const GLOB_REPLACEMENTS: &[(&[u8], &[u8])] =
     &[(b"*/", b"(?:.*/)?"), (b"*", b".*"), (b"", b"[^/]*")];
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PatternSyntax {
     /// A regular expression
     Regexp,
     /// Glob that matches at the front of the path
     RootGlob,
     /// Glob that matches at any suffix of the path (still anchored at
     /// slashes)
     Glob,
     /// a path relative to repository root, which is matched recursively
     Path,
     /// a single exact path relative to repository root
     FilePath,
     /// A path relative to cwd
     RelPath,
     /// an unrooted glob (*.rs matches Rust files in all dirs)
     RelGlob,
     /// A regexp that needn't match the start of a name
     RelRegexp,
     /// A path relative to repository root, which is matched non-recursively
     /// (will not match subdirectories)
     RootFiles,
     /// A file of patterns to read and include
     Include,
     /// A file of patterns to match against files under the same directory
     SubInclude,
     /// SubInclude with the result of parsing the included file
     ///
     /// Note: there is no ExpandedInclude because that expansion can be done
     /// in place by replacing the Include pattern by the included patterns.
     /// SubInclude requires more handling.
     ///
     /// Note: `Box` is used to minimize size impact on other enum variants
     ExpandedSubInclude(Box<SubInclude>),
 }
 
 /// Transforms a glob pattern into a regex
-fn glob_to_re(pat: &[u8]) -> Vec<u8> {
+pub fn glob_to_re(pat: &[u8]) -> Vec<u8> {
     let mut input = pat;
     let mut res: Vec<u8> = vec![];
     let mut group_depth = 0;
 
     while let Some((c, rest)) = input.split_first() {
         input = rest;
 
         match c {
             b'*' => {
                 for (source, repl) in GLOB_REPLACEMENTS {
                     if let Some(rest) = input.drop_prefix(source) {
                         input = rest;
                         res.extend(*repl);
                         break;
                     }
                 }
             }
             b'?' => res.extend(b"."),
             b'[' => {
                 match input.iter().skip(1).position(|b| *b == b']') {
                     None => res.extend(b"\\["),
                     Some(end) => {
                         // Account for the one we skipped
                         let end = end + 1;
 
                         res.extend(b"[");
 
                         for (i, b) in input[..end].iter().enumerate() {
                             if *b == b'!' && i == 0 {
                                 res.extend(b"^")
                             } else if *b == b'^' && i == 0 {
                                 res.extend(b"\\^")
                             } else if *b == b'\\' {
                                 res.extend(b"\\\\")
                             } else {
                                 res.push(*b)
                             }
                         }
                         res.extend(b"]");
                         input = &input[end + 1..];
                     }
                 }
             }
             b'{' => {
                 group_depth += 1;
                 res.extend(b"(?:")
             }
             b'}' if group_depth > 0 => {
                 group_depth -= 1;
                 res.extend(b")");
             }
             b',' if group_depth > 0 => res.extend(b"|"),
             b'\\' => {
                 let c = {
                     if let Some((c, rest)) = input.split_first() {
                         input = rest;
                         c
                     } else {
                         c
                     }
                 };
                 res.extend(&RE_ESCAPE[*c as usize])
             }
             _ => res.extend(&RE_ESCAPE[*c as usize]),
         }
     }
     res
 }
 
 fn escape_pattern(pattern: &[u8]) -> Vec<u8> {
     pattern
         .iter()
         .flat_map(|c| RE_ESCAPE[*c as usize].clone())
         .collect()
 }
 
 pub fn parse_pattern_syntax(
     kind: &[u8],
 ) -> Result<PatternSyntax, PatternError> {
     match kind {
         b"re:" => Ok(PatternSyntax::Regexp),
         b"path:" => Ok(PatternSyntax::Path),
         b"filepath:" => Ok(PatternSyntax::FilePath),
         b"relpath:" => Ok(PatternSyntax::RelPath),
         b"rootfilesin:" => Ok(PatternSyntax::RootFiles),
         b"relglob:" => Ok(PatternSyntax::RelGlob),
         b"relre:" => Ok(PatternSyntax::RelRegexp),
         b"glob:" => Ok(PatternSyntax::Glob),
         b"rootglob:" => Ok(PatternSyntax::RootGlob),
         b"include:" => Ok(PatternSyntax::Include),
         b"subinclude:" => Ok(PatternSyntax::SubInclude),
         _ => Err(PatternError::UnsupportedSyntax(
             String::from_utf8_lossy(kind).to_string(),
         )),
     }
 }
 
 lazy_static! {
     static ref FLAG_RE: Regex = Regex::new(r"^\(\?[aiLmsux]+\)").unwrap();
 }
 
 /// Builds the regex that corresponds to the given pattern.
 /// If within a `syntax: regexp` context, returns the pattern,
 /// otherwise, returns the corresponding regex.
 fn _build_single_regex(entry: &IgnorePattern, glob_suffix: &[u8]) -> Vec<u8> {
     let IgnorePattern {
         syntax, pattern, ..
     } = entry;
     if pattern.is_empty() {
         return vec![];
     }
     match syntax {
         PatternSyntax::Regexp => pattern.to_owned(),
         PatternSyntax::RelRegexp => {
             // The `regex` crate accepts `**` while `re2` and Python's `re`
             // do not. Checking for `*` correctly triggers the same error all
             // engines.
             if pattern[0] == b'^'
                 || pattern[0] == b'*'
                 || pattern.starts_with(b".*")
             {
                 return pattern.to_owned();
             }
             match FLAG_RE.find(pattern) {
                 Some(mat) => {
                     let s = mat.start();
                     let e = mat.end();
                     [
                         &b"(?"[..],
                         &pattern[s + 2..e - 1],
                         &b":"[..],
                         if pattern[e] == b'^'
                             || pattern[e] == b'*'
                             || pattern[e..].starts_with(b".*")
                         {
                             &b""[..]
                         } else {
                             &b".*"[..]
                         },
                         &pattern[e..],
                         &b")"[..],
                     ]
                     .concat()
                 }
                 None => [&b".*"[..], pattern].concat(),
             }
         }
         PatternSyntax::Path | PatternSyntax::RelPath => {
             if pattern == b"." {
                 return vec![];
             }
             [escape_pattern(pattern).as_slice(), b"(?:/|$)"].concat()
         }
         PatternSyntax::RootFiles => {
             let mut res = if pattern == b"." {
                 vec![]
             } else {
                 // Pattern is a directory name.
                 [escape_pattern(pattern).as_slice(), b"/"].concat()
             };
 
             // Anything after the pattern must be a non-directory.
             res.extend(b"[^/]+$");
             res
         }
         PatternSyntax::RelGlob => {
             let glob_re = glob_to_re(pattern);
             if let Some(rest) = glob_re.drop_prefix(b"[^/]*") {
                 [b".*", rest, glob_suffix].concat()
             } else {
                 [b"(?:.*/)?", glob_re.as_slice(), glob_suffix].concat()
             }
         }
         PatternSyntax::Glob | PatternSyntax::RootGlob => {
             [glob_to_re(pattern).as_slice(), glob_suffix].concat()
         }
         PatternSyntax::Include
         | PatternSyntax::SubInclude
         | PatternSyntax::ExpandedSubInclude(_)
         | PatternSyntax::FilePath => unreachable!(),
     }
 }
 
 const GLOB_SPECIAL_CHARACTERS: [u8; 7] =
     [b'*', b'?', b'[', b']', b'{', b'}', b'\\'];
 
 /// TODO support other platforms
 #[cfg(unix)]
 pub fn normalize_path_bytes(bytes: &[u8]) -> Vec<u8> {
     if bytes.is_empty() {
         return b".".to_vec();
     }
     let sep = b'/';
 
     let mut initial_slashes = bytes.iter().take_while(|b| **b == sep).count();
     if initial_slashes > 2 {
         // POSIX allows one or two initial slashes, but treats three or more
         // as single slash.
         initial_slashes = 1;
     }
     let components = bytes
         .split(|b| *b == sep)
         .filter(|c| !(c.is_empty() || c == b"."))
         .fold(vec![], |mut acc, component| {
             if component != b".."
                 || (initial_slashes == 0 && acc.is_empty())
                 || (!acc.is_empty() && acc[acc.len() - 1] == b"..")
             {
                 acc.push(component)
             } else if !acc.is_empty() {
                 acc.pop();
             }
             acc
         });
     let mut new_bytes = components.join(&sep);
 
     if initial_slashes > 0 {
         let mut buf: Vec<_> = (0..initial_slashes).map(|_| sep).collect();
         buf.extend(new_bytes);
         new_bytes = buf;
     }
     if new_bytes.is_empty() {
         b".".to_vec()
     } else {
         new_bytes
     }
 }
 
 /// Wrapper function to `_build_single_regex` that short-circuits 'exact' globs
 /// that don't need to be transformed into a regex.
 pub fn build_single_regex(
     entry: &IgnorePattern,
     glob_suffix: &[u8],
 ) -> Result<Option<Vec<u8>>, PatternError> {
     let IgnorePattern {
         pattern, syntax, ..
     } = entry;
     let pattern = match syntax {
         PatternSyntax::RootGlob
         | PatternSyntax::Path
         | PatternSyntax::RelGlob
         | PatternSyntax::RelPath
         | PatternSyntax::RootFiles => normalize_path_bytes(pattern),
         PatternSyntax::Include | PatternSyntax::SubInclude => {
             return Err(PatternError::NonRegexPattern(entry.clone()))
         }
         _ => pattern.to_owned(),
     };
     let is_simple_rootglob = *syntax == PatternSyntax::RootGlob
         && !pattern.iter().any(|b| GLOB_SPECIAL_CHARACTERS.contains(b));
     if is_simple_rootglob || syntax == &PatternSyntax::FilePath {
         Ok(None)
     } else {
         let mut entry = entry.clone();
         entry.pattern = pattern;
         Ok(Some(_build_single_regex(&entry, glob_suffix)))
     }
 }
 
 lazy_static! {
     static ref SYNTAXES: FastHashMap<&'static [u8], PatternSyntax> = {
         let mut m = FastHashMap::default();
 
         m.insert(b"re:".as_ref(), PatternSyntax::Regexp);
         m.insert(b"regexp:".as_ref(), PatternSyntax::Regexp);
         m.insert(b"path:".as_ref(), PatternSyntax::Path);
         m.insert(b"filepath:".as_ref(), PatternSyntax::FilePath);
         m.insert(b"relpath:".as_ref(), PatternSyntax::RelPath);
         m.insert(b"rootfilesin:".as_ref(), PatternSyntax::RootFiles);
         m.insert(b"relglob:".as_ref(), PatternSyntax::RelGlob);
         m.insert(b"relre:".as_ref(), PatternSyntax::RelRegexp);
         m.insert(b"glob:".as_ref(), PatternSyntax::Glob);
         m.insert(b"rootglob:".as_ref(), PatternSyntax::RootGlob);
         m.insert(b"include:".as_ref(), PatternSyntax::Include);
         m.insert(b"subinclude:".as_ref(), PatternSyntax::SubInclude);
 
         m
     };
 }
 
 #[derive(Debug)]
 pub enum PatternFileWarning {
     /// (file path, syntax bytes)
     InvalidSyntax(PathBuf, Vec<u8>),
     /// File path
     NoSuchFile(PathBuf),
 }
 
 pub fn parse_one_pattern(
     pattern: &[u8],
     source: &Path,
     default: PatternSyntax,
     normalize: bool,
 ) -> IgnorePattern {
     let mut pattern_bytes: &[u8] = pattern;
     let mut syntax = default;
 
     for (s, val) in SYNTAXES.iter() {
         if let Some(rest) = pattern_bytes.drop_prefix(s) {
             syntax = val.clone();
             pattern_bytes = rest;
             break;
         }
     }
 
     let pattern = match syntax {
         PatternSyntax::RootGlob
         | PatternSyntax::Path
         | PatternSyntax::Glob
         | PatternSyntax::RelGlob
         | PatternSyntax::RelPath
         | PatternSyntax::RootFiles
             if normalize =>
         {
             normalize_path_bytes(pattern_bytes)
         }
         _ => pattern_bytes.to_vec(),
     };
 
     IgnorePattern {
         syntax,
         pattern,
         source: source.to_owned(),
     }
 }
 
 pub fn parse_pattern_file_contents(
     lines: &[u8],
     file_path: &Path,
     default_syntax_override: Option<PatternSyntax>,
     warn: bool,
     relativize: bool,
 ) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> {
     let comment_regex = Regex::new(r"((?:^|[^\\])(?:\\\\)*)#.*").unwrap();
 
     #[allow(clippy::trivial_regex)]
     let comment_escape_regex = Regex::new(r"\\#").unwrap();
     let mut inputs: Vec<IgnorePattern> = vec![];
     let mut warnings: Vec<PatternFileWarning> = vec![];
 
     let mut current_syntax =
         default_syntax_override.unwrap_or(PatternSyntax::RelRegexp);
 
     for mut line in lines.split(|c| *c == b'\n') {
         let line_buf;
         if line.contains(&b'#') {
             if let Some(cap) = comment_regex.captures(line) {
                 line = &line[..cap.get(1).unwrap().end()]
             }
             line_buf = comment_escape_regex.replace_all(line, NoExpand(b"#"));
             line = &line_buf;
         }
 
         let line = line.trim_end();
 
         if line.is_empty() {
             continue;
         }
 
         if let Some(syntax) = line.drop_prefix(b"syntax:") {
             let syntax = syntax.trim();
 
             if let Some(parsed) =
                 SYNTAXES.get([syntax, &b":"[..]].concat().as_slice())
             {
                 current_syntax = parsed.clone();
             } else if warn {
                 warnings.push(PatternFileWarning::InvalidSyntax(
                     file_path.to_owned(),
                     syntax.to_owned(),
                 ));
             }
         } else {
             let pattern = parse_one_pattern(
                 line,
                 file_path,
                 current_syntax.clone(),
                 false,
             );
             inputs.push(if relativize {
                 pattern.to_relative()
             } else {
                 pattern
             })
         }
     }
     Ok((inputs, warnings))
 }
 
 pub fn parse_pattern_args(
     patterns: Vec<Vec<u8>>,
     cwd: &Path,
     root: &Path,
 ) -> Result<Vec<IgnorePattern>, HgPathError> {
     let mut ignore_patterns: Vec<IgnorePattern> = Vec::new();
     for pattern in patterns {
         let pattern = parse_one_pattern(
             &pattern,
             Path::new("<args>"),
             PatternSyntax::RelPath,
             true,
         );
         match pattern.syntax {
             PatternSyntax::RelGlob | PatternSyntax::RelPath => {
                 let name = get_path_from_bytes(&pattern.pattern);
                 let canon = canonical_path(root, cwd, name)?;
                 ignore_patterns.push(IgnorePattern {
                     syntax: pattern.syntax,
                     pattern: get_bytes_from_path(canon),
                     source: pattern.source,
                 })
             }
             _ => ignore_patterns.push(pattern.to_owned()),
         };
     }
     Ok(ignore_patterns)
 }
 
 pub fn read_pattern_file(
     file_path: &Path,
     warn: bool,
     inspect_pattern_bytes: &mut impl FnMut(&Path, &[u8]),
 ) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> {
     match std::fs::read(file_path) {
         Ok(contents) => {
             inspect_pattern_bytes(file_path, &contents);
             parse_pattern_file_contents(&contents, file_path, None, warn, true)
         }
         Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok((
             vec![],
             vec![PatternFileWarning::NoSuchFile(file_path.to_owned())],
         )),
         Err(e) => Err(e.into()),
     }
 }
 
 /// Represents an entry in an "ignore" file.
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub struct IgnorePattern {
     pub syntax: PatternSyntax,
     pub pattern: Vec<u8>,
     pub source: PathBuf,
 }
 
 impl IgnorePattern {
     pub fn new(syntax: PatternSyntax, pattern: &[u8], source: &Path) -> Self {
         Self {
             syntax,
             pattern: pattern.to_owned(),
             source: source.to_owned(),
         }
     }
 
     pub fn to_relative(self) -> Self {
         let Self {
             syntax,
             pattern,
             source,
         } = self;
         Self {
             syntax: match syntax {
                 PatternSyntax::Regexp => PatternSyntax::RelRegexp,
                 PatternSyntax::Glob => PatternSyntax::RelGlob,
                 x => x,
             },
             pattern,
             source,
         }
     }
 }
 
 pub type PatternResult<T> = Result<T, PatternError>;
 
 /// Wrapper for `read_pattern_file` that also recursively expands `include:`
 /// and `subinclude:` patterns.
 ///
 /// The former are expanded in place, while `PatternSyntax::ExpandedSubInclude`
 /// is used for the latter to form a tree of patterns.
 pub fn get_patterns_from_file(
     pattern_file: &Path,
     root_dir: &Path,
     inspect_pattern_bytes: &mut impl FnMut(&Path, &[u8]),
 ) -> PatternResult<(Vec<IgnorePattern>, Vec<PatternFileWarning>)> {
     let (patterns, mut warnings) =
         read_pattern_file(pattern_file, true, inspect_pattern_bytes)?;
     let patterns = patterns
         .into_iter()
         .flat_map(|entry| -> PatternResult<_> {
             Ok(match &entry.syntax {
                 PatternSyntax::Include => {
                     let inner_include =
                         root_dir.join(get_path_from_bytes(&entry.pattern));
                     let (inner_pats, inner_warnings) = get_patterns_from_file(
                         &inner_include,
                         root_dir,
                         inspect_pattern_bytes,
                     )?;
                     warnings.extend(inner_warnings);
                     inner_pats
                 }
                 PatternSyntax::SubInclude => {
                     let mut sub_include = SubInclude::new(
                         root_dir,
                         &entry.pattern,
                         &entry.source,
                     )?;
                     let (inner_patterns, inner_warnings) =
                         get_patterns_from_file(
                             &sub_include.path,
                             &sub_include.root,
                             inspect_pattern_bytes,
                         )?;
                     sub_include.included_patterns = inner_patterns;
                     warnings.extend(inner_warnings);
                     vec![IgnorePattern {
                         syntax: PatternSyntax::ExpandedSubInclude(Box::new(
                             sub_include,
                         )),
                         ..entry
                     }]
                 }
                 _ => vec![entry],
             })
         })
         .flatten()
         .collect();
 
     Ok((patterns, warnings))
 }
 
 /// Holds all the information needed to handle a `subinclude:` pattern.
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct SubInclude {
     /// Will be used for repository (hg) paths that start with this prefix.
     /// It is relative to the current working directory, so comparing against
     /// repository paths is painless.
     pub prefix: HgPathBuf,
     /// The file itself, containing the patterns
     pub path: PathBuf,
     /// Folder in the filesystem where this it applies
     pub root: PathBuf,
 
     pub included_patterns: Vec<IgnorePattern>,
 }
 
 impl SubInclude {
     pub fn new(
         root_dir: &Path,
         pattern: &[u8],
         source: &Path,
     ) -> Result<SubInclude, HgPathError> {
         let normalized_source =
             normalize_path_bytes(&get_bytes_from_path(source));
 
         let source_root = get_path_from_bytes(&normalized_source);
         let source_root = source_root.parent().unwrap_or(source_root);
 
         let path = source_root.join(get_path_from_bytes(pattern));
         let new_root = path.parent().unwrap_or_else(|| path.deref());
 
         let prefix = canonical_path(root_dir, root_dir, new_root)?;
 
         Ok(Self {
             prefix: path_to_hg_path_buf(prefix).map(|mut p| {
                 if !p.is_empty() {
                     p.push_byte(b'/');
                 }
                 p
             })?,
             path: path.to_owned(),
             root: new_root.to_owned(),
             included_patterns: Vec::new(),
         })
     }
 }
 
 /// Separate and pre-process subincludes from other patterns for the "ignore"
 /// phase.
 pub fn filter_subincludes(
     ignore_patterns: Vec<IgnorePattern>,
 ) -> Result<(Vec<SubInclude>, Vec<IgnorePattern>), HgPathError> {
     let mut subincludes = vec![];
     let mut others = vec![];
 
     for pattern in ignore_patterns {
         if let PatternSyntax::ExpandedSubInclude(sub_include) = pattern.syntax
         {
             subincludes.push(*sub_include);
         } else {
             others.push(pattern)
         }
     }
     Ok((subincludes, others))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
 
     #[test]
     fn escape_pattern_test() {
         let untouched =
             br#"!"%',/0123456789:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ_`abcdefghijklmnopqrstuvwxyz"#;
         assert_eq!(escape_pattern(untouched), untouched.to_vec());
         // All escape codes
         assert_eq!(
             escape_pattern(br"()[]{}?*+-|^$\\.&~#\t\n\r\v\f"),
             br"\(\)\[\]\{\}\?\*\+\-\|\^\$\\\\\.\&\~\#\\t\\n\\r\\v\\f".to_vec()
         );
     }
 
     #[test]
     fn glob_test() {
         assert_eq!(glob_to_re(br"?"), br".");
         assert_eq!(glob_to_re(br"*"), br"[^/]*");
         assert_eq!(glob_to_re(br"**"), br".*");
         assert_eq!(glob_to_re(br"**/a"), br"(?:.*/)?a");
         assert_eq!(glob_to_re(br"a/**/b"), br"a/(?:.*/)?b");
         assert_eq!(glob_to_re(br"[a*?!^][^b][!c]"), br"[a*?!^][\^b][^c]");
         assert_eq!(glob_to_re(br"{a,b}"), br"(?:a|b)");
         assert_eq!(glob_to_re(br".\*\?"), br"\.\*\?");
     }
 
     #[test]
     fn test_parse_pattern_file_contents() {
         let lines = b"syntax: glob\n*.elc";
 
         assert_eq!(
             parse_pattern_file_contents(
                 lines,
                 Path::new("file_path"),
                 None,
                 false,
                 true,
             )
             .unwrap()
             .0,
             vec![IgnorePattern::new(
                 PatternSyntax::RelGlob,
                 b"*.elc",
                 Path::new("file_path")
             )],
         );
 
         let lines = b"syntax: include\nsyntax: glob";
 
         assert_eq!(
             parse_pattern_file_contents(
                 lines,
                 Path::new("file_path"),
                 None,
                 false,
                 true,
             )
             .unwrap()
             .0,
             vec![]
         );
         let lines = b"glob:**.o";
         assert_eq!(
             parse_pattern_file_contents(
                 lines,
                 Path::new("file_path"),
                 None,
                 false,
                 true,
             )
             .unwrap()
             .0,
             vec![IgnorePattern::new(
                 PatternSyntax::RelGlob,
                 b"**.o",
                 Path::new("file_path")
             )]
         );
     }
 
     #[test]
     fn test_build_single_regex() {
         assert_eq!(
             build_single_regex(
                 &IgnorePattern::new(
                     PatternSyntax::RelGlob,
                     b"rust/target/",
                     Path::new("")
                 ),
                 b"(?:/|$)"
             )
             .unwrap(),
             Some(br"(?:.*/)?rust/target(?:/|$)".to_vec()),
         );
         assert_eq!(
             build_single_regex(
                 &IgnorePattern::new(
                     PatternSyntax::Regexp,
                     br"rust/target/\d+",
                     Path::new("")
                 ),
                 b"(?:/|$)"
             )
             .unwrap(),
             Some(br"rust/target/\d+".to_vec()),
         );
     }
 
     #[test]
     fn test_build_single_regex_shortcut() {
         assert_eq!(
             build_single_regex(
                 &IgnorePattern::new(
                     PatternSyntax::RootGlob,
                     b"",
                     Path::new("")
                 ),
                 b"(?:/|$)"
             )
             .unwrap(),
             None,
         );
         assert_eq!(
             build_single_regex(
                 &IgnorePattern::new(
                     PatternSyntax::RootGlob,
                     b"whatever",
                     Path::new("")
                 ),
                 b"(?:/|$)"
             )
             .unwrap(),
             None,
         );
         assert_eq!(
             build_single_regex(
                 &IgnorePattern::new(
                     PatternSyntax::RootGlob,
                     b"*.o",
                     Path::new("")
                 ),
                 b"(?:/|$)"
             )
             .unwrap(),
             Some(br"[^/]*\.o(?:/|$)".to_vec()),
         );
     }
 
     #[test]
     fn test_build_single_relregex() {
         assert_eq!(
             build_single_regex(
                 &IgnorePattern::new(
                     PatternSyntax::RelRegexp,
                     b"^ba{2}r",
                     Path::new("")
                 ),
                 b"(?:/|$)"
             )
             .unwrap(),
             Some(b"^ba{2}r".to_vec()),
         );
         assert_eq!(
             build_single_regex(
                 &IgnorePattern::new(
                     PatternSyntax::RelRegexp,
                     b"ba{2}r",
                     Path::new("")
                 ),
                 b"(?:/|$)"
             )
             .unwrap(),
             Some(b".*ba{2}r".to_vec()),
         );
         assert_eq!(
             build_single_regex(
                 &IgnorePattern::new(
                     PatternSyntax::RelRegexp,
                     b"(?ia)ba{2}r",
                     Path::new("")
                 ),
                 b"(?:/|$)"
             )
             .unwrap(),
             Some(b"(?ia:.*ba{2}r)".to_vec()),
         );
         assert_eq!(
             build_single_regex(
                 &IgnorePattern::new(
                     PatternSyntax::RelRegexp,
                     b"(?ia)^ba{2}r",
                     Path::new("")
                 ),
                 b"(?:/|$)"
             )
             .unwrap(),
             Some(b"(?ia:^ba{2}r)".to_vec()),
         );
     }
 }