This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9595

rust: replace most "operation" structs with functions
ClosedPublic

Authored by SimonSapin on Dec 14 2020, 11:27 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGdca9cb99971c: rust: replace most "operation" structs with functions
Summary

The hg-core crate has a partially-formed concept of "operation",
represented as structs with constructors and a run method.

Each struct’s contructor takes different parameters,
and each run has a different return type.
Constructors typically don’t do much more than store parameters
for run to access them.

There was a comment about adding an Operation trait
when the language supports expressing something so general,
but it’s hard to imagine how operations with such different APIs
could be used in a generic context.

This commit starts removing the concept of "operation",
since those are pretty much just functions.

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.

Revision Contents
Changeset List

Diff 24332

rust/hg-core/src/operations/cat.rs

// list_tracked_files.rs // list_tracked_files.rs
// //
// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net> // Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net>
// //
// 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.
use std::convert::From; use std::convert::From;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use crate::revlog::changelog::Changelog; use crate::revlog::changelog::Changelog;
use crate::revlog::manifest::{Manifest, ManifestEntry}; use crate::revlog::manifest::Manifest;
use crate::revlog::path_encode::path_encode; use crate::revlog::path_encode::path_encode;
use crate::revlog::revlog::Revlog; use crate::revlog::revlog::Revlog;
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::revlog::Node; use crate::revlog::Node;
use crate::revlog::NodePrefix; use crate::revlog::NodePrefix;
use crate::revlog::Revision; use crate::revlog::Revision;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
CatRevErrorKind::UnknowRevlogDataFormat(format) CatRevErrorKind::UnknowRevlogDataFormat(format)
} }
} }
.into() .into()
} }
} }
/// List files under Mercurial control at a given revision. /// List files under Mercurial control at a given revision.
pub struct CatRev<'a> {
root: &'a Path,
/// The revision to cat the files from.
rev: &'a str,
/// The files to output.
files: &'a [HgPathBuf],
/// The changelog file
changelog: Changelog,
/// The manifest file
manifest: Manifest,
/// The manifest entry corresponding to the revision.
/// ///
/// Used to hold the owner of the returned references. /// * `root`: Repository root
manifest_entry: Option<ManifestEntry>, /// * `rev`: The revision to cat the files from.
} /// * `files`: The files to output.
pub fn cat(
impl<'a> CatRev<'a> { root: &Path,
pub fn new( rev: &str,
root: &'a Path, files: &[HgPathBuf],
rev: &'a str, ) -> Result<Vec<u8>, CatRevError> {
files: &'a [HgPathBuf],
) -> Result<Self, CatRevError> {
let changelog = Changelog::open(&root)?; let changelog = Changelog::open(&root)?;
let manifest = Manifest::open(&root)?; let manifest = Manifest::open(&root)?;
let manifest_entry = None;
Ok(Self {
root,
rev,
files,
changelog,
manifest,
manifest_entry,
})
}
pub fn run(&mut self) -> Result<Vec<u8>, CatRevError> { let changelog_entry = match rev.parse::<Revision>() {
let changelog_entry = match self.rev.parse::<Revision>() { Ok(rev) => changelog.get_rev(rev)?,
Ok(rev) => self.changelog.get_rev(rev)?,
_ => { _ => {
let changelog_node = NodePrefix::from_hex(&self.rev) let changelog_node = NodePrefix::from_hex(&rev)
.map_err(|_| CatRevErrorKind::InvalidRevision)?; .map_err(|_| CatRevErrorKind::InvalidRevision)?;
self.changelog.get_node(changelog_node.borrow())? changelog.get_node(changelog_node.borrow())?
} }
}; };
let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?) let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
.map_err(|_| CatRevErrorKind::CorruptedRevlog)?; .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
self.manifest_entry = let manifest_entry = manifest.get_node((&manifest_node).into())?;
Some(self.manifest.get_node((&manifest_node).into())?);
if let Some(ref manifest_entry) = self.manifest_entry {
let mut bytes = vec![]; let mut bytes = vec![];
for (manifest_file, node_bytes) in for (manifest_file, node_bytes) in manifest_entry.files_with_nodes() {
manifest_entry.files_with_nodes() for cat_file in files.iter() {
{
for cat_file in self.files.iter() {
if cat_file.as_bytes() == manifest_file.as_bytes() { if cat_file.as_bytes() == manifest_file.as_bytes() {
let index_path = let index_path = store_path(root, manifest_file, b".i");
store_path(self.root, manifest_file, b".i"); let data_path = store_path(root, manifest_file, b".d");
let data_path =
store_path(self.root, manifest_file, b".d");
let file_log = let file_log = Revlog::open(&index_path, Some(&data_path))?;
Revlog::open(&index_path, Some(&data_path))?;
let file_node = Node::from_hex(node_bytes) let file_node = Node::from_hex(node_bytes)
.map_err(|_| CatRevErrorKind::CorruptedRevlog)?; .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
let file_rev = let file_rev = file_log.get_node_rev((&file_node).into())?;
file_log.get_node_rev((&file_node).into())?;
let data = file_log.get_rev_data(file_rev)?; let data = file_log.get_rev_data(file_rev)?;
if data.starts_with(&METADATA_DELIMITER) { if data.starts_with(&METADATA_DELIMITER) {
let end_delimiter_position = data let end_delimiter_position = data
[METADATA_DELIMITER.len()..] [METADATA_DELIMITER.len()..]
.windows(METADATA_DELIMITER.len()) .windows(METADATA_DELIMITER.len())
.position(|bytes| bytes == METADATA_DELIMITER); .position(|bytes| bytes == METADATA_DELIMITER);
if let Some(position) = end_delimiter_position { if let Some(position) = end_delimiter_position {
let offset = METADATA_DELIMITER.len() * 2; let offset = METADATA_DELIMITER.len() * 2;
bytes.extend(data[position + offset..].iter()); bytes.extend(data[position + offset..].iter());
} }
} else { } else {
bytes.extend(data); bytes.extend(data);
} }
} }
} }
} }
Ok(bytes) Ok(bytes)
} else {
unreachable!("manifest_entry should have been stored");
}
}
} }
fn store_path(root: &Path, hg_path: &HgPath, suffix: &[u8]) -> PathBuf { fn store_path(root: &Path, hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
let encoded_bytes = let encoded_bytes =
path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat()); path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
[ [
root, root,
&Path::new(".hg/store/"), &Path::new(".hg/store/"),
get_path_from_bytes(&encoded_bytes), get_path_from_bytes(&encoded_bytes),
] ]
.iter() .iter()
.collect() .collect()
} }

