This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9970

rhg: Add support for -R and --repository command-line arguments
ClosedPublic

Authored by SimonSapin on Feb 8 2021, 5:44 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGd8730ff51d5a: rhg: Add support for -R and --repository command-line arguments
rHG1a00a578972f: rhg: Add support for -R and --repository command-line arguments

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.Feb 8 2021, 5:44 PM
Alphare added a subscriber: Alphare.Feb 9 2021, 4:21 AM
Alphare added inline comments.
rust/hg-core/src/repo.rs
57

TIL that some_path.join(some_absolute_path) == some_abolute_path, which makes sense.

rust/rhg/src/commands/files.rs
57–59

There exists a path_to_hg_path_buf util that you should probably use here and below.

64–65

We should see if working_directory is the same as cwd so as to not allocate in the common path. files is a performance-sensitive command in CI/server environments.

tests/test-rhg.t
14

Just to make the same point as yesterday but publicly: this should only be printed if we're in no-fallback mode (and with a different error code). But we'll get to that later.

SimonSapin added a commit: rHG1a00a578972f: rhg: Add support for -R and --repository command-line arguments.Feb 11 2021, 11:37 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG1a00a578972f: rhg: Add support for -R and --repository command-line arguments (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25561

rust/hg-core/src/repo.rs

use crate::config::{Config, ConfigError, ConfigParseError}; use crate::config::{Config, ConfigError, ConfigParseError};
use crate::errors::{HgError, IoResultExt}; use crate::errors::{HgError, IoResultExt};
use crate::requirements; use crate::requirements;
use crate::utils::current_dir;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use memmap::{Mmap, MmapOptions}; use memmap::{Mmap, MmapOptions};
use std::collections::HashSet; use std::collections::HashSet;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
/// A repository on disk /// A repository on disk
pub struct Repo { pub struct Repo {
working_directory: PathBuf, working_directory: PathBuf,
dot_hg: PathBuf, dot_hg: PathBuf,
store: PathBuf, store: PathBuf,
requirements: HashSet<String>, requirements: HashSet<String>,
config: Config, config: Config,
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum RepoError { pub enum RepoError {
NotFound { NotFound {
current_directory: PathBuf, at: PathBuf,
}, },
#[from] #[from]
ConfigParseError(ConfigParseError), ConfigParseError(ConfigParseError),
#[from] #[from]
Other(HgError), Other(HgError),
} }
impl From<ConfigError> for RepoError { impl From<ConfigError> for RepoError {
#[derive(Clone, Copy)] #[derive(Clone, Copy)]
pub(crate) struct Vfs<'a> { pub(crate) struct Vfs<'a> {
base: &'a Path, base: &'a Path,
} }
impl Repo { impl Repo {
/// Search the current directory and its ancestores for a repository: /// Search the current directory and its ancestores for a repository:
/// a working directory that contains a `.hg` sub-directory. /// a working directory that contains a `.hg` sub-directory.
pub fn find(config: &Config) -> Result<Self, RepoError> { ///
/// `explicit_path` is for `--repository` command-line arguments.
pub fn find(
config: &Config,
explicit_path: Option<&Path>,
) -> Result<Self, RepoError> {
if let Some(root) = explicit_path {
// Having an absolute path isn’t necessary here but can help code
// elsewhere
let root = current_dir()?.join(root);
AlphareUnsubmitted
Not Done

TIL that some_path.join(some_absolute_path) == some_abolute_path, which makes sense.

Alphare: TIL that `some_path.join(some_absolute_path) == some_abolute_path`, which makes sense.
if root.join(".hg").is_dir() {
Self::new_at_path(root, config)
} else {
Err(RepoError::NotFound {
at: root.to_owned(),
})
}
} else {
let current_directory = crate::utils::current_dir()?; let current_directory = crate::utils::current_dir()?;
// ancestors() is inclusive: it first yields `current_directory` as-is. // ancestors() is inclusive: it first yields `current_directory`
// as-is.
for ancestor in current_directory.ancestors() { for ancestor in current_directory.ancestors() {
if ancestor.join(".hg").is_dir() { if ancestor.join(".hg").is_dir() {
return Ok(Self::new_at_path(ancestor.to_owned(), config)?); return Self::new_at_path(ancestor.to_owned(), config);
}
} }
Err(RepoError::NotFound {
at: current_directory,
})
} }
Err(RepoError::NotFound { current_directory })
} }
/// To be called after checking that `.hg` is a sub-directory /// To be called after checking that `.hg` is a sub-directory
fn new_at_path( fn new_at_path(
working_directory: PathBuf, working_directory: PathBuf,
config: &Config, config: &Config,
) -> Result<Self, RepoError> { ) -> Result<Self, RepoError> {
let dot_hg = working_directory.join(".hg"); let dot_hg = working_directory.join(".hg");

rust/rhg/src/commands/cat.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 clap::ArgMatches;
use hg::config::Config; 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(
) )
.about(HELP_TEXT) .about(HELP_TEXT)
} }
#[timed] #[timed]
pub fn run( pub fn run(
ui: &Ui, ui: &Ui,
config: &Config, config: &Config,
repo_path: Option<&Path>,
args: &ArgMatches, args: &ArgMatches,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let rev = args.value_of("rev"); let rev = args.value_of("rev");
let file_args = match args.values_of("files") { 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)?; let repo = Repo::find(config, 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())

rust/rhg/src/commands/debugdata.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::ArgGroup; use clap::ArgGroup;
use clap::ArgMatches; use clap::ArgMatches;
use hg::config::Config; 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(
) )
.about(HELP_TEXT) .about(HELP_TEXT)
} }
#[timed] #[timed]
pub fn run( pub fn run(
ui: &Ui, ui: &Ui,
config: &Config, config: &Config,
repo_path: Option<&Path>,
args: &ArgMatches, args: &ArgMatches,
) -> Result<(), CommandError> { ) -> 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)?; let repo = Repo::find(config, 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 = 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 crate::ui::Ui;
use clap::ArgMatches; use clap::ArgMatches;
use hg::config::Config; 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(
ui: &Ui, ui: &Ui,
config: &Config, config: &Config,
repo_path: Option<&Path>,
_args: &ArgMatches, _args: &ArgMatches,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let repo = Repo::find(config)?; 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())?; 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 clap::ArgMatches;
use hg::config::Config; 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(
ui: &Ui, ui: &Ui,
config: &Config, config: &Config,
repo_path: Option<&Path>,
args: &ArgMatches, args: &ArgMatches,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let rev = args.value_of("rev"); let rev = args.value_of("rev");
let repo = Repo::find(config)?; let repo = Repo::find(config, 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(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(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> {
let cwd = hg::utils::current_dir()?; let cwd = HgPathBuf::from(get_bytes_from_path(hg::utils::current_dir()?));
let rooted_cwd = cwd let working_directory =
.strip_prefix(repo.working_directory_path()) HgPathBuf::from(get_bytes_from_path(repo.working_directory_path()));
AlphareUnsubmitted
Not Done

There exists a path_to_hg_path_buf util that you should probably use here and below.

Alphare: There exists a `path_to_hg_path_buf` util that you should probably use here and below.
.expect("cwd was already checked within the repository");
let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
for file in files { for file in files {
stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?; let file = working_directory.join(file);
stdout.write_all(relativize_path(&file, &cwd).as_ref())?;
AlphareUnsubmitted
Not Done

We should see if working_directory is the same as cwd so as to not allocate in the common path. files is a performance-sensitive command in CI/server environments.

Alphare: We should see if `working_directory` is the same as `cwd` so as to not allocate in the common…
stdout.write_all(b"\n")?; stdout.write_all(b"\n")?;
} }
stdout.flush()?; stdout.flush()?;
Ok(()) Ok(())
} }

rust/rhg/src/commands/root.rs

use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::Ui; use crate::ui::Ui;
use clap::ArgMatches; use clap::ArgMatches;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::config::Config; 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(
ui: &Ui, ui: &Ui,
config: &Config, config: &Config,
repo_path: Option<&Path>,
_args: &ArgMatches, _args: &ArgMatches,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let repo = Repo::find(config)?; 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()))?; ui.write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?;
Ok(()) Ok(())
} }

rust/rhg/src/error.rs

// too. // too.
CommandError::abort("") CommandError::abort("")
} }
} }
impl From<RepoError> for CommandError { impl From<RepoError> for CommandError {
fn from(error: RepoError) -> Self { fn from(error: RepoError) -> Self {
match error { match error {
RepoError::NotFound { current_directory } => CommandError::Abort { RepoError::NotFound { at } => CommandError::Abort {
message: format_bytes!( message: format_bytes!(
b"no repository found in '{}' (.hg not found)!", b"no repository found in '{}' (.hg not found)!",
get_bytes_from_path(current_directory) get_bytes_from_path(at)
), ),
}, },
RepoError::ConfigParseError(error) => error.into(), RepoError::ConfigParseError(error) => error.into(),
RepoError::Other(error) => error.into(), RepoError::Other(error) => error.into(),
} }
} }
} }

rust/rhg/src/main.rs

extern crate log; extern crate log;
use clap::App; use clap::App;
use clap::AppSettings; use clap::AppSettings;
use clap::Arg;
use clap::ArgMatches; use clap::ArgMatches;
use format_bytes::format_bytes; use format_bytes::format_bytes;
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> {
app.arg(
Arg::with_name("repository")
.help("repository root directory")
.short("-R")
.long("--repository")
.value_name("REPO")
.takes_value(true),
)
}
fn main() { fn main() {
env_logger::init(); env_logger::init();
let app = App::new("rhg") let app = App::new("rhg")
.setting(AppSettings::AllowInvalidUtf8) .setting(AppSettings::AllowInvalidUtf8)
.setting(AppSettings::SubcommandRequired) .setting(AppSettings::SubcommandRequired)
.setting(AppSettings::VersionlessSubcommands) .setting(AppSettings::VersionlessSubcommands)
.version("0.0.1"); .version("0.0.1");
let app = add_global_args(app);
let app = add_subcommand_args(app); let app = add_subcommand_args(app);
let ui = ui::Ui::new(); let ui = ui::Ui::new();
let matches = app.clone().get_matches_safe().unwrap_or_else(|err| { let matches = app.clone().get_matches_safe().unwrap_or_else(|err| {
let _ = ui.writeln_stderr_str(&err.message); let _ = ui.writeln_stderr_str(&err.message);
std::process::exit(exitcode::UNIMPLEMENTED) std::process::exit(exitcode::UNIMPLEMENTED)
}); });
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 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.
// `hg log -R ./foo`
let global_arg =
|name| args.value_of_os(name).or_else(|| matches.value_of_os(name));
let repo_path = global_arg("repository").map(Path::new);
let result = (|| -> Result<(), CommandError> { let result = (|| -> Result<(), CommandError> {
let config = hg::config::Config::load()?; let config = hg::config::Config::load()?;
run(&ui, &config, args) run(&ui, &config, repo_path, args)
})(); })();
let exit_code = match result { let exit_code = match result {
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,
$( $(
pub mod $command; pub mod $command;
)+ )+
} }
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(commands::$command::args()) .subcommand(add_global_args(commands::$command::args()))
)+ )+
} }
fn subcommand_run_fn(name: &str) -> Option<fn( fn subcommand_run_fn(name: &str) -> Option<fn(
&ui::Ui, &ui::Ui,
&hg::config::Config, &hg::config::Config,
Option<&Path>,
&ArgMatches, &ArgMatches,
) -> Result<(), CommandError>> { ) -> Result<(), CommandError>> {
match name { match name {
$( $(
stringify!($command) => Some(commands::$command::run), stringify!($command) => Some(commands::$command::run),
)+ )+
_ => None, _ => None,
} }

tests/test-rhg.t

#require rust #require rust
Define an rhg function that will only run if rhg exists Define an rhg function that will only run if rhg exists
$ rhg() { $ rhg() {
> if [ -f "$RUNTESTDIR/../rust/target/release/rhg" ]; then > if [ -f "$RUNTESTDIR/../rust/target/release/rhg" ]; then
> "$RUNTESTDIR/../rust/target/release/rhg" "$@" > "$RUNTESTDIR/../rust/target/release/rhg" "$@"
> else > else
> echo "skipped: Cannot find rhg. Try to run cargo build in rust/rhg." > echo "skipped: Cannot find rhg. Try to run cargo build in rust/rhg."
> exit 80 > exit 80
> fi > fi
> } > }
Unimplemented command Unimplemented command
$ rhg unimplemented-command $ rhg unimplemented-command
AlphareUnsubmitted
Not Done

Just to make the same point as yesterday but publicly: this should only be printed if we're in no-fallback mode (and with a different error code). But we'll get to that later.

Alphare: Just to make the same point as yesterday but publicly: this should only be printed if we're in…
error: Found argument 'unimplemented-command' which wasn't expected, or isn't valid in this context error: Found argument 'unimplemented-command' which wasn't expected, or isn't valid in this context
USAGE: USAGE:
rhg <SUBCOMMAND> rhg [OPTIONS] <SUBCOMMAND>
For more information try --help For more information try --help
[252] [252]
Finding root Finding root
$ rhg root $ rhg root
abort: no repository found in '$TESTTMP' (.hg not found)! abort: no repository found in '$TESTTMP' (.hg not found)!
[255] [255]
Crate a shared repository Crate a shared repository
$ echo "[extensions]" >> $HGRCPATH $ echo "[extensions]" >> $HGRCPATH
$ echo "share = " >> $HGRCPATH $ echo "share = " >> $HGRCPATH
$ cd $TESTTMP $ cd $TESTTMP
$ hg init repo1 $ hg init repo1
$ cd repo1 $ echo a > repo1/a
$ echo a > a $ hg -R repo1 commit -A -m'init'
$ hg commit -A -m'init'
adding a adding a
$ cd ..
$ hg share repo1 repo2 $ hg share repo1 repo2
updating working directory updating working directory
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
And check that basic rhg commands work with sharing And check that basic rhg commands work with sharing
$ cd repo2 $ rhg files -R repo2
$ rhg files repo2/a
a $ rhg -R repo2 cat -r 0 repo2/a
$ rhg cat -r 0 a
a a
Same with relative sharing Same with relative sharing
$ cd ..
$ hg share repo2 repo3 --relative $ hg share repo2 repo3 --relative
updating working directory updating working directory
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ cd repo3 $ rhg files -R repo3
$ rhg files repo3/a
a $ rhg -R repo3 cat -r 0 repo3/a
$ rhg cat -r 0 a
a a
Same with share-safe Same with share-safe
$ echo "[format]" >> $HGRCPATH $ echo "[format]" >> $HGRCPATH
$ echo "use-share-safe = True" >> $HGRCPATH $ echo "use-share-safe = True" >> $HGRCPATH
$ cd $TESTTMP $ cd $TESTTMP