rhg: add a `debugrequirements` subcommand

For now it only prints the contents of `.hg/requires` as-is, without parsing.

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

rust/rhg/src/commands/debugrequirements.rs

@@ -0,0 +1,40 b''
+use crate::commands::Command;
+use crate::error::{CommandError, CommandErrorKind};
+use crate::ui::Ui;
+use hg::operations::FindRoot;
+
+pub const HELP_TEXT: &str = "
+Print the current repo requirements.
+";
+
+pub struct DebugRequirementsCommand {}
+
+impl DebugRequirementsCommand {
+    pub fn new() -> Self {
+        DebugRequirementsCommand {}
+    }
+}
+
+impl Command for DebugRequirementsCommand {
+    fn run(&self, ui: &Ui) -> Result<(), CommandError> {
+        let root = FindRoot::new().run()?;
+        let requires = root.join(".hg").join("requires");
+        let requirements = match std::fs::read(requires) {
+            Ok(bytes) => bytes,
+
+            // Treat a missing file the same as an empty file.
+            // From `mercurial/localrepo.py`:
+            // > requires file contains a newline-delimited list of
+            // > features/capabilities the opener (us) must have in order to use
+            // > the repository. This file was introduced in Mercurial 0.9.2,
+            // > which means very old repositories may not have one. We assume
+            // > a missing file translates to no requirements.
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => Vec::new(),
+
+            Err(error) => Err(CommandErrorKind::FileError(error))?,
+        };
+
+        ui.write_stdout(&requirements)?;
+        Ok(())
+    }
+}

rust/rhg/src/commands.rs

@@ -1,13 +1,14 b''
 pub mod cat;
 pub mod debugdata;
+pub mod debugrequirements;
 pub mod files;
 pub mod root;
 use crate::error::CommandError;
 use crate::ui::Ui;
 
 /// The common trait for rhg commands
 ///
 /// Normalize the interface of the commands provided by rhg
 pub trait Command {
     fn run(&self, ui: &Ui) -> Result<(), CommandError>;
 }

rust/rhg/src/error.rs

@@ -1,113 +1,117 b''
 use crate::exitcode;
 use crate::ui::UiError;
 use hg::operations::{FindRootError, FindRootErrorKind};
 use hg::utils::files::get_bytes_from_path;
 use std::convert::From;
 use std::path::PathBuf;
 
 /// The kind of command error
 #[derive(Debug)]
 pub enum CommandErrorKind {
     /// The root of the repository cannot be found
     RootNotFound(PathBuf),
     /// The current directory cannot be found
     CurrentDirNotFound(std::io::Error),
+    /// Error while reading or writing a file
+    // TODO: add the file name/path?
+    FileError(std::io::Error),
     /// The standard output stream cannot be written to
     StdoutError,
     /// The standard error stream cannot be written to
     StderrError,
     /// The command aborted
     Abort(Option<Vec<u8>>),
     /// A mercurial capability as not been implemented.
     Unimplemented,
 }
 
 impl CommandErrorKind {
     pub fn get_exit_code(&self) -> exitcode::ExitCode {
         match self {
             CommandErrorKind::RootNotFound(_) => exitcode::ABORT,
             CommandErrorKind::CurrentDirNotFound(_) => exitcode::ABORT,
+            CommandErrorKind::FileError(_) => exitcode::ABORT,
             CommandErrorKind::StdoutError => exitcode::ABORT,
             CommandErrorKind::StderrError => exitcode::ABORT,
             CommandErrorKind::Abort(_) => exitcode::ABORT,
             CommandErrorKind::Unimplemented => exitcode::UNIMPLEMENTED_COMMAND,
         }
     }
 
     /// Return the message corresponding to the error kind if any
     pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
         match self {
             // TODO use formating macro
             CommandErrorKind::RootNotFound(path) => {
                 let bytes = get_bytes_from_path(path);
                 Some(
                     [
                         b"abort: no repository found in '",
                         bytes.as_slice(),
                         b"' (.hg not found)!\n",
                     ]
                     .concat(),
                 )
             }
             // TODO use formating macro
             CommandErrorKind::CurrentDirNotFound(e) => Some(
                 [
                     b"abort: error getting current working directory: ",
                     e.to_string().as_bytes(),
                     b"\n",
                 ]
                 .concat(),
             ),
             CommandErrorKind::Abort(message) => message.to_owned(),
             _ => None,
         }
     }
 }
 
 /// The error type for the Command trait
 #[derive(Debug)]
 pub struct CommandError {
     pub kind: CommandErrorKind,
 }
 
 impl CommandError {
     /// Exist the process with the corresponding exit code.
     pub fn exit(&self) {
         std::process::exit(self.kind.get_exit_code())
     }
 
     /// Return the message corresponding to the command error if any
     pub fn get_error_message_bytes(&self) -> Option<Vec<u8>> {
         self.kind.get_error_message_bytes()
     }
 }
 
 impl From<CommandErrorKind> for CommandError {
     fn from(kind: CommandErrorKind) -> Self {
         CommandError { kind }
     }
 }
 
 impl From<UiError> for CommandError {
     fn from(error: UiError) -> Self {
         CommandError {
             kind: match error {
                 UiError::StdoutError(_) => CommandErrorKind::StdoutError,
                 UiError::StderrError(_) => CommandErrorKind::StderrError,
             },
         }
     }
 }
 
 impl From<FindRootError> for CommandError {
     fn from(err: FindRootError) -> Self {
         match err.kind {
             FindRootErrorKind::RootNotFound(path) => CommandError {
                 kind: CommandErrorKind::RootNotFound(path),
             },
             FindRootErrorKind::GetCurrentDirError(e) => CommandError {
                 kind: CommandErrorKind::CurrentDirNotFound(e),
             },
         }
     }
 }

