rust-narrow: enable narrow support for plain `rhg files`

Support for `rhg files -r NODE` in a future changeset.

rust/rhg/src/commands/files.rs

@@ -1,112 +1,119 b''
 use crate::error::CommandError;
-use crate::ui::Ui;
+use crate::ui::{print_narrow_sparse_warnings, Ui};
 use crate::utils::path_utils::RelativizePaths;
 use clap::Arg;
+use hg::narrow;
 use hg::operations::list_rev_tracked_files;
 use hg::repo::Repo;
 use hg::utils::filter_map_results;
 use hg::utils::hg_path::HgPath;
 use rayon::prelude::*;
 
 pub const HELP_TEXT: &str = "
 List tracked files.
 
 Returns 0 on success.
 ";
 
 pub fn args() -> clap::Command {
     clap::command!("files")
         .arg(
             Arg::new("rev")
                 .help("search the repository as it is in REV")
                 .short('r')
                 .long("revision")
                 .value_name("REV"),
         )
         .about(HELP_TEXT)
 }
 
 pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
     let relative = invocation.config.get(b"ui", b"relative-paths");
     if relative.is_some() {
         return Err(CommandError::unsupported(
             "non-default ui.relative-paths",
         ));
     }
 
     let rev = invocation.subcommand_args.get_one::<String>("rev");
 
     let repo = invocation.repo?;
 
     // It seems better if this check is removed: this would correspond to
     // automatically enabling the extension if the repo requires it.
     // However we need this check to be in sync with vanilla hg so hg tests
     // pass.
     if repo.has_sparse()
         && invocation.config.get(b"extensions", b"sparse").is_none()
     {
         return Err(CommandError::unsupported(
             "repo is using sparse, but sparse extension is not enabled",
         ));
     }
 
     if let Some(rev) = rev {
         if repo.has_narrow() {
             return Err(CommandError::unsupported(
                 "rhg files -r <rev> is not supported in narrow clones",
             ));
         }
         let files = list_rev_tracked_files(repo, rev)
             .map_err(|e| (e, rev.as_ref()))?;
         display_files(invocation.ui, repo, files.iter())
     } else {
-        // The dirstate always reflects the sparse narrowspec, so if
-        // we only have sparse without narrow all is fine.
-        // If we have narrow, then [hg files] needs to check if
-        // the store narrowspec is in sync with the one of the dirstate,
-        // so we can't support that without explicit code.
-        if repo.has_narrow() {
-            return Err(CommandError::unsupported(
-                "rhg files is not supported in narrow clones",
-            ));
-        }
+        // The dirstate always reflects the sparse narrowspec.
+        let (narrow_matcher, narrow_warnings) = narrow::matcher(repo)?;
+        print_narrow_sparse_warnings(
+            &narrow_warnings,
+            &[],
+            invocation.ui,
+            repo,
+        )?;
         let dirstate = repo.dirstate_map()?;
         let files_res: Result<Vec<_>, _> =
             filter_map_results(dirstate.iter(), |(path, entry)| {
-                Ok(if entry.tracked() { Some(path) } else { None })
+                Ok(if entry.tracked() && narrow_matcher.matches(path) {
+                    Some(path)
+                } else {
+                    None
+                })
             })
             .collect();
 
         let mut files = files_res?;
         files.par_sort_unstable();
 
-        display_files(invocation.ui, repo, files.into_iter().map(Ok))
+        display_files(
+            invocation.ui,
+            repo,
+            files.into_iter().map::<Result<_, CommandError>, _>(Ok),
+        )
     }
 }
 
 fn display_files<'a, E>(
     ui: &Ui,
     repo: &Repo,
     files: impl IntoIterator<Item = Result<&'a HgPath, E>>,
 ) -> Result<(), CommandError>
 where
     CommandError: From<E>,
 {
     let mut stdout = ui.stdout_buffer();
     let mut any = false;
 
     let relativize = RelativizePaths::new(repo)?;
     for result in files {
         let path = result?;
         stdout.write_all(&relativize.relativize(path))?;
         stdout.write_all(b"\n")?;
         any = true;
     }
 
     stdout.flush()?;
     if any {
         Ok(())
     } else {
         Err(CommandError::Unsuccessful)
     }
 }

