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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

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 22794

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(),
))
}
},
}
}