This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11897

rhg: refactor display_status_paths with a struct for common arguments
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG2afaa0145584: rhg: refactor display_status_paths with a struct for common arguments

Diff Detail

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

Revision Contents
Changeset List

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

Diff 31430

rust/rhg/src/commands/status.rs

} else { } else {
if display_states.clean { if display_states.clean {
ds_status.clean.push(to_check.clone()); ds_status.clean.push(to_check.clone());
} }
fixup.push(to_check.into_owned()) fixup.push(to_check.into_owned())
} }
} }
} }
if display_states.modified { let relative_paths = (!ui.plain())
display_status_paths( && config
.get_option(b"commands", b"status.relative")?
.unwrap_or(config.get_bool(b"ui", b"relative-paths")?);
let output = DisplayStatusPaths {
ui, ui,
repo, repo,
config,
no_status, no_status,
&mut ds_status.modified, relative_paths,
b"M", };
)?; if display_states.modified {
output.display(b"M", ds_status.modified)?;
} }
if display_states.added { if display_states.added {
display_status_paths( output.display(b"A", ds_status.added)?;
ui,
repo,
config,
no_status,
&mut ds_status.added,
b"A",
)?;
} }
if display_states.removed { if display_states.removed {
display_status_paths( output.display(b"R", ds_status.removed)?;
ui,
repo,
config,
no_status,
&mut ds_status.removed,
b"R",
)?;
} }
if display_states.deleted { if display_states.deleted {
display_status_paths( output.display(b"!", ds_status.deleted)?;
ui,
repo,
config,
no_status,
&mut ds_status.deleted,
b"!",
)?;
} }
if display_states.unknown { if display_states.unknown {
display_status_paths( output.display(b"?", ds_status.unknown)?;
ui,
repo,
config,
no_status,
&mut ds_status.unknown,
b"?",
)?;
} }
if display_states.ignored { if display_states.ignored {
display_status_paths( output.display(b"I", ds_status.ignored)?;
ui,
repo,
config,
no_status,
&mut ds_status.ignored,
b"I",
)?;
} }
if display_states.clean { if display_states.clean {
display_status_paths( output.display(b"C", ds_status.clean)?;
ui,
repo,
config,
no_status,
&mut ds_status.clean,
b"C",
)?;
} }
let mut dirstate_write_needed = ds_status.dirty; let mut dirstate_write_needed = ds_status.dirty;
let filesystem_time_at_status_start = ds_status let filesystem_time_at_status_start = ds_status
.filesystem_time_at_status_start .filesystem_time_at_status_start
.map(TruncatedTimestamp::from); .map(TruncatedTimestamp::from);
if (fixup.is_empty() || filesystem_time_at_status_start.is_none()) if (fixup.is_empty() || filesystem_time_at_status_start.is_none())
let joined = repo.working_directory_path().join(path); let joined = repo.working_directory_path().join(path);
ignore_files.push(joined); ignore_files.push(joined);
} }
} }
ignore_files ignore_files
} }
struct DisplayStatusPaths<'a> {
ui: &'a Ui,
repo: &'a Repo,
no_status: bool,
relative_paths: bool,
}
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_status_paths( fn display(
ui: &Ui, &self,
repo: &Repo,
config: &Config,
no_status: bool,
paths: &mut [HgPathCow],
status_prefix: &[u8], status_prefix: &[u8],
mut paths: Vec<HgPathCow>,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
paths.sort_unstable(); paths.sort_unstable();
let mut relative: bool = config.get_bool(b"ui", b"relative-paths")?;
relative = config
.get_option(b"commands", b"status.relative")?
.unwrap_or(relative);
let print_path = |path: &[u8]| { let print_path = |path: &[u8]| {
// 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 no_status { if self.no_status {
ui.write_stdout(&format_bytes!(b"{}\n", path)) self.ui.write_stdout(&format_bytes!(b"{}\n", path))
} else { } else {
ui.write_stdout(&format_bytes!(b"{} {}\n", status_prefix, path)) self.ui.write_stdout(&format_bytes!(
b"{} {}\n",
status_prefix,
path
))
} }
}; };
if relative && !ui.plain() { if self.relative_paths {
relativize_paths(repo, paths.iter().map(Ok), |path| { relativize_paths(self.repo, paths.iter().map(Ok), |path| {
print_path(&path) print_path(&path)
})?; })?;
} else { } else {
for path in paths { for path in paths {
print_path(path.as_bytes())? 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.
/// ///
/// 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.
fn unsure_is_modified( fn unsure_is_modified(
repo: &Repo, repo: &Repo,
manifest: &Manifest, manifest: &Manifest,