This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11898

rhg: refactor relativize_path into a struct + method
ClosedPublic

Authored by SimonSapin on Dec 10 2021, 5:14 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG9b0e1f64656f: rhg: refactor relativize_path into a struct + method
Summary

… instead of a function that takes an iterator and a callback.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Dec 10 2021, 5:14 PM
Alphare accepted this revision.Dec 13 2021, 6:44 AM
This revision is now accepted and ready to land.Dec 13 2021, 6:44 AM
SimonSapin added a commit: rHG9b0e1f64656f: rhg: refactor relativize_path into a struct + method.Dec 13 2021, 8:36 AM
Closed by commit rHG9b0e1f64656f: rhg: refactor relativize_path into a struct + method (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 31431

rust/rhg/src/commands/files.rs

use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use crate::ui::UiError; use crate::utils::path_utils::RelativizePaths;
use crate::utils::path_utils::relativize_paths;
use clap::Arg; use clap::Arg;
use hg::errors::HgError; use hg::errors::HgError;
use hg::operations::list_rev_tracked_files; use hg::operations::list_rev_tracked_files;
use hg::operations::Dirstate; use hg::operations::Dirstate;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::hg_path::HgPath; use hg::utils::hg_path::HgPath;
use std::borrow::Cow;
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 fn args() -> clap::App<'static, 'static> { pub fn args() -> clap::App<'static, 'static> {
fn display_files<'a>( fn display_files<'a>(
ui: &Ui, ui: &Ui,
repo: &Repo, repo: &Repo,
files: impl IntoIterator<Item = Result<&'a HgPath, HgError>>, files: impl IntoIterator<Item = Result<&'a HgPath, HgError>>,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
let mut any = false; let mut any = false;
relativize_paths(repo, files, |path: Cow<[u8]>| -> Result<(), UiError> { let relativize = RelativizePaths::new(repo)?;
for result in files {
let path = result?;
stdout.write_all(&relativize.relativize(path))?;
stdout.write_all(b"\n")?;
any = true; any = true;
stdout.write_all(path.as_ref())?; }
stdout.write_all(b"\n")
})?;
stdout.flush()?; stdout.flush()?;
if any { if any {
Ok(()) Ok(())
} else { } else {
Err(CommandError::Unsuccessful) Err(CommandError::Unsuccessful)
} }
} }

rust/rhg/src/commands/status.rs

// status.rs // status.rs
// //
// Copyright 2020, Georges Racinet <georges.racinets@octobus.net> // Copyright 2020, Georges Racinet <georges.racinets@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 crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use crate::utils::path_utils::relativize_paths; use crate::utils::path_utils::RelativizePaths;
use clap::{Arg, SubCommand}; use clap::{Arg, SubCommand};
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg; use hg;
use hg::config::Config; use hg::config::Config;
use hg::dirstate::has_exec_bit; use hg::dirstate::has_exec_bit;
use hg::dirstate::TruncatedTimestamp; use hg::dirstate::TruncatedTimestamp;
use hg::dirstate::RANGE_MASK_31BIT; use hg::dirstate::RANGE_MASK_31BIT;
use hg::errors::{HgError, IoResultExt}; use hg::errors::{HgError, IoResultExt};
} }
} }
let relative_paths = (!ui.plain()) let relative_paths = (!ui.plain())
&& config && config
.get_option(b"commands", b"status.relative")? .get_option(b"commands", b"status.relative")?
.unwrap_or(config.get_bool(b"ui", b"relative-paths")?); .unwrap_or(config.get_bool(b"ui", b"relative-paths")?);
let output = DisplayStatusPaths { let output = DisplayStatusPaths {
ui, ui,
repo,
no_status, no_status,
relative_paths, relativize: if relative_paths {
Some(RelativizePaths::new(repo)?)
} else {
None
},
}; };
if display_states.modified { if display_states.modified {
output.display(b"M", ds_status.modified)?; output.display(b"M", ds_status.modified)?;
} }
if display_states.added { if display_states.added {
output.display(b"A", ds_status.added)?; output.display(b"A", ds_status.added)?;
} }
if display_states.removed { if display_states.removed {
ignore_files.push(joined); ignore_files.push(joined);
} }
} }
ignore_files ignore_files
} }
struct DisplayStatusPaths<'a> { struct DisplayStatusPaths<'a> {
ui: &'a Ui, ui: &'a Ui,
repo: &'a Repo,
no_status: bool, no_status: bool,
relative_paths: bool, relativize: Option<RelativizePaths>,
} }
impl DisplayStatusPaths<'_> { impl DisplayStatusPaths<'_> {
// Probably more elegant to use a Deref or Borrow trait rather than // Probably more elegant to use a Deref or Borrow trait rather than
// harcode HgPathBuf, but probably not really useful at this point // harcode HgPathBuf, but probably not really useful at this point
fn display( fn display(
&self, &self,
status_prefix: &[u8], status_prefix: &[u8],
mut paths: Vec<HgPathCow>, mut paths: Vec<HgPathCow>,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
paths.sort_unstable(); paths.sort_unstable();
let print_path = |path: &[u8]| { for path in paths {
let relative;
let path = if let Some(relativize) = &self.relativize {
relative = relativize.relativize(&path);
&*relative
} else {
path.as_bytes()
};
// TODO optim, probably lots of unneeded copies here, especially // TODO optim, probably lots of unneeded copies here, especially
// if out stream is buffered // if out stream is buffered
if self.no_status { if self.no_status {
self.ui.write_stdout(&format_bytes!(b"{}\n", path)) self.ui.write_stdout(&format_bytes!(b"{}\n", path))?
} else { } else {
self.ui.write_stdout(&format_bytes!( self.ui.write_stdout(&format_bytes!(
b"{} {}\n", b"{} {}\n",
status_prefix, status_prefix,
path path
)) ))?
}
};
if self.relative_paths {
relativize_paths(self.repo, paths.iter().map(Ok), |path| {
print_path(&path)
})?;
} else {
for path in paths {
print_path(path.as_bytes())?
} }
} }
Ok(()) Ok(())
} }
} }
/// Check if a file is modified by comparing actual repo store and file system. /// Check if a file is modified by comparing actual repo store and file system.
/// ///

