rhg: add a `Files` `Command` to prepare the `rhg files` subcommand

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

rust/rhg/src/commands/files.rs

@@ -0,0 +1,50 b''
+use crate::commands::Command;
+use crate::error::{CommandError, CommandErrorKind};
+use crate::ui::Ui;
+use hg::operations::{ListTrackedFiles, ListTrackedFilesErrorKind};
+
+pub const HELP_TEXT: &str = "
+List tracked files.
+
+Returns 0 on success.
+";
+
+pub struct FilesCommand<'a> {
+    ui: &'a Ui,
+}
+
+impl<'a> FilesCommand<'a> {
+    pub fn new(ui: &'a Ui) -> Self {
+        FilesCommand { ui }
+    }
+}
+
+impl<'a> Command<'a> for FilesCommand<'a> {
+    fn run(&self) -> Result<(), CommandError> {
+        let operation_builder = ListTrackedFiles::new()?;
+        let operation = operation_builder.load().map_err(|err| {
+            CommandErrorKind::Abort(Some(
+                [b"abort: ", err.to_string().as_bytes(), b"\n"]
+                    .concat()
+                    .to_vec(),
+            ))
+        })?;
+        let files = operation.run().map_err(|err| match err.kind {
+            ListTrackedFilesErrorKind::ParseError(_) => {
+                CommandErrorKind::Abort(Some(
+                    // TODO find a better error message
+                    b"abort: parse error\n".to_vec(),
+                ))
+            }
+        })?;
+
+        let mut stdout = self.ui.stdout_buffer();
+        for file in files {
+            stdout.write_all(file.as_bytes())?;
+            stdout.write_all(b"\n")?;
+        }
+        stdout.flush()?;
+
+        Ok(())
+    }
+}

rust/hg-core/src/lib.rs