tests/test-rhg-sparse-narrow.t

@@ -1,112 +1,121 b''
 #require rhg
 
   $ NO_FALLBACK="env RHG_ON_UNSUPPORTED=abort"
 
 Rhg works well when sparse working copy is enabled.
 
   $ cd "$TESTTMP"
   $ hg init repo-sparse
   $ cd repo-sparse
   $ cat > .hg/hgrc <<EOF
   > [extensions]
   > sparse=
   > EOF
 
   $ echo a > show
   $ echo x > hide
   $ mkdir dir1 dir2
   $ echo x > dir1/x
   $ echo y > dir1/y
   $ echo z > dir2/z
 
   $ hg ci -Aqm 'initial'
   $ hg debugsparse --include 'show'
   $ ls -A
   .hg
   show
 
   $ tip=$(hg log -r . --template '{node}')
   $ $NO_FALLBACK rhg files -r "$tip"
   dir1/x
   dir1/y
   dir2/z
   hide
   show
   $ $NO_FALLBACK rhg files
   show
 
   $ $NO_FALLBACK rhg cat -r "$tip" hide
   x
 
   $ cd ..
 
 We support most things when narrow is enabled, too, with a couple of caveats.
 
   $ . "$TESTDIR/narrow-library.sh"
   $ real_hg=$RHG_FALLBACK_EXECUTABLE
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > narrow=
   > EOF
 
   $ hg clone --narrow  ./repo-sparse repo-narrow --include dir1
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   new changesets 6d714a4a2998
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd repo-narrow
 
   $ $NO_FALLBACK rhg cat -r "$tip" dir1/x
   x
   $ "$real_hg" cat -r "$tip" dir1/x
   x
 
 TODO: bad error message
 
   $ $NO_FALLBACK rhg cat -r "$tip" hide
   abort: invalid revision identifier: 6d714a4a2998cbfd0620db44da58b749f6565d63
   [255]
   $ "$real_hg" cat -r "$tip" hide
   [1]
 
 A naive implementation of [rhg files] leaks the paths that are supposed to be
-hidden by narrow, so we just fall back to hg.
+hidden by narrow, so we just fall back to hg when accessing a revision.
 
   $ $NO_FALLBACK rhg files -r "$tip"
   unsupported feature: rhg files -r <rev> is not supported in narrow clones
   [252]
   $ "$real_hg" files -r "$tip"
   dir1/x
   dir1/y
 
+The working copy version works with narrow correctly
+
+  $ $NO_FALLBACK rhg files
+  dir1/x
+  dir1/y
+  $ "$real_hg" files
+  dir1/x
+  dir1/y
+
 Hg status needs to do some filtering based on narrow spec
 
   $ mkdir dir2
   $ touch dir2/q
   $ "$real_hg" status
   $ $NO_FALLBACK rhg --config rhg.status=true status
 
 Adding "orphaned" index files:
 
   $ (cd ..; cp repo-sparse/.hg/store/data/hide.i repo-narrow/.hg/store/data/hide.i)
   $ (cd ..; mkdir repo-narrow/.hg/store/data/dir2; cp repo-sparse/.hg/store/data/dir2/z.i repo-narrow/.hg/store/data/dir2/z.i)
   $ "$real_hg" verify -q
 
   $ "$real_hg" files -r "$tip"
   dir1/x
   dir1/y
 
 # TODO: even though [hg files] hides the orphaned dir2/z, [hg cat] still shows it.
 # rhg has the same issue, but at least it's not specific to rhg.
 # This is despite [hg verify] succeeding above.
 
   $ $NO_FALLBACK rhg cat -r "$tip" dir2/z
   z
   $ "$real_hg" cat -r "$tip" dir2/z
   z