Mercurial > hg
view rust/hg-core/src/operations/list_tracked_files.rs @ 45603:be951ca95b08
hg-core: use `.or(Err(Error))` not `.map_err(|_| Error)` (D9100#inline-15067)
Differential Revision: https://phab.mercurial-scm.org/D9108
author | Antoine cezar<acezar@chwitlabs.fr> |
---|---|
date | Mon, 28 Sep 2020 16:52:35 +0200 |
parents | 639f33f22faf |
children | 8d6164098782 |
line wrap: on
line source
// list_tracked_files.rs // // Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net> // // 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::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::PathBuf; /// 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 { /// The `dirstate` content. content: Vec<u8>, } impl ListDirstateTrackedFiles { pub fn new(root: &PathBuf) -> Result<Self, ListDirstateTrackedFilesError> { let dirstate = root.join(".hg/dirstate"); let content = fs::read(&dirstate)?; Ok(Self { content }) } pub fn run( &mut 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, /// 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::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>, } impl<'a> ListRevTrackedFiles<'a> { pub fn new( root: &PathBuf, 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 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 = hex::decode(&self.rev) .or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?; self.changelog.get_node(&changelog_node)? } }; let manifest_node = hex::decode(&changelog_entry.manifest_node()?) .or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?; self.manifest_entry = Some(self.manifest.get_node(&manifest_node)?); 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" ) } } }