rhg: Fall back to Python if verbose status is requested by config

Differential Revision: https://phab.mercurial-scm.org/D11943

rust/rhg/src/commands/status.rs

@@ -1,527 +1,538
 // status.rs
 //
 // Copyright 2020, Georges Racinet <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::error::CommandError;
 use crate::ui::Ui;
 use crate::utils::path_utils::RelativizePaths;
 use clap::{Arg, SubCommand};
 use format_bytes::format_bytes;
 use hg;
 use hg::config::Config;
 use hg::dirstate::has_exec_bit;
 use hg::dirstate::status::StatusPath;
 use hg::dirstate::TruncatedTimestamp;
 use hg::dirstate::RANGE_MASK_31BIT;
 use hg::errors::{HgError, IoResultExt};
 use hg::lock::LockError;
 use hg::manifest::Manifest;
 use hg::matchers::AlwaysMatcher;
 use hg::repo::Repo;
 use hg::utils::files::get_bytes_from_os_string;
 use hg::utils::files::get_bytes_from_path;
 use hg::utils::files::get_path_from_bytes;
 use hg::utils::hg_path::{hg_path_to_path_buf, HgPath};
 use hg::StatusOptions;
 use log::info;
 use std::io;
 use std::path::PathBuf;
 
 pub const HELP_TEXT: &str = "
 Show changed files in the working directory
 
 This is a pure Rust version of `hg status`.
 
 Some options might be missing, check the list below.
 ";
 
 pub fn args() -> clap::App<'static, 'static> {
     SubCommand::with_name("status")
         .alias("st")
         .about(HELP_TEXT)
         .arg(
             Arg::with_name("all")
                 .help("show status of all files")
                 .short("-A")
                 .long("--all"),
         )
         .arg(
             Arg::with_name("modified")
                 .help("show only modified files")
                 .short("-m")
                 .long("--modified"),
         )
         .arg(
             Arg::with_name("added")
                 .help("show only added files")
                 .short("-a")
                 .long("--added"),
         )
         .arg(
             Arg::with_name("removed")
                 .help("show only removed files")
                 .short("-r")
                 .long("--removed"),
         )
         .arg(
             Arg::with_name("clean")
                 .help("show only clean files")
                 .short("-c")
                 .long("--clean"),
         )
         .arg(
             Arg::with_name("deleted")
                 .help("show only deleted files")
                 .short("-d")
                 .long("--deleted"),
         )
         .arg(
             Arg::with_name("unknown")
                 .help("show only unknown (not tracked) files")
                 .short("-u")
                 .long("--unknown"),
         )
         .arg(
             Arg::with_name("ignored")
                 .help("show only ignored files")
                 .short("-i")
                 .long("--ignored"),
         )
         .arg(
             Arg::with_name("copies")
                 .help("show source of copied files (DEFAULT: ui.statuscopies)")
                 .short("-C")
                 .long("--copies"),
         )
         .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
 #[derive(Copy, Clone, Debug)]
 pub struct DisplayStates {
     pub modified: bool,
     pub added: bool,
     pub removed: bool,
     pub clean: bool,
     pub deleted: bool,
     pub unknown: bool,
     pub ignored: bool,
 }
 
 pub const DEFAULT_DISPLAY_STATES: DisplayStates = DisplayStates {
     modified: true,
     added: true,
     removed: true,
     clean: false,
     deleted: true,
     unknown: true,
     ignored: false,
 };
 
 pub const ALL_DISPLAY_STATES: DisplayStates = DisplayStates {
     modified: true,
     added: true,
     removed: true,
     clean: true,
     deleted: true,
     unknown: true,
     ignored: true,
 };
 
 impl DisplayStates {
     pub fn is_empty(&self) -> bool {
         !(self.modified
             || self.added
             || self.removed
             || self.clean
             || self.deleted
             || self.unknown
             || self.ignored)
     }
 }
 
 pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
     let status_enabled_default = false;
     let status_enabled = invocation.config.get_option(b"rhg", b"status")?;
     if !status_enabled.unwrap_or(status_enabled_default) {
         return Err(CommandError::unsupported(
             "status is experimental in rhg (enable it with 'rhg.status = true' \
             or enable fallback with 'rhg.on-unsupported = fallback')"
         ));
     }
 
     // TODO: lift these limitations
     if invocation.config.get_bool(b"ui", b"tweakdefaults")? {
         return Err(CommandError::unsupported(
             "ui.tweakdefaults is not yet supported with rhg status",
         ));
     }
     if invocation.config.get_bool(b"ui", b"statuscopies")? {
         return Err(CommandError::unsupported(
             "ui.statuscopies is not yet supported with rhg status",
         ));
     }
     if invocation
         .config
         .get(b"commands", b"status.terse")
         .is_some()
     {
         return Err(CommandError::unsupported(
             "status.terse is not yet supported with rhg status",
         ));
     }
 
     let ui = invocation.ui;
     let config = invocation.config;
     let args = invocation.subcommand_args;
+
+    let verbose = !ui.plain()
+        && !args.is_present("print0")
+        && (config.get_bool(b"ui", b"verbose")?
+            || config.get_bool(b"commands", b"status.verbose")?);
+    if verbose {
+        return Err(CommandError::unsupported(
+            "verbose status is not supported yet",
+        ));
+    }
+
     let all = args.is_present("all");
     let display_states = if all {
         // TODO when implementing `--quiet`: it excludes clean files
         // from `--all`
         ALL_DISPLAY_STATES
     } else {
         let requested = DisplayStates {
             modified: args.is_present("modified"),
             added: args.is_present("added"),
             removed: args.is_present("removed"),
             clean: args.is_present("clean"),
             deleted: args.is_present("deleted"),
             unknown: args.is_present("unknown"),
             ignored: args.is_present("ignored"),
         };
         if requested.is_empty() {
             DEFAULT_DISPLAY_STATES
         } else {
             requested
         }
     };
     let no_status = args.is_present("no-status");
     let list_copies = all
         || args.is_present("copies")
         || config.get_bool(b"ui", b"statuscopies")?;
 
     let repo = invocation.repo?;
 
     if repo.has_sparse() || repo.has_narrow() {
         return Err(CommandError::unsupported(
             "rhg status is not supported for sparse checkouts or narrow clones yet"
         ));
     }
 
     let mut dmap = repo.dirstate_map_mut()?;
 
     let options = StatusOptions {
         // we're currently supporting file systems with exec flags only
         // anyway
         check_exec: true,
         list_clean: display_states.clean,
         list_unknown: display_states.unknown,
         list_ignored: display_states.ignored,
         list_copies,
         collect_traversed_dirs: false,
     };
     let (mut ds_status, pattern_warnings) = dmap.status(
         &AlwaysMatcher,
         repo.working_directory_path().to_owned(),
         ignore_files(repo, config),
         options,
     )?;
     for warning in pattern_warnings {
         match warning {
             hg::PatternFileWarning::InvalidSyntax(path, syntax) => ui
                 .write_stderr(&format_bytes!(
                     b"{}: ignoring invalid syntax '{}'\n",
                     get_bytes_from_path(path),
                     &*syntax
                 ))?,
             hg::PatternFileWarning::NoSuchFile(path) => {
                 let path = if let Ok(relative) =
                     path.strip_prefix(repo.working_directory_path())
                 {
                     relative
                 } else {
                     &*path
                 };
                 ui.write_stderr(&format_bytes!(
                     b"skipping unreadable pattern file '{}': \
                       No such file or directory\n",
                     get_bytes_from_path(path),
                 ))?
             }
         }
     }
 
     for (path, error) in ds_status.bad {
         let error = match error {
             hg::BadMatch::OsError(code) => {
                 std::io::Error::from_raw_os_error(code).to_string()
             }
             hg::BadMatch::BadType(ty) => {
                 format!("unsupported file type (type is {})", ty)
             }
         };
         ui.write_stderr(&format_bytes!(
             b"{}: {}\n",
             path.as_bytes(),
             error.as_bytes()
         ))?
     }
     if !ds_status.unsure.is_empty() {
         info!(
             "Files to be rechecked by retrieval from filelog: {:?}",
             ds_status.unsure.iter().map(|s| &s.path).collect::<Vec<_>>()
         );
     }
     let mut fixup = Vec::new();
     if !ds_status.unsure.is_empty()
         && (display_states.modified || display_states.clean)
     {
         let p1 = repo.dirstate_parents()?.p1;
         let manifest = repo.manifest_for_node(p1).map_err(|e| {
             CommandError::from((e, &*format!("{:x}", p1.short())))
         })?;
         for to_check in ds_status.unsure {
             if unsure_is_modified(repo, &manifest, &to_check.path)? {
                 if display_states.modified {
                     ds_status.modified.push(to_check);
                 }
             } else {
                 if display_states.clean {
                     ds_status.clean.push(to_check.clone());
                 }
                 fixup.push(to_check.path.into_owned())
             }
         }
     }
     let relative_paths = (!ui.plain())
         && config
             .get_option(b"commands", b"status.relative")?
             .unwrap_or(config.get_bool(b"ui", b"relative-paths")?);
     let output = DisplayStatusPaths {
         ui,
         no_status,
         relativize: if relative_paths {
             Some(RelativizePaths::new(repo)?)
         } else {
             None
         },
     };
     if display_states.modified {
         output.display(b"M", ds_status.modified)?;
     }
     if display_states.added {
         output.display(b"A", ds_status.added)?;
     }
     if display_states.removed {
         output.display(b"R", ds_status.removed)?;
     }
     if display_states.deleted {
         output.display(b"!", ds_status.deleted)?;
     }
     if display_states.unknown {
         output.display(b"?", ds_status.unknown)?;
     }
     if display_states.ignored {
         output.display(b"I", ds_status.ignored)?;
     }
     if display_states.clean {
         output.display(b"C", ds_status.clean)?;
     }
 
     let mut dirstate_write_needed = ds_status.dirty;
     let filesystem_time_at_status_start =
         ds_status.filesystem_time_at_status_start;
 
     if (fixup.is_empty() || filesystem_time_at_status_start.is_none())
         && !dirstate_write_needed
     {
         // Nothing to update
         return Ok(());
     }
 
     // Update the dirstate on disk if we can
     let with_lock_result =
         repo.try_with_wlock_no_wait(|| -> Result<(), CommandError> {
             if let Some(mtime_boundary) = filesystem_time_at_status_start {
                 for hg_path in fixup {
                     use std::os::unix::fs::MetadataExt;
                     let fs_path = hg_path_to_path_buf(&hg_path)
                         .expect("HgPath conversion");
                     // Specifically do not reuse `fs_metadata` from
                     // `unsure_is_clean` which was needed before reading
                     // contents. Here we access metadata again after reading
                     // content, in case it changed in the meantime.
                     let fs_metadata = repo
                         .working_directory_vfs()
                         .symlink_metadata(&fs_path)?;
                     if let Some(mtime) =
                         TruncatedTimestamp::for_reliable_mtime_of(
                             &fs_metadata,
                             &mtime_boundary,
                         )
                         .when_reading_file(&fs_path)?
                     {
                         let mode = fs_metadata.mode();
                         let size = fs_metadata.len() as u32 & RANGE_MASK_31BIT;
                         let mut entry = dmap
                             .get(&hg_path)?
                             .expect("ambiguous file not in dirstate");
                         entry.set_clean(mode, size, mtime);
                         dmap.add_file(&hg_path, entry)?;
                         dirstate_write_needed = true
                     }
                 }
             }
             drop(dmap); // Avoid "already mutably borrowed" RefCell panics
             if dirstate_write_needed {
                 repo.write_dirstate()?
             }
             Ok(())
         });
     match with_lock_result {
         Ok(closure_result) => closure_result?,
         Err(LockError::AlreadyHeld) => {
             // Not updating the dirstate is not ideal but not critical:
             // don’t keep our caller waiting until some other Mercurial
             // process releases the lock.
         }
         Err(LockError::Other(HgError::IoError { error, .. }))
             if error.kind() == io::ErrorKind::PermissionDenied =>
         {
             // `hg status` on a read-only repository is fine
         }
         Err(LockError::Other(error)) => {
             // Report other I/O errors
             Err(error)?
         }
     }
     Ok(())
 }
 
 fn ignore_files(repo: &Repo, config: &Config) -> Vec<PathBuf> {
     let mut ignore_files = Vec::new();
     let repo_ignore = repo.working_directory_vfs().join(".hgignore");
     if repo_ignore.exists() {
         ignore_files.push(repo_ignore)
     }
     for (key, value) in config.iter_section(b"ui") {
         if key == b"ignore" || key.starts_with(b"ignore.") {
             let path = get_path_from_bytes(value);
             // TODO: expand "~/" and environment variable here, like Python
             // does with `os.path.expanduser` and `os.path.expandvars`
 
             let joined = repo.working_directory_path().join(path);
             ignore_files.push(joined);
         }
     }
     ignore_files
 }
 
 struct DisplayStatusPaths<'a> {
     ui: &'a Ui,
     no_status: bool,
     relativize: Option<RelativizePaths>,
 }
 
 impl DisplayStatusPaths<'_> {
     // Probably more elegant to use a Deref or Borrow trait rather than
     // harcode HgPathBuf, but probably not really useful at this point
     fn display(
         &self,
         status_prefix: &[u8],
         mut paths: Vec<StatusPath<'_>>,
     ) -> Result<(), CommandError> {
         paths.sort_unstable();
         for StatusPath { path, copy_source } in paths {
             let relative;
             let path = if let Some(relativize) = &self.relativize {
                 relative = relativize.relativize(&path);
                 &*relative
             } else {
                 path.as_bytes()
             };
             // TODO optim, probably lots of unneeded copies here, especially
             // if out stream is buffered
             if self.no_status {
                 self.ui.write_stdout(&format_bytes!(b"{}\n", path))?
             } else {
                 self.ui.write_stdout(&format_bytes!(
                     b"{} {}\n",
                     status_prefix,
                     path
                 ))?
             }
             if let Some(source) = copy_source {
                 self.ui.write_stdout(&format_bytes!(
                     b"  {}\n",
                     source.as_bytes()
                 ))?
             }
         }
         Ok(())
     }
 }
 
 /// 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
 /// to time resolution limits.
 fn unsure_is_modified(
     repo: &Repo,
     manifest: &Manifest,
     hg_path: &HgPath,
 ) -> Result<bool, HgError> {
     let vfs = repo.working_directory_vfs();
     let fs_path = hg_path_to_path_buf(hg_path).expect("HgPath conversion");
     let fs_metadata = vfs.symlink_metadata(&fs_path)?;
     let is_symlink = fs_metadata.file_type().is_symlink();
     // TODO: Also account for `FALLBACK_SYMLINK` and `FALLBACK_EXEC` from the
     // dirstate
     let fs_flags = if is_symlink {
         Some(b'l')
     } else if has_exec_bit(&fs_metadata) {
         Some(b'x')
     } else {
         None
     };
 
     let entry = manifest
         .find_by_path(hg_path)?
         .expect("ambgious file not in p1");
     if entry.flags != fs_flags {
         return Ok(true);
     }
     let filelog = repo.filelog(hg_path)?;
     let fs_len = fs_metadata.len();
     // TODO: check `fs_len` here like below, but based on
     // `RevlogEntry::uncompressed_len` without decompressing the full filelog
     // contents where possible. This is only valid if the revlog data does not
     // contain metadata. See how Python’s `revlog.rawsize` calls
     // `storageutil.filerevisioncopied`.
     // (Maybe also check for content-modifying flags? See `revlog.size`.)
     let filelog_entry =
         filelog.data_for_node(entry.node_id()?).map_err(|_| {
             HgError::corrupted("filelog missing node from manifest")
         })?;
     let contents_in_p1 = filelog_entry.data()?;
     if contents_in_p1.len() as u64 != fs_len {
         // No need to read the file contents:
         // it cannot be equal if it has a different length.
         return Ok(true);
     }
 
     let fs_contents = if is_symlink {
         get_bytes_from_os_string(vfs.read_link(fs_path)?.into_os_string())
     } else {
         vfs.read(fs_path)?
     };
     Ok(contents_in_p1 != &*fs_contents)
 }

