This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10911

rhg: add relative path output functionality in status command
AbandonedPublic

Authored by pulkit on Jun 25 2021, 5:34 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers

Diff Detail

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

Event Timeline

pulkit created this revision.Jun 25 2021, 5:34 AM
SimonSapin added a subscriber: SimonSapin.Jun 29 2021, 1:41 PM

Rather than semi-duplicating the logic from rhg files just to move it to a reusable function in the next commit, I’d prefer to extract it from rhg files into something reusable first and then use it here in rhg status.

pulkit planned changes to this revision.Oct 5 2021, 7:49 AM
pulkit abandoned this revision.Oct 5 2021, 8:48 AM

Revision Contents
Changeset List

PathPackages
Mrust/rhg/src/commands/status.rs (83 lines)

Diff 28696

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, UiError};
use clap::{Arg, SubCommand}; use clap::{Arg, SubCommand};
use hg; use hg;
use hg::config::Config;
use hg::dirstate_tree::dirstate_map::DirstateMap; use hg::dirstate_tree::dirstate_map::DirstateMap;
use hg::errors::HgResultExt; use hg::errors::HgResultExt;
use hg::errors::IoResultExt; use hg::errors::IoResultExt;
use hg::matchers::AlwaysMatcher; use hg::matchers::AlwaysMatcher;
use hg::operations::cat; use hg::operations::cat;
use hg::repo::Repo; use hg::repo::Repo;
use hg::revlog::node::Node; use hg::revlog::node::Node;
use hg::utils::current_dir;
use hg::utils::files::{get_bytes_from_path, relativize_path};
use hg::utils::hg_path::HgPathBuf;
use hg::utils::hg_path::{hg_path_to_os_string, HgPath}; use hg::utils::hg_path::{hg_path_to_os_string, HgPath};
use hg::StatusError; use hg::StatusError;
use hg::{HgPathCow, StatusOptions}; use hg::{HgPathCow, StatusOptions};
use log::{info, warn}; use log::{info, warn};
use std::convert::TryInto; use std::convert::TryInto;
use std::fs; use std::fs;
use std::io::BufReader; use std::io::BufReader;
use std::io::Read; use std::io::Read;
} }
if invocation.config.get_bool(b"ui", b"statuscopies").ok() == Some(true) { if invocation.config.get_bool(b"ui", b"statuscopies").ok() == Some(true) {
return Err(CommandError::unsupported( return Err(CommandError::unsupported(
"ui.statuscopies is not yet supported with rhg status", "ui.statuscopies is not yet supported with rhg status",
)); ));
} }
let ui = invocation.ui; let ui = invocation.ui;
let config = invocation.config;
let args = invocation.subcommand_args; let args = invocation.subcommand_args;
let display_states = if args.is_present("all") { let display_states = if args.is_present("all") {
// TODO when implementing `--quiet`: it excludes clean files // TODO when implementing `--quiet`: it excludes clean files
// from `--all` // from `--all`
ALL_DISPLAY_STATES ALL_DISPLAY_STATES
} else { } else {
let requested = DisplayStates { let requested = DisplayStates {
modified: args.is_present("modified"), modified: args.is_present("modified"),
} else { } else {
if display_states.clean { if display_states.clean {
ds_status.clean.push(to_check); ds_status.clean.push(to_check);
} }
} }
} }
} }
if display_states.modified { if display_states.modified {
display_status_paths(ui, &mut ds_status.modified, b"M")?; display_status_paths(ui, repo, config, &mut ds_status.modified, b"M")?;
} }
if display_states.added { if display_states.added {
display_status_paths(ui, &mut ds_status.added, b"A")?; display_status_paths(ui, repo, config, &mut ds_status.added, b"A")?;
} }
if display_states.removed { if display_states.removed {
display_status_paths(ui, &mut ds_status.removed, b"R")?; display_status_paths(ui, repo, config, &mut ds_status.removed, b"R")?;
} }
if display_states.deleted { if display_states.deleted {
display_status_paths(ui, &mut ds_status.deleted, b"!")?; display_status_paths(ui, repo, config, &mut ds_status.deleted, b"!")?;
} }
if display_states.unknown { if display_states.unknown {
display_status_paths(ui, &mut ds_status.unknown, b"?")?; display_status_paths(ui, repo, config, &mut ds_status.unknown, b"?")?;
} }
if display_states.ignored { if display_states.ignored {
display_status_paths(ui, &mut ds_status.ignored, b"I")?; display_status_paths(ui, repo, config, &mut ds_status.ignored, b"I")?;
} }
if display_states.clean { if display_states.clean {
display_status_paths(ui, &mut ds_status.clean, b"C")?; display_status_paths(ui, repo, config, &mut ds_status.clean, b"C")?;
} }
Ok(()) Ok(())
} }
// 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_status_paths( fn display_status_paths(
ui: &Ui, ui: &Ui,
repo: &Repo,
config: &Config,
paths: &mut [HgPathCow], paths: &mut [HgPathCow],
status_prefix: &[u8], status_prefix: &[u8],
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
paths.sort_unstable(); paths.sort_unstable();
let mut relative: bool =
config.get_bool(b"ui", b"relative-paths").unwrap_or(false);
relative = config
.get_bool(b"commands", b"status.relative")
.unwrap_or(relative);
if relative {
let cwd = current_dir()?;
let working_directory = repo.working_directory_path();
let working_directory = cwd.join(working_directory); // Make it absolute
let working_directory_hgpath =
HgPathBuf::from(get_bytes_from_path(working_directory.to_owned()));
let outside_repo: bool;
let cwd_hgpath: HgPathBuf;
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
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));
}
let print_path = |path: &HgPath| -> Result<(), UiError> {
ui.write_stdout(
&[
status_prefix,
b" ",
relativize_path(path, &cwd_hgpath).as_ref(),
b"\n",
]
.concat(),
)
};
for file in paths {
if outside_repo {
let file = working_directory_hgpath.join(file);
print_path(&file)?;
} else {
print_path(file)?;
}
}
} else {
for path in paths { for path in paths {
// Same TODO as in commands::root // Same TODO as in commands::root
let bytes: &[u8] = path.as_bytes(); let bytes: &[u8] = 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
ui.write_stdout(&[status_prefix, b" ", bytes, b"\n"].concat())?; ui.write_stdout(&[status_prefix, b" ", bytes, b"\n"].concat())?;
} }
}
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.
/// ///
/// This meant to be used for those that the dirstate cannot resolve, due /// This meant to be used for those that the dirstate cannot resolve, due
/// to time resolution limits. /// to time resolution limits.
/// ///