rhg: fix the bug where sparse config is interpreted as relglob instead of glob

relglob apparently (in contrast with relpath) matches everywhere in the tree,
whereas glob only matches at the root.
The python version interprets these patterns as "glob" (see
"normalize(include, b'glob', ...)" in match.py)

rust/hg-core/src/sparse.rs

@@ -1,339 +1,339 b''
 use std::{collections::HashSet, path::Path};
 
 use format_bytes::{write_bytes, DisplayBytes};
 
 use crate::{
     errors::HgError,
     filepatterns::parse_pattern_file_contents,
     matchers::{
         AlwaysMatcher, DifferenceMatcher, IncludeMatcher, Matcher,
         UnionMatcher,
     },
     operations::cat,
     repo::Repo,
     requirements::SPARSE_REQUIREMENT,
     utils::{hg_path::HgPath, SliceExt},
     IgnorePattern, PatternError, PatternFileWarning, PatternSyntax, Revision,
     NULL_REVISION,
 };
 
 /// Command which is triggering the config read
 #[derive(Copy, Clone, Debug)]
 pub enum SparseConfigContext {
     Sparse,
     Narrow,
 }
 
 impl DisplayBytes for SparseConfigContext {
     fn display_bytes(
         &self,
         output: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         match self {
             SparseConfigContext::Sparse => write_bytes!(output, b"sparse"),
             SparseConfigContext::Narrow => write_bytes!(output, b"narrow"),
         }
     }
 }
 
 /// Possible warnings when reading sparse configuration
 #[derive(Debug, derive_more::From)]
 pub enum SparseWarning {
     /// Warns about improper paths that start with "/"
     RootWarning {
         context: SparseConfigContext,
         line: Vec<u8>,
     },
     /// Warns about a profile missing from the given changelog revision
     ProfileNotFound { profile: Vec<u8>, rev: Revision },
     #[from]
     Pattern(PatternFileWarning),
 }
 
 /// Parsed sparse config
 #[derive(Debug, Default)]
 pub struct SparseConfig {
     // Line-separated
     pub(crate) includes: Vec<u8>,
     // Line-separated
     pub(crate) excludes: Vec<u8>,
     pub(crate) profiles: HashSet<Vec<u8>>,
     pub(crate) warnings: Vec<SparseWarning>,
 }
 
 /// All possible errors when reading sparse/narrow config
 #[derive(Debug, derive_more::From)]
 pub enum SparseConfigError {
     IncludesAfterExcludes {
         context: SparseConfigContext,
     },
     EntryOutsideSection {
         context: SparseConfigContext,
         line: Vec<u8>,
     },
     /// Narrow config does not support '%include' directives
     IncludesInNarrow,
     /// An invalid pattern prefix was given to the narrow spec. Includes the
     /// entire pattern for context.
     InvalidNarrowPrefix(Vec<u8>),
     #[from]
     HgError(HgError),
     #[from]
     PatternError(PatternError),
 }
 
 /// Parse sparse config file content.
 pub(crate) fn parse_config(
     raw: &[u8],
     context: SparseConfigContext,
 ) -> Result<SparseConfig, SparseConfigError> {
     let mut includes = vec![];
     let mut excludes = vec![];
     let mut profiles = HashSet::new();
     let mut warnings = vec![];
 
     #[derive(PartialEq, Eq)]
     enum Current {
         Includes,
         Excludes,
         None,
     }
 
     let mut current = Current::None;
     let mut in_section = false;
 
     for line in raw.split(|c| *c == b'\n') {
         let line = line.trim();
         if line.is_empty() || line[0] == b'#' {
             // empty or comment line, skip
             continue;
         }
         if line.starts_with(b"%include ") {
             let profile = line[b"%include ".len()..].trim();
             if !profile.is_empty() {
                 profiles.insert(profile.into());
             }
         } else if line == b"[include]" {
             if in_section && current == Current::Includes {
                 return Err(SparseConfigError::IncludesAfterExcludes {
                     context,
                 });
             }
             in_section = true;
             current = Current::Includes;
             continue;
         } else if line == b"[exclude]" {
             in_section = true;
             current = Current::Excludes;
         } else {
             if current == Current::None {
                 return Err(SparseConfigError::EntryOutsideSection {
                     context,
                     line: line.into(),
                 });
             }
             if line.trim().starts_with(b"/") {
                 warnings.push(SparseWarning::RootWarning {
                     context,
                     line: line.into(),
                 });
                 continue;
             }
             match current {
                 Current::Includes => {
                     includes.push(b'\n');
                     includes.extend(line.iter());
                 }
                 Current::Excludes => {
                     excludes.push(b'\n');
                     excludes.extend(line.iter());
                 }
                 Current::None => unreachable!(),
             }
         }
     }
 
     Ok(SparseConfig {
         includes,
         excludes,
         profiles,
         warnings,
     })
 }
 
 fn read_temporary_includes(
     repo: &Repo,
 ) -> Result<Vec<Vec<u8>>, SparseConfigError> {
     let raw = repo.hg_vfs().try_read("tempsparse")?.unwrap_or_default();
     if raw.is_empty() {
         return Ok(vec![]);
     }
     Ok(raw.split(|c| *c == b'\n').map(ToOwned::to_owned).collect())
 }
 
 /// Obtain sparse checkout patterns for the given revision
 fn patterns_for_rev(
     repo: &Repo,
     rev: Revision,
 ) -> Result<Option<SparseConfig>, SparseConfigError> {
     if !repo.has_sparse() {
         return Ok(None);
     }
     let raw = repo.hg_vfs().try_read("sparse")?.unwrap_or_default();
 
     if raw.is_empty() {
         return Ok(None);
     }
 
     let mut config = parse_config(&raw, SparseConfigContext::Sparse)?;
 
     if !config.profiles.is_empty() {
         let mut profiles: Vec<Vec<u8>> = config.profiles.into_iter().collect();
         let mut visited = HashSet::new();
 
         while let Some(profile) = profiles.pop() {
             if visited.contains(&profile) {
                 continue;
             }
             visited.insert(profile.to_owned());
 
             let output =
                 cat(repo, &rev.to_string(), vec![HgPath::new(&profile)])
                     .map_err(|_| {
                         HgError::corrupted(
                             "dirstate points to non-existent parent node"
                                 .to_string(),
                         )
                     })?;
             if output.results.is_empty() {
                 config.warnings.push(SparseWarning::ProfileNotFound {
                     profile: profile.to_owned(),
                     rev,
                 })
             }
 
             let subconfig = parse_config(
                 &output.results[0].1,
                 SparseConfigContext::Sparse,
             )?;
             if !subconfig.includes.is_empty() {
                 config.includes.push(b'\n');
                 config.includes.extend(&subconfig.includes);
             }
             if !subconfig.includes.is_empty() {
                 config.includes.push(b'\n');
                 config.excludes.extend(&subconfig.excludes);
             }
             config.warnings.extend(subconfig.warnings.into_iter());
             profiles.extend(subconfig.profiles.into_iter());
         }
 
         config.profiles = visited;
     }
 
     if !config.includes.is_empty() {
         config.includes.extend(b"\n.hg*");
     }
 
     Ok(Some(config))
 }
 
 /// Obtain a matcher for sparse working directories.
 pub fn matcher(
     repo: &Repo,
 ) -> Result<(Box<dyn Matcher + Sync>, Vec<SparseWarning>), SparseConfigError> {
     let mut warnings = vec![];
     if !repo.requirements().contains(SPARSE_REQUIREMENT) {
         return Ok((Box::new(AlwaysMatcher), warnings));
     }
 
     let parents = repo.dirstate_parents()?;
     let mut revs = vec![];
     let p1_rev =
         repo.changelog()?
             .rev_from_node(parents.p1.into())
             .map_err(|_| {
                 HgError::corrupted(
                     "dirstate points to non-existent parent node".to_string(),
                 )
             })?;
     if p1_rev != NULL_REVISION {
         revs.push(p1_rev)
     }
     let p2_rev =
         repo.changelog()?
             .rev_from_node(parents.p2.into())
             .map_err(|_| {
                 HgError::corrupted(
                     "dirstate points to non-existent parent node".to_string(),
                 )
             })?;
     if p2_rev != NULL_REVISION {
         revs.push(p2_rev)
     }
     let mut matchers = vec![];
 
     for rev in revs.iter() {
         let config = patterns_for_rev(repo, *rev);
         if let Ok(Some(config)) = config {
             warnings.extend(config.warnings);
             let mut m: Box<dyn Matcher + Sync> = Box::new(AlwaysMatcher);
             if !config.includes.is_empty() {
                 let (patterns, subwarnings) = parse_pattern_file_contents(
                     &config.includes,
                     Path::new(""),
-                    Some(b"relglob:".as_ref()),
+                    Some(b"glob:".as_ref()),
                     false,
                 )?;
                 warnings.extend(subwarnings.into_iter().map(From::from));
                 m = Box::new(IncludeMatcher::new(patterns)?);
             }
             if !config.excludes.is_empty() {
                 let (patterns, subwarnings) = parse_pattern_file_contents(
                     &config.excludes,
                     Path::new(""),
-                    Some(b"relglob:".as_ref()),
+                    Some(b"glob:".as_ref()),
                     false,
                 )?;
                 warnings.extend(subwarnings.into_iter().map(From::from));
                 m = Box::new(DifferenceMatcher::new(
                     m,
                     Box::new(IncludeMatcher::new(patterns)?),
                 ));
             }
             matchers.push(m);
         }
     }
     let result: Box<dyn Matcher + Sync> = match matchers.len() {
         0 => Box::new(AlwaysMatcher),
         1 => matchers.pop().expect("1 is equal to 0"),
         _ => Box::new(UnionMatcher::new(matchers)),
     };
 
     let matcher =
         force_include_matcher(result, &read_temporary_includes(repo)?)?;
     Ok((matcher, warnings))
 }
 
 /// Returns a matcher that returns true for any of the forced includes before
 /// testing against the actual matcher
 fn force_include_matcher(
     result: Box<dyn Matcher + Sync>,
     temp_includes: &[Vec<u8>],
 ) -> Result<Box<dyn Matcher + Sync>, PatternError> {
     if temp_includes.is_empty() {
         return Ok(result);
     }
     let forced_include_matcher = IncludeMatcher::new(
         temp_includes
             .iter()
             .map(|include| {
                 IgnorePattern::new(PatternSyntax::Path, include, Path::new(""))
             })
             .collect(),
     )?;
     Ok(Box::new(UnionMatcher::new(vec![
         Box::new(forced_include_matcher),
         result,
     ])))
 }

