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

Revision Contents
Changeset List

Diff 24258

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 fn find_root() -> Result<PathBuf, FindRootError> {
pub struct FindRoot<'a> { let current_dir = std::env::current_dir().map_err(|e| FindRootError {
current_dir: Option<&'a Path>, kind: FindRootErrorKind::GetCurrentDirError(e),
} })?;
Ok(find_root_from_path(&current_dir)?.into())
impl<'a> FindRoot<'a> {
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(())
} }
} }