rust/hg-core/src/operations/debugdata.rs

// debugdata.rs // debugdata.rs
// //
// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net> // Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net>
// //
// 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.
use super::find_root; use std::path::Path;
use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefix; use crate::revlog::NodePrefix;
use crate::revlog::Revision; use crate::revlog::Revision;
/// Kind of data to debug /// Kind of data to debug
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub enum DebugDataKind { pub enum DebugDataKind {
Changelog, Changelog,
Manifest, Manifest,
} }
/// Kind of error encountered by DebugData /// Kind of error encountered by DebugData
#[derive(Debug)] #[derive(Debug)]
pub enum DebugDataErrorKind { pub enum DebugDataErrorKind {
FindRootError(find_root::FindRootError),
/// Error when reading a `revlog` file. /// Error when reading a `revlog` file.
IoError(std::io::Error), IoError(std::io::Error),
/// The revision has not been found. /// The revision has not been found.
InvalidRevision, InvalidRevision,
/// Found more than one revision whose ID match the requested prefix /// Found more than one revision whose ID match the requested prefix
AmbiguousPrefix, AmbiguousPrefix,
/// A `revlog` file is corrupted. /// A `revlog` file is corrupted.
CorruptedRevlog, CorruptedRevlog,
} }
impl From<DebugDataErrorKind> for DebugDataError { impl From<DebugDataErrorKind> for DebugDataError {
fn from(kind: DebugDataErrorKind) -> Self { fn from(kind: DebugDataErrorKind) -> Self {
DebugDataError { kind } DebugDataError { kind }
} }
} }
impl From<find_root::FindRootError> for DebugDataError {
fn from(err: find_root::FindRootError) -> Self {
let kind = DebugDataErrorKind::FindRootError(err);
DebugDataError { kind }
}
}
impl From<std::io::Error> for DebugDataError { impl From<std::io::Error> for DebugDataError {
fn from(err: std::io::Error) -> Self { fn from(err: std::io::Error) -> Self {
let kind = DebugDataErrorKind::IoError(err); let kind = DebugDataErrorKind::IoError(err);
DebugDataError { kind } DebugDataError { kind }
} }
} }
impl From<RevlogError> for DebugDataError { impl From<RevlogError> for DebugDataError {
DebugDataErrorKind::UnknowRevlogDataFormat(format) DebugDataErrorKind::UnknowRevlogDataFormat(format)
} }
} }
.into() .into()
} }
} }
/// Dump the contents data of a revision. /// Dump the contents data of a revision.
pub struct DebugData<'a> { pub fn debug_data(
/// Revision or hash of the revision. root: &Path,
rev: &'a str, rev: &str,
/// Kind of data to debug.
kind: DebugDataKind, kind: DebugDataKind,
} ) -> Result<Vec<u8>, DebugDataError> {
let index_file = match kind {
impl<'a> DebugData<'a> {
pub fn new(rev: &'a str, kind: DebugDataKind) -> Self {
DebugData { rev, kind }
}
pub fn run(&mut self) -> Result<Vec<u8>, DebugDataError> {
let root = find_root::FindRoot::new().run()?;
let index_file = match self.kind {
DebugDataKind::Changelog => root.join(".hg/store/00changelog.i"), DebugDataKind::Changelog => root.join(".hg/store/00changelog.i"),
DebugDataKind::Manifest => root.join(".hg/store/00manifest.i"), DebugDataKind::Manifest => root.join(".hg/store/00manifest.i"),
}; };
let revlog = Revlog::open(&index_file, None)?; let revlog = Revlog::open(&index_file, None)?;
let data = match self.rev.parse::<Revision>() { let data = match rev.parse::<Revision>() {
Ok(rev) => revlog.get_rev_data(rev)?, Ok(rev) => revlog.get_rev_data(rev)?,
_ => { _ => {
let node = NodePrefix::from_hex(&self.rev) let node = NodePrefix::from_hex(&rev)
.map_err(|_| DebugDataErrorKind::InvalidRevision)?; .map_err(|_| DebugDataErrorKind::InvalidRevision)?;
let rev = revlog.get_node_rev(node.borrow())?; let rev = revlog.get_node_rev(node.borrow())?;
revlog.get_rev_data(rev)? revlog.get_rev_data(rev)?
} }
}; };
Ok(data) Ok(data)
} }
}

