( )⚙ D11613 rhg: refactor function to relativize paths in utils

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11613

rhg: refactor function to relativize paths in utils
ClosedPublic

Authored by pulkit on Oct 5 2021, 8:45 AM.

Details

Reviewers
martinvonz
Group Reviewers
hg-reviewers
Commits
rHG9ecf802b06e0: rhg: refactor function to relativize paths in utils
Summary

Commands like files, status supports printing relative paths. Hence we need
to re-use this code in other places too. So let's take this out from rhg files
into a utility function.

Next patch will make rhg status use it.

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

pulkit created this revision.Oct 5 2021, 8:45 AM
martinvonz accepted this revision.Oct 11 2021, 1:48 PM
martinvonz added a subscriber: martinvonz.
martinvonz added inline comments.
rust/rhg/src/utils/path_utils.rs
19

I generally find iterators easier to work with than callbacks. That makes error handling easier and it makes it easy to stop iteration at any point. I'll take this as is, but consider following up with a rewrite.

This revision is now accepted and ready to land.Oct 11 2021, 1:48 PM
pulkit added a commit: rHG9ecf802b06e0: rhg: refactor function to relativize paths in utils.Oct 11 2021, 2:31 PM
Closed by commit rHG9ecf802b06e0: rhg: refactor function to relativize paths in utils (authored by pulkit). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30701

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::relativize_paths;
use clap::Arg; use clap::Arg;
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::current_dir; use hg::utils::hg_path::HgPath;
use hg::utils::files::{get_bytes_from_path, relativize_path}; use std::borrow::Cow;
use hg::utils::hg_path::{HgPath, 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 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 = &'a HgPath>, files: impl IntoIterator<Item = &'a HgPath>,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
let cwd = current_dir()?;
let working_directory = repo.working_directory_path();
let working_directory = cwd.join(working_directory); // Make it absolute
let mut any = false; let mut any = false;
if let Ok(cwd_relative_to_repo) = cwd.strip_prefix(&working_directory) {
// The current directory is inside the repo, so we can work with
// relative paths
let cwd = HgPathBuf::from(get_bytes_from_path(cwd_relative_to_repo));
for file in files {
any = true;
stdout.write_all(relativize_path(&file, &cwd).as_ref())?;
stdout.write_all(b"\n")?;
}
} else {
let working_directory =
HgPathBuf::from(get_bytes_from_path(working_directory));
let cwd = HgPathBuf::from(get_bytes_from_path(cwd));
for file in files {
any = true;
// Absolute path in the filesystem
let file = working_directory.join(file);
stdout.write_all(relativize_path(&file, &cwd).as_ref())?;
stdout.write_all(b"\n")?;
}
}
relativize_paths(repo, files, |path: Cow<[u8]>| -> Result<(), UiError> {
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/main.rs

use hg::utils::SliceExt; use hg::utils::SliceExt;
use std::ffi::OsString; use std::ffi::OsString;
use std::path::PathBuf; use std::path::PathBuf;
use std::process::Command; use std::process::Command;
mod blackbox; mod blackbox;
mod error; mod error;
mod ui; mod ui;
pub mod utils {
pub mod path_utils;
}
use error::CommandError; use error::CommandError;
fn main_with_result( fn main_with_result(
process_start_time: &blackbox::ProcessStartTime, process_start_time: &blackbox::ProcessStartTime,
ui: &ui::Ui, ui: &ui::Ui,
repo: Result<&Repo, &NoRepoInCwdError>, repo: Result<&Repo, &NoRepoInCwdError>,
config: &Config, config: &Config,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {

rust/rhg/src/utils/path_utils.rs

  • This file was added.
// path utils module
//
// 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::error::CommandError;
use crate::ui::UiError;
use hg::repo::Repo;
use hg::utils::current_dir;
use hg::utils::files::{get_bytes_from_path, relativize_path};
use hg::utils::hg_path::HgPath;
use hg::utils::hg_path::HgPathBuf;
use std::borrow::Cow;
pub fn relativize_paths(
repo: &Repo,
paths: impl IntoIterator<Item = impl AsRef<HgPath>>,
mut callback: impl FnMut(Cow<[u8]>) -> Result<(), UiError>,
) -> Result<(), CommandError> {
martinvonzUnsubmitted
Not Done

I generally find iterators easier to work with than callbacks. That makes error handling easier and it makes it easy to stop iteration at any point. I'll take this as is, but consider following up with a rewrite.

martinvonz: I generally find iterators easier to work with than callbacks. That makes error handling easier…
let cwd = current_dir()?;
let repo_root = repo.working_directory_path();
let repo_root = cwd.join(repo_root); // Make it absolute
let repo_root_hgpath =
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) {
// The current directory is inside the repo, so we can work with
// relative paths
outside_repo = false;
cwd_hgpath =
HgPathBuf::from(get_bytes_from_path(cwd_relative_to_repo));
} else {
outside_repo = true;
cwd_hgpath = HgPathBuf::from(get_bytes_from_path(cwd));
}
for file in paths {
if outside_repo {
let file = repo_root_hgpath.join(file.as_ref());
callback(relativize_path(&file, &cwd_hgpath))?;
} else {
callback(relativize_path(file.as_ref(), &cwd_hgpath))?;
}
}
Ok(())
}