rhg: `cat` command: print error messages for missing files

And exit with an error code if no file was matched.
This matches the behavior of Python-based hg.

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

rust/hg-core/src/operations/cat.rs

@@ -1,75 +1,105 b''
 // list_tracked_files.rs
 //
 // Copyright 2020 Antoine Cezar <[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 std::path::PathBuf;
 
 use crate::repo::Repo;
 use crate::revlog::changelog::Changelog;
 use crate::revlog::manifest::Manifest;
 use crate::revlog::path_encode::path_encode;
 use crate::revlog::revlog::Revlog;
 use crate::revlog::revlog::RevlogError;
 use crate::revlog::Node;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::{HgPath, HgPathBuf};
 
+pub struct CatOutput {
+    /// Whether any file in the manifest matched the paths given as CLI
+    /// arguments
+    pub found_any: bool,
+    /// The contents of matching files, in manifest order
+    pub concatenated: Vec<u8>,
+    /// Which of the CLI arguments did not match any manifest file
+    pub missing: Vec<HgPathBuf>,
+    /// The node ID that the given revset was resolved to
+    pub node: Node,
+}
+
 const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n'];
 
-/// List files under Mercurial control at a given revision.
+/// Output the given revision of files
 ///
 /// * `root`: Repository root
 /// * `rev`: The revision to cat the files from.
 /// * `files`: The files to output.
-pub fn cat(
+pub fn cat<'a>(
     repo: &Repo,
     revset: &str,
-    files: &[HgPathBuf],
-) -> Result<Vec<u8>, RevlogError> {
+    files: &'a [HgPathBuf],
+) -> Result<CatOutput, RevlogError> {
     let rev = crate::revset::resolve_single(revset, repo)?;
     let changelog = Changelog::open(repo)?;
     let manifest = Manifest::open(repo)?;
     let changelog_entry = changelog.get_rev(rev)?;
+    let node = *changelog
+        .node_from_rev(rev)
+        .expect("should succeed when changelog.get_rev did");
     let manifest_node =
         Node::from_hex_for_repo(&changelog_entry.manifest_node()?)?;
     let manifest_entry = manifest.get_node(manifest_node.into())?;
     let mut bytes = vec![];
+    let mut matched = vec![false; files.len()];
+    let mut found_any = false;
 
     for (manifest_file, node_bytes) in manifest_entry.files_with_nodes() {
-        for cat_file in files.iter() {
+        for (cat_file, is_matched) in files.iter().zip(&mut matched) {
             if cat_file.as_bytes() == manifest_file.as_bytes() {
+                *is_matched = true;
+                found_any = true;
                 let index_path = store_path(manifest_file, b".i");
                 let data_path = store_path(manifest_file, b".d");
 
                 let file_log =
                     Revlog::open(repo, &index_path, Some(&data_path))?;
                 let file_node = Node::from_hex_for_repo(node_bytes)?;
                 let file_rev = file_log.get_node_rev(file_node.into())?;
                 let data = file_log.get_rev_data(file_rev)?;
                 if data.starts_with(&METADATA_DELIMITER) {
                     let end_delimiter_position = data
                         [METADATA_DELIMITER.len()..]
                         .windows(METADATA_DELIMITER.len())
                         .position(|bytes| bytes == METADATA_DELIMITER);
                     if let Some(position) = end_delimiter_position {
                         let offset = METADATA_DELIMITER.len() * 2;
                         bytes.extend(data[position + offset..].iter());
                     }
                 } else {
                     bytes.extend(data);
                 }
             }
         }
     }
 
-    Ok(bytes)
+    let missing: Vec<_> = files
+        .iter()
+        .zip(&matched)
+        .filter(|pair| !*pair.1)
+        .map(|pair| pair.0.clone())
+        .collect();
+    Ok(CatOutput {
+        found_any,
+        concatenated: bytes,
+        missing,
+        node,
+    })
 }
 
 fn store_path(hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
     let encoded_bytes =
         path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
     get_path_from_bytes(&encoded_bytes).into()
 }

rust/hg-core/src/operations/mod.rs

@@ -1,12 +1,12 b''
 //! A distinction is made between operations and commands.
 //! An operation is what can be done whereas a command is what is exposed by
 //! the cli. A single command can use several operations to achieve its goal.
 
 mod cat;
 mod debugdata;
 mod dirstate_status;
 mod list_tracked_files;
-pub use cat::cat;
+pub use cat::{cat, CatOutput};
 pub use debugdata::{debug_data, DebugDataKind};
 pub use list_tracked_files::Dirstate;
 pub use list_tracked_files::{list_rev_tracked_files, FilesForRev};

rust/hg-core/src/revlog/changelog.rs

@@ -1,61 +1,65 b''
 use crate::errors::HgError;
 use crate::repo::Repo;
 use crate::revlog::revlog::{Revlog, RevlogError};
-use crate::revlog::NodePrefix;
 use crate::revlog::Revision;
+use crate::revlog::{Node, NodePrefix};
 
 /// A specialized `Revlog` to work with `changelog` data format.
 pub struct Changelog {
     /// The generic `revlog` format.
     pub(crate) revlog: Revlog,
 }
 
 impl Changelog {
     /// Open the `changelog` of a repository given by its root.
     pub fn open(repo: &Repo) -> Result<Self, RevlogError> {
         let revlog = Revlog::open(repo, "00changelog.i", None)?;
         Ok(Self { revlog })
     }
 
     /// Return the `ChangelogEntry` a given node id.
     pub fn get_node(
         &self,
         node: NodePrefix,
     ) -> Result<ChangelogEntry, RevlogError> {
         let rev = self.revlog.get_node_rev(node)?;
         self.get_rev(rev)
     }
 
     /// Return the `ChangelogEntry` of a given node revision.
     pub fn get_rev(
         &self,
         rev: Revision,
     ) -> Result<ChangelogEntry, RevlogError> {
         let bytes = self.revlog.get_rev_data(rev)?;
         Ok(ChangelogEntry { bytes })
     }
+
+    pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> {
+        Some(self.revlog.index.get_entry(rev)?.hash())
+    }
 }
 
 /// `Changelog` entry which knows how to interpret the `changelog` data bytes.
 #[derive(Debug)]
 pub struct ChangelogEntry {
     /// The data bytes of the `changelog` entry.
     bytes: Vec<u8>,
 }
 
 impl ChangelogEntry {
     /// Return an iterator over the lines of the entry.
     pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
         self.bytes
             .split(|b| b == &b'\n')
             .filter(|line| !line.is_empty())
     }
 
     /// Return the node id of the `manifest` referenced by this `changelog`
     /// entry.
     pub fn manifest_node(&self) -> Result<&[u8], RevlogError> {
         self.lines()
             .next()
             .ok_or_else(|| HgError::corrupted("empty changelog entry").into())
     }
 }

rust/hg-core/src/revlog/node.rs

