( )⚙ D10003 rhg: Group values passed to every sub-command into a struct

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10003

rhg: Group values passed to every sub-command into a struct
ClosedPublic

Authored by SimonSapin on Feb 17 2021, 7:57 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG80840b651721: rhg: Group values passed to every sub-command into a struct
rHGd5d0b3306771: rhg: Group values passed to every sub-command into a struct
Summary

The set of which values this is is evidently not stable yet,
so this will make changes easier. Also it is growing, and the function
signatures are getting out hand.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Feb 17 2021, 7:57 AM
Alphare accepted this revision.Feb 18 2021, 3:53 AM
Alphare added a subscriber: Alphare.
Alphare added inline comments.
rust/rhg/src/main.rs
145

Possibly this should get a docstring.

SimonSapin added a commit: rHGd5d0b3306771: rhg: Group values passed to every sub-command into a struct.Feb 24 2021, 11:07 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGd5d0b3306771: rhg: Group values passed to every sub-command into a struct (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25640

rust/rhg/src/commands/cat.rs

use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui;
use clap::Arg; use clap::Arg;
use clap::ArgMatches;
use hg::config::Config;
use hg::operations::cat; use hg::operations::cat;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::hg_path::HgPathBuf; use hg::utils::hg_path::HgPathBuf;
use micro_timer::timed; use micro_timer::timed;
use std::convert::TryFrom; use std::convert::TryFrom;
use std::path::Path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Output the current or given revision of files Output the current or given revision of files
"; ";
pub fn args() -> clap::App<'static, 'static> { pub fn args() -> clap::App<'static, 'static> {
clap::SubCommand::with_name("cat") clap::SubCommand::with_name("cat")
.arg( .arg(
.empty_values(false) .empty_values(false)
.value_name("FILE") .value_name("FILE")
.help("Activity to start: activity@category"), .help("Activity to start: activity@category"),
) )
.about(HELP_TEXT) .about(HELP_TEXT)
} }
#[timed] #[timed]
pub fn run( pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
ui: &Ui, let rev = invocation.subcommand_args.value_of("rev");
config: &Config, let file_args = match invocation.subcommand_args.values_of("files") {
repo_path: Option<&Path>,
args: &ArgMatches,
) -> Result<(), CommandError> {
let rev = args.value_of("rev");
let file_args = match args.values_of("files") {
Some(files) => files.collect(), Some(files) => files.collect(),
None => vec![], None => vec![],
}; };
let repo = Repo::find(config, repo_path)?; let repo = Repo::find(invocation.non_repo_config, invocation.repo_path)?;
let cwd = hg::utils::current_dir()?; let cwd = hg::utils::current_dir()?;
let mut files = vec![]; let mut files = vec![];
for file in file_args.iter() { for file in file_args.iter() {
// TODO: actually normalize `..` path segments etc? // TODO: actually normalize `..` path segments etc?
let normalized = cwd.join(&file); let normalized = cwd.join(&file);
let stripped = normalized let stripped = normalized
.strip_prefix(&repo.working_directory_path()) .strip_prefix(&repo.working_directory_path())
// TODO: error message for path arguments outside of the repo // TODO: error message for path arguments outside of the repo
.map_err(|_| CommandError::abort(""))?; .map_err(|_| CommandError::abort(""))?;
let hg_file = HgPathBuf::try_from(stripped.to_path_buf()) let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
.map_err(|e| CommandError::abort(e.to_string()))?; .map_err(|e| CommandError::abort(e.to_string()))?;
files.push(hg_file); files.push(hg_file);
} }
match rev { match rev {
Some(rev) => { Some(rev) => {
let data = cat(&repo, rev, &files).map_err(|e| (e, rev))?; let data = cat(&repo, rev, &files).map_err(|e| (e, rev))?;
ui.write_stdout(&data)?; invocation.ui.write_stdout(&data)?;
Ok(()) Ok(())
} }
None => Err(CommandError::Unimplemented.into()), None => Err(CommandError::Unimplemented.into()),
} }
} }

rust/rhg/src/commands/config.rs