rust/rhg/src/ui.rs

@@ -1,132 +1,132
 use format_bytes::format_bytes;
 use std::borrow::Cow;
 use std::env;
 use std::io;
 use std::io::{ErrorKind, Write};
 
 #[derive(Debug)]
 pub struct Ui {
     stdout: std::io::Stdout,
     stderr: std::io::Stderr,
 }
 
 /// The kind of user interface error
 pub enum UiError {
     /// The standard output stream cannot be written to
     StdoutError(io::Error),
     /// The standard error stream cannot be written to
     StderrError(io::Error),
 }
 
 /// The commandline user interface
 impl Ui {
     pub fn new() -> Self {
         Ui {
             stdout: std::io::stdout(),
             stderr: std::io::stderr(),
         }
     }
 
     /// Returns a buffered handle on stdout for faster batch printing
     /// operations.
     pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> {
         StdoutBuffer::new(self.stdout.lock())
     }
 
     /// Write bytes to stdout
     pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> {
         let mut stdout = self.stdout.lock();
 
         stdout.write_all(bytes).or_else(handle_stdout_error)?;
 
         stdout.flush().or_else(handle_stdout_error)
     }
 
     /// Write bytes to stderr
     pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> {
         let mut stderr = self.stderr.lock();
 
         stderr.write_all(bytes).or_else(handle_stderr_error)?;
 
         stderr.flush().or_else(handle_stderr_error)
     }
 
-    /// is plain mode active
+    /// Return whether plain mode is active.
     ///
     /// Plain mode means that all configuration variables which affect
     /// the behavior and output of Mercurial should be
     /// ignored. Additionally, the output should be stable,
     /// reproducible and suitable for use in scripts or applications.
     ///
     /// The only way to trigger plain mode is by setting either the
     /// `HGPLAIN' or `HGPLAINEXCEPT' environment variables.
     ///
     /// The return value can either be
     /// - False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT
     /// - False if feature is disabled by default and not included in HGPLAIN
     /// - True otherwise
     pub fn plain(&self) -> bool {
         // TODO: add support for HGPLAINEXCEPT
         env::var_os("HGPLAIN").is_some()
     }
 }
 
 /// A buffered stdout writer for faster batch printing operations.
 pub struct StdoutBuffer<W: Write> {
     buf: io::BufWriter<W>,
 }
 
 impl<W: Write> StdoutBuffer<W> {
     pub fn new(writer: W) -> Self {
         let buf = io::BufWriter::new(writer);
         Self { buf }
     }
 
     /// Write bytes to stdout buffer
     pub fn write_all(&mut self, bytes: &[u8]) -> Result<(), UiError> {
         self.buf.write_all(bytes).or_else(handle_stdout_error)
     }
 
     /// Flush bytes to stdout
     pub fn flush(&mut self) -> Result<(), UiError> {
         self.buf.flush().or_else(handle_stdout_error)
     }
 }
 
 /// Sometimes writing to stdout is not possible, try writing to stderr to
 /// signal that failure, otherwise just bail.
 fn handle_stdout_error(error: io::Error) -> Result<(), UiError> {
     if let ErrorKind::BrokenPipe = error.kind() {
         // This makes `| head` work for example
         return Ok(());
     }
     let mut stderr = io::stderr();
 
     stderr
         .write_all(&format_bytes!(
             b"abort: {}\n",
             error.to_string().as_bytes()
         ))
         .map_err(UiError::StderrError)?;
 
     stderr.flush().map_err(UiError::StderrError)?;
 
     Err(UiError::StdoutError(error))
 }
 
 /// Sometimes writing to stderr is not possible.
 fn handle_stderr_error(error: io::Error) -> Result<(), UiError> {
     // A broken pipe should not result in a error
     // like with `| head` for example
     if let ErrorKind::BrokenPipe = error.kind() {
         return Ok(());
     }
     Err(UiError::StdoutError(error))
 }
 
 /// Encode rust strings according to the user system.
 pub fn utf8_to_local(s: &str) -> Cow<[u8]> {
     // TODO encode for the user's system //
     let bytes = s.as_bytes();
     Cow::Borrowed(bytes)
 }