rust/hg-core/src/operations/find_root.rs

impl fmt::Display for FindRootError { impl fmt::Display for FindRootError {
fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
unimplemented!() unimplemented!()
} }
} }
/// Find the root of the repository /// Find the root of the repository
/// by searching for a .hg directory in the current directory and its /// by searching for a .hg directory in the process’ current directory and its
/// ancestors /// ancestors
pub struct FindRoot<'a> { pub fn find_root() -> Result<PathBuf, FindRootError> {
current_dir: Option<&'a Path>, let current_dir = std::env::current_dir().map_err(|e| FindRootError {
} kind: FindRootErrorKind::GetCurrentDirError(e),
})?;
impl<'a> FindRoot<'a> { Ok(find_root_from_path(&current_dir)?.into())
pub fn new() -> Self {
Self { current_dir: None }
}
pub fn new_from_path(current_dir: &'a Path) -> Self {
Self {
current_dir: Some(current_dir),
}
} }
pub fn run(&self) -> Result<PathBuf, FindRootError> { /// Find the root of the repository
let current_dir = match self.current_dir { /// by searching for a .hg directory in the given directory and its ancestors
None => std::env::current_dir().or_else(|e| { pub fn find_root_from_path(start: &Path) -> Result<&Path, FindRootError> {
Err(FindRootError { if start.join(".hg").exists() {
kind: FindRootErrorKind::GetCurrentDirError(e), return Ok(start);
}) }
})?, for ancestor in start.ancestors() {
Some(path) => path.into(), if ancestor.join(".hg").exists() {
}; return Ok(ancestor);
if current_dir.join(".hg").exists() {
return Ok(current_dir);
}
let ancestors = current_dir.ancestors();
for parent in ancestors {
if parent.join(".hg").exists() {
return Ok(parent.into());
} }
} }
Err(FindRootError { Err(FindRootError {
kind: FindRootErrorKind::RootNotFound(current_dir.to_path_buf()), kind: FindRootErrorKind::RootNotFound(start.into()),
}) })
} }
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use std::fs; use std::fs;
use tempfile; use tempfile;
#[test] #[test]
fn dot_hg_not_found() { fn dot_hg_not_found() {
let tmp_dir = tempfile::tempdir().unwrap(); let tmp_dir = tempfile::tempdir().unwrap();
let path = tmp_dir.path(); let path = tmp_dir.path();
let err = FindRoot::new_from_path(&path).run().unwrap_err(); let err = find_root_from_path(&path).unwrap_err();
// TODO do something better // TODO do something better
assert!(match err { assert!(match err {
FindRootError { kind } => match kind { FindRootError { kind } => match kind {
FindRootErrorKind::RootNotFound(p) => p == path.to_path_buf(), FindRootErrorKind::RootNotFound(p) => p == path.to_path_buf(),
_ => false, _ => false,
}, },
}) })
} }
#[test] #[test]
fn dot_hg_in_current_path() { fn dot_hg_in_current_path() {
let tmp_dir = tempfile::tempdir().unwrap(); let tmp_dir = tempfile::tempdir().unwrap();
let root = tmp_dir.path(); let root = tmp_dir.path();
fs::create_dir_all(root.join(".hg")).unwrap(); fs::create_dir_all(root.join(".hg")).unwrap();
let result = FindRoot::new_from_path(&root).run().unwrap(); let result = find_root_from_path(&root).unwrap();
assert_eq!(result, root) assert_eq!(result, root)
} }
#[test] #[test]
fn dot_hg_in_parent() { fn dot_hg_in_parent() {
let tmp_dir = tempfile::tempdir().unwrap(); let tmp_dir = tempfile::tempdir().unwrap();
let root = tmp_dir.path(); let root = tmp_dir.path();
fs::create_dir_all(root.join(".hg")).unwrap(); fs::create_dir_all(root.join(".hg")).unwrap();
let result = let directory = root.join("some/nested/directory");
FindRoot::new_from_path(&root.join("some/nested/directory")) let result = find_root_from_path(&directory).unwrap();
.run()
.unwrap();
assert_eq!(result, root) assert_eq!(result, root)
} }
} /* tests */ } /* tests */

