rust: replace most "operation" structs with functions

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.

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

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

@@ -1,176 +1,139 b''
 // list_tracked_files.rs
 //
 // Copyright 2020 Antoine Cezar <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use std::convert::From;
 use std::path::{Path, PathBuf};
 
 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::revlog::Revlog;
 use crate::revlog::revlog::RevlogError;
 use crate::revlog::Node;
 use crate::revlog::NodePrefix;
 use crate::revlog::Revision;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::{HgPath, HgPathBuf};
 
 const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n'];
 
 /// Kind of error encountered by `CatRev`
 #[derive(Debug)]
 pub enum CatRevErrorKind {
     /// Error when reading a `revlog` file.
     IoError(std::io::Error),
     /// The revision has not been found.
     InvalidRevision,
     /// Found more than one revision whose ID match the requested prefix
     AmbiguousPrefix,
     /// A `revlog` file is corrupted.
     CorruptedRevlog,
     /// The `revlog` format version is not supported.
     UnsuportedRevlogVersion(u16),
     /// The `revlog` data format is not supported.
     UnknowRevlogDataFormat(u8),
 }
 
 /// A `CatRev` error
 #[derive(Debug)]
 pub struct CatRevError {
     /// Kind of error encountered by `CatRev`
     pub kind: CatRevErrorKind,
 }
 
 impl From<CatRevErrorKind> for CatRevError {
     fn from(kind: CatRevErrorKind) -> Self {
         CatRevError { kind }
     }
 }
 
 impl From<RevlogError> for CatRevError {
     fn from(err: RevlogError) -> Self {
         match err {
             RevlogError::IoError(err) => CatRevErrorKind::IoError(err),
             RevlogError::UnsuportedVersion(version) => {
                 CatRevErrorKind::UnsuportedRevlogVersion(version)
             }
             RevlogError::InvalidRevision => CatRevErrorKind::InvalidRevision,
             RevlogError::AmbiguousPrefix => CatRevErrorKind::AmbiguousPrefix,
             RevlogError::Corrupted => CatRevErrorKind::CorruptedRevlog,
             RevlogError::UnknowDataFormat(format) => {
                 CatRevErrorKind::UnknowRevlogDataFormat(format)
             }
         }
         .into()
     }
 }
 
 /// 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.