tests/test-conflict.t

@@ -1,426 +1,422
-TODO: fix rhg bugs that make this test fail when status is enabled
-  $ unset RHG_STATUS
-
-
   $ hg init
   $ cat << EOF > a
   > Small Mathematical Series.
   > One
   > Two
   > Three
   > Four
   > Five
   > Hop we are done.
   > EOF
   $ hg add a
   $ hg commit -m ancestor
   $ cat << EOF > a
   > Small Mathematical Series.
   > 1
   > 2
   > 3
   > 4
   > 5
   > Hop we are done.
   > EOF
   $ hg commit -m branch1
   $ hg co 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat << EOF > a
   > Small Mathematical Series.
   > 1
   > 2
   > 3
   > 6
   > 8
   > Hop we are done.
   > EOF
   $ hg commit -m branch2
   created new head
 
   $ hg merge 1
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ hg id
   618808747361+c0c68e4fe667+ tip
 
   $ echo "[commands]" >> $HGRCPATH
   $ echo "status.verbose=true" >> $HGRCPATH
   $ hg status
   M a
   ? a.orig
   # The repository is in an unfinished *merge* state.
   
   # Unresolved merge conflicts:
   # 
   #     a
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   # To continue:    hg commit
   # To abort:       hg merge --abort
   
   $ hg status -Tjson
   [
    {
     "itemtype": "file",
     "path": "a",
     "status": "M",
     "unresolved": true
    },
    {
     "itemtype": "file",
     "path": "a.orig",
     "status": "?"
    },
    {
     "itemtype": "morestatus",
     "unfinished": "merge",
     "unfinishedmsg": "To continue:    hg commit\nTo abort:       hg merge --abort"
    }
   ]
 
   $ hg status -0
   M a\x00? a.orig\x00 (no-eol) (esc)
   $ cat a
   Small Mathematical Series.
   1
   2
   3
   <<<<<<< working copy: 618808747361 - test: branch2
   6
   8
   =======
   4
   5
   >>>>>>> merge rev:    c0c68e4fe667 - test: branch1
   Hop we are done.
 
   $ hg status --config commands.status.verbose=0
   M a
   ? a.orig
 
 Verify custom conflict markers
 
   $ hg up -q --clean .
   $ cat <<EOF >> .hg/hgrc
   > [command-templates]
   > mergemarker = '{author} {rev}'
   > EOF
 
   $ hg merge 1
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ cat a
   Small Mathematical Series.
   1
   2
   3
   <<<<<<< working copy: test 2
   6
   8
   =======
   4
   5
   >>>>>>> merge rev:    test 1
   Hop we are done.
 
 Verify custom conflict markers with legacy config name
 
   $ hg up -q --clean .
   $ cat <<EOF >> .hg/hgrc
   > [ui]
   > mergemarkertemplate = '{author} {rev}'
   > EOF
 
   $ hg merge 1
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ cat a
   Small Mathematical Series.
   1
   2
   3
   <<<<<<< working copy: test 2
   6
   8
   =======
   4
   5
   >>>>>>> merge rev:    test 1
   Hop we are done.
 
 Verify line splitting of custom conflict marker which causes multiple lines
 
   $ hg up -q --clean .
   $ cat >> .hg/hgrc <<EOF
   > [command-templates]
   > mergemarker={author} {rev}\nfoo\nbar\nbaz
   > EOF
 
   $ hg -q merge 1
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   [1]
 
   $ cat a
   Small Mathematical Series.
   1
   2
   3
   <<<<<<< working copy: test 2
   6
   8
   =======
   4
   5
   >>>>>>> merge rev:    test 1
   Hop we are done.
 
 Verify line trimming of custom conflict marker using multi-byte characters
 
   $ hg up -q --clean .
   $ "$PYTHON" <<EOF
   > fp = open('logfile', 'wb')
   > fp.write(b'12345678901234567890123456789012345678901234567890' +
   >          b'1234567890') # there are 5 more columns for 80 columns
   > 
   > # 2 x 4 = 8 columns, but 3 x 4 = 12 bytes
   > fp.write(u'\u3042\u3044\u3046\u3048'.encode('utf-8'))
   > 
   > fp.close()
   > EOF
   $ hg add logfile
   $ hg --encoding utf-8 commit --logfile logfile
 
   $ cat >> .hg/hgrc <<EOF
   > [command-templates]
   > mergemarker={desc|firstline}
   > EOF
 
   $ hg -q --encoding utf-8 merge 1
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   [1]
 
   $ cat a
   Small Mathematical Series.
   1
   2
   3
   <<<<<<< working copy: 1234567890123456789012345678901234567890123456789012345...
   6
   8
   =======
   4
   5
   >>>>>>> merge rev:    branch1
   Hop we are done.
 
 Verify basic conflict markers
 
   $ hg up -q --clean 2
   $ printf "\n[ui]\nmergemarkers=basic\n" >> .hg/hgrc
 
   $ hg merge 1
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ cat a
   Small Mathematical Series.
   1
   2
   3
   <<<<<<< working copy
   6
   8
   =======
   4
   5
   >>>>>>> merge rev
   Hop we are done.
 
 internal:merge3
 
   $ hg up -q --clean .
 
   $ hg merge 1 --tool internal:merge3
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ cat a
   Small Mathematical Series.
   <<<<<<< working copy
   1
   2
   3
   6
   8
   ||||||| base
   One
   Two
   Three
   Four
   Five
   =======
   1
   2
   3
   4
   5
   >>>>>>> merge rev
   Hop we are done.
 
 internal:mergediff
 
   $ hg co -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat << EOF > a
   > Small Mathematical Series.
   > 1
   > 2
   > 3
   > 4
   > 4.5
   > 5
   > Hop we are done.
   > EOF
   $ hg co -m 2 -t internal:mergediff
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ cat a
   Small Mathematical Series.
   1
   2
   3
   <<<<<<<
   ------- base
   +++++++ working copy
    4
   +4.5
    5
   ======= destination
   6
   8
   >>>>>>>
   Hop we are done.
 Test the same thing as above but modify a bit more so we instead get the working
 copy in full and the diff from base to destination.
   $ hg co -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat << EOF > a
   > Small Mathematical Series.
   > 1
   > 2
   > 3.5
   > 4.5
   > 5.5
   > Hop we are done.
   > EOF
   $ hg co -m 2 -t internal:mergediff
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ cat a
   Small Mathematical Series.
   1
   2
   <<<<<<<
   ======= working copy
   3.5
   4.5
   5.5
   ------- base
   +++++++ destination
    3
   -4
   -5
   +6
   +8
   >>>>>>>
   Hop we are done.
 
 Add some unconflicting changes on each head, to make sure we really
 are merging, unlike :local and :other
 
   $ hg up -C
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "e0693e20f496: 123456789012345678901234567890123456789012345678901234567890????"
   1 other heads for branch "default"
   $ printf "\n\nEnd of file\n" >> a
   $ hg ci -m "Add some stuff at the end"
   $ hg up -r 1
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ printf "Start of file\n\n\n" > tmp
   $ cat a >> tmp
   $ mv tmp a
   $ hg ci -m "Add some stuff at the beginning"
 
 Now test :merge-other and :merge-local
 
   $ hg merge
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   1 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ hg resolve --tool :merge-other a
   merging a
   (no more unresolved files)
   $ cat a
   Start of file
   
   
   Small Mathematical Series.
   1
   2
   3
   6
   8
   Hop we are done.
   
   
   End of file
 
   $ hg up -C
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   updated to "18b51d585961: Add some stuff at the beginning"
   1 other heads for branch "default"
   $ hg merge --tool :merge-local
   merging a
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat a
   Start of file
   
   
   Small Mathematical Series.
   1
   2
   3
   4
   5
   Hop we are done.
   
   
   End of file