rust/hg-core/src/operations/list_tracked_files.rs

fn from(err: std::io::Error) -> Self { fn from(err: std::io::Error) -> Self {
let kind = ListDirstateTrackedFilesErrorKind::IoError(err); let kind = ListDirstateTrackedFilesErrorKind::IoError(err);
ListDirstateTrackedFilesError { kind } ListDirstateTrackedFilesError { kind }
} }
} }
/// List files under Mercurial control in the working directory /// List files under Mercurial control in the working directory
/// by reading the dirstate /// by reading the dirstate
pub struct ListDirstateTrackedFiles { pub struct Dirstate {
/// The `dirstate` content. /// The `dirstate` content.
content: Vec<u8>, content: Vec<u8>,
} }
impl ListDirstateTrackedFiles { impl Dirstate {
pub fn new(root: &Path) -> Result<Self, ListDirstateTrackedFilesError> { pub fn new(root: &Path) -> Result<Self, ListDirstateTrackedFilesError> {
let dirstate = root.join(".hg/dirstate"); let dirstate = root.join(".hg/dirstate");
let content = fs::read(&dirstate)?; let content = fs::read(&dirstate)?;
Ok(Self { content }) Ok(Self { content })
} }
pub fn run( pub fn tracked_files(
&mut self, &self,
) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> { ) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> {
let (_, entries, _) = parse_dirstate(&self.content) let (_, entries, _) = parse_dirstate(&self.content)
.map_err(ListDirstateTrackedFilesErrorKind::ParseError)?; .map_err(ListDirstateTrackedFilesErrorKind::ParseError)?;
let mut files: Vec<&HgPath> = entries let mut files: Vec<&HgPath> = entries
.into_iter() .into_iter()
.filter_map(|(path, entry)| match entry.state { .filter_map(|(path, entry)| match entry.state {
EntryState::Removed => None, EntryState::Removed => None,
_ => Some(path), _ => Some(path),
ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format) ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format)
} }
} }
.into() .into()
} }
} }
/// List files under Mercurial control at a given revision. /// List files under Mercurial control at a given revision.
pub struct ListRevTrackedFiles<'a> { pub fn list_rev_tracked_files(
/// The revision to list the files from.
rev: &'a str,
/// The changelog file
changelog: Changelog,
/// The manifest file
manifest: Manifest,
/// The manifest entry corresponding to the revision.
///
/// Used to hold the owner of the returned references.
manifest_entry: Option<ManifestEntry>,
}
impl<'a> ListRevTrackedFiles<'a> {
pub fn new(
root: &Path, root: &Path,
rev: &'a str, rev: &str,
) -> Result<Self, ListRevTrackedFilesError> { ) -> Result<FilesForRev, ListRevTrackedFilesError> {
let changelog = Changelog::open(root)?; let changelog = Changelog::open(root)?;
let manifest = Manifest::open(root)?; let manifest = Manifest::open(root)?;
Ok(Self { let changelog_entry = match rev.parse::<Revision>() {
rev, Ok(rev) => changelog.get_rev(rev)?,
changelog,
manifest,
manifest_entry: None,
})
}
pub fn run(
&mut self,
) -> Result<impl Iterator<Item = &HgPath>, ListRevTrackedFilesError> {
let changelog_entry = match self.rev.parse::<Revision>() {
Ok(rev) => self.changelog.get_rev(rev)?,
_ => { _ => {
let changelog_node = NodePrefix::from_hex(&self.rev) let changelog_node = NodePrefix::from_hex(&rev)
.or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?; .or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?;
self.changelog.get_node(changelog_node.borrow())? changelog.get_node(changelog_node.borrow())?
} }
}; };
let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?) let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
.or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?; .or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?;
let manifest_entry = manifest.get_node((&manifest_node).into())?;
Ok(FilesForRev(manifest_entry))
}
self.manifest_entry = pub struct FilesForRev(ManifestEntry);
Some(self.manifest.get_node((&manifest_node).into())?);
if let Some(ref manifest_entry) = self.manifest_entry { impl FilesForRev {
Ok(manifest_entry.files()) pub fn iter(&self) -> impl Iterator<Item = &HgPath> {
} else { self.0.files()
panic!(
"manifest entry should have been stored in self.manifest_node to ensure its lifetime since references are returned from it"
)
}
} }
} }