-    manifest_entry: Option<ManifestEntry>,
-}
+///
+/// * `root`: Repository root
+/// * `rev`: The revision to cat the files from.
+/// * `files`: The files to output.
+pub fn cat(
+    root: &Path,
+    rev: &str,
+    files: &[HgPathBuf],
+) -> Result<Vec<u8>, CatRevError> {
+    let changelog = Changelog::open(&root)?;
+    let manifest = Manifest::open(&root)?;
+
+    let changelog_entry = match rev.parse::<Revision>() {
+        Ok(rev) => changelog.get_rev(rev)?,
+        _ => {
+            let changelog_node = NodePrefix::from_hex(&rev)
+                .map_err(|_| CatRevErrorKind::InvalidRevision)?;
+            changelog.get_node(changelog_node.borrow())?
+        }
+    };
+    let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
+        .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
+
+    let manifest_entry = manifest.get_node((&manifest_node).into())?;
+    let mut bytes = vec![];
 
-impl<'a> CatRev<'a> {
-    pub fn new(
-        root: &'a Path,
-        rev: &'a str,
-        files: &'a [HgPathBuf],
-    ) -> Result<Self, CatRevError> {
-        let changelog = Changelog::open(&root)?;
-        let manifest = Manifest::open(&root)?;
-        let manifest_entry = None;
+    for (manifest_file, node_bytes) in manifest_entry.files_with_nodes() {
+        for cat_file in files.iter() {
+            if cat_file.as_bytes() == manifest_file.as_bytes() {
+                let index_path = store_path(root, manifest_file, b".i");
+                let data_path = store_path(root, manifest_file, b".d");
 
-        Ok(Self {
-            root,
-            rev,
-            files,
-            changelog,
-            manifest,
-            manifest_entry,
-        })
+                let file_log = Revlog::open(&index_path, Some(&data_path))?;
+                let file_node = Node::from_hex(node_bytes)
+                    .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
+                let file_rev = file_log.get_node_rev((&file_node).into())?;
+                let data = file_log.get_rev_data(file_rev)?;
+                if data.starts_with(&METADATA_DELIMITER) {
+                    let end_delimiter_position = data
+                        [METADATA_DELIMITER.len()..]
+                        .windows(METADATA_DELIMITER.len())
+                        .position(|bytes| bytes == METADATA_DELIMITER);
+                    if let Some(position) = end_delimiter_position {
+                        let offset = METADATA_DELIMITER.len() * 2;
+                        bytes.extend(data[position + offset..].iter());
+                    }
+                } else {
+                    bytes.extend(data);
+                }
+            }
+        }
     }
 
-    pub fn run(&mut self) -> Result<Vec<u8>, CatRevError> {
-        let changelog_entry = match self.rev.parse::<Revision>() {
-            Ok(rev) => self.changelog.get_rev(rev)?,
-            _ => {
-                let changelog_node = NodePrefix::from_hex(&self.rev)
-                    .map_err(|_| CatRevErrorKind::InvalidRevision)?;
-                self.changelog.get_node(changelog_node.borrow())?
-            }
-        };
-        let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
-            .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
-
-        self.manifest_entry =
-            Some(self.manifest.get_node((&manifest_node).into())?);
-        if let Some(ref manifest_entry) = self.manifest_entry {
-            let mut bytes = vec![];
-
-            for (manifest_file, node_bytes) in
-                manifest_entry.files_with_nodes()
-            {
-                for cat_file in self.files.iter() {
-                    if cat_file.as_bytes() == manifest_file.as_bytes() {
-                        let index_path =
-                            store_path(self.root, manifest_file, b".i");
-                        let data_path =
-                            store_path(self.root, manifest_file, b".d");
-
-                        let file_log =
-                            Revlog::open(&index_path, Some(&data_path))?;
-                        let file_node = Node::from_hex(node_bytes)
-                            .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
-                        let file_rev =
-                            file_log.get_node_rev((&file_node).into())?;
-                        let data = file_log.get_rev_data(file_rev)?;
-                        if data.starts_with(&METADATA_DELIMITER) {
-                            let end_delimiter_position = data
-                                [METADATA_DELIMITER.len()..]
-                                .windows(METADATA_DELIMITER.len())
-                                .position(|bytes| bytes == METADATA_DELIMITER);
-                            if let Some(position) = end_delimiter_position {
-                                let offset = METADATA_DELIMITER.len() * 2;
-                                bytes.extend(data[position + offset..].iter());
-                            }
-                        } else {
-                            bytes.extend(data);
-                        }
-                    }
-                }
-            }
-
-            Ok(bytes)
-        } else {
-            unreachable!("manifest_entry should have been stored");
-        }
-    }
+    Ok(bytes)
 }
 
 fn store_path(root: &Path, hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
     let encoded_bytes =
         path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
     [
         root,
         &Path::new(".hg/store/"),
         get_path_from_bytes(&encoded_bytes),
     ]
     .iter()
     .collect()
 }

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

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

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

@@ -1,119 +1,100 b''
 use std::fmt;
 use std::path::{Path, PathBuf};
 
 /// Kind of error encoutered by FindRoot
 #[derive(Debug)]
 pub enum FindRootErrorKind {
     /// Root of the repository has not been found
     /// Contains the current directory used by FindRoot
     RootNotFound(PathBuf),
     /// The current directory does not exists or permissions are insufficient
     /// to get access to it
     GetCurrentDirError(std::io::Error),
 }
 
 /// A FindRoot error
 #[derive(Debug)]
 pub struct FindRootError {
     /// Kind of error encoutered by FindRoot
     pub kind: FindRootErrorKind,
 }
 
 impl std::error::Error for FindRootError {}
 
 impl fmt::Display for FindRootError {
     fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
         unimplemented!()
     }
 }
 
 /// 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
-pub struct FindRoot<'a> {
-    current_dir: Option<&'a Path>,
+pub fn find_root() -> Result<PathBuf, FindRootError> {
+    let current_dir = std::env::current_dir().map_err(|e| FindRootError {
+        kind: FindRootErrorKind::GetCurrentDirError(e),
+    })?;
+    Ok(find_root_from_path(&current_dir)?.into())
 }
 
-impl<'a> FindRoot<'a> {
-    pub fn new() -> Self {
-        Self { current_dir: None }
+/// Find the root of the repository
+/// by searching for a .hg directory in the given directory and its ancestors
+pub fn find_root_from_path(start: &Path) -> Result<&Path, FindRootError> {
+    if start.join(".hg").exists() {
+        return Ok(start);
     }
-
-    pub fn new_from_path(current_dir: &'a Path) -> Self {
-        Self {
-            current_dir: Some(current_dir),
+    for ancestor in start.ancestors() {
+        if ancestor.join(".hg").exists() {
+            return Ok(ancestor);
         }
     }
-
-    pub fn run(&self) -> Result<PathBuf, FindRootError> {
-        let current_dir = match self.current_dir {
-            None => std::env::current_dir().or_else(|e| {
-                Err(FindRootError {
-                    kind: FindRootErrorKind::GetCurrentDirError(e),
-                })
-            })?,
-            Some(path) => path.into(),
-        };
-
-        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 {
-            kind: FindRootErrorKind::RootNotFound(current_dir.to_path_buf()),
-        })
-    }
+    Err(FindRootError {
+        kind: FindRootErrorKind::RootNotFound(start.into()),
+    })
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use std::fs;
     use tempfile;
 
     #[test]
     fn dot_hg_not_found() {
         let tmp_dir = tempfile::tempdir().unwrap();
         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
         assert!(match err {
             FindRootError { kind } => match kind {
                 FindRootErrorKind::RootNotFound(p) => p == path.to_path_buf(),
                 _ => false,
             },
         })
     }
 
     #[test]
     fn dot_hg_in_current_path() {
         let tmp_dir = tempfile::tempdir().unwrap();
         let root = tmp_dir.path();
         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)
     }
 
     #[test]
     fn dot_hg_in_parent() {
         let tmp_dir = tempfile::tempdir().unwrap();
         let root = tmp_dir.path();
         fs::create_dir_all(root.join(".hg")).unwrap();
 
-        let result =
-            FindRoot::new_from_path(&root.join("some/nested/directory"))
-                .run()
-                .unwrap();
+        let directory = root.join("some/nested/directory");
+        let result = find_root_from_path(&directory).unwrap();
 
         assert_eq!(result, root)
     }
 } /* tests */

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

@@ -1,194 +1,167 b''
 // list_tracked_files.rs
 //
 // Copyright 2020 Antoine Cezar <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::dirstate::parsers::parse_dirstate;
 use crate::revlog::changelog::Changelog;
 use crate::revlog::manifest::{Manifest, ManifestEntry};
 use crate::revlog::node::{Node, NodePrefix};
 use crate::revlog::revlog::RevlogError;
 use crate::revlog::Revision;
 use crate::utils::hg_path::HgPath;
 use crate::{DirstateParseError, EntryState};
 use rayon::prelude::*;
 use std::convert::From;
 use std::fs;
 use std::path::Path;
 
 /// Kind of error encountered by `ListDirstateTrackedFiles`
 #[derive(Debug)]
 pub enum ListDirstateTrackedFilesErrorKind {
     /// Error when reading the `dirstate` file
     IoError(std::io::Error),
     /// Error when parsing the `dirstate` file
     ParseError(DirstateParseError),
 }
 
 /// A `ListDirstateTrackedFiles` error
 #[derive(Debug)]
 pub struct ListDirstateTrackedFilesError {
     /// Kind of error encountered by `ListDirstateTrackedFiles`
     pub kind: ListDirstateTrackedFilesErrorKind,
 }
 
 impl From<ListDirstateTrackedFilesErrorKind>
     for ListDirstateTrackedFilesError
 {
     fn from(kind: ListDirstateTrackedFilesErrorKind) -> Self {
         ListDirstateTrackedFilesError { kind }
     }
 }
 
 impl From<std::io::Error> for ListDirstateTrackedFilesError {
     fn from(err: std::io::Error) -> Self {
         let kind = ListDirstateTrackedFilesErrorKind::IoError(err);
         ListDirstateTrackedFilesError { kind }
     }
 }
 
 /// List files under Mercurial control in the working directory
 /// by reading the dirstate
-pub struct ListDirstateTrackedFiles {
+pub struct Dirstate {
     /// The `dirstate` content.
     content: Vec<u8>,
 }
 
-impl ListDirstateTrackedFiles {
+impl Dirstate {
     pub fn new(root: &Path) -> Result<Self, ListDirstateTrackedFilesError> {
         let dirstate = root.join(".hg/dirstate");
         let content = fs::read(&dirstate)?;
         Ok(Self { content })
     }
 
-    pub fn run(
-        &mut self,
+    pub fn tracked_files(
+        &self,
     ) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> {
         let (_, entries, _) = parse_dirstate(&self.content)
             .map_err(ListDirstateTrackedFilesErrorKind::ParseError)?;
         let mut files: Vec<&HgPath> = entries
             .into_iter()
             .filter_map(|(path, entry)| match entry.state {
                 EntryState::Removed => None,
                 _ => Some(path),
             })
             .collect();
         files.par_sort_unstable();
         Ok(files)
     }
 }
 
 /// Kind of error encountered by `ListRevTrackedFiles`
 #[derive(Debug)]
 pub enum ListRevTrackedFilesErrorKind {
     /// Error when reading a `revlog` file.
     IoError(std::io::Error),
     /// The revision has not been found.
     InvalidRevision,
     /// Found more than one revision whose ID match the requested prefix
     AmbiguousPrefix,
     /// A `revlog` file is corrupted.
     CorruptedRevlog,
     /// The `revlog` format version is not supported.
     UnsuportedRevlogVersion(u16),
     /// The `revlog` data format is not supported.
     UnknowRevlogDataFormat(u8),
 }
 
 /// A `ListRevTrackedFiles` error
 #[derive(Debug)]
 pub struct ListRevTrackedFilesError {
     /// Kind of error encountered by `ListRevTrackedFiles`
     pub kind: ListRevTrackedFilesErrorKind,
 }
 
 impl From<ListRevTrackedFilesErrorKind> for ListRevTrackedFilesError {
     fn from(kind: ListRevTrackedFilesErrorKind) -> Self {
         ListRevTrackedFilesError { kind }
     }
 }
 
 impl From<RevlogError> for ListRevTrackedFilesError {
     fn from(err: RevlogError) -> Self {
         match err {
             RevlogError::IoError(err) => {
                 ListRevTrackedFilesErrorKind::IoError(err)
             }
             RevlogError::UnsuportedVersion(version) => {
                 ListRevTrackedFilesErrorKind::UnsuportedRevlogVersion(version)
             }
             RevlogError::InvalidRevision => {
                 ListRevTrackedFilesErrorKind::InvalidRevision
             }
             RevlogError::AmbiguousPrefix => {
                 ListRevTrackedFilesErrorKind::AmbiguousPrefix
             }
             RevlogError::Corrupted => {
                 ListRevTrackedFilesErrorKind::CorruptedRevlog
             }
             RevlogError::UnknowDataFormat(format) => {
                 ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format)
             }
         }
         .into()
     }
 }
 
 /// List files under Mercurial control at a given revision.
-pub struct ListRevTrackedFiles<'a> {
-    /// 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>,
+pub fn list_rev_tracked_files(
+    root: &Path,
+    rev: &str,
+) -> Result<FilesForRev, ListRevTrackedFilesError> {
+    let changelog = Changelog::open(root)?;
+    let manifest = Manifest::open(root)?;
+
+    let changelog_entry = match rev.parse::<Revision>() {
+        Ok(rev) => changelog.get_rev(rev)?,
+        _ => {
+            let changelog_node = NodePrefix::from_hex(&rev)
+                .or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?;
+            changelog.get_node(changelog_node.borrow())?
+        }
+    };
+    let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
+        .or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?;
+    let manifest_entry = manifest.get_node((&manifest_node).into())?;
+    Ok(FilesForRev(manifest_entry))
 }
 
-impl<'a> ListRevTrackedFiles<'a> {
-    pub fn new(
-        root: &Path,
-        rev: &'a str,
-    ) -> Result<Self, ListRevTrackedFilesError> {
-        let changelog = Changelog::open(root)?;
-        let manifest = Manifest::open(root)?;
-
-        Ok(Self {
-            rev,
-            changelog,
-            manifest,
-            manifest_entry: None,
-        })
-    }
+pub struct FilesForRev(ManifestEntry);
 
-    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)
-                    .or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?;
-                self.changelog.get_node(changelog_node.borrow())?
-            }
-        };
-        let manifest_node = Node::from_hex(&changelog_entry.manifest_node()?)
-            .or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?;
-
-        self.manifest_entry =
-            Some(self.manifest.get_node((&manifest_node).into())?);
-
-        if let Some(ref manifest_entry) = self.manifest_entry {
-            Ok(manifest_entry.files())
-        } else {
-            panic!(
-                "manifest entry should have been stored in self.manifest_node to ensure its lifetime since references are returned from it"
-            )
-        }
+impl FilesForRev {
+    pub fn iter(&self) -> impl Iterator<Item = &HgPath> {
+        self.0.files()
     }
 }

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

@@ -1,28 +1,23 b''
 //! A distinction is made between operations and commands.
 //! 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.
 
 mod cat;
 mod debugdata;
 mod dirstate_status;
 mod find_root;
 mod list_tracked_files;
-pub use cat::{CatRev, CatRevError, CatRevErrorKind};
+pub use cat::{cat, CatRevError, CatRevErrorKind};
 pub use debugdata::{
-    DebugData, DebugDataError, DebugDataErrorKind, DebugDataKind,
+    debug_data, DebugDataError, DebugDataErrorKind, DebugDataKind,
 };
-pub use find_root::{FindRoot, FindRootError, FindRootErrorKind};
-pub use list_tracked_files::{
-    ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
-    ListDirstateTrackedFilesErrorKind,
+pub use find_root::{
+    find_root, find_root_from_path, FindRootError, FindRootErrorKind,
 };
 pub use list_tracked_files::{
-    ListRevTrackedFiles, ListRevTrackedFilesError,
+    list_rev_tracked_files, FilesForRev, ListRevTrackedFilesError,
     ListRevTrackedFilesErrorKind,
 };
-
-// TODO add an `Operation` trait when GAT have landed (rust #44265):
-// 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.
+pub use list_tracked_files::{
+    Dirstate, ListDirstateTrackedFilesError, ListDirstateTrackedFilesErrorKind,
+};

rust/rhg/src/commands/cat.rs

@@ -1,108 +1,106 b''
 use crate::commands::Command;
 use crate::error::{CommandError, CommandErrorKind};
 use crate::ui::utf8_to_local;
 use crate::ui::Ui;
-use hg::operations::FindRoot;
-use hg::operations::{CatRev, CatRevError, CatRevErrorKind};
+use hg::operations::find_root;
+use hg::operations::{cat, CatRevError, CatRevErrorKind};
 use hg::requirements;
 use hg::utils::hg_path::HgPathBuf;
 use micro_timer::timed;
 use std::convert::TryFrom;
 
 pub const HELP_TEXT: &str = "
 Output the current or given revision of files
 ";
 
 pub struct CatCommand<'a> {
     rev: Option<&'a str>,
     files: Vec<&'a str>,
 }
 
 impl<'a> CatCommand<'a> {
     pub fn new(rev: Option<&'a str>, files: Vec<&'a str>) -> Self {
         Self { rev, files }
     }
 
     fn display(&self, ui: &Ui, data: &[u8]) -> Result<(), CommandError> {
         ui.write_stdout(data)?;
         Ok(())
     }
 }
 
 impl<'a> Command for CatCommand<'a> {
     #[timed]
     fn run(&self, ui: &Ui) -> Result<(), CommandError> {
-        let root = FindRoot::new().run()?;
+        let root = find_root()?;
         requirements::check(&root)?;
         let cwd = std::env::current_dir()
             .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
 
         let mut files = vec![];
         for file in self.files.iter() {
             let normalized = cwd.join(&file);
             let stripped = normalized
                 .strip_prefix(&root)
                 .or(Err(CommandErrorKind::Abort(None)))?;
             let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
                 .or(Err(CommandErrorKind::Abort(None)))?;
             files.push(hg_file);
         }
 
         match self.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))?;
-                let data =
-                    operation.run().map_err(|e| map_rev_error(rev, e))?;
                 self.display(ui, &data)
             }
             None => Err(CommandErrorKind::Unimplemented.into()),
         }
     }
 }
 
 /// Convert `CatRevErrorKind` to `CommandError`
 fn map_rev_error(rev: &str, err: CatRevError) -> CommandError {
     CommandError {
         kind: match err.kind {
             CatRevErrorKind::IoError(err) => CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!("abort: {}\n", err)).into(),
             )),
             CatRevErrorKind::InvalidRevision => CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!(
                     "abort: invalid revision identifier {}\n",
                     rev
                 ))
                 .into(),
             )),
             CatRevErrorKind::AmbiguousPrefix => CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!(
                     "abort: ambiguous revision identifier {}\n",
                     rev
                 ))
                 .into(),
             )),
             CatRevErrorKind::UnsuportedRevlogVersion(version) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unsupported revlog version {}\n",
                         version
                     ))
                     .into(),
                 ))
             }
             CatRevErrorKind::CorruptedRevlog => CommandErrorKind::Abort(Some(
                 "abort: corrupted revlog\n".into(),
             )),
             CatRevErrorKind::UnknowRevlogDataFormat(format) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unknow revlog dataformat {:?}\n",
                         format
                     ))
                     .into(),
                 ))
             }
         },
     }
 }

