rhg: make `rhg files` work if `ui.relative-files=true` is specified

rust/rhg/src/commands/files.rs

@@ -1,110 +1,112 b''
 use crate::error::CommandError;
-use crate::ui::{print_narrow_sparse_warnings, Ui};
+use crate::ui::{print_narrow_sparse_warnings, Ui, RelativePaths, relative_paths};
 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() {
+    match relative_paths(invocation.config)? {
+      RelativePaths::Legacy | RelativePaths::Bool(true) => (),
+      RelativePaths::Bool(false) => {
         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",
         ));
     }
 
     let (narrow_matcher, narrow_warnings) = narrow::matcher(repo)?;
     print_narrow_sparse_warnings(&narrow_warnings, &[], invocation.ui, repo)?;
 
     if let Some(rev) = rev {
         let files = list_rev_tracked_files(repo, rev, narrow_matcher)
             .map_err(|e| (e, rev.as_ref()))?;
         display_files(invocation.ui, repo, files.iter())
     } else {
         // The dirstate always reflects the sparse narrowspec.
         let dirstate = repo.dirstate_map()?;
         let files_res: Result<Vec<_>, _> =
             filter_map_results(dirstate.iter(), |(path, entry)| {
                 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::<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)
     }
 }

rust/rhg/src/ui.rs