use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui;
use clap::Arg; use clap::Arg;
use clap::ArgMatches;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::config::Config;
use hg::errors::HgError; use hg::errors::HgError;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::SliceExt; use hg::utils::SliceExt;
use std::path::Path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
With one argument of the form section.name, print just the value of that config item. With one argument of the form section.name, print just the value of that config item.
"; ";
pub fn args() -> clap::App<'static, 'static> { pub fn args() -> clap::App<'static, 'static> {
clap::SubCommand::with_name("config") clap::SubCommand::with_name("config")
.arg( .arg(
Arg::with_name("name") Arg::with_name("name")
.help("the section.name to print") .help("the section.name to print")
.value_name("NAME") .value_name("NAME")
.required(true) .required(true)
.takes_value(true), .takes_value(true),
) )
.about(HELP_TEXT) .about(HELP_TEXT)
} }
pub fn run( pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
ui: &Ui, let opt_repo =
config: &Config, Repo::find_optional(invocation.non_repo_config, invocation.repo_path)?;
repo_path: Option<&Path>,
args: &ArgMatches,
) -> Result<(), CommandError> {
let opt_repo = Repo::find_optional(config, repo_path)?;
let config = if let Some(repo) = &opt_repo { let config = if let Some(repo) = &opt_repo {
repo.config() repo.config()
} else { } else {
config invocation.non_repo_config
}; };
let (section, name) = invocation
let (section, name) = args .subcommand_args
.value_of("name") .value_of("name")
.expect("missing required CLI argument") .expect("missing required CLI argument")
.as_bytes() .as_bytes()
.split_2(b'.') .split_2(b'.')
.ok_or_else(|| HgError::abort(""))?; .ok_or_else(|| HgError::abort(""))?;
let value = config.get(section, name).unwrap_or(b""); let value = config.get(section, name).unwrap_or(b"");
ui.write_stdout(&format_bytes!(b"{}\n", value))?; invocation.ui.write_stdout(&format_bytes!(b"{}\n", value))?;
Ok(()) Ok(())
} }

rust/rhg/src/commands/debugdata.rs

use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui;
use clap::Arg; use clap::Arg;
use clap::ArgGroup; use clap::ArgGroup;
use clap::ArgMatches;
use hg::config::Config;
use hg::operations::{debug_data, DebugDataKind}; use hg::operations::{debug_data, DebugDataKind};
use hg::repo::Repo; use hg::repo::Repo;
use micro_timer::timed; use micro_timer::timed;
use std::path::Path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Dump the contents of a data file revision Dump the contents of a data file revision
"; ";
pub fn args() -> clap::App<'static, 'static> { pub fn args() -> clap::App<'static, 'static> {
clap::SubCommand::with_name("debugdata") clap::SubCommand::with_name("debugdata")
.arg( .arg(
.help("revision") .help("revision")
.required(true) .required(true)
.value_name("REV"), .value_name("REV"),
) )
.about(HELP_TEXT) .about(HELP_TEXT)
} }
#[timed] #[timed]
pub fn run( pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
ui: &Ui, let args = invocation.subcommand_args;
config: &Config,
repo_path: Option<&Path>,
args: &ArgMatches,
) -> Result<(), CommandError> {
let rev = args let rev = args
.value_of("rev") .value_of("rev")
.expect("rev should be a required argument"); .expect("rev should be a required argument");
let kind = let kind =
match (args.is_present("changelog"), args.is_present("manifest")) { match (args.is_present("changelog"), args.is_present("manifest")) {
(true, false) => DebugDataKind::Changelog, (true, false) => DebugDataKind::Changelog,
(false, true) => DebugDataKind::Manifest, (false, true) => DebugDataKind::Manifest,
(true, true) => { (true, true) => {
unreachable!("Should not happen since options are exclusive") unreachable!("Should not happen since options are exclusive")
} }
(false, false) => { (false, false) => {
unreachable!("Should not happen since options are required") unreachable!("Should not happen since options are required")
} }
}; };
let repo = Repo::find(config, repo_path)?; let repo = Repo::find(invocation.non_repo_config, invocation.repo_path)?;
let data = debug_data(&repo, rev, kind).map_err(|e| (e, rev))?; let data = debug_data(&repo, rev, kind).map_err(|e| (e, rev))?;
let mut stdout = ui.stdout_buffer(); let mut stdout = invocation.ui.stdout_buffer();
stdout.write_all(&data)?; stdout.write_all(&data)?;
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }

rust/rhg/src/commands/debugrequirements.rs