@@ -1,405 +1,415 b''
 // Copyright 2019-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.
 
 //! Definitions and utilities for Revision nodes
 //!
 //! In Mercurial code base, it is customary to call "a node" the binary SHA
 //! of a revision.
 
 use crate::errors::HgError;
 use bytes_cast::BytesCast;
 use std::convert::{TryFrom, TryInto};
 use std::fmt;
 
 /// The length in bytes of a `Node`
 ///
 /// This constant is meant to ease refactors of this module, and
 /// are private so that calling code does not expect all nodes have
 /// the same size, should we support several formats concurrently in
 /// the future.
 pub const NODE_BYTES_LENGTH: usize = 20;
 
 /// Id of the null node.
 ///
 /// Used to indicate the absence of node.
 pub const NULL_NODE_ID: [u8; NODE_BYTES_LENGTH] = [0u8; NODE_BYTES_LENGTH];
 
 /// The length in bytes of a `Node`
 ///
 /// see also `NODES_BYTES_LENGTH` about it being private.
 const NODE_NYBBLES_LENGTH: usize = 2 * NODE_BYTES_LENGTH;
 
+/// Default for UI presentation
+const SHORT_PREFIX_DEFAULT_NYBBLES_LENGTH: u8 = 12;
+
 /// Private alias for readability and to ease future change
 type NodeData = [u8; NODE_BYTES_LENGTH];
 
 /// Binary revision SHA
 ///
 /// ## Future changes of hash size
 ///
 /// To accomodate future changes of hash size, Rust callers
 /// should use the conversion methods at the boundaries (FFI, actual
 /// computation of hashes and I/O) only, and only if required.
 ///
 /// All other callers outside of unit tests should just handle `Node` values
 /// and never make any assumption on the actual length, using [`nybbles_len`]
 /// if they need a loop boundary.
 ///
 /// All methods that create a `Node` either take a type that enforces
 /// the size or return an error at runtime.
 ///
 /// [`nybbles_len`]: #method.nybbles_len
 #[derive(Copy, Clone, Debug, PartialEq, BytesCast, derive_more::From)]
 #[repr(transparent)]
 pub struct Node {
     data: NodeData,
 }
 
 /// The node value for NULL_REVISION
 pub const NULL_NODE: Node = Node {
     data: [0; NODE_BYTES_LENGTH],
 };
 
 /// Return an error if the slice has an unexpected length
 impl<'a> TryFrom<&'a [u8]> for &'a Node {
     type Error = ();
 
     #[inline]
     fn try_from(bytes: &'a [u8]) -> Result<Self, Self::Error> {
         match Node::from_bytes(bytes) {
             Ok((node, rest)) if rest.is_empty() => Ok(node),
             _ => Err(()),
         }
     }
 }
 
 /// Return an error if the slice has an unexpected length
 impl TryFrom<&'_ [u8]> for Node {
     type Error = std::array::TryFromSliceError;
 
     #[inline]
     fn try_from(bytes: &'_ [u8]) -> Result<Self, Self::Error> {
         let data = bytes.try_into()?;
         Ok(Self { data })
     }
 }
 
 impl From<&'_ NodeData> for Node {
     #[inline]
     fn from(data: &'_ NodeData) -> Self {
         Self { data: *data }
     }
 }
 
 impl fmt::LowerHex for Node {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         for &byte in &self.data {
             write!(f, "{:02x}", byte)?
         }
         Ok(())
     }
 }
 
 #[derive(Debug)]
 pub struct FromHexError;
 
 /// Low level utility function, also for prefixes
 fn get_nybble(s: &[u8], i: usize) -> u8 {
     if i % 2 == 0 {
         s[i / 2] >> 4
     } else {
         s[i / 2] & 0x0f
     }
 }
 
 impl Node {
     /// Retrieve the `i`th half-byte of the binary data.
     ///
     /// This is also the `i`th hexadecimal digit in numeric form,
     /// also called a [nybble](https://en.wikipedia.org/wiki/Nibble).
     pub fn get_nybble(&self, i: usize) -> u8 {
         get_nybble(&self.data, i)
     }
 
     /// Length of the data, in nybbles
     pub fn nybbles_len(&self) -> usize {
         // public exposure as an instance method only, so that we can
         // easily support several sizes of hashes if needed in the future.
         NODE_NYBBLES_LENGTH
     }
 
     /// Convert from hexadecimal string representation
     ///
     /// Exact length is required.
     ///
     /// To be used in FFI and I/O only, in order to facilitate future
     /// changes of hash format.
     pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Node, FromHexError> {
         let prefix = NodePrefix::from_hex(hex)?;
         if prefix.nybbles_len() == NODE_NYBBLES_LENGTH {
             Ok(Self { data: prefix.data })
         } else {
             Err(FromHexError)
         }
     }
 
     /// `from_hex`, but for input from an internal file of the repository such
     /// as a changelog or manifest entry.
     ///
     /// An error is treated as repository corruption.
     pub fn from_hex_for_repo(hex: impl AsRef<[u8]>) -> Result<Node, HgError> {
         Self::from_hex(hex.as_ref()).map_err(|FromHexError| {
             HgError::CorruptedRepository(format!(
                 "Expected a full hexadecimal node ID, found {}",
                 String::from_utf8_lossy(hex.as_ref())
             ))
         })
     }
 
     /// Provide access to binary data
     ///
     /// This is needed by FFI layers, for instance to return expected
     /// binary values to Python.
     pub fn as_bytes(&self) -> &[u8] {
         &self.data
     }
+
+    pub fn short(&self) -> NodePrefix {
+        NodePrefix {
+            nybbles_len: SHORT_PREFIX_DEFAULT_NYBBLES_LENGTH,
+            data: self.data,
+        }
+    }
 }
 
 /// The beginning of a binary revision SHA.
 ///
 /// Since it can potentially come from an hexadecimal representation with
 /// odd length, it needs to carry around whether the last 4 bits are relevant
 /// or not.
 #[derive(Debug, PartialEq, Copy, Clone)]
 pub struct NodePrefix {
     /// In `1..=NODE_NYBBLES_LENGTH`
     nybbles_len: u8,
     /// The first `4 * length_in_nybbles` bits are used (considering bits
     /// within a bytes in big-endian: most significant first), the rest
     /// are zero.
     data: NodeData,
 }
 
 impl NodePrefix {
     /// Convert from hexadecimal string representation
     ///
     /// Similarly to `hex::decode`, can be used with Unicode string types
     /// (`String`, `&str`) as well as bytes.
     ///
     /// To be used in FFI and I/O only, in order to facilitate future
     /// changes of hash format.
     pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Self, FromHexError> {
         let hex = hex.as_ref();
         let len = hex.len();
         if len > NODE_NYBBLES_LENGTH || len == 0 {
             return Err(FromHexError);
         }
 
         let mut data = [0; NODE_BYTES_LENGTH];
         let mut nybbles_len = 0;
         for &ascii_byte in hex {
             let nybble = match char::from(ascii_byte).to_digit(16) {
                 Some(digit) => digit as u8,
                 None => return Err(FromHexError),
             };
             // Fill in the upper half of a byte first, then the lower half.
             let shift = if nybbles_len % 2 == 0 { 4 } else { 0 };
             data[nybbles_len as usize / 2] |= nybble << shift;
             nybbles_len += 1;
         }
         Ok(Self { data, nybbles_len })
     }
 
     pub fn nybbles_len(&self) -> usize {
         self.nybbles_len as _
     }
 
     pub fn is_prefix_of(&self, node: &Node) -> bool {
         let full_bytes = self.nybbles_len() / 2;
         if self.data[..full_bytes] != node.data[..full_bytes] {
             return false;
         }
         if self.nybbles_len() % 2 == 0 {
             return true;
         }
         let last = self.nybbles_len() - 1;
         self.get_nybble(last) == node.get_nybble(last)
     }
 
     /// Retrieve the `i`th half-byte from the prefix.
     ///
     /// This is also the `i`th hexadecimal digit in numeric form,
     /// also called a [nybble](https://en.wikipedia.org/wiki/Nibble).
     pub fn get_nybble(&self, i: usize) -> u8 {
         assert!(i < self.nybbles_len());
         get_nybble(&self.data, i)
     }
 
     fn iter_nybbles(&self) -> impl Iterator<Item = u8> + '_ {
         (0..self.nybbles_len()).map(move |i| get_nybble(&self.data, i))
     }
 
     /// Return the index first nybble that's different from `node`
     ///
     /// If the return value is `None` that means that `self` is
     /// a prefix of `node`, but the current method is a bit slower
     /// than `is_prefix_of`.
     ///
     /// Returned index is as in `get_nybble`, i.e., starting at 0.
     pub fn first_different_nybble(&self, node: &Node) -> Option<usize> {
         self.iter_nybbles()
             .zip(NodePrefix::from(*node).iter_nybbles())
             .position(|(a, b)| a != b)
     }
 }
 
 impl fmt::LowerHex for NodePrefix {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let full_bytes = self.nybbles_len() / 2;
         for &byte in &self.data[..full_bytes] {
             write!(f, "{:02x}", byte)?
         }
         if self.nybbles_len() % 2 == 1 {
             let last = self.nybbles_len() - 1;
             write!(f, "{:x}", self.get_nybble(last))?
         }
         Ok(())
     }
 }
 
 /// A shortcut for full `Node` references
 impl From<&'_ Node> for NodePrefix {
     fn from(node: &'_ Node) -> Self {
         NodePrefix {
             nybbles_len: node.nybbles_len() as _,
             data: node.data,
         }
     }
 }
 
 /// A shortcut for full `Node` references
 impl From<Node> for NodePrefix {
     fn from(node: Node) -> Self {
         NodePrefix {
             nybbles_len: node.nybbles_len() as _,
             data: node.data,
         }
     }
 }
 
 impl PartialEq<Node> for NodePrefix {
     fn eq(&self, other: &Node) -> bool {
         Self::from(*other) == *self
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     const SAMPLE_NODE_HEX: &str = "0123456789abcdeffedcba9876543210deadbeef";
     const SAMPLE_NODE: Node = Node {
         data: [
             0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba,
             0x98, 0x76, 0x54, 0x32, 0x10, 0xde, 0xad, 0xbe, 0xef,
         ],
     };
 
     /// Pad an hexadecimal string to reach `NODE_NYBBLES_LENGTH`
     /// The padding is made with zeros.
     pub fn hex_pad_right(hex: &str) -> String {
         let mut res = hex.to_string();
         while res.len() < NODE_NYBBLES_LENGTH {
             res.push('0');
         }
         res
     }
 
     #[test]
     fn test_node_from_hex() {
         let not_hex = "012... oops";
         let too_short = "0123";
         let too_long = format!("{}0", SAMPLE_NODE_HEX);
         assert_eq!(Node::from_hex(SAMPLE_NODE_HEX).unwrap(), SAMPLE_NODE);
         assert!(Node::from_hex(not_hex).is_err());
         assert!(Node::from_hex(too_short).is_err());
         assert!(Node::from_hex(&too_long).is_err());
     }
 
     #[test]
     fn test_node_encode_hex() {
         assert_eq!(format!("{:x}", SAMPLE_NODE), SAMPLE_NODE_HEX);
     }
 
     #[test]
     fn test_prefix_from_to_hex() -> Result<(), FromHexError> {
         assert_eq!(format!("{:x}", NodePrefix::from_hex("0e1")?), "0e1");
         assert_eq!(format!("{:x}", NodePrefix::from_hex("0e1a")?), "0e1a");
         assert_eq!(
             format!("{:x}", NodePrefix::from_hex(SAMPLE_NODE_HEX)?),
             SAMPLE_NODE_HEX
         );
         Ok(())
     }
 
     #[test]
     fn test_prefix_from_hex_errors() {
         assert!(NodePrefix::from_hex("testgr").is_err());
         let mut long = format!("{:x}", NULL_NODE);
         long.push('c');
         assert!(NodePrefix::from_hex(&long).is_err())
     }
 
     #[test]
     fn test_is_prefix_of() -> Result<(), FromHexError> {
         let mut node_data = [0; NODE_BYTES_LENGTH];
         node_data[0] = 0x12;
         node_data[1] = 0xca;
         let node = Node::from(node_data);
         assert!(NodePrefix::from_hex("12")?.is_prefix_of(&node));
         assert!(!NodePrefix::from_hex("1a")?.is_prefix_of(&node));
         assert!(NodePrefix::from_hex("12c")?.is_prefix_of(&node));
         assert!(!NodePrefix::from_hex("12d")?.is_prefix_of(&node));
         Ok(())
     }
 
     #[test]
     fn test_get_nybble() -> Result<(), FromHexError> {
         let prefix = NodePrefix::from_hex("dead6789cafe")?;
         assert_eq!(prefix.get_nybble(0), 13);
         assert_eq!(prefix.get_nybble(7), 9);
         Ok(())
     }
 
     #[test]
     fn test_first_different_nybble_even_prefix() {
         let prefix = NodePrefix::from_hex("12ca").unwrap();
         let mut node = Node::from([0; NODE_BYTES_LENGTH]);
         assert_eq!(prefix.first_different_nybble(&node), Some(0));
         node.data[0] = 0x13;
         assert_eq!(prefix.first_different_nybble(&node), Some(1));
         node.data[0] = 0x12;
         assert_eq!(prefix.first_different_nybble(&node), Some(2));
         node.data[1] = 0xca;
         // now it is a prefix
         assert_eq!(prefix.first_different_nybble(&node), None);
     }
 
     #[test]
     fn test_first_different_nybble_odd_prefix() {
         let prefix = NodePrefix::from_hex("12c").unwrap();
         let mut node = Node::from([0; NODE_BYTES_LENGTH]);
         assert_eq!(prefix.first_different_nybble(&node), Some(0));
         node.data[0] = 0x13;
         assert_eq!(prefix.first_different_nybble(&node), Some(1));
         node.data[0] = 0x12;
         assert_eq!(prefix.first_different_nybble(&node), Some(2));
         node.data[1] = 0xca;
         // now it is a prefix
         assert_eq!(prefix.first_different_nybble(&node), None);
     }
 }
 
 #[cfg(test)]
 pub use tests::hex_pad_right;

rust/hg-core/src/revlog/revlog.rs

@@ -1,393 +1,393 b''
 use std::borrow::Cow;
 use std::io::Read;
 use std::ops::Deref;
 use std::path::Path;
 
 use byteorder::{BigEndian, ByteOrder};
 use crypto::digest::Digest;
 use crypto::sha1::Sha1;
 use flate2::read::ZlibDecoder;
 use micro_timer::timed;
 use zstd;
 
 use super::index::Index;
 use super::node::{NodePrefix, NODE_BYTES_LENGTH, NULL_NODE};
 use super::nodemap;
 use super::nodemap::{NodeMap, NodeMapError};
 use super::nodemap_docket::NodeMapDocket;
 use super::patch;
 use crate::errors::HgError;
 use crate::repo::Repo;
 use crate::revlog::Revision;
 
 #[derive(derive_more::From)]
 pub enum RevlogError {
     InvalidRevision,
     /// Found more than one entry whose ID match the requested prefix
     AmbiguousPrefix,
     #[from]
     Other(HgError),
 }
 
 impl From<NodeMapError> for RevlogError {
     fn from(error: NodeMapError) -> Self {
         match error {
             NodeMapError::MultipleResults => RevlogError::AmbiguousPrefix,
             NodeMapError::RevisionNotInIndex(_) => RevlogError::corrupted(),
         }
     }
 }
 
 impl RevlogError {
     fn corrupted() -> Self {
         RevlogError::Other(HgError::corrupted("corrupted revlog"))
     }
 }
 
 /// Read only implementation of revlog.
 pub struct Revlog {
     /// When index and data are not interleaved: bytes of the revlog index.
     /// When index and data are interleaved: bytes of the revlog index and
     /// data.
-    index: Index,
+    pub(crate) index: Index,
     /// When index and data are not interleaved: bytes of the revlog data
     data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>,
     /// When present on disk: the persistent nodemap for this revlog
     nodemap: Option<nodemap::NodeTree>,
 }
 
 impl Revlog {
     /// Open a revlog index file.
     ///
     /// It will also open the associated data file if index and data are not
     /// interleaved.
     #[timed]
     pub fn open(
         repo: &Repo,
         index_path: impl AsRef<Path>,
         data_path: Option<&Path>,
     ) -> Result<Self, RevlogError> {
         let index_path = index_path.as_ref();
         let index_mmap = repo.store_vfs().mmap_open(&index_path)?;
 
         let version = get_version(&index_mmap);
         if version != 1 {
             // A proper new version should have had a repo/store requirement.
             return Err(RevlogError::corrupted());
         }
 
         let index = Index::new(Box::new(index_mmap))?;
 
         let default_data_path = index_path.with_extension("d");
 
         // type annotation required
         // won't recognize Mmap as Deref<Target = [u8]>
         let data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>> =
             if index.is_inline() {
                 None
             } else {
                 let data_path = data_path.unwrap_or(&default_data_path);
                 let data_mmap = repo.store_vfs().mmap_open(data_path)?;
                 Some(Box::new(data_mmap))
             };
 
         let nodemap = NodeMapDocket::read_from_file(repo, index_path)?.map(
             |(docket, data)| {
                 nodemap::NodeTree::load_bytes(
                     Box::new(data),
                     docket.data_length,
                 )
             },
         );
 
         Ok(Revlog {
             index,
             data_bytes,
             nodemap,
         })
     }
 
     /// Return number of entries of the `Revlog`.
     pub fn len(&self) -> usize {
         self.index.len()
     }
 
     /// Returns `true` if the `Revlog` has zero `entries`.
     pub fn is_empty(&self) -> bool {
         self.index.is_empty()
     }
 
     /// Return the full data associated to a node.
     #[timed]
     pub fn get_node_rev(
         &self,
         node: NodePrefix,
     ) -> Result<Revision, RevlogError> {
         if let Some(nodemap) = &self.nodemap {
             return nodemap
                 .find_bin(&self.index, node)?
                 .ok_or(RevlogError::InvalidRevision);
         }
 
         // Fallback to linear scan when a persistent nodemap is not present.
         // This happens when the persistent-nodemap experimental feature is not
         // enabled, or for small revlogs.
         //
         // TODO: consider building a non-persistent nodemap in memory to
         // optimize these cases.
         let mut found_by_prefix = None;
         for rev in (0..self.len() as Revision).rev() {
             let index_entry =
                 self.index.get_entry(rev).ok_or(HgError::corrupted(
                     "revlog references a revision not in the index",
                 ))?;
             if node == *index_entry.hash() {
                 return Ok(rev);
             }
             if node.is_prefix_of(index_entry.hash()) {
                 if found_by_prefix.is_some() {
                     return Err(RevlogError::AmbiguousPrefix);
                 }
                 found_by_prefix = Some(rev)
             }
         }
         found_by_prefix.ok_or(RevlogError::InvalidRevision)
     }
 
     /// Returns whether the given revision exists in this revlog.
     pub fn has_rev(&self, rev: Revision) -> bool {
         self.index.get_entry(rev).is_some()
     }
 
     /// Return the full data associated to a revision.
     ///
     /// All entries required to build the final data out of deltas will be
     /// retrieved as needed, and the deltas will be applied to the inital
     /// snapshot to rebuild the final data.
     #[timed]
     pub fn get_rev_data(&self, rev: Revision) -> Result<Vec<u8>, RevlogError> {
         // Todo return -> Cow
         let mut entry = self.get_entry(rev)?;
         let mut delta_chain = vec![];
         while let Some(base_rev) = entry.base_rev {
             delta_chain.push(entry);
             entry = self
                 .get_entry(base_rev)
                 .map_err(|_| RevlogError::corrupted())?;
         }
 
         // TODO do not look twice in the index
         let index_entry = self
             .index
             .get_entry(rev)
             .ok_or(RevlogError::InvalidRevision)?;
 
         let data: Vec<u8> = if delta_chain.is_empty() {
             entry.data()?.into()
         } else {
             Revlog::build_data_from_deltas(entry, &delta_chain)?
         };
 
         if self.check_hash(
             index_entry.p1(),
             index_entry.p2(),
             index_entry.hash().as_bytes(),
             &data,
         ) {
             Ok(data)
         } else {
             Err(RevlogError::corrupted())
         }
     }
 
     /// Check the hash of some given data against the recorded hash.
     pub fn check_hash(
         &self,
         p1: Revision,
         p2: Revision,
         expected: &[u8],
         data: &[u8],
     ) -> bool {
         let e1 = self.index.get_entry(p1);
         let h1 = match e1 {
             Some(ref entry) => entry.hash(),
             None => &NULL_NODE,
         };
         let e2 = self.index.get_entry(p2);
         let h2 = match e2 {
             Some(ref entry) => entry.hash(),
             None => &NULL_NODE,
         };
 
         hash(data, h1.as_bytes(), h2.as_bytes()).as_slice() == expected
     }
 
     /// Build the full data of a revision out its snapshot
     /// and its deltas.
     #[timed]
     fn build_data_from_deltas(
         snapshot: RevlogEntry,
         deltas: &[RevlogEntry],
     ) -> Result<Vec<u8>, RevlogError> {
         let snapshot = snapshot.data()?;
         let deltas = deltas
             .iter()
             .rev()
             .map(RevlogEntry::data)
             .collect::<Result<Vec<Cow<'_, [u8]>>, RevlogError>>()?;
         let patches: Vec<_> =
             deltas.iter().map(|d| patch::PatchList::new(d)).collect();
         let patch = patch::fold_patch_lists(&patches);
         Ok(patch.apply(&snapshot))
     }
 
     /// Return the revlog data.
     fn data(&self) -> &[u8] {
         match self.data_bytes {
             Some(ref data_bytes) => &data_bytes,
             None => panic!(
                 "forgot to load the data or trying to access inline data"
             ),
         }
     }
 
     /// Get an entry of the revlog.
     fn get_entry(&self, rev: Revision) -> Result<RevlogEntry, RevlogError> {
         let index_entry = self
             .index
             .get_entry(rev)
             .ok_or(RevlogError::InvalidRevision)?;
         let start = index_entry.offset();
         let end = start + index_entry.compressed_len();
         let data = if self.index.is_inline() {
             self.index.data(start, end)
         } else {
             &self.data()[start..end]
         };
         let entry = RevlogEntry {
             rev,
             bytes: data,
             compressed_len: index_entry.compressed_len(),
             uncompressed_len: index_entry.uncompressed_len(),
             base_rev: if index_entry.base_revision() == rev {
                 None
             } else {
                 Some(index_entry.base_revision())
             },
         };
         Ok(entry)
     }
 }
 
 /// The revlog entry's bytes and the necessary informations to extract
 /// the entry's data.
 #[derive(Debug)]
 pub struct RevlogEntry<'a> {
     rev: Revision,
     bytes: &'a [u8],
     compressed_len: usize,
     uncompressed_len: usize,
     base_rev: Option<Revision>,
 }
 
 impl<'a> RevlogEntry<'a> {
     /// Extract the data contained in the entry.
     pub fn data(&self) -> Result<Cow<'_, [u8]>, RevlogError> {
         if self.bytes.is_empty() {
             return Ok(Cow::Borrowed(&[]));
         }
         match self.bytes[0] {
             // Revision data is the entirety of the entry, including this
             // header.
             b'\0' => Ok(Cow::Borrowed(self.bytes)),
             // Raw revision data follows.
             b'u' => Ok(Cow::Borrowed(&self.bytes[1..])),
             // zlib (RFC 1950) data.
             b'x' => Ok(Cow::Owned(self.uncompressed_zlib_data()?)),
             // zstd data.
             b'\x28' => Ok(Cow::Owned(self.uncompressed_zstd_data()?)),
             // A proper new format should have had a repo/store requirement.
             _format_type => Err(RevlogError::corrupted()),
         }
     }
 
     fn uncompressed_zlib_data(&self) -> Result<Vec<u8>, RevlogError> {
         let mut decoder = ZlibDecoder::new(self.bytes);
         if self.is_delta() {
             let mut buf = Vec::with_capacity(self.compressed_len);
             decoder
                 .read_to_end(&mut buf)
                 .map_err(|_| RevlogError::corrupted())?;
             Ok(buf)
         } else {
             let mut buf = vec![0; self.uncompressed_len];
             decoder
                 .read_exact(&mut buf)
                 .map_err(|_| RevlogError::corrupted())?;
             Ok(buf)
         }
     }
 
     fn uncompressed_zstd_data(&self) -> Result<Vec<u8>, RevlogError> {
         if self.is_delta() {
             let mut buf = Vec::with_capacity(self.compressed_len);
             zstd::stream::copy_decode(self.bytes, &mut buf)
                 .map_err(|_| RevlogError::corrupted())?;
             Ok(buf)
         } else {
             let mut buf = vec![0; self.uncompressed_len];
             let len = zstd::block::decompress_to_buffer(self.bytes, &mut buf)
                 .map_err(|_| RevlogError::corrupted())?;
             if len != self.uncompressed_len {
                 Err(RevlogError::corrupted())
             } else {
                 Ok(buf)
             }
         }
     }
 
     /// Tell if the entry is a snapshot or a delta
     /// (influences on decompression).
     fn is_delta(&self) -> bool {
         self.base_rev.is_some()
     }
 }
 
 /// Format version of the revlog.
 pub fn get_version(index_bytes: &[u8]) -> u16 {
     BigEndian::read_u16(&index_bytes[2..=3])
 }
 
 /// Calculate the hash of a revision given its data and its parents.
 fn hash(data: &[u8], p1_hash: &[u8], p2_hash: &[u8]) -> Vec<u8> {
     let mut hasher = Sha1::new();
     let (a, b) = (p1_hash, p2_hash);
     if a > b {
         hasher.input(b);
         hasher.input(a);
     } else {
         hasher.input(a);
         hasher.input(b);
     }
     hasher.input(data);
     let mut hash = vec![0; NODE_BYTES_LENGTH];
     hasher.result(&mut hash);
     hash
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     use super::super::index::IndexEntryBuilder;
 
     #[test]
     fn version_test() {
         let bytes = IndexEntryBuilder::new()
             .is_first(true)
             .with_version(1)
             .build();
 
         assert_eq!(get_version(&bytes), 1)
     }
 }