rust/hg-core/src/operations/mod.rs

//! A distinction is made between operations and commands. //! A distinction is made between operations and commands.
//! An operation is what can be done whereas a command is what is exposed by //! An operation is what can be done whereas a command is what is exposed by
//! the cli. A single command can use several operations to achieve its goal. //! the cli. A single command can use several operations to achieve its goal.
mod cat; mod cat;
mod debugdata; mod debugdata;
mod dirstate_status; mod dirstate_status;
mod find_root; mod find_root;
mod list_tracked_files; mod list_tracked_files;
pub use cat::{CatRev, CatRevError, CatRevErrorKind}; pub use cat::{cat, CatRevError, CatRevErrorKind};
pub use debugdata::{ pub use debugdata::{
DebugData, DebugDataError, DebugDataErrorKind, DebugDataKind, debug_data, DebugDataError, DebugDataErrorKind, DebugDataKind,
}; };
pub use find_root::{FindRoot, FindRootError, FindRootErrorKind}; pub use find_root::{
pub use list_tracked_files::{ find_root, find_root_from_path, FindRootError, FindRootErrorKind,
ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
ListDirstateTrackedFilesErrorKind,
}; };
pub use list_tracked_files::{ pub use list_tracked_files::{
ListRevTrackedFiles, ListRevTrackedFilesError, list_rev_tracked_files, FilesForRev, ListRevTrackedFilesError,
ListRevTrackedFilesErrorKind, ListRevTrackedFilesErrorKind,
}; };
pub use list_tracked_files::{
// TODO add an `Operation` trait when GAT have landed (rust #44265): Dirstate, ListDirstateTrackedFilesError, ListDirstateTrackedFilesErrorKind,
// there is no way to currently define a trait which can both return };
// references to `self` and to passed data, which is what we would need.
// Generic Associated Types may fix this and allow us to have a unified
// interface.

rust/rhg/src/commands/cat.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::{CommandError, CommandErrorKind};
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::FindRoot; use hg::operations::find_root;
use hg::operations::{CatRev, CatRevError, CatRevErrorKind}; use hg::operations::{cat, CatRevError, CatRevErrorKind};
use hg::requirements; use hg::requirements;
use hg::utils::hg_path::HgPathBuf; use hg::utils::hg_path::HgPathBuf;
use micro_timer::timed; use micro_timer::timed;
use std::convert::TryFrom; use std::convert::TryFrom;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Output the current or given revision of files Output the current or given revision of files
"; ";
ui.write_stdout(data)?; ui.write_stdout(data)?;
Ok(()) Ok(())
} }
} }
impl<'a> Command for CatCommand<'a> { impl<'a> Command for CatCommand<'a> {
#[timed] #[timed]
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let root = FindRoot::new().run()?; let root = find_root()?;
requirements::check(&root)?; requirements::check(&root)?;
let cwd = std::env::current_dir() let cwd = std::env::current_dir()
.or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?; .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
let mut files = vec![]; let mut files = vec![];
for file in self.files.iter() { for file in self.files.iter() {
let normalized = cwd.join(&file); let normalized = cwd.join(&file);
let stripped = normalized let stripped = normalized
.strip_prefix(&root) .strip_prefix(&root)
.or(Err(CommandErrorKind::Abort(None)))?; .or(Err(CommandErrorKind::Abort(None)))?;
let hg_file = HgPathBuf::try_from(stripped.to_path_buf()) let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
.or(Err(CommandErrorKind::Abort(None)))?; .or(Err(CommandErrorKind::Abort(None)))?;
files.push(hg_file); files.push(hg_file);
} }
match self.rev { match self.rev {
Some(rev) => { Some(rev) => {
let mut operation = CatRev::new(&root, rev, &files) let data = cat(&root, rev, &files)
.map_err(|e| map_rev_error(rev, e))?; .map_err(|e| map_rev_error(rev, e))?;
let data =
operation.run().map_err(|e| map_rev_error(rev, e))?;
self.display(ui, &data) self.display(ui, &data)
} }
None => Err(CommandErrorKind::Unimplemented.into()), None => Err(CommandErrorKind::Unimplemented.into()),
} }
} }
} }
/// Convert `CatRevErrorKind` to `CommandError` /// Convert `CatRevErrorKind` to `CommandError`