rust/rhg/src/utils/path_utils.rs

// path utils module // path utils module
// //
// 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 crate::error::CommandError;
use crate::ui::UiError;
use hg::errors::HgError; use hg::errors::HgError;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::current_dir; use hg::utils::current_dir;
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; use hg::utils::hg_path::HgPath;
use hg::utils::hg_path::HgPathBuf; use hg::utils::hg_path::HgPathBuf;
use std::borrow::Cow; use std::borrow::Cow;
pub fn relativize_paths( pub struct RelativizePaths {
repo: &Repo, repo_root: HgPathBuf,
paths: impl IntoIterator<Item = Result<impl AsRef<HgPath>, HgError>>, cwd: HgPathBuf,
mut callback: impl FnMut(Cow<[u8]>) -> Result<(), UiError>, outside_repo: bool,
) -> Result<(), CommandError> { }
impl RelativizePaths {
pub fn new(repo: &Repo) -> Result<Self, HgError> {
let cwd = current_dir()?; let cwd = current_dir()?;
let repo_root = repo.working_directory_path(); let repo_root = repo.working_directory_path();
let repo_root = cwd.join(repo_root); // Make it absolute let repo_root = cwd.join(repo_root); // Make it absolute
let repo_root_hgpath = let repo_root_hgpath =
HgPathBuf::from(get_bytes_from_path(repo_root.to_owned())); HgPathBuf::from(get_bytes_from_path(repo_root.to_owned()));
let outside_repo: bool;
let cwd_hgpath: HgPathBuf;
if let Ok(cwd_relative_to_repo) = cwd.strip_prefix(&repo_root) { if let Ok(cwd_relative_to_repo) = cwd.strip_prefix(&repo_root) {
// The current directory is inside the repo, so we can work with // The current directory is inside the repo, so we can work with
// relative paths // relative paths
outside_repo = false; Ok(Self {
cwd_hgpath = repo_root: repo_root_hgpath,
HgPathBuf::from(get_bytes_from_path(cwd_relative_to_repo)); cwd: HgPathBuf::from(get_bytes_from_path(
cwd_relative_to_repo,
)),
outside_repo: false,
})
} else { } else {
outside_repo = true; Ok(Self {
cwd_hgpath = HgPathBuf::from(get_bytes_from_path(cwd)); repo_root: repo_root_hgpath,
cwd: HgPathBuf::from(get_bytes_from_path(cwd)),
outside_repo: true,
})
}
} }
for file in paths { pub fn relativize<'a>(&self, path: &'a HgPath) -> Cow<'a, [u8]> {
if outside_repo { if self.outside_repo {
let file = repo_root_hgpath.join(file?.as_ref()); let joined = self.repo_root.join(path);
callback(relativize_path(&file, &cwd_hgpath))?; Cow::Owned(relativize_path(&joined, &self.cwd).into_owned())
} else { } else {
callback(relativize_path(file?.as_ref(), &cwd_hgpath))?; relativize_path(path, &self.cwd)
} }
} }
Ok(())
} }