rust/rhg/src/main.rs

@@ -1,177 +1,185 b''
 extern crate log;
 use clap::App;
 use clap::AppSettings;
 use clap::Arg;
 use clap::ArgGroup;
 use clap::ArgMatches;
 use clap::SubCommand;
 use hg::operations::DebugDataKind;
 use std::convert::TryFrom;
 
 mod commands;
 mod error;
 mod exitcode;
 mod ui;
 use commands::Command;
 use error::CommandError;
 
 fn main() {
     env_logger::init();
     let app = App::new("rhg")
         .setting(AppSettings::AllowInvalidUtf8)
         .setting(AppSettings::SubcommandRequired)
         .setting(AppSettings::VersionlessSubcommands)
         .version("0.0.1")
         .subcommand(
             SubCommand::with_name("root").about(commands::root::HELP_TEXT),
         )
         .subcommand(
             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(commands::files::HELP_TEXT),
         )
         .subcommand(
             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(commands::cat::HELP_TEXT),
         )
         .subcommand(
             SubCommand::with_name("debugdata")
                 .about(commands::debugdata::HELP_TEXT)
                 .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"),
                 ),
+        )
+        .subcommand(
+            SubCommand::with_name("debugrequirements")
+                .about(commands::debugrequirements::HELP_TEXT),
         );
 
     let matches = app.clone().get_matches_safe().unwrap_or_else(|err| {
         let _ = ui::Ui::new().writeln_stderr_str(&err.message);
         std::process::exit(exitcode::UNIMPLEMENTED_COMMAND)
     });
 
     let ui = ui::Ui::new();
 
     let command_result = match_subcommand(matches, &ui);
 
     match command_result {
         Ok(_) => std::process::exit(exitcode::OK),
         Err(e) => {
             let message = e.get_error_message_bytes();
             if let Some(msg) = message {
                 match ui.write_stderr(&msg) {
                     Ok(_) => (),
                     Err(_) => std::process::exit(exitcode::ABORT),
                 };
             };
             e.exit()
         }
     }
 }
 
 fn match_subcommand(
     matches: ArgMatches,
     ui: &ui::Ui,
 ) -> Result<(), CommandError> {
     match matches.subcommand() {
         ("root", _) => commands::root::RootCommand::new().run(&ui),
         ("files", Some(matches)) => {
             commands::files::FilesCommand::try_from(matches)?.run(&ui)
         }
         ("cat", Some(matches)) => {
             commands::cat::CatCommand::try_from(matches)?.run(&ui)
         }
         ("debugdata", Some(matches)) => {
             commands::debugdata::DebugDataCommand::try_from(matches)?.run(&ui)
         }
+        ("debugrequirements", _) => {
+            commands::debugrequirements::DebugRequirementsCommand::new()
+                .run(&ui)
+        }
         _ => unreachable!(), // Because of AppSettings::SubcommandRequired,
     }
 }
 
 impl<'a> TryFrom<&'a ArgMatches<'_>> for commands::files::FilesCommand<'a> {
     type Error = CommandError;
 
     fn try_from(args: &'a ArgMatches) -> Result<Self, Self::Error> {
         let rev = args.value_of("rev");
         Ok(commands::files::FilesCommand::new(rev))
     }
 }
 
 impl<'a> TryFrom<&'a ArgMatches<'_>> for commands::cat::CatCommand<'a> {
     type Error = CommandError;
 
     fn try_from(args: &'a ArgMatches) -> Result<Self, Self::Error> {
         let rev = args.value_of("rev");
         let files = match args.values_of("files") {
             Some(files) => files.collect(),
             None => vec![],
         };
         Ok(commands::cat::CatCommand::new(rev, files))
     }
 }
 
 impl<'a> TryFrom<&'a ArgMatches<'_>>
     for commands::debugdata::DebugDataCommand<'a>
 {
     type Error = CommandError;
 
     fn try_from(args: &'a ArgMatches) -> Result<Self, Self::Error> {
         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")
             }
         };
         Ok(commands::debugdata::DebugDataCommand::new(rev, kind))
     }
 }

tests/test-rhg.t

@@ -1,117 +1,126 b''
 #require rust
 
 Define an rhg function that will only run if rhg exists
   $ rhg() {
   > if [ -f "$RUNTESTDIR/../rust/target/debug/rhg" ]; then
   >   "$RUNTESTDIR/../rust/target/debug/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>
   
   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: 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
   $ 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; do
   >   echo $i >> file$i
   >   hg add file$i
   >   hg commit -m "commit $i" -q
   > done
   $ rhg debugdata -c 2
   e36fa63d37a576b27a69057598351db6ee5746bd
   test
   0 0
   file3
   
   commit 3 (no-eol)
   $ rhg debugdata -m 2
   file1\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   file2\x005d9299349fc01ddd25d0070d149b124d8f10411e (esc)
   file3\x002661d26c649684b482d10f91960cc3db683c38b4 (esc)
 
 Debuging with full node id
   $ rhg debugdata -c `hg log -r 0 -T '{node}'`
   c8e64718e1ca0312eeee0f59d37f8dc612793856
   test
   0 0
   file1
   
   commit 1 (no-eol)
 
 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