rust/rhg/src/commands/cat.rs

@@ -1,69 +1,84 b''
 use crate::error::CommandError;
 use clap::Arg;
+use format_bytes::format_bytes;
 use hg::operations::cat;
 use hg::utils::hg_path::HgPathBuf;
 use micro_timer::timed;
 use std::convert::TryFrom;
 
 pub const HELP_TEXT: &str = "
 Output the current or given revision of files
 ";
 
 pub fn args() -> clap::App<'static, 'static> {
     clap::SubCommand::with_name("cat")
         .arg(
             Arg::with_name("rev")
                 .help("search the repository as it is in REV")
                 .short("-r")
                 .long("--revision")
                 .value_name("REV")
                 .takes_value(true),
         )
         .arg(
             clap::Arg::with_name("files")
                 .required(true)
                 .multiple(true)
                 .empty_values(false)
                 .value_name("FILE")
                 .help("Activity to start: activity@category"),
         )
         .about(HELP_TEXT)
 }
 
 #[timed]
 pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
     let rev = invocation.subcommand_args.value_of("rev");
     let file_args = match invocation.subcommand_args.values_of("files") {
         Some(files) => files.collect(),
         None => vec![],
     };
 
     let repo = invocation.repo?;
     let cwd = hg::utils::current_dir()?;
     let working_directory = repo.working_directory_path();
     let working_directory = cwd.join(working_directory); // Make it absolute
 
     let mut files = vec![];
     for file in file_args.iter() {
         // TODO: actually normalize `..` path segments etc?
         let normalized = cwd.join(&file);
         let stripped = normalized
             .strip_prefix(&working_directory)
             // TODO: error message for path arguments outside of the repo
             .map_err(|_| CommandError::abort(""))?;
         let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
             .map_err(|e| CommandError::abort(e.to_string()))?;
         files.push(hg_file);
     }
 
     match rev {
         Some(rev) => {
-            let data = cat(&repo, rev, &files).map_err(|e| (e, rev))?;
-            invocation.ui.write_stdout(&data)?;
-            Ok(())
+            let output = cat(&repo, rev, &files).map_err(|e| (e, rev))?;
+            invocation.ui.write_stdout(&output.concatenated)?;
+            if !output.missing.is_empty() {
+                let short = format!("{:x}", output.node.short()).into_bytes();
+                for path in &output.missing {
+                    invocation.ui.write_stderr(&format_bytes!(
+                        b"{}: no such file in rev {}\n",
+                        path.as_bytes(),
+                        short
+                    ))?;
+                }
+            }
+            if output.found_any {
+                Ok(())
+            } else {
+                Err(CommandError::Unsuccessful)
+            }
         }
         None => Err(CommandError::unsupported(
             "`rhg cat` without `--rev` / `-r`",
         )),
     }
 }

