requirements: move loading to hg-core and add parsing

No functional change, checking comes later.

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

rust/hg-core/src/requirements.rs

@@ -0,0 +1,53 b''
+use std::io;
+use std::path::Path;
+
+#[derive(Debug)]
+pub enum RequirementsError {
+    // TODO: include a path?
+    Io(io::Error),
+    /// The `requires` file is corrupted
+    Corrupted,
+    /// The repository requires a feature that we don�t support
+    Unsupported {
+        feature: String,
+    },
+}
+
+fn parse(bytes: &[u8]) -> Result<Vec<String>, ()> {
+    // The Python code reading this file uses `str.splitlines`
+    // which looks for a number of line separators (even including a couple of
+    // non-ASCII ones), but Python code writing it always uses `\n`.
+    let lines = bytes.split(|&byte| byte == b'\n');
+
+    lines
+        .filter(|line| !line.is_empty())
+        .map(|line| {
+            // Python uses Unicode `str.isalnum` but feature names are all
+            // ASCII
+            if line[0].is_ascii_alphanumeric() {
+                Ok(String::from_utf8(line.into()).unwrap())
+            } else {
+                Err(())
+            }
+        })
+        .collect()
+}
+
+pub fn load(repo_root: &Path) -> Result<Vec<String>, RequirementsError> {
+    match std::fs::read(repo_root.join(".hg").join("requires")) {
+        Ok(bytes) => parse(&bytes).map_err(|()| RequirementsError::Corrupted),
+
+        // 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 => {
+            Ok(Vec::new())
+        }
+
+        Err(error) => Err(RequirementsError::Io(error))?,
+    }
+}

rust/hg-core/src/lib.rs

@@ -1,192 +1,193 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 requirements;
 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/debugrequirements.rs

@@ -1,40 +1,30 b''
 use crate::commands::Command;
-use crate::error::{CommandError, CommandErrorKind};
+use crate::error::CommandError;
 use crate::ui::Ui;
 use hg::operations::FindRoot;
+use hg::requirements;
 
 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)?;
+        let mut output = String::new();
+        for req in requirements::load(&root)? {
+            output.push_str(&req);
+            output.push('\n');
+        }
+        ui.write_stdout(output.as_bytes())?;
         Ok(())
     }
 }

rust/rhg/src/error.rs

@@ -1,117 +1,130 b''
 use crate::exitcode;
 use crate::ui::UiError;
 use hg::operations::{FindRootError, FindRootErrorKind};
+use hg::requirements::RequirementsError;
 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),
+    /// `.hg/requires`
+    RequirementsError(RequirementsError),
     /// 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::RequirementsError(_) => 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::RequirementsError(
+                RequirementsError::Corrupted,
+            ) => Some(
+                "abort: .hg/requires is corrupted\n".as_bytes().to_owned(),
+            ),
             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),
             },
         }
     }
 }
+
+impl From<RequirementsError> for CommandError {
+    fn from(err: RequirementsError) -> Self {
+        CommandError {
+            kind: CommandErrorKind::RequirementsError(err),
+        }
+    }
+}