( )⚙ D9398 requirements: move loading to hg-core and add parsing

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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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
11

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 23670

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.
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 {
martinvonzUnsubmitted
Not Done

i assume you meant "don't" :)

martinvonz: i assume you meant "don't" :)
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),
}
}
}