rhg: Add support for -R and --repository command-line arguments

Differential Revision: https://phab.mercurial-scm.org/D9970

rust/hg-core/src/repo.rs

@@ -1,216 +1,238 b''
 use crate::config::{Config, ConfigError, ConfigParseError};
 use crate::errors::{HgError, IoResultExt};
 use crate::requirements;
+use crate::utils::current_dir;
 use crate::utils::files::get_path_from_bytes;
 use memmap::{Mmap, MmapOptions};
 use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 
 /// A repository on disk
 pub struct Repo {
     working_directory: PathBuf,
     dot_hg: PathBuf,
     store: PathBuf,
     requirements: HashSet<String>,
     config: Config,
 }
 
 #[derive(Debug, derive_more::From)]
 pub enum RepoError {
     NotFound {
-        current_directory: PathBuf,
+        at: PathBuf,
     },
     #[from]
     ConfigParseError(ConfigParseError),
     #[from]
     Other(HgError),
 }
 
 impl From<ConfigError> for RepoError {
     fn from(error: ConfigError) -> Self {
         match error {
             ConfigError::Parse(error) => error.into(),
             ConfigError::Other(error) => error.into(),
         }
     }
 }
 
 /// Filesystem access abstraction for the contents of a given "base" diretory
 #[derive(Clone, Copy)]
 pub(crate) struct Vfs<'a> {
     base: &'a Path,
 }
 
 impl Repo {
     /// Search the current directory and its ancestores for a repository:
     /// a working directory that contains a `.hg` sub-directory.
-    pub fn find(config: &Config) -> Result<Self, RepoError> {
+    ///
+    /// `explicit_path` is for `--repository` command-line arguments.
+    pub fn find(
+        config: &Config,
+        explicit_path: Option<&Path>,
+    ) -> Result<Self, RepoError> {
+        if let Some(root) = explicit_path {
+            // Having an absolute path isn’t necessary here but can help code
+            // elsewhere
+            let root = current_dir()?.join(root);
+            if root.join(".hg").is_dir() {
+                Self::new_at_path(root, config)
+            } else {
+                Err(RepoError::NotFound {
+                    at: root.to_owned(),
+                })
+            }
+        } else {
         let current_directory = crate::utils::current_dir()?;
-        // ancestors() is inclusive: it first yields `current_directory` as-is.
+            // ancestors() is inclusive: it first yields `current_directory`
+            // as-is.
         for ancestor in current_directory.ancestors() {
             if ancestor.join(".hg").is_dir() {
-                return Ok(Self::new_at_path(ancestor.to_owned(), config)?);
+                    return Self::new_at_path(ancestor.to_owned(), config);
             }
         }
-        Err(RepoError::NotFound { current_directory })
+            Err(RepoError::NotFound {
+                at: current_directory,
+            })
+        }
     }
 
     /// To be called after checking that `.hg` is a sub-directory
     fn new_at_path(
         working_directory: PathBuf,
         config: &Config,
     ) -> Result<Self, RepoError> {
         let dot_hg = working_directory.join(".hg");
 
         let mut repo_config_files = Vec::new();
         repo_config_files.push(dot_hg.join("hgrc"));
         repo_config_files.push(dot_hg.join("hgrc-not-shared"));
 
         let hg_vfs = Vfs { base: &dot_hg };
         let mut reqs = requirements::load_if_exists(hg_vfs)?;
         let relative =
             reqs.contains(requirements::RELATIVE_SHARED_REQUIREMENT);
         let shared =
             reqs.contains(requirements::SHARED_REQUIREMENT) || relative;
 
         // From `mercurial/localrepo.py`:
         //
         // if .hg/requires contains the sharesafe requirement, it means
         // there exists a `.hg/store/requires` too and we should read it
         // NOTE: presence of SHARESAFE_REQUIREMENT imply that store requirement
         // is present. We never write SHARESAFE_REQUIREMENT for a repo if store
         // is not present, refer checkrequirementscompat() for that
         //
         // However, if SHARESAFE_REQUIREMENT is not present, it means that the
         // repository was shared the old way. We check the share source
         // .hg/requires for SHARESAFE_REQUIREMENT to detect whether the
         // current repository needs to be reshared
         let share_safe = reqs.contains(requirements::SHARESAFE_REQUIREMENT);
 
         let store_path;
         if !shared {
             store_path = dot_hg.join("store");
             if share_safe {
                 reqs.extend(requirements::load(Vfs { base: &store_path })?);
             }
         } else {
             let bytes = hg_vfs.read("sharedpath")?;
             let mut shared_path = get_path_from_bytes(&bytes).to_owned();
             if relative {
                 shared_path = dot_hg.join(shared_path)
             }
             if !shared_path.is_dir() {
                 return Err(HgError::corrupted(format!(
                     ".hg/sharedpath points to nonexistent directory {}",
                     shared_path.display()
                 ))
                 .into());
             }
 
             store_path = shared_path.join("store");
 
             let source_is_share_safe =
                 requirements::load(Vfs { base: &shared_path })?
                     .contains(requirements::SHARESAFE_REQUIREMENT);
 
             if share_safe && !source_is_share_safe {
                 return Err(match config
                     .get(b"safe-mismatch", b"source-not-safe")
                 {
                     Some(b"abort") | None => HgError::abort(
                         "share source does not support share-safe requirement",
                     ),
                     _ => HgError::unsupported("share-safe downgrade"),
                 }
                 .into());
             } else if source_is_share_safe && !share_safe {
                 return Err(
                     match config.get(b"safe-mismatch", b"source-safe") {
                         Some(b"abort") | None => HgError::abort(
                             "version mismatch: source uses share-safe \
                             functionality while the current share does not",
                         ),
                         _ => HgError::unsupported("share-safe upgrade"),
                     }
                     .into(),
                 );
             }
 
             if share_safe {
                 repo_config_files.insert(0, shared_path.join("hgrc"))
             }
         }
 
         let repo_config = config.combine_with_repo(&repo_config_files)?;
 
         let repo = Self {
             requirements: reqs,
             working_directory,
             store: store_path,
             dot_hg,
             config: repo_config,
         };
 
         requirements::check(&repo)?;
 
         Ok(repo)
     }
 
     pub fn working_directory_path(&self) -> &Path {
         &self.working_directory
     }
 
     pub fn requirements(&self) -> &HashSet<String> {
         &self.requirements
     }
 
     pub fn config(&self) -> &Config {
         &self.config
     }
 
     /// For accessing repository files (in `.hg`), except for the store
     /// (`.hg/store`).
     pub(crate) fn hg_vfs(&self) -> Vfs<'_> {
         Vfs { base: &self.dot_hg }
     }
 
     /// For accessing repository store files (in `.hg/store`)
     pub(crate) fn store_vfs(&self) -> Vfs<'_> {
         Vfs { base: &self.store }
     }
 
     /// For accessing the working copy
 
     // The undescore prefix silences the "never used" warning. Remove before
     // using.
     pub(crate) fn _working_directory_vfs(&self) -> Vfs<'_> {
         Vfs {
             base: &self.working_directory,
         }
     }
 }
 
 impl Vfs<'_> {
     pub(crate) fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
         self.base.join(relative_path)
     }
 
     pub(crate) fn read(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Vec<u8>, HgError> {
         let path = self.join(relative_path);
         std::fs::read(&path).for_file(&path)
     }
 
     pub(crate) fn mmap_open(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Mmap, HgError> {
         let path = self.base.join(relative_path);
         let file = std::fs::File::open(&path).for_file(&path)?;
         // TODO: what are the safety requirements here?
         let mmap = unsafe { MmapOptions::new().map(&file) }.for_file(&path)?;
         Ok(mmap)
     }
 }

rust/rhg/src/commands/cat.rs

@@ -1,73 +1,75 b''
 use crate::error::CommandError;
 use crate::ui::Ui;
 use clap::Arg;
 use clap::ArgMatches;
 use hg::config::Config;
 use hg::operations::cat;
 use hg::repo::Repo;
 use hg::utils::hg_path::HgPathBuf;
 use micro_timer::timed;
 use std::convert::TryFrom;
+use std::path::Path;
 
 pub const HELP_TEXT: &str = "
 Output the current or given revision of files
 ";
 
 pub fn args() -> clap::App<'static, 'static> {
     clap::SubCommand::with_name("cat")
         .arg(
             Arg::with_name("rev")
                 .help("search the repository as it is in REV")
                 .short("-r")
                 .long("--revision")
                 .value_name("REV")
                 .takes_value(true),
         )
         .arg(
             clap::Arg::with_name("files")
                 .required(true)
                 .multiple(true)
                 .empty_values(false)
                 .value_name("FILE")
                 .help("Activity to start: activity@category"),
         )
         .about(HELP_TEXT)
 }
 
 #[timed]
 pub fn run(
     ui: &Ui,
     config: &Config,
+    repo_path: Option<&Path>,
     args: &ArgMatches,
 ) -> Result<(), CommandError> {
     let rev = args.value_of("rev");
     let file_args = match args.values_of("files") {
         Some(files) => files.collect(),
         None => vec![],
     };
 
-    let repo = Repo::find(config)?;
+    let repo = Repo::find(config, repo_path)?;
     let cwd = hg::utils::current_dir()?;
 
     let mut files = vec![];
     for file in file_args.iter() {
         // TODO: actually normalize `..` path segments etc?
         let normalized = cwd.join(&file);
         let stripped = normalized
             .strip_prefix(&repo.working_directory_path())
             // TODO: error message for path arguments outside of the repo
             .map_err(|_| CommandError::abort(""))?;
         let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
             .map_err(|e| CommandError::abort(e.to_string()))?;
         files.push(hg_file);
     }
 
     match rev {
         Some(rev) => {
             let data = cat(&repo, rev, &files).map_err(|e| (e, rev))?;
             ui.write_stdout(&data)?;
             Ok(())
         }
         None => Err(CommandError::Unimplemented.into()),
     }
 }

rust/rhg/src/commands/debugdata.rs

@@ -1,72 +1,74 b''
 use crate::error::CommandError;
 use crate::ui::Ui;
 use clap::Arg;
 use clap::ArgGroup;
 use clap::ArgMatches;
 use hg::config::Config;
 use hg::operations::{debug_data, DebugDataKind};
 use hg::repo::Repo;
 use micro_timer::timed;
+use std::path::Path;
 
 pub const HELP_TEXT: &str = "
 Dump the contents of a data file revision
 ";
 
 pub fn args() -> clap::App<'static, 'static> {
     clap::SubCommand::with_name("debugdata")
         .arg(
             Arg::with_name("changelog")
                 .help("open changelog")
                 .short("-c")
                 .long("--changelog"),
         )
         .arg(
             Arg::with_name("manifest")
                 .help("open manifest")
                 .short("-m")
                 .long("--manifest"),
         )
         .group(
             ArgGroup::with_name("")
                 .args(&["changelog", "manifest"])
                 .required(true),
         )
         .arg(
             Arg::with_name("rev")
                 .help("revision")
                 .required(true)
                 .value_name("REV"),
         )
         .about(HELP_TEXT)
 }
 
 #[timed]
 pub fn run(
     ui: &Ui,
     config: &Config,
+    repo_path: Option<&Path>,
     args: &ArgMatches,
 ) -> Result<(), CommandError> {
     let rev = args
         .value_of("rev")
         .expect("rev should be a required argument");
     let kind =
         match (args.is_present("changelog"), args.is_present("manifest")) {
             (true, false) => DebugDataKind::Changelog,
             (false, true) => DebugDataKind::Manifest,
             (true, true) => {
                 unreachable!("Should not happen since options are exclusive")
             }
             (false, false) => {
                 unreachable!("Should not happen since options are required")
             }
         };
 
-    let repo = Repo::find(config)?;
+    let repo = Repo::find(config, repo_path)?;
     let data = debug_data(&repo, rev, kind).map_err(|e| (e, rev))?;
 
     let mut stdout = ui.stdout_buffer();
     stdout.write_all(&data)?;
     stdout.flush()?;
 
     Ok(())
 }

rust/rhg/src/commands/debugrequirements.rs

@@ -1,30 +1,32 b''
 use crate::error::CommandError;
 use crate::ui::Ui;
 use clap::ArgMatches;
 use hg::config::Config;
 use hg::repo::Repo;
+use std::path::Path;
 
 pub const HELP_TEXT: &str = "
 Print the current repo requirements.
 ";
 
 pub fn args() -> clap::App<'static, 'static> {
     clap::SubCommand::with_name("debugrequirements").about(HELP_TEXT)
 }
 
 pub fn run(
     ui: &Ui,
     config: &Config,
+    repo_path: Option<&Path>,
     _args: &ArgMatches,
 ) -> Result<(), CommandError> {
-    let repo = Repo::find(config)?;
+    let repo = Repo::find(config, repo_path)?;
     let mut output = String::new();
     let mut requirements: Vec<_> = repo.requirements().iter().collect();
     requirements.sort();
     for req in requirements {
         output.push_str(req);
         output.push('\n');
     }
     ui.write_stdout(output.as_bytes())?;
     Ok(())
 }

rust/rhg/src/commands/files.rs

@@ -1,69 +1,70 b''
 use crate::error::CommandError;
 use crate::ui::Ui;
 use clap::Arg;
 use clap::ArgMatches;
 use hg::config::Config;
 use hg::operations::list_rev_tracked_files;
 use hg::operations::Dirstate;
 use hg::repo::Repo;
 use hg::utils::files::{get_bytes_from_path, relativize_path};
 use hg::utils::hg_path::{HgPath, HgPathBuf};
+use std::path::Path;
 
 pub const HELP_TEXT: &str = "
 List tracked files.
 
 Returns 0 on success.
 ";
 
 pub fn args() -> clap::App<'static, 'static> {
     clap::SubCommand::with_name("files")
         .arg(
             Arg::with_name("rev")
                 .help("search the repository as it is in REV")
                 .short("-r")
                 .long("--revision")
                 .value_name("REV")
                 .takes_value(true),
         )
         .about(HELP_TEXT)
 }
 
 pub fn run(
     ui: &Ui,
     config: &Config,
+    repo_path: Option<&Path>,
     args: &ArgMatches,
 ) -> Result<(), CommandError> {
     let rev = args.value_of("rev");
 
-    let repo = Repo::find(config)?;
+    let repo = Repo::find(config, repo_path)?;
     if let Some(rev) = rev {
         let files =
             list_rev_tracked_files(&repo, rev).map_err(|e| (e, rev))?;
         display_files(ui, &repo, files.iter())
     } else {
         let distate = Dirstate::new(&repo)?;
         let files = distate.tracked_files()?;
         display_files(ui, &repo, files)
     }
 }
 
 fn display_files<'a>(
     ui: &Ui,
     repo: &Repo,
     files: impl IntoIterator<Item = &'a HgPath>,
 ) -> Result<(), CommandError> {
-    let cwd = hg::utils::current_dir()?;
-    let rooted_cwd = cwd
-        .strip_prefix(repo.working_directory_path())
-        .expect("cwd was already checked within the repository");
-    let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));
+    let cwd = HgPathBuf::from(get_bytes_from_path(hg::utils::current_dir()?));
+    let working_directory =
+        HgPathBuf::from(get_bytes_from_path(repo.working_directory_path()));
 
     let mut stdout = ui.stdout_buffer();
 
     for file in files {
-        stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?;
+        let file = working_directory.join(file);
+        stdout.write_all(relativize_path(&file, &cwd).as_ref())?;
         stdout.write_all(b"\n")?;
     }
     stdout.flush()?;
     Ok(())
 }