@@ -1,295 +1,307 b''
 use crate::color::ColorConfig;
 use crate::color::Effect;
 use crate::error::CommandError;
 use format_bytes::format_bytes;
 use format_bytes::write_bytes;
 use hg::config::Config;
 use hg::config::PlainInfo;
 use hg::errors::HgError;
 use hg::repo::Repo;
 use hg::sparse;
 use hg::utils::files::get_bytes_from_path;
 use hg::PatternFileWarning;
 use std::borrow::Cow;
 use std::io;
 use std::io::{ErrorKind, Write};
 
 pub struct Ui {
     stdout: std::io::Stdout,
     stderr: std::io::Stderr,
     colors: Option<ColorConfig>,
 }
 
 /// The kind of user interface error
 pub enum UiError {
     /// The standard output stream cannot be written to
     StdoutError(io::Error),
     /// The standard error stream cannot be written to
     StderrError(io::Error),
 }
 
 /// The commandline user interface
 impl Ui {
     pub fn new(config: &Config) -> Result<Self, HgError> {
         Ok(Ui {
             // If using something else, also adapt `isatty()` below.
             stdout: std::io::stdout(),
 
             stderr: std::io::stderr(),
             colors: ColorConfig::new(config)?,
         })
     }
 
     /// Default to no color if color configuration errors.
     ///
     /// Useful when we’re already handling another error.
     pub fn new_infallible(config: &Config) -> Self {
         Ui {
             // If using something else, also adapt `isatty()` below.
             stdout: std::io::stdout(),
 
             stderr: std::io::stderr(),
             colors: ColorConfig::new(config).unwrap_or(None),
         }
     }
 
     /// Returns a buffered handle on stdout for faster batch printing
     /// operations.
     pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> {
         StdoutBuffer::new(self.stdout.lock())
     }
 
     /// Write bytes to stdout
     pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> {
         let mut stdout = self.stdout.lock();
 
         stdout.write_all(bytes).or_else(handle_stdout_error)?;
 
         stdout.flush().or_else(handle_stdout_error)
     }
 
     /// Write bytes to stderr
     pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> {
         let mut stderr = self.stderr.lock();
 
         stderr.write_all(bytes).or_else(handle_stderr_error)?;
 
         stderr.flush().or_else(handle_stderr_error)
     }
 
     /// Write bytes to stdout with the given label
     ///
     /// Like the optional `label` parameter in `mercurial/ui.py`,
     /// this label influences the color used for this output.
     pub fn write_stdout_labelled(
         &self,
         bytes: &[u8],
         label: &str,
     ) -> Result<(), UiError> {
         if let Some(colors) = &self.colors {
             if let Some(effects) = colors.styles.get(label.as_bytes()) {
                 if !effects.is_empty() {
                     return self
                         .write_stdout_with_effects(bytes, effects)
                         .or_else(handle_stdout_error);
                 }
             }
         }
         self.write_stdout(bytes)
     }
 
     fn write_stdout_with_effects(
         &self,
         bytes: &[u8],
         effects: &[Effect],
     ) -> io::Result<()> {
         let stdout = &mut self.stdout.lock();
         let mut write_line = |line: &[u8], first: bool| {
             // `line` does not include the newline delimiter
             if !first {
                 stdout.write_all(b"\n")?;
             }
             if line.is_empty() {
                 return Ok(());
             }
             /// 0x1B == 27 == 0o33
             const ASCII_ESCAPE: &[u8] = b"\x1b";
             write_bytes!(stdout, b"{}[0", ASCII_ESCAPE)?;
             for effect in effects {
                 write_bytes!(stdout, b";{}", effect)?;
             }
             write_bytes!(stdout, b"m")?;
             stdout.write_all(line)?;
             write_bytes!(stdout, b"{}[0m", ASCII_ESCAPE)
         };
         let mut lines = bytes.split(|&byte| byte == b'\n');
         if let Some(first) = lines.next() {
             write_line(first, true)?;
             for line in lines {
                 write_line(line, false)?
             }
         }
         stdout.flush()
     }
 }
 
 // TODO: pass the PlainInfo to call sites directly and
 // delete this function
 pub fn plain(opt_feature: Option<&str>) -> bool {
     let plain_info = PlainInfo::from_env();
     match opt_feature {
         None => plain_info.is_plain(),
         Some(feature) => plain_info.is_feature_plain(feature),
     }
 }
 
 /// A buffered stdout writer for faster batch printing operations.
 pub struct StdoutBuffer<W: Write> {
     buf: io::BufWriter<W>,
 }
 
 impl<W: Write> StdoutBuffer<W> {
     pub fn new(writer: W) -> Self {
         let buf = io::BufWriter::new(writer);
         Self { buf }
     }
 
     /// Write bytes to stdout buffer
     pub fn write_all(&mut self, bytes: &[u8]) -> Result<(), UiError> {
         self.buf.write_all(bytes).or_else(handle_stdout_error)
     }
 
     /// Flush bytes to stdout
     pub fn flush(&mut self) -> Result<(), UiError> {
         self.buf.flush().or_else(handle_stdout_error)
     }
 }
 
 /// Sometimes writing to stdout is not possible, try writing to stderr to
 /// signal that failure, otherwise just bail.
 fn handle_stdout_error(error: io::Error) -> Result<(), UiError> {
     if let ErrorKind::BrokenPipe = error.kind() {
         // This makes `| head` work for example
         return Ok(());
     }
     let mut stderr = io::stderr();
 
     stderr
         .write_all(&format_bytes!(
             b"abort: {}\n",
             error.to_string().as_bytes()
         ))
         .map_err(UiError::StderrError)?;
 
     stderr.flush().map_err(UiError::StderrError)?;
 
     Err(UiError::StdoutError(error))
 }
 
 /// Sometimes writing to stderr is not possible.
 fn handle_stderr_error(error: io::Error) -> Result<(), UiError> {
     // A broken pipe should not result in a error
     // like with `| head` for example
     if let ErrorKind::BrokenPipe = error.kind() {
         return Ok(());
     }
     Err(UiError::StdoutError(error))
 }
 
 /// Encode rust strings according to the user system.
 pub fn utf8_to_local(s: &str) -> Cow<[u8]> {
     // TODO encode for the user's system //
     let bytes = s.as_bytes();
     Cow::Borrowed(bytes)
 }
 
 /// Decode user system bytes to Rust string.
 pub fn local_to_utf8(s: &[u8]) -> Cow<str> {
     // TODO decode from the user's system
     String::from_utf8_lossy(s)
 }
 
 /// Should formatted output be used?
 ///
 /// Note: rhg does not have the formatter mechanism yet,
 /// but this is also used when deciding whether to use color.
 pub fn formatted(config: &Config) -> Result<bool, HgError> {
     if let Some(formatted) = config.get_option(b"ui", b"formatted")? {
         Ok(formatted)
     } else {
         isatty(config)
     }
 }
 