@@ -1,191 +1,192 b''
 // Copyright 2018-2020 Georges Racinet <[e-mail]>
 //           and Mercurial contributors
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 mod ancestors;
 pub mod dagops;
 pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors};
 mod dirstate;
 pub mod discovery;
 pub mod testing; // unconditionally built, for use from integration tests
 pub use dirstate::{
     dirs_multiset::{DirsMultiset, DirsMultisetIter},
     dirstate_map::DirstateMap,
     parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE},
     status::{
         status, BadMatch, BadType, DirstateStatus, StatusError, StatusOptions,
     },
     CopyMap, CopyMapIter, DirstateEntry, DirstateParents, EntryState,
     StateMap, StateMapIter,
 };
 mod filepatterns;
 pub mod matchers;
 pub mod revlog;
 pub use revlog::*;
 pub mod operations;
 pub mod utils;
 
 // Remove this to see (potential) non-artificial compile failures. MacOS
 // *should* compile, but fail to compile tests for example as of 2020-03-06
 #[cfg(not(target_os = "linux"))]
 compile_error!(
     "`hg-core` has only been tested on Linux and will most \
      likely not behave correctly on other platforms."
 );
 
 use crate::utils::hg_path::{HgPathBuf, HgPathError};
 pub use filepatterns::{
     parse_pattern_syntax, read_pattern_file, IgnorePattern,
     PatternFileWarning, PatternSyntax,
 };
 use std::collections::HashMap;
 use twox_hash::RandomXxHashBuilder64;
 
 /// This is a contract between the `micro-timer` crate and us, to expose
 /// the `log` crate as `crate::log`.
 use log;
 
 pub type LineNumber = usize;
 
 /// Rust's default hasher is too slow because it tries to prevent collision
 /// attacks. We are not concerned about those: if an ill-minded person has
 /// write access to your repository, you have other issues.
 pub type FastHashMap<K, V> = HashMap<K, V, RandomXxHashBuilder64>;
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum DirstateParseError {
     TooLittleData,
     Overflow,
+    // TODO refactor to use bytes instead of String
     CorruptedEntry(String),
     Damaged,
 }
 
 impl From<std::io::Error> for DirstateParseError {
     fn from(e: std::io::Error) -> Self {
         DirstateParseError::CorruptedEntry(e.to_string())
     }
 }
 
 impl ToString for DirstateParseError {
     fn to_string(&self) -> String {
         use crate::DirstateParseError::*;
         match self {
             TooLittleData => "Too little data for dirstate.".to_string(),
             Overflow => "Overflow in dirstate.".to_string(),
             CorruptedEntry(e) => format!("Corrupted entry: {:?}.", e),
             Damaged => "Dirstate appears to be damaged.".to_string(),
         }
     }
 }
 
 #[derive(Debug, PartialEq)]
 pub enum DirstatePackError {
     CorruptedEntry(String),
     CorruptedParent,
     BadSize(usize, usize),
 }
 
 impl From<std::io::Error> for DirstatePackError {
     fn from(e: std::io::Error) -> Self {
         DirstatePackError::CorruptedEntry(e.to_string())
     }
 }
 #[derive(Debug, PartialEq)]
 pub enum DirstateMapError {
     PathNotFound(HgPathBuf),
     EmptyPath,
     InvalidPath(HgPathError),
 }
 
 impl ToString for DirstateMapError {
     fn to_string(&self) -> String {
         match self {
             DirstateMapError::PathNotFound(_) => {
                 "expected a value, found none".to_string()
             }
             DirstateMapError::EmptyPath => "Overflow in dirstate.".to_string(),
             DirstateMapError::InvalidPath(e) => e.to_string(),
         }
     }
 }
 
 #[derive(Debug)]
 pub enum DirstateError {
     Parse(DirstateParseError),
     Pack(DirstatePackError),
     Map(DirstateMapError),
     IO(std::io::Error),
 }
 
 impl From<DirstateParseError> for DirstateError {
     fn from(e: DirstateParseError) -> Self {
         DirstateError::Parse(e)
     }
 }
 
 impl From<DirstatePackError> for DirstateError {
     fn from(e: DirstatePackError) -> Self {
         DirstateError::Pack(e)
     }
 }
 
 #[derive(Debug)]
 pub enum PatternError {
     Path(HgPathError),
     UnsupportedSyntax(String),
     UnsupportedSyntaxInFile(String, String, usize),
     TooLong(usize),
     IO(std::io::Error),
     /// Needed a pattern that can be turned into a regex but got one that
     /// can't. This should only happen through programmer error.
     NonRegexPattern(IgnorePattern),
 }
 
 impl ToString for PatternError {
     fn to_string(&self) -> String {
         match self {
             PatternError::UnsupportedSyntax(syntax) => {
                 format!("Unsupported syntax {}", syntax)
             }
             PatternError::UnsupportedSyntaxInFile(syntax, file_path, line) => {
                 format!(
                     "{}:{}: unsupported syntax {}",
                     file_path, line, syntax
                 )
             }
             PatternError::TooLong(size) => {
                 format!("matcher pattern is too long ({} bytes)", size)
             }
             PatternError::IO(e) => e.to_string(),
             PatternError::Path(e) => e.to_string(),
             PatternError::NonRegexPattern(pattern) => {
                 format!("'{:?}' cannot be turned into a regex", pattern)
             }
         }
     }
 }
 
 impl From<DirstateMapError> for DirstateError {
     fn from(e: DirstateMapError) -> Self {
         DirstateError::Map(e)
     }
 }
 
 impl From<std::io::Error> for DirstateError {
     fn from(e: std::io::Error) -> Self {
         DirstateError::IO(e)
     }
 }
 
 impl From<std::io::Error> for PatternError {
     fn from(e: std::io::Error) -> Self {
         PatternError::IO(e)
     }
 }
 
 impl From<HgPathError> for PatternError {
     fn from(e: HgPathError) -> Self {
         PatternError::Path(e)
     }
 }

rust/rhg/src/commands.rs

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

rust/rhg/src/error.rs

@@ -1,106 +1,110 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),
     /// 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>>),
 }
 
 impl CommandErrorKind {
     pub fn get_exit_code(&self) -> exitcode::ExitCode {
         match self {
             CommandErrorKind::RootNotFound(_) => exitcode::ABORT,
             CommandErrorKind::CurrentDirNotFound(_) => exitcode::ABORT,
             CommandErrorKind::StdoutError => exitcode::ABORT,
             CommandErrorKind::StderrError => exitcode::ABORT,
+            CommandErrorKind::Abort(_) => exitcode::ABORT,
         }
     }
 
     /// 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),
             },
         }
     }
 }