rust/rhg/src/commands/root.rs

@@ -1,28 +1,30 b''
 use crate::error::CommandError;
 use crate::ui::Ui;
 use clap::ArgMatches;
 use format_bytes::format_bytes;
 use hg::config::Config;
 use hg::repo::Repo;
 use hg::utils::files::get_bytes_from_path;
+use std::path::Path;
 
 pub const HELP_TEXT: &str = "
 Print the root directory of the current repository.
 
 Returns 0 on success.
 ";
 
 pub fn args() -> clap::App<'static, 'static> {
     clap::SubCommand::with_name("root").about(HELP_TEXT)
 }
 
 pub fn run(
     ui: &Ui,
     config: &Config,
+    repo_path: Option<&Path>,
     _args: &ArgMatches,
 ) -> Result<(), CommandError> {
-    let repo = Repo::find(config)?;
+    let repo = Repo::find(config, repo_path)?;
     let bytes = get_bytes_from_path(repo.working_directory_path());
     ui.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?;
     Ok(())
 }

rust/rhg/src/error.rs

@@ -1,115 +1,115 b''
 use crate::ui::utf8_to_local;
 use crate::ui::UiError;
 use format_bytes::format_bytes;
 use hg::config::{ConfigError, ConfigParseError};
 use hg::errors::HgError;
 use hg::repo::RepoError;
 use hg::revlog::revlog::RevlogError;
 use hg::utils::files::get_bytes_from_path;
 use std::convert::From;
 
 /// The kind of command error
 #[derive(Debug)]
 pub enum CommandError {
     /// Exit with an error message and "standard" failure exit code.
     Abort { message: Vec<u8> },
 
     /// A mercurial capability as not been implemented.
     ///
     /// There is no error message printed in this case.
     /// Instead, we exit with a specic status code and a wrapper script may
     /// fallback to Python-based Mercurial.
     Unimplemented,
 }
 
 impl CommandError {
     pub fn abort(message: impl AsRef<str>) -> Self {
         CommandError::Abort {
             // TODO: bytes-based (instead of Unicode-based) formatting
             // of error messages to handle non-UTF-8 filenames etc:
             // https://www.mercurial-scm.org/wiki/EncodingStrategy#Mixing_output
             message: utf8_to_local(message.as_ref()).into(),
         }
     }
 }
 
 impl From<HgError> for CommandError {
     fn from(error: HgError) -> Self {
         match error {
             HgError::UnsupportedFeature(_) => CommandError::Unimplemented,
             _ => CommandError::abort(error.to_string()),
         }
     }
 }
 
 impl From<UiError> for CommandError {
     fn from(_error: UiError) -> Self {
         // If we already failed writing to stdout or stderr,
         // writing an error message to stderr about it would be likely to fail
         // too.
         CommandError::abort("")
     }
 }
 
 impl From<RepoError> for CommandError {
     fn from(error: RepoError) -> Self {
         match error {
-            RepoError::NotFound { current_directory } => CommandError::Abort {
+            RepoError::NotFound { at } => CommandError::Abort {
                 message: format_bytes!(
                     b"no repository found in '{}' (.hg not found)!",
-                    get_bytes_from_path(current_directory)
+                    get_bytes_from_path(at)
                 ),
             },
             RepoError::ConfigParseError(error) => error.into(),
             RepoError::Other(error) => error.into(),
         }
     }
 }
 
 impl From<ConfigError> for CommandError {
     fn from(error: ConfigError) -> Self {
         match error {
             ConfigError::Parse(error) => error.into(),
             ConfigError::Other(error) => error.into(),
         }
     }
 }
 
 impl From<ConfigParseError> for CommandError {
     fn from(error: ConfigParseError) -> Self {
         let ConfigParseError {
             origin,
             line,
             bytes,
         } = error;
         let line_message = if let Some(line_number) = line {
             format_bytes!(b" at line {}", line_number.to_string().into_bytes())
         } else {
             Vec::new()
         };
         CommandError::Abort {
             message: format_bytes!(
                 b"config parse error in {}{}: '{}'",
                 origin,
                 line_message,
                 bytes
             ),
         }
     }
 }
 
 impl From<(RevlogError, &str)> for CommandError {
     fn from((err, rev): (RevlogError, &str)) -> CommandError {
         match err {
             RevlogError::InvalidRevision => CommandError::abort(format!(
                 "invalid revision identifier {}",
                 rev
             )),
             RevlogError::AmbiguousPrefix => CommandError::abort(format!(
                 "ambiguous revision identifier {}",
                 rev
             )),
             RevlogError::Other(error) => error.into(),
         }
     }
 }

rust/rhg/src/main.rs

@@ -1,94 +1,116 b''
 extern crate log;
 use clap::App;
 use clap::AppSettings;
+use clap::Arg;
 use clap::ArgMatches;
 use format_bytes::format_bytes;
+use std::path::Path;
 
 mod error;
 mod exitcode;
 mod ui;
 use error::CommandError;
 
+fn add_global_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
+    app.arg(
+        Arg::with_name("repository")
+            .help("repository root directory")
+            .short("-R")
+            .long("--repository")
+            .value_name("REPO")
+            .takes_value(true),
+    )
+}
+
 fn main() {
     env_logger::init();
     let app = App::new("rhg")
         .setting(AppSettings::AllowInvalidUtf8)
         .setting(AppSettings::SubcommandRequired)
         .setting(AppSettings::VersionlessSubcommands)
         .version("0.0.1");
+    let app = add_global_args(app);
     let app = add_subcommand_args(app);
 
     let ui = ui::Ui::new();
 
     let matches = app.clone().get_matches_safe().unwrap_or_else(|err| {
         let _ = ui.writeln_stderr_str(&err.message);
         std::process::exit(exitcode::UNIMPLEMENTED)
     });
+
     let (subcommand_name, subcommand_matches) = matches.subcommand();
     let run = subcommand_run_fn(subcommand_name)
         .expect("unknown subcommand name from clap despite AppSettings::SubcommandRequired");
     let args = subcommand_matches
         .expect("no subcommand arguments from clap despite AppSettings::SubcommandRequired");
 
+    // Global arguments can be in either based on e.g. `hg -R ./foo log` v.s.
+    // `hg log -R ./foo`
+    let global_arg =
+        |name| args.value_of_os(name).or_else(|| matches.value_of_os(name));
+
+    let repo_path = global_arg("repository").map(Path::new);
     let result = (|| -> Result<(), CommandError> {
         let config = hg::config::Config::load()?;
-        run(&ui, &config, args)
+        run(&ui, &config, repo_path, args)
     })();
 
     let exit_code = match result {
         Ok(_) => exitcode::OK,
 
         // Exit with a specific code and no error message to let a potential
         // wrapper script fallback to Python-based Mercurial.
         Err(CommandError::Unimplemented) => exitcode::UNIMPLEMENTED,
 
         Err(CommandError::Abort { message }) => {
             if !message.is_empty() {
                 // Ignore errors when writing to stderr, we’re already exiting
                 // with failure code so there’s not much more we can do.
                 let _ =
                     ui.write_stderr(&format_bytes!(b"abort: {}\n", message));
             }
             exitcode::ABORT
         }
     };
     std::process::exit(exit_code)
 }
 
 macro_rules! subcommands {
     ($( $command: ident )+) => {
         mod commands {
             $(
                 pub mod $command;
             )+
         }
 
         fn add_subcommand_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
             app
             $(
-                .subcommand(commands::$command::args())
+                .subcommand(add_global_args(commands::$command::args()))
             )+
         }
 
         fn subcommand_run_fn(name: &str) -> Option<fn(
             &ui::Ui,
             &hg::config::Config,
+            Option<&Path>,
             &ArgMatches,
         ) -> Result<(), CommandError>> {
             match name {
                 $(
                     stringify!($command) => Some(commands::$command::run),
                 )+
                 _ => None,
             }
         }
     };
 }
 
 subcommands! {
     cat
     debugdata
     debugrequirements
     files
     root
 }