use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui;
use clap::ArgMatches;
use hg::config::Config;
use hg::repo::Repo; use hg::repo::Repo;
use std::path::Path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the current repo requirements. Print the current repo requirements.
"; ";
pub fn args() -> clap::App<'static, 'static> { pub fn args() -> clap::App<'static, 'static> {
clap::SubCommand::with_name("debugrequirements").about(HELP_TEXT) clap::SubCommand::with_name("debugrequirements").about(HELP_TEXT)
} }
pub fn run( pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
ui: &Ui, let repo = Repo::find(invocation.non_repo_config, invocation.repo_path)?;
config: &Config,
repo_path: Option<&Path>,
_args: &ArgMatches,
) -> Result<(), CommandError> {
let repo = Repo::find(config, repo_path)?;
let mut output = String::new(); let mut output = String::new();
let mut requirements: Vec<_> = repo.requirements().iter().collect(); let mut requirements: Vec<_> = repo.requirements().iter().collect();
requirements.sort(); requirements.sort();
for req in requirements { for req in requirements {
output.push_str(req); output.push_str(req);
output.push('\n'); output.push('\n');
} }
ui.write_stdout(output.as_bytes())?; invocation.ui.write_stdout(output.as_bytes())?;
Ok(()) Ok(())
} }

rust/rhg/src/commands/files.rs

use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use clap::Arg; use clap::Arg;
use clap::ArgMatches;
use hg::config::Config;
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::files::{get_bytes_from_path, relativize_path}; use hg::utils::files::{get_bytes_from_path, relativize_path};
use hg::utils::hg_path::{HgPath, HgPathBuf}; use hg::utils::hg_path::{HgPath, HgPathBuf};
use std::path::Path;
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> {
clap::SubCommand::with_name("files") clap::SubCommand::with_name("files")
.arg( .arg(
Arg::with_name("rev") Arg::with_name("rev")
.help("search the repository as it is in REV") .help("search the repository as it is in REV")
.short("-r") .short("-r")
.long("--revision") .long("--revision")
.value_name("REV") .value_name("REV")
.takes_value(true), .takes_value(true),
) )
.about(HELP_TEXT) .about(HELP_TEXT)
} }
pub fn run( pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
ui: &Ui, let rev = invocation.subcommand_args.value_of("rev");
config: &Config,
repo_path: Option<&Path>,
args: &ArgMatches,
) -> Result<(), CommandError> {
let rev = args.value_of("rev");
let repo = Repo::find(config, repo_path)?; let repo = Repo::find(invocation.non_repo_config, invocation.repo_path)?;
if let Some(rev) = rev { if let Some(rev) = rev {
let files = let files =
list_rev_tracked_files(&repo, rev).map_err(|e| (e, rev))?; list_rev_tracked_files(&repo, rev).map_err(|e| (e, rev))?;
display_files(ui, &repo, files.iter()) display_files(invocation.ui, &repo, files.iter())
} else { } else {
let distate = Dirstate::new(&repo)?; let distate = Dirstate::new(&repo)?;
let files = distate.tracked_files()?; let files = distate.tracked_files()?;
display_files(ui, &repo, files) display_files(invocation.ui, &repo, files)
} }
} }
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> {

rust/rhg/src/commands/root.rs

use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui;
use clap::ArgMatches;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::config::Config;
use hg::repo::Repo; use hg::repo::Repo;
use hg::utils::files::get_bytes_from_path; use hg::utils::files::get_bytes_from_path;
use std::path::Path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the root directory of the current repository. Print the root directory of the current repository.
Returns 0 on success. Returns 0 on success.
"; ";
pub fn args() -> clap::App<'static, 'static> { pub fn args() -> clap::App<'static, 'static> {
clap::SubCommand::with_name("root").about(HELP_TEXT) clap::SubCommand::with_name("root").about(HELP_TEXT)
} }
pub fn run( pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
ui: &Ui, let repo = Repo::find(invocation.non_repo_config, invocation.repo_path)?;
config: &Config,
repo_path: Option<&Path>,
_args: &ArgMatches,
) -> Result<(), CommandError> {
let repo = Repo::find(config, repo_path)?;
let bytes = get_bytes_from_path(repo.working_directory_path()); let bytes = get_bytes_from_path(repo.working_directory_path());
ui.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?; invocation
.ui
.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?;
Ok(()) Ok(())
} }

rust/rhg/src/main.rs