rust/rhg/src/commands/debugdata.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::{CommandError, CommandErrorKind};
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::find_root;
use hg::operations::{ use hg::operations::{
DebugData, DebugDataError, DebugDataErrorKind, DebugDataKind, debug_data, DebugDataError, DebugDataErrorKind, DebugDataKind,
}; };
use micro_timer::timed; use micro_timer::timed;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Dump the contents of a data file revision Dump the contents of a data file revision
"; ";
pub struct DebugDataCommand<'a> { pub struct DebugDataCommand<'a> {
rev: &'a str, rev: &'a str,
kind: DebugDataKind, kind: DebugDataKind,
} }
impl<'a> DebugDataCommand<'a> { impl<'a> DebugDataCommand<'a> {
pub fn new(rev: &'a str, kind: DebugDataKind) -> Self { pub fn new(rev: &'a str, kind: DebugDataKind) -> Self {
DebugDataCommand { rev, kind } DebugDataCommand { rev, kind }
} }
} }
impl<'a> Command for DebugDataCommand<'a> { impl<'a> Command for DebugDataCommand<'a> {
#[timed] #[timed]
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let mut operation = DebugData::new(self.rev, self.kind); let root = find_root()?;
let data = let data = debug_data(&root, self.rev, self.kind)
operation.run().map_err(|e| to_command_error(self.rev, e))?; .map_err(|e| to_command_error(self.rev, e))?;
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
stdout.write_all(&data)?; stdout.write_all(&data)?;
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }
} }
/// Convert operation errors to command errors /// Convert operation errors to command errors
fn to_command_error(rev: &str, err: DebugDataError) -> CommandError { fn to_command_error(rev: &str, err: DebugDataError) -> CommandError {
match err.kind { match err.kind {
DebugDataErrorKind::FindRootError(err) => CommandError::from(err),
DebugDataErrorKind::IoError(err) => CommandError { DebugDataErrorKind::IoError(err) => CommandError {
kind: CommandErrorKind::Abort(Some( kind: CommandErrorKind::Abort(Some(
utf8_to_local(&format!("abort: {}\n", err)).into(), utf8_to_local(&format!("abort: {}\n", err)).into(),
)), )),
}, },
DebugDataErrorKind::InvalidRevision => CommandError { DebugDataErrorKind::InvalidRevision => CommandError {
kind: CommandErrorKind::Abort(Some( kind: CommandErrorKind::Abort(Some(
utf8_to_local(&format!( utf8_to_local(&format!(

rust/rhg/src/commands/debugrequirements.rs

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

rust/rhg/src/commands/files.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::{CommandError, CommandErrorKind};
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::FindRoot; use hg::operations::find_root;
use hg::operations::{ use hg::operations::{
ListDirstateTrackedFiles, ListDirstateTrackedFilesError, list_rev_tracked_files, ListRevTrackedFilesError,
ListDirstateTrackedFilesErrorKind, ListRevTrackedFilesErrorKind,
}; };
use hg::operations::{ use hg::operations::{
ListRevTrackedFiles, ListRevTrackedFilesError, Dirstate, ListDirstateTrackedFilesError, ListDirstateTrackedFilesErrorKind,
ListRevTrackedFilesErrorKind,
}; };
use hg::requirements; use hg::requirements;
use hg::utils::files::{get_bytes_from_path, relativize_path}; use hg::utils::files::{get_bytes_from_path, relativize_path};
use hg::utils::hg_path::{HgPath, HgPathBuf}; use hg::utils::hg_path::{HgPath, HgPathBuf};
use std::path::Path; use std::path::Path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
List tracked files. List tracked files.
} }
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }
} }
impl<'a> Command for FilesCommand<'a> { impl<'a> Command for FilesCommand<'a> {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let root = FindRoot::new().run()?; let root = find_root()?;
requirements::check(&root)?; requirements::check(&root)?;
if let Some(rev) = self.rev { if let Some(rev) = self.rev {
let mut operation = ListRevTrackedFiles::new(&root, rev) let files = list_rev_tracked_files(&root, rev)
.map_err(|e| map_rev_error(rev, e))?; .map_err(|e| map_rev_error(rev, e))?;
let files = operation.run().map_err(|e| map_rev_error(rev, e))?; self.display_files(ui, &root, files.iter())
self.display_files(ui, &root, files)
} else { } else {
let mut operation = ListDirstateTrackedFiles::new(&root) let distate = Dirstate::new(&root).map_err(map_dirstate_error)?;
.map_err(map_dirstate_error)?; let files = distate.tracked_files().map_err(map_dirstate_error)?;
let files = operation.run().map_err(map_dirstate_error)?;
self.display_files(ui, &root, files) self.display_files(ui, &root, files)
} }
} }
} }
/// Convert `ListRevTrackedFilesErrorKind` to `CommandError` /// Convert `ListRevTrackedFilesErrorKind` to `CommandError`
fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError { fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError {
CommandError { CommandError {

rust/rhg/src/commands/root.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::operations::FindRoot; use hg::operations::find_root;
use hg::utils::files::get_bytes_from_path; use hg::utils::files::get_bytes_from_path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the root directory of the current repository. Print the root directory of the current repository.
Returns 0 on success. Returns 0 on success.
"; ";
pub struct RootCommand {} pub struct RootCommand {}
impl RootCommand { impl RootCommand {
pub fn new() -> Self { pub fn new() -> Self {
RootCommand {} RootCommand {}
} }
} }
impl Command for RootCommand { impl Command for RootCommand {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let path_buf = FindRoot::new().run()?; let path_buf = find_root()?;
let bytes = get_bytes_from_path(path_buf); let bytes = get_bytes_from_path(path_buf);
ui.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?; ui.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?;
Ok(()) Ok(())
} }
} }