rust/rhg/src/error.rs

@@ -1,143 +1,146 b''
 use crate::ui::utf8_to_local;
 use crate::ui::UiError;
 use crate::NoRepoInCwdError;
 use format_bytes::format_bytes;
 use hg::config::{ConfigError, ConfigParseError};
 use hg::errors::HgError;
 use hg::repo::RepoError;
 use hg::revlog::revlog::RevlogError;
 use hg::utils::files::get_bytes_from_path;
 use std::convert::From;
 
 /// The kind of command error
 #[derive(Debug)]
 pub enum CommandError {
     /// Exit with an error message and "standard" failure exit code.
     Abort { message: Vec<u8> },
 
+    /// Exit with a failure exit code but no message.
+    Unsuccessful,
+
     /// Encountered something (such as a CLI argument, repository layout, …)
     /// not supported by this version of `rhg`. Depending on configuration
     /// `rhg` may attempt to silently fall back to Python-based `hg`, which
     /// may or may not support this feature.
     UnsupportedFeature { message: Vec<u8> },
 }
 
 impl CommandError {
     pub fn abort(message: impl AsRef<str>) -> Self {
         CommandError::Abort {
             // TODO: bytes-based (instead of Unicode-based) formatting
             // of error messages to handle non-UTF-8 filenames etc:
             // https://www.mercurial-scm.org/wiki/EncodingStrategy#Mixing_output
             message: utf8_to_local(message.as_ref()).into(),
         }
     }
 
     pub fn unsupported(message: impl AsRef<str>) -> Self {
         CommandError::UnsupportedFeature {
             message: utf8_to_local(message.as_ref()).into(),
         }
     }
 }
 
 /// For now we don’t differenciate between invalid CLI args and valid for `hg`
 /// but not supported yet by `rhg`.
 impl From<clap::Error> for CommandError {
     fn from(error: clap::Error) -> Self {
         CommandError::unsupported(error.to_string())
     }
 }
 
 impl From<HgError> for CommandError {
     fn from(error: HgError) -> Self {
         match error {
             HgError::UnsupportedFeature(message) => {
                 CommandError::unsupported(message)
             }
             _ => CommandError::abort(error.to_string()),
         }
     }
 }
 
 impl From<UiError> for CommandError {
     fn from(_error: UiError) -> Self {
         // If we already failed writing to stdout or stderr,
         // writing an error message to stderr about it would be likely to fail
         // too.
         CommandError::abort("")
     }
 }
 
 impl From<RepoError> for CommandError {
     fn from(error: RepoError) -> Self {
         match error {
             RepoError::NotFound { at } => CommandError::Abort {
                 message: format_bytes!(
                     b"abort: repository {} not found",
                     get_bytes_from_path(at)
                 ),
             },
             RepoError::ConfigParseError(error) => error.into(),
             RepoError::Other(error) => error.into(),
         }
     }
 }
 
 impl<'a> From<&'a NoRepoInCwdError> for CommandError {
     fn from(error: &'a NoRepoInCwdError) -> Self {
         let NoRepoInCwdError { cwd } = error;
         CommandError::Abort {
             message: format_bytes!(
                 b"abort: no repository found in '{}' (.hg not found)!",
                 get_bytes_from_path(cwd)
             ),
         }
     }
 }
 
 impl From<ConfigError> for CommandError {
     fn from(error: ConfigError) -> Self {
         match error {
             ConfigError::Parse(error) => error.into(),
             ConfigError::Other(error) => error.into(),
         }
     }
 }
 
 impl From<ConfigParseError> for CommandError {
     fn from(error: ConfigParseError) -> Self {
         let ConfigParseError {
             origin,
             line,
             message,
         } = error;
         let line_message = if let Some(line_number) = line {
             format_bytes!(b":{}", line_number.to_string().into_bytes())
         } else {
             Vec::new()
         };
         CommandError::Abort {
             message: format_bytes!(
                 b"config error at {}{}: {}",
                 origin,
                 line_message,
                 message
             ),
         }
     }
 }
 
 impl From<(RevlogError, &str)> for CommandError {
     fn from((err, rev): (RevlogError, &str)) -> CommandError {
         match err {
             RevlogError::InvalidRevision => CommandError::abort(format!(
                 "abort: invalid revision identifier: {}",
                 rev
             )),
             RevlogError::AmbiguousPrefix => CommandError::abort(format!(
                 "abort: ambiguous revision identifier: {}",
                 rev
             )),
             RevlogError::Other(error) => error.into(),
         }
     }
 }

