This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9013

hg-core: simplify `list_tracked_files` operation
ClosedPublic

Authored by acezar on Sep 11 2020, 3:53 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG72b7d58d6e35: hg-core: simplify `list_tracked_files` operation
Summary

Use directly ListDirstateTrackedFiles rather than having an operation builder.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

acezar created this revision.Sep 11 2020, 3:53 AM
Alphare accepted this revision.Sep 17 2020, 6:14 AM
Alphare added a subscriber: Alphare.

Good stuff, thanks for removing the cruft I introduced. :D

acezar updated this revision to Diff 22724.Sep 18 2020, 10:49 AM
acezar added a commit: rHG72b7d58d6e35: hg-core: simplify `list_tracked_files` operation.Sep 23 2020, 10:57 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG72b7d58d6e35: hg-core: simplify `list_tracked_files` operation (authored by acezar). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 22724

rust/hg-core/src/operations/list_tracked_files.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 super::find_root;
use crate::dirstate::parsers::parse_dirstate; use crate::dirstate::parsers::parse_dirstate;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::{DirstateParseError, EntryState}; use crate::{DirstateParseError, EntryState};
use rayon::prelude::*; use rayon::prelude::*;
use std::convert::From; use std::convert::From;
use std::fmt; use std::fmt;
use std::fs; use std::fs;
use std::io; use std::ops::Deref;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
/// Kind of error encoutered by ListTrackedFiles /// Kind of error encountered by `ListDirstateTrackedFiles`
#[derive(Debug)] #[derive(Debug)]
pub enum ListTrackedFilesErrorKind { pub enum ListDirstateTrackedFilesErrorKind {
/// Error when reading the `dirstate` file
IoError(std::io::Error),
/// Error when parsing the `dirstate` file
ParseError(DirstateParseError), ParseError(DirstateParseError),
} }
/// A ListTrackedFiles error /// A `ListDirstateTrackedFiles` error
#[derive(Debug)] #[derive(Debug)]
pub struct ListTrackedFilesError { pub struct ListDirstateTrackedFilesError {
/// Kind of error encoutered by ListTrackedFiles /// Kind of error encountered by `ListDirstateTrackedFiles`
pub kind: ListTrackedFilesErrorKind, pub kind: ListDirstateTrackedFilesErrorKind,
} }
impl std::error::Error for ListTrackedFilesError {} impl std::error::Error for ListDirstateTrackedFilesError {}
impl fmt::Display for ListTrackedFilesError { impl fmt::Display for ListDirstateTrackedFilesError {
fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
unimplemented!() unimplemented!()
} }
} }
impl From<ListTrackedFilesErrorKind> for ListTrackedFilesError { impl From<ListDirstateTrackedFilesErrorKind>
fn from(kind: ListTrackedFilesErrorKind) -> Self { for ListDirstateTrackedFilesError
ListTrackedFilesError { kind } {
fn from(kind: ListDirstateTrackedFilesErrorKind) -> Self {
ListDirstateTrackedFilesError { kind }
} }
} }
/// List files under Mercurial control in the working directory impl From<std::io::Error> for ListDirstateTrackedFilesError {
pub struct ListTrackedFiles { fn from(err: std::io::Error) -> Self {
root: PathBuf, let kind = ListDirstateTrackedFilesErrorKind::IoError(err);
} ListDirstateTrackedFilesError { kind }
impl ListTrackedFiles {
pub fn new() -> Result<Self, find_root::FindRootError> {
let root = find_root::FindRoot::new().run()?;
Ok(ListTrackedFiles { root })
}
/// Load the tracked files data from disk
pub fn load(&self) -> Result<ListDirstateTrackedFiles, io::Error> {
let dirstate = &self.root.join(".hg/dirstate");
let content = fs::read(&dirstate)?;
Ok(ListDirstateTrackedFiles { content })
}
/// Returns the repository root directory
/// TODO I think this is a crutch that creates a dependency that should not
/// be there. Operations that need the root of the repository should get
/// it themselves, probably in a lazy fashion. But this would make the
/// current series even larger, so this is simplified for now.
pub fn get_root(&self) -> &Path {
&self.root
} }
} }
/// 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 ListDirstateTrackedFiles {
/// The `dirstate` content.
content: Vec<u8>, content: Vec<u8>,
} }
impl ListDirstateTrackedFiles { impl ListDirstateTrackedFiles {
pub fn run(&self) -> Result<Vec<&HgPath>, ListTrackedFilesError> { 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) let (_, entries, _) = parse_dirstate(&self.content)
.map_err(ListTrackedFilesErrorKind::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),
}) })
.collect(); .collect();
files.par_sort_unstable(); files.par_sort_unstable();
Ok(files) Ok(files)
} }
} }

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 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 debugdata::{ pub use debugdata::{
DebugData, DebugDataError, DebugDataErrorKind, DebugDataKind, DebugData, DebugDataError, DebugDataErrorKind, DebugDataKind,
}; };
pub use find_root::{FindRoot, FindRootError, FindRootErrorKind}; pub use find_root::{FindRoot, FindRootError, FindRootErrorKind};
pub use list_tracked_files::{ pub use list_tracked_files::{
ListTrackedFiles, ListTrackedFilesError, ListTrackedFilesErrorKind, ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
ListDirstateTrackedFilesErrorKind,
}; };
// TODO add an `Operation` trait when GAT have landed (rust #44265): // TODO add an `Operation` trait when GAT have landed (rust #44265):
// there is no way to currently define a trait which can both return // 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. // 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 // Generic Associated Types may fix this and allow us to have a unified
// interface. // interface.

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::Ui; use crate::ui::Ui;
use hg::operations::{ListTrackedFiles, ListTrackedFilesErrorKind}; use hg::operations::FindRoot;
use hg::operations::{
ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
ListDirstateTrackedFilesErrorKind,
};
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::HgPathBuf; use hg::utils::hg_path::HgPathBuf;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
List tracked files. List tracked files.
Returns 0 on success. Returns 0 on success.
"; ";
pub struct FilesCommand {} pub struct FilesCommand {}
impl FilesCommand { impl FilesCommand {
pub fn new() -> Self { pub fn new() -> Self {
FilesCommand {} FilesCommand {}
} }
} }
impl Command for FilesCommand { impl Command for FilesCommand {
fn run(&self, ui: &Ui) -> Result<(), CommandError> { fn run(&self, ui: &Ui) -> Result<(), CommandError> {
let operation_builder = ListTrackedFiles::new()?; let root = FindRoot::new().run()?;
let operation = operation_builder.load().map_err(|err| { let mut operation = ListDirstateTrackedFiles::new(&root)
CommandErrorKind::Abort(Some( .map_err(map_dirstate_error)?;
[b"abort: ", err.to_string().as_bytes(), b"\n"] let files = operation.run().map_err(map_dirstate_error)?;
.concat()
.to_vec(),
))
})?;
let files = operation.run().map_err(|err| match err.kind {
ListTrackedFilesErrorKind::ParseError(_) => {
CommandErrorKind::Abort(Some(
// TODO find a better error message
b"abort: parse error\n".to_vec(),
))
}
})?;
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 rooted_cwd = cwd let rooted_cwd = cwd
.strip_prefix(operation_builder.get_root()) .strip_prefix(&root)
.expect("cwd was already checked within the repository"); .expect("cwd was already checked within the repository");
let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd)); let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
for file in files { for file in files {
stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?; stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?;
stdout.write_all(b"\n")?; stdout.write_all(b"\n")?;
} }
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }
} }
/// Convert operation errors to command errors
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(),
))
}
},
}
}