rust/rhg/src/commands/debugdata.rs

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

rust/rhg/src/commands/debugrequirements.rs

@@ -1,30 +1,30 b''
 use crate::commands::Command;
 use crate::error::CommandError;
 use crate::ui::Ui;
-use hg::operations::FindRoot;
+use hg::operations::find_root;
 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 root = find_root()?;
         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/commands/files.rs

@@ -1,147 +1,144 b''
 use crate::commands::Command;
 use crate::error::{CommandError, CommandErrorKind};
 use crate::ui::utf8_to_local;
 use crate::ui::Ui;
-use hg::operations::FindRoot;
+use hg::operations::find_root;
 use hg::operations::{
-    ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
-    ListDirstateTrackedFilesErrorKind,
+    list_rev_tracked_files, ListRevTrackedFilesError,
+    ListRevTrackedFilesErrorKind,
 };
 use hg::operations::{
-    ListRevTrackedFiles, ListRevTrackedFilesError,
-    ListRevTrackedFilesErrorKind,
+    Dirstate, ListDirstateTrackedFilesError, ListDirstateTrackedFilesErrorKind,
 };
 use hg::requirements;
 use hg::utils::files::{get_bytes_from_path, relativize_path};
 use hg::utils::hg_path::{HgPath, HgPathBuf};
 use std::path::Path;
 
 pub const HELP_TEXT: &str = "
 List tracked files.
 
 Returns 0 on success.
 ";
 
 pub struct FilesCommand<'a> {
     rev: Option<&'a str>,
 }
 
 impl<'a> FilesCommand<'a> {
     pub fn new(rev: Option<&'a str>) -> Self {
         FilesCommand { rev }
     }
 
     fn display_files(
         &self,
         ui: &Ui,
         root: &Path,
         files: impl IntoIterator<Item = &'a HgPath>,
     ) -> Result<(), CommandError> {
         let cwd = std::env::current_dir()
             .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
         let rooted_cwd = cwd
             .strip_prefix(root)
             .expect("cwd was already checked within the repository");
         let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));
 
         let mut stdout = ui.stdout_buffer();
 
         for file in files {
             stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?;
             stdout.write_all(b"\n")?;
         }
         stdout.flush()?;
         Ok(())
     }
 }
 
 impl<'a> Command for FilesCommand<'a> {
     fn run(&self, ui: &Ui) -> Result<(), CommandError> {
-        let root = FindRoot::new().run()?;
+        let root = find_root()?;
         requirements::check(&root)?;
         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))?;
