This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9398

requirements: move loading to hg-core and add parsing
ClosedPublic

Authored by SimonSapin on Nov 25 2020, 7:41 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGa2eda1ff22aa: requirements: move loading to hg-core and add parsing
Summary

No functional change, checking comes later.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.Nov 25 2020, 7:41 AM
pulkit accepted this revision.Nov 26 2020, 7:28 AM
This revision is now accepted and ready to land.Nov 26 2020, 7:28 AM
SimonSapin added a commit: rHGa2eda1ff22aa: requirements: move loading to hg-core and add parsing.Nov 26 2020, 8:15 AM
Closed by commit rHGa2eda1ff22aa: requirements: move loading to hg-core and add parsing (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.
martinvonz added a subscriber: martinvonz.Nov 30 2020, 12:27 PM
martinvonz added inline comments.
rust/hg-core/src/requirements.rs
10

i assume you meant "don't" :)

SimonSapin added a comment.Nov 30 2020, 12:35 PM

@martinvonz yes. The patch I submitted had don’t. I’m not sure what happened next. See https://phab.mercurial-scm.org/D9444#142315

Revision Contents
Changeset List

Diff 23692

rust/hg-core/src/lib.rs

// Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net> // Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net>
// and Mercurial contributors // and Mercurial contributors
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
mod ancestors; mod ancestors;
pub mod dagops; pub mod dagops;
pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors}; pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors};
mod dirstate; mod dirstate;
pub mod discovery; pub mod discovery;
pub mod requirements;
pub mod testing; // unconditionally built, for use from integration tests pub mod testing; // unconditionally built, for use from integration tests
pub use dirstate::{ pub use dirstate::{
dirs_multiset::{DirsMultiset, DirsMultisetIter}, dirs_multiset::{DirsMultiset, DirsMultisetIter},
dirstate_map::DirstateMap, dirstate_map::DirstateMap,
parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE}, parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE},
status::{ status::{
status, BadMatch, BadType, DirstateStatus, StatusError, StatusOptions, status, BadMatch, BadType, DirstateStatus, StatusError, StatusOptions,
}, },

rust/hg-core/src/requirements.rs

  • This file was added.
  • This file uses an unknown character encoding.
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稚 support
martinvonzUnsubmitted
Not Done

i assume you meant "don't" :)

martinvonz: i assume you meant "don't" :)
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/rhg/src/commands/debugrequirements.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::FindRoot; use hg::operations::FindRoot;
use hg::requirements;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the current repo requirements. Print the current repo requirements.
"; ";
pub struct DebugRequirementsCommand {} pub struct DebugRequirementsCommand {}
impl DebugRequirementsCommand { impl DebugRequirementsCommand {
pub fn new() -> Self { pub fn new() -> Self {
DebugRequirementsCommand {} DebugRequirementsCommand {}
} }
} }
impl Command for DebugRequirementsCommand { impl Command for DebugRequirementsCommand {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let root = FindRoot::new().run()?; let root = FindRoot::new().run()?;
let requires = root.join(".hg").join("requires"); let mut output = String::new();
let requirements = match std::fs::read(requires) { for req in requirements::load(&root)? {
Ok(bytes) => bytes, output.push_str(&req);
output.push('\n');
// Treat a missing file the same as an empty file. }
// From `mercurial/localrepo.py`: ui.write_stdout(output.as_bytes())?;
// > 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(()) Ok(())
} }
} }

rust/rhg/src/error.rs

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