tests/test-rhg.t

@@ -1,262 +1,257 b''
 #require rust
 
 Define an rhg function that will only run if rhg exists
   $ rhg() {
   > if [ -f "$RUNTESTDIR/../rust/target/release/rhg" ]; then
   >   "$RUNTESTDIR/../rust/target/release/rhg" "$@"
   > else
   >   echo "skipped: Cannot find rhg. Try to run cargo build in rust/rhg."
   >   exit 80
   > fi
   > }
 
 Unimplemented command
   $ rhg unimplemented-command
   error: Found argument 'unimplemented-command' which wasn't expected, or isn't valid in this context
   
   USAGE:
-      rhg <SUBCOMMAND>
+      rhg [OPTIONS] <SUBCOMMAND>
   
   For more information try --help
   [252]
 
 Finding root
   $ rhg root
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
 
   $ hg init repository
   $ cd repository
   $ rhg root
   $TESTTMP/repository
 
 Unwritable file descriptor
   $ rhg root > /dev/full
   abort: No space left on device (os error 28)
   [255]
 
 Deleted repository
   $ rm -rf `pwd`
   $ rhg root
   abort: $ENOENT$: current directory
   [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
   $ rhg files
   file1
   file2
   file3
 
 Listing tracked files from subdirectory
   $ mkdir -p path/to/directory
   $ cd path/to/directory
   $ rhg files
   ../../../file1
   ../../../file2
   ../../../file3
 
 Listing tracked files through broken pipe
   $ 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
   $ rhg debugdata -c 2
   8d0267cb034247ebfa5ee58ce59e22e57a492297
   test
   0 0
   file-3
   
   Commit 3 (no-eol)
   $ rhg debugdata -m 2
   file-1\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   file-2\x005d9299349fc01ddd25d0070d149b124d8f10411e (esc)
   file-3\x002661d26c649684b482d10f91960cc3db683c38b4 (esc)
 
 Debuging with full node id
   $ 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
   $ rhg files -r cf8b83
   file-1
   file-2
   file-3
   $ rhg cat -r cf8b83 file-2
   2
   $ rhg cat -r c file-2
   abort: ambiguous revision identifier c
   [255]
   $ rhg cat -r d file-2
   2
 
 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
   $ 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"
   $ rhg cat -r 1 copy_of_original
   original content
 
 Requirements
   $ rhg debugrequirements
   dotencode
   fncache
   generaldelta
   revlogv1
   sparserevlog
   store
 
   $ echo indoor-pool >> .hg/requires
   $ rhg files
   [252]
 
   $ rhg cat -r 1 copy_of_original
   [252]
 
   $ rhg debugrequirements
   [252]
 
   $ echo -e '\xFF' >> .hg/requires
   $ rhg debugrequirements
   abort: corrupted repository: parse error in 'requires' file
   [255]
 
 Persistent nodemap
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg init repository
   $ cd repository
   $ 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
   $ rhg files -r c3ae8dec9fad
   of
 
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg --config format.use-persistent-nodemap=True init repository
   $ cd repository
   $ 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
   $ rhg files -r c3ae8dec9fad
   of
   $ rhg cat -r c3ae8dec9fad of
   r5000
 
 Crate a shared repository
 
   $ echo "[extensions]"      >> $HGRCPATH
   $ echo "share = "          >> $HGRCPATH
 
   $ cd $TESTTMP
   $ hg init repo1
-  $ cd repo1
-  $ echo a > a
-  $ hg commit -A -m'init'
+  $ echo a > repo1/a
+  $ hg -R repo1 commit -A -m'init'
   adding a
 
-  $ cd ..
   $ 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
 
-  $ cd repo2
-  $ rhg files
-  a
-  $ rhg cat -r 0 a
+  $ rhg files -R repo2
+  repo2/a
+  $ rhg -R repo2 cat -r 0 repo2/a
   a
 
 Same with relative sharing
 
-  $ cd ..
   $ hg share repo2 repo3 --relative
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
-  $ cd repo3
-  $ rhg files
-  a
-  $ rhg cat -r 0 a
+  $ rhg files -R repo3
+  repo3/a
+  $ 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
   $ rhg files
   a
   $ rhg cat -r 0 a
   a