-            let files = operation.run().map_err(|e| map_rev_error(rev, e))?;
-            self.display_files(ui, &root, files)
+            self.display_files(ui, &root, files.iter())
         } else {
-            let mut operation = ListDirstateTrackedFiles::new(&root)
-                .map_err(map_dirstate_error)?;
-            let files = operation.run().map_err(map_dirstate_error)?;
+            let distate = Dirstate::new(&root).map_err(map_dirstate_error)?;
+            let files = distate.tracked_files().map_err(map_dirstate_error)?;
             self.display_files(ui, &root, files)
         }
     }
 }
 
 /// Convert `ListRevTrackedFilesErrorKind` to `CommandError`
 fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError {
     CommandError {
         kind: match err.kind {
             ListRevTrackedFilesErrorKind::IoError(err) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!("abort: {}\n", err)).into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::InvalidRevision => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: invalid revision identifier {}\n",
                         rev
                     ))
                     .into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::AmbiguousPrefix => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: ambiguous revision identifier {}\n",
                         rev
                     ))
                     .into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::UnsuportedRevlogVersion(version) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unsupported revlog version {}\n",
                         version
                     ))
                     .into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::CorruptedRevlog => {
                 CommandErrorKind::Abort(Some(
                     "abort: corrupted revlog\n".into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unknow revlog dataformat {:?}\n",
                         format
                     ))
                     .into(),
                 ))
             }
         },
     }
 }
 
 /// Convert `ListDirstateTrackedFilesError` to `CommandError`
 fn map_dirstate_error(err: ListDirstateTrackedFilesError) -> CommandError {
     CommandError {
         kind: match err.kind {
             ListDirstateTrackedFilesErrorKind::IoError(err) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!("abort: {}\n", err)).into(),
                 ))
             }
             ListDirstateTrackedFilesErrorKind::ParseError(_) => {
                 CommandErrorKind::Abort(Some(
                     // TODO find a better error message
                     b"abort: parse error\n".to_vec(),
                 ))
             }
         },
     }
 }

rust/rhg/src/commands/root.rs

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