tests/test-sparse.t

@@ -1,440 +1,463 b''
 test sparse
 
   $ hg init myrepo
   $ cd myrepo
   $ cat > .hg/hgrc <<EOF
   > [extensions]
   > sparse=
   > strip=
   > EOF
 
   $ echo a > show
   $ echo x > hide
   $ hg ci -Aqm 'initial'
 
   $ echo b > show
   $ echo y > hide
   $ echo aa > show2
   $ echo xx > hide2
   $ hg ci -Aqm 'two'
 
 Verify basic --include
 
   $ hg up -q 0
+
+Test that sparse pattern by default is interpreted as "glob:", and is interpreted relative to the root.
+
+  $ hg debugsparse --reset
+  $ hg debugsparse -X 'foo*bar'
+  $ cat .hg/sparse
+  [exclude]
+  foo*bar
+
+  $ mk() { mkdir -p "$1"; touch "$1"/"$2"; }
+  $ mk 'foo' bar
+  $ mk 'foo-bar' x
+  $ mk 'unanchoredfoo-bar' x
+  $ mk 'foo*bar' x
+  $ mk 'dir/foo-bar' x
+  $ hg status --config rhg.on-unsupported=abort
+  ? dir/foo-bar/x
+  ? foo/bar
+  ? unanchoredfoo-bar/x
+  $ hg clean -a --no-confirm
+  $ rm -r foo*bar
+  $ hg debugsparse --reset
+
   $ hg debugsparse --include 'hide'
   $ ls -A
   .hg
   hide
 
 Absolute paths outside the repo should just be rejected
 
 #if no-windows
   $ hg debugsparse --include /foo/bar
   abort: paths cannot be absolute
   [255]
   $ hg debugsparse --include '$TESTTMP/myrepo/hide'
 
   $ hg debugsparse --include '/root'
   abort: paths cannot be absolute
   [255]
 #else
 TODO: See if this can be made to fail the same way as on Unix
   $ hg debugsparse --include /c/foo/bar
   abort: paths cannot be absolute
   [255]
   $ hg debugsparse --include '$TESTTMP/myrepo/hide'
 
   $ hg debugsparse --include '/c/root'
   abort: paths cannot be absolute
   [255]
 #endif
 
 Paths should be treated as cwd-relative, not repo-root-relative
   $ mkdir subdir && cd subdir
   $ hg debugsparse --include path
   $ hg debugsparse
   [include]
   $TESTTMP/myrepo/hide
   hide
   subdir/path
   
   $ cd ..
   $ echo hello > subdir/file2.ext
   $ cd subdir
   $ hg debugsparse --include '**.ext'  # let us test globs
   $ hg debugsparse --include 'path:abspath'  # and a path: pattern
   $ cd ..
   $ hg debugsparse
   [include]
   $TESTTMP/myrepo/hide
   hide
   path:abspath
   subdir/**.ext
   subdir/path
   
   $ rm -rf subdir
 
 Verify commiting while sparse includes other files
 
   $ echo z > hide
   $ hg ci -Aqm 'edit hide'
   $ ls -A
   .hg
   hide
   $ hg manifest
   hide
   show
 
 Verify --reset brings files back
 
   $ hg debugsparse --reset
   $ ls -A
   .hg
   hide
   show
   $ cat hide
   z
   $ cat show
   a
 
 Verify 'hg debugsparse' default output
 
   $ hg up -q null
   $ hg debugsparse --include 'show*'
 
   $ hg debugsparse
   [include]
   show*
   
 Verify update only writes included files
 
   $ hg up -q 0
   $ ls -A
   .hg
   show
 
   $ hg up -q 1
   $ ls -A
   .hg
   show
   show2
 
 Verify status only shows included files
 
   $ touch hide
   $ touch hide3
   $ echo c > show
   $ hg status
   M show
 
 Adding an excluded file should fail
 
   $ hg add hide3
   abort: cannot add 'hide3' - it is outside the sparse checkout
   (include file with `hg debugsparse --include <pattern>` or use `hg add -s <file>` to include file directory while adding)
   [255]
 
 But adding a truly excluded file shouldn't count
 
   $ hg add hide3 -X hide3
 
 Verify deleting sparseness while a file has changes fails
 
   $ hg debugsparse --delete 'show*'
   pending changes to 'hide'
   abort: cannot change sparseness due to pending changes (delete the files or use --force to bring them back dirty)
   [255]
 
 Verify deleting sparseness with --force brings back files
 
   $ hg debugsparse -f --delete 'show*'
   pending changes to 'hide'
   $ ls -A
   .hg
   hide
   hide2
   hide3
   show
   show2
   $ hg st
   M hide
   M show
   ? hide3
 
 Verify editing sparseness fails if pending changes
 
   $ hg debugsparse --include 'show*'
   pending changes to 'hide'
   abort: could not update sparseness due to pending changes
   [255]
 
 Verify adding sparseness hides files
 
   $ hg debugsparse -f --exclude 'hide*'
   pending changes to 'hide'
   $ ls -A
   .hg
   hide
   hide3
   show
   show2
   $ hg st
   M show
 
   $ hg up -qC .
 TODO: add an option to purge to also purge files outside the sparse config?
   $ hg purge --all --config extensions.purge=
   $ ls -A
   .hg
   hide
   hide3
   show
   show2
 For now, manually remove the files
   $ rm hide hide3
 
 Verify rebase temporarily includes excluded files
 
   $ hg rebase -d 1 -r 2 --config extensions.rebase=
   rebasing 2:b91df4f39e75 tip "edit hide"
   temporarily included 2 file(s) in the sparse checkout for merging
   merging hide
   warning: conflicts while merging hide! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
   [240]
 
   $ hg debugsparse
   [exclude]
   hide*
   
   Temporarily Included Files (for merge/rebase):
   hide
 
   $ cat hide
   <<<<<<< dest:   39278f7c08a9 - test: two
   y
   =======
   z
   >>>>>>> source: b91df4f39e75 - test: edit hide
 
 Verify aborting a rebase cleans up temporary files
 
   $ hg rebase --abort --config extensions.rebase=
   cleaned up 1 temporarily added file(s) from the sparse checkout
   rebase aborted
   $ rm hide.orig
 
   $ ls -A
   .hg
   show
   show2
 
 Verify merge fails if merging excluded files
 
   $ hg up -q 1
   $ hg merge -r 2
   temporarily included 2 file(s) in the sparse checkout for merging
   merging hide
   warning: conflicts while merging hide! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ hg debugsparse
   [exclude]
   hide*
   
   Temporarily Included Files (for merge/rebase):
   hide
 
   $ hg up -C .
   cleaned up 1 temporarily added file(s) from the sparse checkout
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugsparse
   [exclude]
   hide*
   
 
 Multiple -I and -X can be passed at once
 
   $ hg debugsparse --reset -I '*2' -X 'hide2'
   $ ls -A
   .hg
   hide.orig
   show2
   $ hg debugsparse --reset -X 'hide*'
 
 Verify strip -k resets dirstate correctly
 
   $ hg status
   $ hg debugsparse
   [exclude]
   hide*
   
   $ hg log -r . -T '{rev}\n' --stat
   1
    hide  |  2 +-
    hide2 |  1 +
    show  |  2 +-
    show2 |  1 +
    4 files changed, 4 insertions(+), 2 deletions(-)
   
   $ hg strip -r . -k
   saved backup bundle to $TESTTMP/myrepo/.hg/strip-backup/39278f7c08a9-ce59e002-backup.hg
   $ hg status
   M show
   ? show2
 
 Verify rebase succeeds if all changed files are in sparse checkout
 
   $ hg commit -Aqm "add show2"
   $ hg rebase -d 1 --config extensions.rebase=
   rebasing 2:bdde55290160 tip "add show2"
   saved backup bundle to $TESTTMP/myrepo/.hg/strip-backup/bdde55290160-216ed9c6-rebase.hg
 
 Verify log --sparse only shows commits that affect the sparse checkout
 
   $ hg log -T '{rev} '
   2 1 0  (no-eol)
   $ hg log --sparse -T '{rev} '
   2 0  (no-eol)
 
 Test status on a file in a subdir
 
   $ mkdir -p dir1/dir2
   $ touch dir1/dir2/file
   $ hg debugsparse -I dir1/dir2
   $ hg status
   ? dir1/dir2/file
 
 Mix files and subdirectories, both "glob:" and unprefixed
 
   $ hg debugsparse --reset
   $ touch dir1/notshown
   $ hg commit -A dir1/notshown -m "notshown"
   $ hg debugsparse --include 'dir1/dir2'
   $ "$PYTHON" $TESTDIR/list-tree.py . | grep -E -v '\.[\/]\.hg'
   ./
   ./dir1/
   ./dir1/dir2/
   ./dir1/dir2/file
   ./hide.orig
   $ hg debugsparse --delete 'dir1/dir2'
   $ hg debugsparse --include 'glob:dir1/dir2'
   $ "$PYTHON" $TESTDIR/list-tree.py . | grep -E -v '\.[\/]\.hg'
   ./
   ./dir1/
   ./dir1/dir2/
   ./dir1/dir2/file
   ./hide.orig
 
 Test that add -s adds dirs to sparse profile
 
   $ hg debugsparse --reset
   $ hg debugsparse --include empty
   $ hg debugsparse
   [include]
   empty
   
 
   $ mkdir add
   $ touch add/foo
   $ touch add/bar
   $ hg add add/foo
   abort: cannot add 'add/foo' - it is outside the sparse checkout
   (include file with `hg debugsparse --include <pattern>` or use `hg add -s <file>` to include file directory while adding)
   [255]
   $ hg add -s add/foo
   $ hg st
   A add/foo
   ? add/bar
   $ hg debugsparse
   [include]
   add
   empty
   
   $ hg add -s add/*
   add/foo already tracked!
   $ hg st
   A add/bar
   A add/foo
   $ hg debugsparse
   [include]
   add
   empty
   
 
   $ cd ..
 
 Test non-sparse repos work while sparse is loaded
   $ hg init sparserepo
   $ hg init nonsparserepo
   $ cd sparserepo
   $ cat > .hg/hgrc <<EOF
   > [extensions]
   > sparse=
   > EOF
   $ cd ../nonsparserepo
   $ echo x > x && hg add x && hg commit -qAm x
   $ cd ../sparserepo
   $ hg clone ../nonsparserepo ../nonsparserepo2
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Test debugrebuilddirstate
   $ cd ../sparserepo
   $ touch included
   $ touch excluded
   $ hg add included excluded
   $ hg commit -m 'a commit' -q
   $ cp .hg/dirstate ../dirstateboth
   $ hg debugsparse -X excluded
   $ cp ../dirstateboth .hg/dirstate
   $ hg debugrebuilddirstate
   $ hg debugdirstate
   n   0         -1 unset               included
 
 Test debugdirstate --minimal where file is in the parent manifest but not the
 dirstate
   $ hg debugsparse -X included
   $ hg debugdirstate
   $ cp .hg/dirstate ../dirstateallexcluded
   $ hg debugsparse --reset
   $ hg debugsparse -X excluded
   $ cp ../dirstateallexcluded .hg/dirstate
   $ touch includedadded
   $ hg add includedadded
   $ hg debugdirstate --no-dates
   a   0         -1 unset               includedadded
   $ hg debugrebuilddirstate --minimal
   $ hg debugdirstate --no-dates
   n   0         -1 unset               included
   a   0         -1 * includedadded (glob)
 
 Test debugdirstate --minimal where a file is not in parent manifest
 but in the dirstate. This should take into account excluded files in the
 manifest
   $ cp ../dirstateboth .hg/dirstate
   $ touch includedadded
   $ hg add includedadded
   $ touch excludednomanifest
   $ hg add excludednomanifest
   $ cp .hg/dirstate ../moreexcluded
   $ hg forget excludednomanifest
   $ rm excludednomanifest
   $ hg debugsparse -X excludednomanifest
   $ cp ../moreexcluded .hg/dirstate
   $ hg manifest
   excluded
   included
 We have files in the dirstate that are included and excluded. Some are in the
 manifest and some are not.
   $ hg debugdirstate --no-dates
   n * excluded (glob)
   a * excludednomanifest (glob)
   n * included (glob)
   a * includedadded (glob)
   $ hg debugrebuilddirstate --minimal
   $ hg debugdirstate --no-dates
   n * included (glob)
   a * includedadded (glob)