extern crate log; extern crate log;
use crate::ui::Ui;
use clap::App; use clap::App;
use clap::AppSettings; use clap::AppSettings;
use clap::Arg; use clap::Arg;
use clap::ArgMatches; use clap::ArgMatches;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::config::Config;
use std::path::Path; use std::path::Path;
mod error; mod error;
mod exitcode; mod exitcode;
mod ui; mod ui;
use error::CommandError; use error::CommandError;
fn add_global_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> { fn add_global_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
let app = add_global_args(app); let app = add_global_args(app);
let app = add_subcommand_args(app); let app = add_subcommand_args(app);
let matches = app.clone().get_matches_safe()?; let matches = app.clone().get_matches_safe()?;
let (subcommand_name, subcommand_matches) = matches.subcommand(); let (subcommand_name, subcommand_matches) = matches.subcommand();
let run = subcommand_run_fn(subcommand_name) let run = subcommand_run_fn(subcommand_name)
.expect("unknown subcommand name from clap despite AppSettings::SubcommandRequired"); .expect("unknown subcommand name from clap despite AppSettings::SubcommandRequired");
let args = subcommand_matches let subcommand_args = subcommand_matches
.expect("no subcommand arguments from clap despite AppSettings::SubcommandRequired"); .expect("no subcommand arguments from clap despite AppSettings::SubcommandRequired");
// Global arguments can be in either based on e.g. `hg -R ./foo log` v.s. // Global arguments can be in either based on e.g. `hg -R ./foo log` v.s.
// `hg log -R ./foo` // `hg log -R ./foo`
let value_of_global_arg = let value_of_global_arg = |name| {
|name| args.value_of_os(name).or_else(|| matches.value_of_os(name)); subcommand_args
.value_of_os(name)
.or_else(|| matches.value_of_os(name))
};
// For arguments where multiple occurences are allowed, return a // For arguments where multiple occurences are allowed, return a
// possibly-iterator of all values. // possibly-iterator of all values.
let values_of_global_arg = |name: &str| { let values_of_global_arg = |name: &str| {
let a = matches.values_of_os(name).into_iter().flatten(); let a = matches.values_of_os(name).into_iter().flatten();
let b = args.values_of_os(name).into_iter().flatten(); let b = subcommand_args.values_of_os(name).into_iter().flatten();
a.chain(b) a.chain(b)
}; };
let repo_path = value_of_global_arg("repository").map(Path::new);
let config_args = values_of_global_arg("config") let config_args = values_of_global_arg("config")
// `get_bytes_from_path` works for OsStr the same as for Path // `get_bytes_from_path` works for OsStr the same as for Path
.map(hg::utils::files::get_bytes_from_path); .map(hg::utils::files::get_bytes_from_path);
let config = hg::config::Config::load(config_args)?; let non_repo_config = &hg::config::Config::load(config_args)?;
run(&ui, &config, repo_path, args)
let repo_path = value_of_global_arg("repository").map(Path::new);
run(&CliInvocation {
ui,
subcommand_args,
non_repo_config,
repo_path,
})
} }
fn main() { fn main() {
let ui = ui::Ui::new(); let ui = Ui::new();
let exit_code = match main_with_result(&ui) { let exit_code = match main_with_result(&ui) {
Ok(()) => exitcode::OK, Ok(()) => exitcode::OK,
// Exit with a specific code and no error message to let a potential // Exit with a specific code and no error message to let a potential
// wrapper script fallback to Python-based Mercurial. // wrapper script fallback to Python-based Mercurial.
Err(CommandError::Unimplemented) => exitcode::UNIMPLEMENTED, Err(CommandError::Unimplemented) => exitcode::UNIMPLEMENTED,
fn add_subcommand_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> { fn add_subcommand_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
app app
$( $(
.subcommand(add_global_args(commands::$command::args())) .subcommand(add_global_args(commands::$command::args()))
)+ )+
} }
fn subcommand_run_fn(name: &str) -> Option<fn( pub type RunFn = fn(&CliInvocation) -> Result<(), CommandError>;
&ui::Ui,
&hg::config::Config, fn subcommand_run_fn(name: &str) -> Option<RunFn> {
Option<&Path>,
&ArgMatches,
) -> Result<(), CommandError>> {
match name { match name {
$( $(
stringify!($command) => Some(commands::$command::run), stringify!($command) => Some(commands::$command::run),
)+ )+
_ => None, _ => None,
} }
} }
}; };
} }
subcommands! { subcommands! {
cat cat
debugdata debugdata
debugrequirements debugrequirements
files files
root root
config config
} }
pub struct CliInvocation<'a> {
AlphareUnsubmitted
Not Done

Possibly this should get a docstring.

Alphare: Possibly this should get a docstring.
ui: &'a Ui,
subcommand_args: &'a ArgMatches<'a>,
non_repo_config: &'a Config,
repo_path: Option<&'a Path>,
}