+pub enum RelativePaths {
+    Legacy,
+    Bool(bool),
+}
+
+pub fn relative_paths(config: &Config) -> Result<RelativePaths, HgError> {
+    Ok(match config.get(b"ui", b"relative-paths") {
+        None | Some(b"legacy") => RelativePaths::Legacy,
+        _ => RelativePaths::Bool(config.get_bool(b"ui", b"relative-paths")?),
+    })
+}
+
 fn isatty(config: &Config) -> Result<bool, HgError> {
     Ok(if config.get_bool(b"ui", b"nontty")? {
         false
     } else {
         atty::is(atty::Stream::Stdout)
     })
 }
 
 /// Return the formatted bytestring corresponding to a pattern file warning,
 /// as expected by the CLI.
 pub(crate) fn format_pattern_file_warning(
     warning: &PatternFileWarning,
     repo: &Repo,
 ) -> Vec<u8> {
     match warning {
         PatternFileWarning::InvalidSyntax(path, syntax) => format_bytes!(
             b"{}: ignoring invalid syntax '{}'\n",
             get_bytes_from_path(path),
             &*syntax
         ),
         PatternFileWarning::NoSuchFile(path) => {
             let path = if let Ok(relative) =
                 path.strip_prefix(repo.working_directory_path())
             {
                 relative
             } else {
                 &*path
             };
             format_bytes!(
                 b"skipping unreadable pattern file '{}': \
                     No such file or directory\n",
                 get_bytes_from_path(path),
             )
         }
     }
 }
 
 /// Print with `Ui` the formatted bytestring corresponding to a
 /// sparse/narrow warning, as expected by the CLI.
 pub(crate) fn print_narrow_sparse_warnings(
     narrow_warnings: &[sparse::SparseWarning],
     sparse_warnings: &[sparse::SparseWarning],
     ui: &Ui,
     repo: &Repo,
 ) -> Result<(), CommandError> {
     for warning in narrow_warnings.iter().chain(sparse_warnings) {
         match &warning {
             sparse::SparseWarning::RootWarning { context, line } => {
                 let msg = format_bytes!(
                     b"warning: {} profile cannot use paths \"
                 starting with /, ignoring {}\n",
                     context,
                     line
                 );
                 ui.write_stderr(&msg)?;
             }
             sparse::SparseWarning::ProfileNotFound { profile, rev } => {
                 let msg = format_bytes!(
                     b"warning: sparse profile '{}' not found \"
                 in rev {} - ignoring it\n",
                     profile,
                     rev
                 );
                 ui.write_stderr(&msg)?;
             }
             sparse::SparseWarning::Pattern(e) => {
                 ui.write_stderr(&format_pattern_file_warning(e, repo))?;
             }
         }
     }
     Ok(())
 }

tests/test-rhg.t

@@ -1,417 +1,419 b''
 #require rhg
 
   $ NO_FALLBACK="env RHG_ON_UNSUPPORTED=abort"
 
 Unimplemented command
   $ $NO_FALLBACK rhg unimplemented-command
   unsupported feature: error: The subcommand 'unimplemented-command' wasn't recognized
   
   Usage: rhg [OPTIONS] <COMMAND>
   
   For more information try '--help'
   
   [252]
   $ rhg unimplemented-command --config rhg.on-unsupported=abort-silent
   [252]
 
 Finding root
   $ $NO_FALLBACK rhg root
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
 
   $ hg init repository
   $ cd repository
   $ $NO_FALLBACK rhg root
   $TESTTMP/repository
 
 Reading and setting configuration
   $ echo "[ui]" >> $HGRCPATH
   $ echo "username = user1" >> $HGRCPATH
   $ $NO_FALLBACK rhg config ui.username
   user1
   $ echo "[ui]" >> .hg/hgrc
   $ echo "username = user2" >> .hg/hgrc
   $ $NO_FALLBACK rhg config ui.username
   user2
   $ $NO_FALLBACK rhg --config ui.username=user3 config ui.username
   user3
 
 Unwritable file descriptor
   $ $NO_FALLBACK rhg root > /dev/full
   abort: No space left on device (os error 28)
   [255]
 
 Deleted repository
   $ rm -rf `pwd`
   $ $NO_FALLBACK rhg root
   abort: error getting current working directory: $ENOENT$
   [255]
 
 Listing tracked files
   $ cd $TESTTMP
   $ hg init repository
   $ cd repository
   $ for i in 1 2 3; do
   >   echo $i >> file$i
   >   hg add file$i
   > done
   > hg commit -m "commit $i" -q
 
 Listing tracked files from root
   $ $NO_FALLBACK rhg files
   file1
   file2
   file3
 
 Listing tracked files from subdirectory
   $ mkdir -p path/to/directory
   $ cd path/to/directory
   $ $NO_FALLBACK rhg files
   ../../../file1
   ../../../file2
   ../../../file3
 
   $ $NO_FALLBACK rhg files --config ui.relative-paths=legacy