rust/rhg/src/exitcode.rs

@@ -1,10 +1,13 b''
 pub type ExitCode = i32;
 
 /// Successful exit
 pub const OK: ExitCode = 0;
 
 /// Generic abort
 pub const ABORT: ExitCode = 255;
 
+/// Generic something completed but did not succeed
+pub const UNSUCCESSFUL: ExitCode = 1;
+
 /// Command or feature not implemented by rhg
 pub const UNIMPLEMENTED: ExitCode = 252;

rust/rhg/src/main.rs

@@ -1,440 +1,442 b''
 extern crate log;
 use crate::ui::Ui;
 use clap::App;
 use clap::AppSettings;
 use clap::Arg;
 use clap::ArgMatches;
 use format_bytes::{format_bytes, join};
 use hg::config::Config;
 use hg::repo::{Repo, RepoError};
 use hg::utils::files::{get_bytes_from_os_str, get_path_from_bytes};
 use hg::utils::SliceExt;
 use std::ffi::OsString;
 use std::path::PathBuf;
 use std::process::Command;
 
 mod blackbox;
 mod error;
 mod exitcode;
 mod ui;
 use error::CommandError;
 
 fn main_with_result(
     process_start_time: &blackbox::ProcessStartTime,
     ui: &ui::Ui,
     repo: Result<&Repo, &NoRepoInCwdError>,
     config: &Config,
 ) -> Result<(), CommandError> {
     check_extensions(config)?;
 
     let app = App::new("rhg")
         .global_setting(AppSettings::AllowInvalidUtf8)
         .setting(AppSettings::SubcommandRequired)
         .setting(AppSettings::VersionlessSubcommands)
         .arg(
             Arg::with_name("repository")
                 .help("repository root directory")
                 .short("-R")
                 .long("--repository")
                 .value_name("REPO")
                 .takes_value(true)
                 // Both ok: `hg -R ./foo log` or `hg log -R ./foo`
                 .global(true),
         )
         .arg(
             Arg::with_name("config")
                 .help("set/override config option (use 'section.name=value')")
                 .long("--config")
                 .value_name("CONFIG")
                 .takes_value(true)
                 .global(true)
                 // Ok: `--config section.key1=val --config section.key2=val2`
                 .multiple(true)
                 // Not ok: `--config section.key1=val section.key2=val2`
                 .number_of_values(1),
         )
         .arg(
             Arg::with_name("cwd")
                 .help("change working directory")
                 .long("--cwd")
                 .value_name("DIR")
                 .takes_value(true)
                 .global(true),
         )
         .version("0.0.1");
     let app = add_subcommand_args(app);
 
     let matches = app.clone().get_matches_safe()?;
 
     let (subcommand_name, subcommand_matches) = matches.subcommand();
     let run = subcommand_run_fn(subcommand_name)
         .expect("unknown subcommand name from clap despite AppSettings::SubcommandRequired");
     let subcommand_args = subcommand_matches
         .expect("no subcommand arguments from clap despite AppSettings::SubcommandRequired");
 
     let invocation = CliInvocation {
         ui,
         subcommand_args,
         config,
         repo,
     };
     let blackbox = blackbox::Blackbox::new(&invocation, process_start_time)?;
     blackbox.log_command_start();
     let result = run(&invocation);
     blackbox.log_command_end(exit_code(&result));
     result
 }
 
 fn main() {
     // Run this first, before we find out if the blackbox extension is even
     // enabled, in order to include everything in-between in the duration
     // measurements. Reading config files can be slow if they’re on NFS.
     let process_start_time = blackbox::ProcessStartTime::now();
 
     env_logger::init();
     let ui = ui::Ui::new();
 
     let early_args = EarlyArgs::parse(std::env::args_os());
 
     let initial_current_dir = early_args.cwd.map(|cwd| {
         let cwd = get_path_from_bytes(&cwd);
         std::env::current_dir()
             .and_then(|initial| {
                 std::env::set_current_dir(cwd)?;
                 Ok(initial)
             })
             .unwrap_or_else(|error| {
                 exit(
                     &None,
                     &ui,
                     OnUnsupported::Abort,
                     Err(CommandError::abort(format!(
                         "abort: {}: '{}'",
                         error,
                         cwd.display()
                     ))),
                 )
             })
     });
 
     let non_repo_config =
         Config::load(early_args.config).unwrap_or_else(|error| {
             // Normally this is decided based on config, but we don’t have that
             // available. As of this writing config loading never returns an
             // "unsupported" error but that is not enforced by the type system.
             let on_unsupported = OnUnsupported::Abort;
 
             exit(&initial_current_dir, &ui, on_unsupported, Err(error.into()))
         });
 
     if let Some(repo_path_bytes) = &early_args.repo {
         lazy_static::lazy_static! {
             static ref SCHEME_RE: regex::bytes::Regex =
                 // Same as `_matchscheme` in `mercurial/util.py`
                 regex::bytes::Regex::new("^[a-zA-Z0-9+.\\-]+:").unwrap();
         }
         if SCHEME_RE.is_match(&repo_path_bytes) {
             exit(
                 &initial_current_dir,
                 &ui,
                 OnUnsupported::from_config(&non_repo_config),
                 Err(CommandError::UnsupportedFeature {
                     message: format_bytes!(
                         b"URL-like --repository {}",
                         repo_path_bytes
                     ),
                 }),
             )
         }
     }
     let repo_path = early_args.repo.as_deref().map(get_path_from_bytes);
     let repo_result = match Repo::find(&non_repo_config, repo_path) {
         Ok(repo) => Ok(repo),
         Err(RepoError::NotFound { at }) if repo_path.is_none() => {
             // Not finding a repo is not fatal yet, if `-R` was not given
             Err(NoRepoInCwdError { cwd: at })
         }
         Err(error) => exit(
             &initial_current_dir,
             &ui,
             OnUnsupported::from_config(&non_repo_config),
             Err(error.into()),
         ),
     };
 
     let config = if let Ok(repo) = &repo_result {
         repo.config()
     } else {
         &non_repo_config
     };
 
     let result = main_with_result(
         &process_start_time,
         &ui,
         repo_result.as_ref(),
         config,
     );
     exit(
         &initial_current_dir,
         &ui,
         OnUnsupported::from_config(config),
         result,
     )
 }
 
 fn exit_code(result: &Result<(), CommandError>) -> i32 {
     match result {
         Ok(()) => exitcode::OK,
         Err(CommandError::Abort { .. }) => exitcode::ABORT,
+        Err(CommandError::Unsuccessful) => exitcode::UNSUCCESSFUL,
 
         // Exit with a specific code and no error message to let a potential
         // wrapper script fallback to Python-based Mercurial.
         Err(CommandError::UnsupportedFeature { .. }) => {
             exitcode::UNIMPLEMENTED
         }
     }
 }
 
 fn exit(
     initial_current_dir: &Option<PathBuf>,
     ui: &Ui,
     mut on_unsupported: OnUnsupported,
     result: Result<(), CommandError>,
 ) -> ! {
     if let (
         OnUnsupported::Fallback { executable },
         Err(CommandError::UnsupportedFeature { .. }),
     ) = (&on_unsupported, &result)
     {
         let mut args = std::env::args_os();
         let executable_path = get_path_from_bytes(&executable);
         let this_executable = args.next().expect("exepcted argv[0] to exist");
         if executable_path == &PathBuf::from(this_executable) {
             // Avoid spawning infinitely many processes until resource
             // exhaustion.
             let _ = ui.write_stderr(&format_bytes!(
                 b"Blocking recursive fallback. The 'rhg.fallback-executable = {}' config \
                 points to `rhg` itself.\n",
                 executable
             ));
             on_unsupported = OnUnsupported::Abort
         } else {
             // `args` is now `argv[1..]` since we’ve already consumed `argv[0]`
             let mut command = Command::new(executable_path);
             command.args(args);
             if let Some(initial) = initial_current_dir {
                 command.current_dir(initial);
             }
             let result = command.status();
             match result {
                 Ok(status) => std::process::exit(
                     status.code().unwrap_or(exitcode::ABORT),
                 ),
                 Err(error) => {
                     let _ = ui.write_stderr(&format_bytes!(
                         b"tried to fall back to a '{}' sub-process but got error {}\n",
                         executable, format_bytes::Utf8(error)
                     ));
                     on_unsupported = OnUnsupported::Abort
                 }
             }
         }
     }
     match &result {
         Ok(_) => {}
+        Err(CommandError::Unsuccessful) => {}
         Err(CommandError::Abort { message }) => {
             if !message.is_empty() {
                 // Ignore errors when writing to stderr, we’re already exiting
                 // with failure code so there’s not much more we can do.
                 let _ = ui.write_stderr(&format_bytes!(b"{}\n", message));
             }
         }
         Err(CommandError::UnsupportedFeature { message }) => {
             match on_unsupported {
                 OnUnsupported::Abort => {
                     let _ = ui.write_stderr(&format_bytes!(
                         b"unsupported feature: {}\n",
                         message
                     ));
                 }
                 OnUnsupported::AbortSilent => {}
                 OnUnsupported::Fallback { .. } => unreachable!(),
             }
         }
     }
     std::process::exit(exit_code(&result))
 }
 
 macro_rules! subcommands {
     ($( $command: ident )+) => {
         mod commands {
             $(
                 pub mod $command;
             )+
         }
 
         fn add_subcommand_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {
             app
             $(
                 .subcommand(commands::$command::args())
             )+
         }
 
         pub type RunFn = fn(&CliInvocation) -> Result<(), CommandError>;
 
         fn subcommand_run_fn(name: &str) -> Option<RunFn> {
             match name {
                 $(
                     stringify!($command) => Some(commands::$command::run),
                 )+
                 _ => None,
             }
         }
     };
 }
 
 subcommands! {
     cat
     debugdata
     debugrequirements
     files
     root
     config
 }
 pub struct CliInvocation<'a> {
     ui: &'a Ui,
     subcommand_args: &'a ArgMatches<'a>,
     config: &'a Config,
     /// References inside `Result` is a bit peculiar but allow
     /// `invocation.repo?` to work out with `&CliInvocation` since this
     /// `Result` type is `Copy`.
     repo: Result<&'a Repo, &'a NoRepoInCwdError>,
 }
 
 struct NoRepoInCwdError {
     cwd: PathBuf,
 }
 
 /// CLI arguments to be parsed "early" in order to be able to read
 /// configuration before using Clap. Ideally we would also use Clap for this,
 /// see <https://github.com/clap-rs/clap/discussions/2366>.
 ///
 /// These arguments are still declared when we do use Clap later, so that Clap
 /// does not return an error for their presence.
 struct EarlyArgs {
     /// Values of all `--config` arguments. (Possibly none)
     config: Vec<Vec<u8>>,
     /// Value of the `-R` or `--repository` argument, if any.
     repo: Option<Vec<u8>>,
     /// Value of the `--cwd` argument, if any.
     cwd: Option<Vec<u8>>,
 }
 
 impl EarlyArgs {
     fn parse(args: impl IntoIterator<Item = OsString>) -> Self {
         let mut args = args.into_iter().map(get_bytes_from_os_str);
         let mut config = Vec::new();
         let mut repo = None;
         let mut cwd = None;
         // Use `while let` instead of `for` so that we can also call
         // `args.next()` inside the loop.
         while let Some(arg) = args.next() {
             if arg == b"--config" {
                 if let Some(value) = args.next() {
                     config.push(value)
                 }
             } else if let Some(value) = arg.drop_prefix(b"--config=") {
                 config.push(value.to_owned())
             }
 
             if arg == b"--cwd" {
                 if let Some(value) = args.next() {
                     cwd = Some(value)
                 }
             } else if let Some(value) = arg.drop_prefix(b"--cwd=") {
                 cwd = Some(value.to_owned())
             }
 
             if arg == b"--repository" || arg == b"-R" {
                 if let Some(value) = args.next() {
                     repo = Some(value)
                 }
             } else if let Some(value) = arg.drop_prefix(b"--repository=") {
                 repo = Some(value.to_owned())
             } else if let Some(value) = arg.drop_prefix(b"-R") {
                 repo = Some(value.to_owned())
             }
         }
         Self { config, repo, cwd }
     }
 }
 
 /// What to do when encountering some unsupported feature.
 ///
 /// See `HgError::UnsupportedFeature` and `CommandError::UnsupportedFeature`.
 enum OnUnsupported {
     /// Print an error message describing what feature is not supported,
     /// and exit with code 252.
     Abort,
     /// Silently exit with code 252.
     AbortSilent,
     /// Try running a Python implementation
     Fallback { executable: Vec<u8> },
 }
 
 impl OnUnsupported {
     const DEFAULT: Self = OnUnsupported::Abort;
     const DEFAULT_FALLBACK_EXECUTABLE: &'static [u8] = b"hg";
 
     fn from_config(config: &Config) -> Self {
         match config
             .get(b"rhg", b"on-unsupported")
             .map(|value| value.to_ascii_lowercase())
             .as_deref()
         {
             Some(b"abort") => OnUnsupported::Abort,
             Some(b"abort-silent") => OnUnsupported::AbortSilent,
             Some(b"fallback") => OnUnsupported::Fallback {
                 executable: config
                     .get(b"rhg", b"fallback-executable")
                     .unwrap_or(Self::DEFAULT_FALLBACK_EXECUTABLE)
                     .to_owned(),
             },
             None => Self::DEFAULT,
             Some(_) => {
                 // TODO: warn about unknown config value
                 Self::DEFAULT
             }
         }
     }
 }
 
 const SUPPORTED_EXTENSIONS: &[&[u8]] = &[b"blackbox", b"share"];
 
 fn check_extensions(config: &Config) -> Result<(), CommandError> {
     let enabled = config.get_section_keys(b"extensions");
 
     let mut unsupported = enabled;
     for supported in SUPPORTED_EXTENSIONS {
         unsupported.remove(supported);
     }
 
     if let Some(ignored_list) =
         config.get_simple_list(b"rhg", b"ignored-extensions")
     {
         for ignored in ignored_list {
             unsupported.remove(ignored);
         }
     }
 
     if unsupported.is_empty() {
         Ok(())
     } else {
         Err(CommandError::UnsupportedFeature {
             message: format_bytes!(
                 b"extensions: {} (consider adding them to 'rhg.ignored-extensions' config)",
                 join(unsupported, b", ")
             ),
         })
     }
 }