This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11815

rhg: Add support for `rhg status -n`
ClosedPublic

Authored by SimonSapin on Nov 26 2021, 10:00 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGc12ed33558cb: rhg: Add support for `rhg status -n`
Summary

The RHG_STATUS=1 bit added here can be removed when unset RHG_STATUS near
the top of the file is removed.

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

SimonSapin created this revision.Nov 26 2021, 10:00 AM
Alphare accepted this revision.Nov 26 2021, 10:08 AM
This revision is now accepted and ready to land.Nov 26 2021, 10:08 AM
SimonSapin added a commit: rHGc12ed33558cb: rhg: Add support for `rhg status -n`.Nov 26 2021, 10:36 AM
Closed by commit rHGc12ed33558cb: rhg: Add support for `rhg status -n` (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/rhg/src/commands/status.rs (103 lines)
Mtests/test-status.t (7 lines)

Diff 31166

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, UiError}; use crate::ui::Ui;
use crate::utils::path_utils::relativize_paths; use crate::utils::path_utils::relativize_paths;
use clap::{Arg, SubCommand}; use clap::{Arg, SubCommand};
use format_bytes::format_bytes;
use hg; use hg;
use hg::config::Config; use hg::config::Config;
use hg::dirstate::{has_exec_bit, TruncatedTimestamp}; use hg::dirstate::{has_exec_bit, TruncatedTimestamp};
use hg::errors::HgError; use hg::errors::HgError;
use hg::manifest::Manifest; use hg::manifest::Manifest;
use hg::matchers::AlwaysMatcher; use hg::matchers::AlwaysMatcher;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::files::get_bytes_from_os_string; use hg::utils::files::get_bytes_from_os_string;
use hg::utils::hg_path::{hg_path_to_os_string, HgPath}; use hg::utils::hg_path::{hg_path_to_os_string, HgPath};
use hg::{HgPathCow, StatusOptions}; use hg::{HgPathCow, StatusOptions};
use log::{info, warn}; use log::{info, warn};
use std::borrow::Cow;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Show changed files in the working directory Show changed files in the working directory
This is a pure Rust version of `hg status`. This is a pure Rust version of `hg status`.
Some options might be missing, check the list below. Some options might be missing, check the list below.
"; ";
.long("--unknown"), .long("--unknown"),
) )
.arg( .arg(
Arg::with_name("ignored") Arg::with_name("ignored")
.help("show only ignored files") .help("show only ignored files")
.short("-i") .short("-i")
.long("--ignored"), .long("--ignored"),
) )
.arg(
Arg::with_name("no-status")
.help("hide status prefix")
.short("-n")
.long("--no-status"),
)
} }
/// Pure data type allowing the caller to specify file states to display /// Pure data type allowing the caller to specify file states to display
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]
pub struct DisplayStates { pub struct DisplayStates {
pub modified: bool, pub modified: bool,
pub added: bool, pub added: bool,
pub removed: bool, pub removed: bool,
ignored: args.is_present("ignored"), ignored: args.is_present("ignored"),
}; };
if requested.is_empty() { if requested.is_empty() {
DEFAULT_DISPLAY_STATES DEFAULT_DISPLAY_STATES
} else { } else {
requested requested
} }
}; };
let no_status = args.is_present("no-status");
let repo = invocation.repo?; let repo = invocation.repo?;
let mut dmap = repo.dirstate_map_mut()?; let mut dmap = repo.dirstate_map_mut()?;
let options = StatusOptions { let options = StatusOptions {
// TODO should be provided by the dirstate parsing and // TODO should be provided by the dirstate parsing and
// hence be stored on dmap. Using a value that assumes we aren't // hence be stored on dmap. Using a value that assumes we aren't
// below the time resolution granularity of the FS and the // below the time resolution granularity of the FS and the
} 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, repo, config, &mut ds_status.modified, b"M")?; display_status_paths(
ui,
repo,
config,
no_status,
&mut ds_status.modified,
b"M",
)?;
} }
if display_states.added { if display_states.added {
display_status_paths(ui, repo, config, &mut ds_status.added, b"A")?; display_status_paths(
ui,
repo,
config,
no_status,
&mut ds_status.added,
b"A",
)?;
} }
if display_states.removed { if display_states.removed {
display_status_paths(ui, repo, config, &mut ds_status.removed, b"R")?; display_status_paths(
ui,
repo,
config,
no_status,
&mut ds_status.removed,
b"R",
)?;
} }
if display_states.deleted { if display_states.deleted {
display_status_paths(ui, repo, config, &mut ds_status.deleted, b"!")?; display_status_paths(
ui,
repo,
config,
no_status,
&mut ds_status.deleted,
b"!",
)?;
} }
if display_states.unknown { if display_states.unknown {
display_status_paths(ui, repo, config, &mut ds_status.unknown, b"?")?; display_status_paths(
ui,
repo,
config,
no_status,
&mut ds_status.unknown,
b"?",
)?;
} }
if display_states.ignored { if display_states.ignored {
display_status_paths(ui, repo, config, &mut ds_status.ignored, b"I")?; display_status_paths(
ui,
repo,
config,
no_status,
&mut ds_status.ignored,
b"I",
)?;
} }
if display_states.clean { if display_states.clean {
display_status_paths(ui, repo, config, &mut ds_status.clean, b"C")?; display_status_paths(
ui,
repo,
config,
no_status,
&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, repo: &Repo,
config: &Config, config: &Config,
no_status: bool,
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")?; let mut relative: bool = config.get_bool(b"ui", b"relative-paths")?;
relative = config relative = config
.get_option(b"commands", b"status.relative")? .get_option(b"commands", b"status.relative")?
.unwrap_or(relative); .unwrap_or(relative);
let print_path = |path: &[u8]| {
// TODO optim, probably lots of unneeded copies here, especially
// if out stream is buffered
if no_status {
ui.write_stdout(&format_bytes!(b"{}\n", path))
} else {
ui.write_stdout(&format_bytes!(b"{} {}\n", status_prefix, path))
}
};
if relative && !ui.plain() { if relative && !ui.plain() {
relativize_paths( relativize_paths(repo, paths.iter().map(Ok), |path| {
repo, print_path(&path)
paths.iter().map(Ok), })?;
|path: Cow<[u8]>| -> Result<(), UiError> {
ui.write_stdout(
&[status_prefix, b" ", path.as_ref(), b"\n"].concat(),
)
},
)?;
} else { } else {
for path in paths { for path in paths {
// Same TODO as in commands::root print_path(path.as_bytes())?
let bytes: &[u8] = path.as_bytes();
// TODO optim, probably lots of unneeded copies here, especially
// if out stream is buffered
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

tests/test-status.t

hg status: hg status:
$ hg status $ hg status
A added A added
R removed R removed
! deleted ! deleted
? unknown ? unknown
hg status -n:
$ env RHG_STATUS=1 RHG_ON_UNSUPPORTED=abort hg status -n
added
removed
deleted
unknown
hg status modified added removed deleted unknown never-existed ignored: hg status modified added removed deleted unknown never-existed ignored:
$ hg status modified added removed deleted unknown never-existed ignored $ hg status modified added removed deleted unknown never-existed ignored
never-existed: * (glob) never-existed: * (glob)
A added A added
R removed R removed
! deleted ! deleted
? unknown ? unknown