-  unsupported feature: non-default ui.relative-paths
-  [252]
+  ../../../file1
+  ../../../file2
+  ../../../file3
 
   $ $NO_FALLBACK rhg files --config ui.relative-paths=false
   unsupported feature: non-default ui.relative-paths
   [252]
 
   $ $NO_FALLBACK rhg files --config ui.relative-paths=true
-  unsupported feature: non-default ui.relative-paths
-  [252]
+  ../../../file1
+  ../../../file2
+  ../../../file3
 
 Listing tracked files through broken pipe
   $ $NO_FALLBACK rhg files | head -n 1
   ../../../file1
 
 Debuging data in inline index
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg init repository
   $ cd repository
   $ for i in 1 2 3 4 5 6; do
   >   echo $i >> file-$i
   >   hg add file-$i
   >   hg commit -m "Commit $i" -q
   > done
   $ $NO_FALLBACK rhg debugdata -c 2
   8d0267cb034247ebfa5ee58ce59e22e57a492297
   test
   0 0
   file-3
   
   Commit 3 (no-eol)
   $ $NO_FALLBACK rhg debugdata -m 2
   file-1\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   file-2\x005d9299349fc01ddd25d0070d149b124d8f10411e (esc)
   file-3\x002661d26c649684b482d10f91960cc3db683c38b4 (esc)
 
 Debuging with full node id
   $ $NO_FALLBACK rhg debugdata -c `hg log -r 0 -T '{node}'`
   d1d1c679d3053e8926061b6f45ca52009f011e3f
   test
   0 0
   file-1
   
   Commit 1 (no-eol)
 
 Specifying revisions by changeset ID
   $ hg log -T '{node}\n'
   c6ad58c44207b6ff8a4fbbca7045a5edaa7e908b
   d654274993d0149eecc3cc03214f598320211900
   f646af7e96481d3a5470b695cf30ad8e3ab6c575
   cf8b83f14ead62b374b6e91a0e9303b85dfd9ed7
   91c6f6e73e39318534dc415ea4e8a09c99cd74d6
   6ae9681c6d30389694d8701faf24b583cf3ccafe
   $ $NO_FALLBACK rhg files -r cf8b83
   file-1
   file-2
   file-3
   $ $NO_FALLBACK rhg cat -r cf8b83 file-2
   2
   $ $NO_FALLBACK rhg cat --rev cf8b83 file-2
   2
   $ $NO_FALLBACK rhg cat -r c file-2
   abort: ambiguous revision identifier: c
   [255]
   $ $NO_FALLBACK rhg cat -r d file-2
   2
   $ $NO_FALLBACK rhg cat -r 0000 file-2
   file-2: no such file in rev 000000000000
   [1]
 
 Cat files
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg init repository
   $ cd repository
   $ echo "original content" > original
   $ hg add original
   $ hg commit -m "add original" original
 Without `--rev`
   $ $NO_FALLBACK rhg cat original
   original content
 With `--rev`
   $ $NO_FALLBACK rhg cat -r 0 original
   original content
 Cat copied file should not display copy metadata
   $ hg copy original copy_of_original
   $ hg commit -m "add copy of original"
   $ $NO_FALLBACK rhg cat original
   original content
   $ $NO_FALLBACK rhg cat -r 1 copy_of_original
   original content
 
 
 Fallback to Python
   $ $NO_FALLBACK rhg cat original --exclude="*.rs"
   unsupported feature: error: Found argument '--exclude' which wasn't expected, or isn't valid in this context
   
     If you tried to supply '--exclude' as a value rather than a flag, use '-- --exclude'
   
   Usage: rhg cat <FILE>...
   
   For more information try '--help'
   
   [252]
   $ rhg cat original --exclude="*.rs"
   original content
 
 Check that `fallback-immediately` overrides `$NO_FALLBACK`
   $ $NO_FALLBACK rhg cat original --exclude="*.rs" --config rhg.fallback-immediately=1
   original content
 
   $ (unset RHG_FALLBACK_EXECUTABLE; rhg cat original --exclude="*.rs")
   abort: 'rhg.on-unsupported=fallback' without 'rhg.fallback-executable' set.
   [255]
 
   $ (unset RHG_FALLBACK_EXECUTABLE; rhg cat original)
   original content
 
   $ rhg cat original --exclude="*.rs" --config rhg.fallback-executable=false
   [1]
 
   $ rhg cat original --exclude="*.rs" --config rhg.fallback-executable=hg-non-existent
   abort: invalid fallback 'hg-non-existent': cannot find binary path
   [253]
 
   $ rhg cat original --exclude="*.rs" --config rhg.fallback-executable=rhg
   Blocking recursive fallback. The 'rhg.fallback-executable = rhg' config points to `rhg` itself.
   unsupported feature: error: Found argument '--exclude' which wasn't expected, or isn't valid in this context
   
     If you tried to supply '--exclude' as a value rather than a flag, use '-- --exclude'
   
   Usage: rhg cat <FILE>...
   
   For more information try '--help'
   
   [252]
 
 Fallback with shell path segments
   $ $NO_FALLBACK rhg cat .
   unsupported feature: `..` or `.` path segment
   [252]
   $ $NO_FALLBACK rhg cat ..
   unsupported feature: `..` or `.` path segment
   [252]
   $ $NO_FALLBACK rhg cat ../..
   unsupported feature: `..` or `.` path segment
   [252]
 
 Fallback with filesets
   $ $NO_FALLBACK rhg cat "set:c or b"
   unsupported feature: fileset
   [252]
 
 Fallback with generic hooks
   $ $NO_FALLBACK rhg cat original --config hooks.pre-cat=something
   unsupported feature: pre-cat hook defined
   [252]
 
   $ $NO_FALLBACK rhg cat original --config hooks.post-cat=something
   unsupported feature: post-cat hook defined
   [252]
 
   $ $NO_FALLBACK rhg cat original --config hooks.fail-cat=something
   unsupported feature: fail-cat hook defined
   [252]
 
 Fallback with [defaults]
   $ $NO_FALLBACK rhg cat original --config "defaults.cat=-r null"
   unsupported feature: `defaults` config set
   [252]
 
 
 Requirements
   $ $NO_FALLBACK rhg debugrequirements
   dotencode
   fncache
   generaldelta
   persistent-nodemap
   revlog-compression-zstd (zstd !)
   revlogv1
   share-safe
   sparserevlog
   store
 
   $ echo indoor-pool >> .hg/requires
   $ $NO_FALLBACK rhg files
   unsupported feature: repository requires feature unknown to this Mercurial: indoor-pool
   [252]
 
   $ $NO_FALLBACK rhg cat -r 1 copy_of_original
   unsupported feature: repository requires feature unknown to this Mercurial: indoor-pool
   [252]
 
   $ $NO_FALLBACK rhg debugrequirements
   unsupported feature: repository requires feature unknown to this Mercurial: indoor-pool
   [252]
 
   $ echo -e '\xFF' >> .hg/requires
   $ $NO_FALLBACK rhg debugrequirements
   abort: parse error in 'requires' file
   [255]
 
 Persistent nodemap
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg --config format.use-persistent-nodemap=no init repository
   $ cd repository
   $ $NO_FALLBACK rhg debugrequirements | grep nodemap
   [1]
   $ hg debugbuilddag .+5000 --overwritten-file --config "storage.revlog.nodemap.mode=warn"
   $ hg id -r tip
   c3ae8dec9fad tip
   $ ls .hg/store/00changelog*
   .hg/store/00changelog.d
   .hg/store/00changelog.i
   $ $NO_FALLBACK rhg files -r c3ae8dec9fad
   of
 
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg --config format.use-persistent-nodemap=True init repository
   $ cd repository
   $ $NO_FALLBACK rhg debugrequirements | grep nodemap
   persistent-nodemap
   $ hg debugbuilddag .+5000 --overwritten-file --config "storage.revlog.nodemap.mode=warn"
   $ hg id -r tip
   c3ae8dec9fad tip
   $ ls .hg/store/00changelog*
   .hg/store/00changelog-*.nd (glob)
   .hg/store/00changelog.d
   .hg/store/00changelog.i
   .hg/store/00changelog.n
 
 Specifying revisions by changeset ID
   $ $NO_FALLBACK rhg files -r c3ae8dec9fad
   of
   $ $NO_FALLBACK rhg cat -r c3ae8dec9fad of
   r5000
 
 Crate a shared repository
 
   $ echo "[extensions]"      >> $HGRCPATH
   $ echo "share = "          >> $HGRCPATH
 
   $ cd $TESTTMP
   $ hg init repo1
   $ echo a > repo1/a
   $ hg -R repo1 commit -A -m'init'
   adding a
 
   $ hg share repo1 repo2
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 And check that basic rhg commands work with sharing
 
   $ $NO_FALLBACK rhg files -R repo2
   repo2/a
   $ $NO_FALLBACK rhg -R repo2 cat -r 0 repo2/a
   a
 
 Same with relative sharing
 
   $ hg share repo2 repo3 --relative
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ $NO_FALLBACK rhg files -R repo3
   repo3/a
   $ $NO_FALLBACK rhg -R repo3 cat -r 0 repo3/a
   a
 
 Same with share-safe
 
   $ echo "[format]"         >> $HGRCPATH
   $ echo "use-share-safe = True" >> $HGRCPATH
 
   $ cd $TESTTMP
   $ hg init repo4
   $ cd repo4
   $ echo a > a
   $ hg commit -A -m'init'
   adding a
 
   $ cd ..
   $ hg share repo4 repo5
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 And check that basic rhg commands work with sharing
 
   $ cd repo5
   $ $NO_FALLBACK rhg files
   a
   $ $NO_FALLBACK rhg cat -r 0 a
   a
 
 The blackbox extension is supported
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "blackbox =" >> $HGRCPATH
   $ echo "[blackbox]" >> $HGRCPATH
   $ echo "maxsize = 1" >> $HGRCPATH
   $ $NO_FALLBACK rhg files > /dev/null
   $ cat .hg/blackbox.log
   ????-??-?? ??:??:??.??? * @d3873e73d99ef67873dac33fbcc66268d5d2b6f4 (*)> (rust) files exited 0 after * seconds (glob)
   $ cat .hg/blackbox.log.1
   ????-??-?? ??:??:??.??? * @d3873e73d99ef67873dac33fbcc66268d5d2b6f4 (*)> (rust) files (glob)
 
 Subrepos are not supported
 
   $ touch .hgsub
   $ $NO_FALLBACK rhg files
   unsupported feature: subrepos (.hgsub is present)
   [252]
   $ rhg files
   a
   $ rm .hgsub
 
 The `:required` extension suboptions are correctly ignored
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "blackbox:required = yes" >> $HGRCPATH
   $ rhg files
   a
   $ echo "*:required = yes" >> $HGRCPATH
   $ rhg files
   a
 
 We can ignore all extensions at once
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "thisextensionbetternotexist=" >> $HGRCPATH
   $ echo "thisextensionbetternotexisteither=" >> $HGRCPATH
   $ $NO_FALLBACK rhg files
   unsupported feature: extensions: thisextensionbetternotexist, thisextensionbetternotexisteither (consider adding them to 'rhg.ignored-extensions' config)
   [252]
 
   $ echo "[rhg]" >> $HGRCPATH
   $ echo "ignored-extensions=*" >> $HGRCPATH
   $ $NO_FALLBACK rhg files
   a