rhg: allow specifying a changeset ID prefix

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

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

@@ -1,169 +1,172 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::convert::From;
 use std::path::{Path, PathBuf};
 
 use crate::revlog::changelog::Changelog;
 use crate::revlog::manifest::{Manifest, ManifestEntry};
 use crate::revlog::path_encode::path_encode;
 use crate::revlog::revlog::Revlog;
 use crate::revlog::revlog::RevlogError;
 use crate::revlog::Revision;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::{HgPath, HgPathBuf};
 
 const METADATA_DELIMITER: [u8; 2] = [b'\x01', b'\n'];
 
 /// Kind of error encountered by `CatRev`
 #[derive(Debug)]
 pub enum CatRevErrorKind {
     /// Error when reading a `revlog` file.
     IoError(std::io::Error),
     /// The revision has not been found.
     InvalidRevision,
+    /// Found more than one revision whose ID match the requested prefix
+    AmbiguousPrefix,
     /// A `revlog` file is corrupted.
     CorruptedRevlog,
     /// The `revlog` format version is not supported.
     UnsuportedRevlogVersion(u16),
     /// The `revlog` data format is not supported.
     UnknowRevlogDataFormat(u8),
 }
 
 /// A `CatRev` error
 #[derive(Debug)]
 pub struct CatRevError {
     /// Kind of error encountered by `CatRev`
     pub kind: CatRevErrorKind,
 }
 
 impl From<CatRevErrorKind> for CatRevError {
     fn from(kind: CatRevErrorKind) -> Self {
         CatRevError { kind }
     }
 }
 
 impl From<RevlogError> for CatRevError {
     fn from(err: RevlogError) -> Self {
         match err {
             RevlogError::IoError(err) => CatRevErrorKind::IoError(err),
             RevlogError::UnsuportedVersion(version) => {
                 CatRevErrorKind::UnsuportedRevlogVersion(version)
             }
             RevlogError::InvalidRevision => CatRevErrorKind::InvalidRevision,
+            RevlogError::AmbiguousPrefix => CatRevErrorKind::AmbiguousPrefix,
             RevlogError::Corrupted => CatRevErrorKind::CorruptedRevlog,
             RevlogError::UnknowDataFormat(format) => {
                 CatRevErrorKind::UnknowRevlogDataFormat(format)
             }
         }
         .into()
     }
 }
 
 /// List files under Mercurial control at a given revision.
 pub struct CatRev<'a> {
     root: &'a PathBuf,
     /// The revision to cat the files from.
     rev: &'a str,
     /// The files to output.
     files: &'a [HgPathBuf],
     /// The changelog file
     changelog: Changelog,
     /// The manifest file
     manifest: Manifest,
     /// The manifest entry corresponding to the revision.
     ///
     /// Used to hold the owner of the returned references.
     manifest_entry: Option<ManifestEntry>,
 }
 
 impl<'a> CatRev<'a> {
     pub fn new(
         root: &'a PathBuf,
         rev: &'a str,
         files: &'a [HgPathBuf],
     ) -> Result<Self, CatRevError> {
         let changelog = Changelog::open(&root)?;
         let manifest = Manifest::open(&root)?;
         let manifest_entry = None;
 
         Ok(Self {
             root,
             rev,
             files,
             changelog,
             manifest,
             manifest_entry,
         })
     }
 
     pub fn run(&mut self) -> Result<Vec<u8>, CatRevError> {
         let changelog_entry = match self.rev.parse::<Revision>() {
             Ok(rev) => self.changelog.get_rev(rev)?,
             _ => {
                 let changelog_node = hex::decode(&self.rev)
                     .map_err(|_| CatRevErrorKind::InvalidRevision)?;
                 self.changelog.get_node(&changelog_node)?
             }
         };
         let manifest_node = hex::decode(&changelog_entry.manifest_node()?)
             .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
 
         self.manifest_entry = Some(self.manifest.get_node(&manifest_node)?);
         if let Some(ref manifest_entry) = self.manifest_entry {
             let mut bytes = vec![];
 
             for (manifest_file, node_bytes) in
                 manifest_entry.files_with_nodes()
             {
                 for cat_file in self.files.iter() {
                     if cat_file.as_bytes() == manifest_file.as_bytes() {
                         let index_path =
                             store_path(self.root, manifest_file, b".i");
                         let data_path =
                             store_path(self.root, manifest_file, b".d");
 
                         let file_log =
                             Revlog::open(&index_path, Some(&data_path))?;
                         let file_node = hex::decode(&node_bytes)
                             .map_err(|_| CatRevErrorKind::CorruptedRevlog)?;
                         let file_rev = file_log.get_node_rev(&file_node)?;
                         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)
         } else {
             unreachable!("manifest_entry should have been stored");
         }
     }
 }
 
 fn store_path(root: &Path, hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
     let encoded_bytes =
         path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
     [
         root,
         &Path::new(".hg/store/"),
         get_path_from_bytes(&encoded_bytes),
     ]
     .iter()
     .collect()
 }

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

@@ -1,114 +1,119 b''
 // debugdata.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 super::find_root;
 use crate::revlog::revlog::{Revlog, RevlogError};
 use crate::revlog::Revision;
 
 /// Kind of data to debug
 #[derive(Debug, Copy, Clone)]
 pub enum DebugDataKind {
     Changelog,
     Manifest,
 }
 
 /// Kind of error encountered by DebugData
 #[derive(Debug)]
 pub enum DebugDataErrorKind {
     FindRootError(find_root::FindRootError),
     /// Error when reading a `revlog` file.
     IoError(std::io::Error),
     /// The revision has not been found.
     InvalidRevision,
+    /// Found more than one revision whose ID match the requested prefix
+    AmbiguousPrefix,
     /// A `revlog` file is corrupted.
     CorruptedRevlog,
     /// The `revlog` format version is not supported.
     UnsuportedRevlogVersion(u16),
     /// The `revlog` data format is not supported.
     UnknowRevlogDataFormat(u8),
 }
 
 /// A DebugData error
 #[derive(Debug)]
 pub struct DebugDataError {
     /// Kind of error encountered by DebugData
     pub kind: DebugDataErrorKind,
 }
 
 impl From<DebugDataErrorKind> for DebugDataError {
     fn from(kind: DebugDataErrorKind) -> Self {
         DebugDataError { kind }
     }
 }
 
 impl From<find_root::FindRootError> for DebugDataError {
     fn from(err: find_root::FindRootError) -> Self {
         let kind = DebugDataErrorKind::FindRootError(err);
         DebugDataError { kind }
     }
 }
 
 impl From<std::io::Error> for DebugDataError {
     fn from(err: std::io::Error) -> Self {
         let kind = DebugDataErrorKind::IoError(err);
         DebugDataError { kind }
     }
 }
 
 impl From<RevlogError> for DebugDataError {
     fn from(err: RevlogError) -> Self {
         match err {
             RevlogError::IoError(err) => DebugDataErrorKind::IoError(err),
             RevlogError::UnsuportedVersion(version) => {
                 DebugDataErrorKind::UnsuportedRevlogVersion(version)
             }
             RevlogError::InvalidRevision => {
                 DebugDataErrorKind::InvalidRevision
             }
+            RevlogError::AmbiguousPrefix => {
+                DebugDataErrorKind::AmbiguousPrefix
+            }
             RevlogError::Corrupted => DebugDataErrorKind::CorruptedRevlog,
             RevlogError::UnknowDataFormat(format) => {
                 DebugDataErrorKind::UnknowRevlogDataFormat(format)
             }
         }
         .into()
     }
 }
 
 /// Dump the contents data of a revision.
 pub struct DebugData<'a> {
     /// Revision or hash of the revision.
     rev: &'a str,
     /// Kind of data to debug.
     kind: DebugDataKind,
 }
 
 impl<'a> DebugData<'a> {
     pub fn new(rev: &'a str, kind: DebugDataKind) -> Self {
         DebugData { rev, kind }
     }
 
     pub fn run(&mut self) -> Result<Vec<u8>, DebugDataError> {
         let root = find_root::FindRoot::new().run()?;
         let index_file = match self.kind {
             DebugDataKind::Changelog => root.join(".hg/store/00changelog.i"),
             DebugDataKind::Manifest => root.join(".hg/store/00manifest.i"),
         };
         let revlog = Revlog::open(&index_file, None)?;
 
         let data = match self.rev.parse::<Revision>() {
             Ok(rev) => revlog.get_rev_data(rev)?,
             _ => {
                 let node = hex::decode(&self.rev)
                     .map_err(|_| DebugDataErrorKind::InvalidRevision)?;
                 let rev = revlog.get_node_rev(&node)?;
                 revlog.get_rev_data(rev)?
             }
         };
 
         Ok(data)
     }
 }

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

@@ -1,187 +1,192 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 crate::dirstate::parsers::parse_dirstate;
 use crate::revlog::changelog::Changelog;
 use crate::revlog::manifest::{Manifest, ManifestEntry};
 use crate::revlog::revlog::RevlogError;
 use crate::revlog::Revision;
 use crate::utils::hg_path::HgPath;
 use crate::{DirstateParseError, EntryState};
 use rayon::prelude::*;
 use std::convert::From;
 use std::fs;
 use std::path::PathBuf;
 
 /// Kind of error encountered by `ListDirstateTrackedFiles`
 #[derive(Debug)]
 pub enum ListDirstateTrackedFilesErrorKind {
     /// Error when reading the `dirstate` file
     IoError(std::io::Error),
     /// Error when parsing the `dirstate` file
     ParseError(DirstateParseError),
 }
 
 /// A `ListDirstateTrackedFiles` error
 #[derive(Debug)]
 pub struct ListDirstateTrackedFilesError {
     /// Kind of error encountered by `ListDirstateTrackedFiles`
     pub kind: ListDirstateTrackedFilesErrorKind,
 }
 
 impl From<ListDirstateTrackedFilesErrorKind>
     for ListDirstateTrackedFilesError
 {
     fn from(kind: ListDirstateTrackedFilesErrorKind) -> Self {
         ListDirstateTrackedFilesError { kind }
     }
 }
 
 impl From<std::io::Error> for ListDirstateTrackedFilesError {
     fn from(err: std::io::Error) -> Self {
         let kind = ListDirstateTrackedFilesErrorKind::IoError(err);
         ListDirstateTrackedFilesError { kind }
     }
 }
 
 /// List files under Mercurial control in the working directory
 /// by reading the dirstate
 pub struct ListDirstateTrackedFiles {
     /// The `dirstate` content.
     content: Vec<u8>,
 }
 
 impl ListDirstateTrackedFiles {
     pub fn new(root: &PathBuf) -> Result<Self, ListDirstateTrackedFilesError> {
         let dirstate = root.join(".hg/dirstate");
         let content = fs::read(&dirstate)?;
         Ok(Self { content })
     }
 
     pub fn run(
         &mut self,
     ) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> {
         let (_, entries, _) = parse_dirstate(&self.content)
             .map_err(ListDirstateTrackedFilesErrorKind::ParseError)?;
         let mut files: Vec<&HgPath> = entries
             .into_iter()
             .filter_map(|(path, entry)| match entry.state {
                 EntryState::Removed => None,
                 _ => Some(path),
             })
             .collect();
         files.par_sort_unstable();
         Ok(files)
     }
 }
 
 /// Kind of error encountered by `ListRevTrackedFiles`
 #[derive(Debug)]
 pub enum ListRevTrackedFilesErrorKind {
     /// Error when reading a `revlog` file.
     IoError(std::io::Error),
     /// The revision has not been found.
     InvalidRevision,
+    /// Found more than one revision whose ID match the requested prefix
+    AmbiguousPrefix,
     /// A `revlog` file is corrupted.
     CorruptedRevlog,
     /// The `revlog` format version is not supported.
     UnsuportedRevlogVersion(u16),
     /// The `revlog` data format is not supported.
     UnknowRevlogDataFormat(u8),
 }
 
 /// A `ListRevTrackedFiles` error
 #[derive(Debug)]
 pub struct ListRevTrackedFilesError {
     /// Kind of error encountered by `ListRevTrackedFiles`
     pub kind: ListRevTrackedFilesErrorKind,
 }
 
 impl From<ListRevTrackedFilesErrorKind> for ListRevTrackedFilesError {
     fn from(kind: ListRevTrackedFilesErrorKind) -> Self {
         ListRevTrackedFilesError { kind }
     }
 }
 
 impl From<RevlogError> for ListRevTrackedFilesError {
     fn from(err: RevlogError) -> Self {
         match err {
             RevlogError::IoError(err) => {
                 ListRevTrackedFilesErrorKind::IoError(err)
             }
             RevlogError::UnsuportedVersion(version) => {
                 ListRevTrackedFilesErrorKind::UnsuportedRevlogVersion(version)
             }
             RevlogError::InvalidRevision => {
                 ListRevTrackedFilesErrorKind::InvalidRevision
             }
+            RevlogError::AmbiguousPrefix => {
+                ListRevTrackedFilesErrorKind::AmbiguousPrefix
+            }
             RevlogError::Corrupted => {
                 ListRevTrackedFilesErrorKind::CorruptedRevlog
             }
             RevlogError::UnknowDataFormat(format) => {
                 ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format)
             }
         }
         .into()
     }
 }
 
 /// List files under Mercurial control at a given revision.
 pub struct ListRevTrackedFiles<'a> {
     /// The revision to list the files from.
     rev: &'a str,
     /// The changelog file
     changelog: Changelog,
     /// The manifest file
     manifest: Manifest,
     /// The manifest entry corresponding to the revision.
     ///
     /// Used to hold the owner of the returned references.
     manifest_entry: Option<ManifestEntry>,
 }
 
 impl<'a> ListRevTrackedFiles<'a> {
     pub fn new(
         root: &PathBuf,
         rev: &'a str,
     ) -> Result<Self, ListRevTrackedFilesError> {
         let changelog = Changelog::open(&root)?;
         let manifest = Manifest::open(&root)?;
 
         Ok(Self {
             rev,
             changelog,
             manifest,
             manifest_entry: None,
         })
     }
 
     pub fn run(
         &mut self,
     ) -> Result<impl Iterator<Item = &HgPath>, ListRevTrackedFilesError> {
         let changelog_entry = match self.rev.parse::<Revision>() {
             Ok(rev) => self.changelog.get_rev(rev)?,
             _ => {
                 let changelog_node = hex::decode(&self.rev)
                     .or(Err(ListRevTrackedFilesErrorKind::InvalidRevision))?;
                 self.changelog.get_node(&changelog_node)?
             }
         };
         let manifest_node = hex::decode(&changelog_entry.manifest_node()?)
             .or(Err(ListRevTrackedFilesErrorKind::CorruptedRevlog))?;
 
         self.manifest_entry = Some(self.manifest.get_node(&manifest_node)?);
 
         if let Some(ref manifest_entry) = self.manifest_entry {
             Ok(manifest_entry.files())
         } else {
             panic!(
                 "manifest entry should have been stored in self.manifest_node to ensure its lifetime since references are returned from it"
             )
         }
     }
 }

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

@@ -1,335 +1,344 b''
 use std::borrow::Cow;
 use std::fs::File;
 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 memmap::{Mmap, MmapOptions};
 use micro_timer::timed;
 use zstd;
 
 use super::index::Index;
 use super::node::{NODE_BYTES_LENGTH, NULL_NODE_ID};
 use super::patch;
 use crate::revlog::Revision;
 
 pub enum RevlogError {
     IoError(std::io::Error),
     UnsuportedVersion(u16),
     InvalidRevision,
+    /// Found more than one entry whose ID match the requested prefix
+    AmbiguousPrefix,
     Corrupted,
     UnknowDataFormat(u8),
 }
 
 fn mmap_open(path: &Path) -> Result<Mmap, std::io::Error> {
     let file = File::open(path)?;
     let mmap = unsafe { MmapOptions::new().map(&file) }?;
     Ok(mmap)
 }
 
 /// 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,
     /// When index and data are not interleaved: bytes of the revlog data
     data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>,
 }
 
 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(
         index_path: &Path,
         data_path: Option<&Path>,
     ) -> Result<Self, RevlogError> {
         let index_mmap =
             mmap_open(&index_path).map_err(RevlogError::IoError)?;
 
         let version = get_version(&index_mmap);
         if version != 1 {
             return Err(RevlogError::UnsuportedVersion(version));
         }
 
         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 =
                     mmap_open(data_path).map_err(RevlogError::IoError)?;
                 Some(Box::new(data_mmap))
             };
 
         Ok(Revlog { index, data_bytes })
     }
 
     /// 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: &[u8]) -> Result<Revision, RevlogError> {
         // This is brute force. But it is fast enough for now.
         // Optimization will come later.
+        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(RevlogError::Corrupted)?;
-            if node == index_entry.hash() {
+            if index_entry.hash() == node {
                 return Ok(rev);
             }
+            if index_entry.hash().starts_with(node) {
+                if found_by_prefix.is_some() {
+                    return Err(RevlogError::AmbiguousPrefix);
+                }
+                found_by_prefix = Some(rev)
+            }
         }
-        Err(RevlogError::InvalidRevision)
+        found_by_prefix.ok_or(RevlogError::InvalidRevision)
     }
 
     /// 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).or(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(),
             &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_ID,
         };
         let e2 = self.index.get_entry(p2);
         let h2 = match e2 {
             Some(ref entry) => entry.hash(),
             None => &NULL_NODE_ID,
         };
 
         hash(data, &h1, &h2).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()?)),
             format_type => Err(RevlogError::UnknowDataFormat(format_type)),
         }
     }
 
     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)
                 .or(Err(RevlogError::Corrupted))?;
             Ok(buf)
         } else {
             let mut buf = vec![0; self.uncompressed_len];
             decoder
                 .read_exact(&mut buf)
                 .or(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)
                 .or(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)
                 .or(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,101 +1,108 b''
 use crate::commands::Command;
 use crate::error::{CommandError, CommandErrorKind};
 use crate::ui::utf8_to_local;
 use crate::ui::Ui;
 use hg::operations::FindRoot;
 use hg::operations::{CatRev, CatRevError, CatRevErrorKind};
 use hg::requirements;
 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 struct CatCommand<'a> {
     rev: Option<&'a str>,
     files: Vec<&'a str>,
 }
 
 impl<'a> CatCommand<'a> {
     pub fn new(rev: Option<&'a str>, files: Vec<&'a str>) -> Self {
         Self { rev, files }
     }
 
     fn display(&self, ui: &Ui, data: &[u8]) -> Result<(), CommandError> {
         ui.write_stdout(data)?;
         Ok(())
     }
 }
 
 impl<'a> Command for CatCommand<'a> {
     #[timed]
     fn run(&self, ui: &Ui) -> Result<(), CommandError> {
         let root = FindRoot::new().run()?;
         requirements::check(&root)?;
         let cwd = std::env::current_dir()
             .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
 
         let mut files = vec![];
         for file in self.files.iter() {
             let normalized = cwd.join(&file);
             let stripped = normalized
                 .strip_prefix(&root)
                 .or(Err(CommandErrorKind::Abort(None)))?;
             let hg_file = HgPathBuf::try_from(stripped.to_path_buf())
                 .or(Err(CommandErrorKind::Abort(None)))?;
             files.push(hg_file);
         }
 
         match self.rev {
             Some(rev) => {
                 let mut operation = CatRev::new(&root, rev, &files)
                     .map_err(|e| map_rev_error(rev, e))?;
                 let data =
                     operation.run().map_err(|e| map_rev_error(rev, e))?;
                 self.display(ui, &data)
             }
             None => Err(CommandErrorKind::Unimplemented.into()),
         }
     }
 }
 
 /// Convert `CatRevErrorKind` to `CommandError`
 fn map_rev_error(rev: &str, err: CatRevError) -> CommandError {
     CommandError {
         kind: match err.kind {
             CatRevErrorKind::IoError(err) => CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!("abort: {}\n", err)).into(),
             )),
             CatRevErrorKind::InvalidRevision => CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!(
                     "abort: invalid revision identifier {}\n",
                     rev
                 ))
                 .into(),
             )),
+            CatRevErrorKind::AmbiguousPrefix => CommandErrorKind::Abort(Some(
+                utf8_to_local(&format!(
+                    "abort: ambiguous revision identifier {}\n",
+                    rev
+                ))
+                .into(),
+            )),
             CatRevErrorKind::UnsuportedRevlogVersion(version) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unsupported revlog version {}\n",
                         version
                     ))
                     .into(),
                 ))
             }
             CatRevErrorKind::CorruptedRevlog => CommandErrorKind::Abort(Some(
                 "abort: corrupted revlog\n".into(),
             )),
             CatRevErrorKind::UnknowRevlogDataFormat(format) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unknow revlog dataformat {:?}\n",
                         format
                     ))
                     .into(),
                 ))
             }
         },
     }
 }

rust/rhg/src/commands/debugdata.rs

@@ -1,82 +1,91 b''
 use crate::commands::Command;
 use crate::error::{CommandError, CommandErrorKind};
 use crate::ui::utf8_to_local;
 use crate::ui::Ui;
 use hg::operations::{
     DebugData, DebugDataError, DebugDataErrorKind, DebugDataKind,
 };
 use micro_timer::timed;
 
 pub const HELP_TEXT: &str = "
 Dump the contents of a data file revision
 ";
 
 pub struct DebugDataCommand<'a> {
     rev: &'a str,
     kind: DebugDataKind,
 }
 
 impl<'a> DebugDataCommand<'a> {
     pub fn new(rev: &'a str, kind: DebugDataKind) -> Self {
         DebugDataCommand { rev, kind }
     }
 }
 
 impl<'a> Command for DebugDataCommand<'a> {
     #[timed]
     fn run(&self, ui: &Ui) -> Result<(), CommandError> {
         let mut operation = DebugData::new(self.rev, self.kind);
         let data =
             operation.run().map_err(|e| to_command_error(self.rev, e))?;
 
         let mut stdout = ui.stdout_buffer();
         stdout.write_all(&data)?;
         stdout.flush()?;
 
         Ok(())
     }
 }
 
 /// Convert operation errors to command errors
 fn to_command_error(rev: &str, err: DebugDataError) -> CommandError {
     match err.kind {
         DebugDataErrorKind::FindRootError(err) => CommandError::from(err),
         DebugDataErrorKind::IoError(err) => CommandError {
             kind: CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!("abort: {}\n", err)).into(),
             )),
         },
         DebugDataErrorKind::InvalidRevision => CommandError {
             kind: CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!(
                     "abort: invalid revision identifier{}\n",
                     rev
                 ))
                 .into(),
             )),
         },
+        DebugDataErrorKind::AmbiguousPrefix => CommandError {
+            kind: CommandErrorKind::Abort(Some(
+                utf8_to_local(&format!(
+                    "abort: ambiguous revision identifier{}\n",
+                    rev
+                ))
+                .into(),
+            )),
+        },
         DebugDataErrorKind::UnsuportedRevlogVersion(version) => CommandError {
             kind: CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!(
                     "abort: unsupported revlog version {}\n",
                     version
                 ))
                 .into(),
             )),
         },
         DebugDataErrorKind::CorruptedRevlog => CommandError {
             kind: CommandErrorKind::Abort(Some(
                 "abort: corrupted revlog\n".into(),
             )),
         },
         DebugDataErrorKind::UnknowRevlogDataFormat(format) => CommandError {
             kind: CommandErrorKind::Abort(Some(
                 utf8_to_local(&format!(
                     "abort: unknow revlog dataformat {:?}\n",
                     format
                 ))
                 .into(),
             )),
         },
     }
 }

rust/rhg/src/commands/files.rs

@@ -1,138 +1,147 b''
 use crate::commands::Command;
 use crate::error::{CommandError, CommandErrorKind};
 use crate::ui::utf8_to_local;
 use crate::ui::Ui;
 use hg::operations::FindRoot;
 use hg::operations::{
     ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
     ListDirstateTrackedFilesErrorKind,
 };
 use hg::operations::{
     ListRevTrackedFiles, ListRevTrackedFilesError,
     ListRevTrackedFilesErrorKind,
 };
 use hg::requirements;
 use hg::utils::files::{get_bytes_from_path, relativize_path};
 use hg::utils::hg_path::{HgPath, HgPathBuf};
 use std::path::PathBuf;
 
 pub const HELP_TEXT: &str = "
 List tracked files.
 
 Returns 0 on success.
 ";
 
 pub struct FilesCommand<'a> {
     rev: Option<&'a str>,
 }
 
 impl<'a> FilesCommand<'a> {
     pub fn new(rev: Option<&'a str>) -> Self {
         FilesCommand { rev }
     }
 
     fn display_files(
         &self,
         ui: &Ui,
         root: &PathBuf,
         files: impl IntoIterator<Item = &'a HgPath>,
     ) -> Result<(), CommandError> {
         let cwd = std::env::current_dir()
             .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
         let rooted_cwd = cwd
             .strip_prefix(&root)
             .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();
 
         for file in files {
             stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?;
             stdout.write_all(b"\n")?;
         }
         stdout.flush()?;
         Ok(())
     }
 }
 
 impl<'a> Command for FilesCommand<'a> {
     fn run(&self, ui: &Ui) -> Result<(), CommandError> {
         let root = FindRoot::new().run()?;
         requirements::check(&root)?;
         if let Some(rev) = self.rev {
             let mut operation = ListRevTrackedFiles::new(&root, rev)
                 .map_err(|e| map_rev_error(rev, e))?;
             let files = operation.run().map_err(|e| map_rev_error(rev, e))?;
             self.display_files(ui, &root, files)
         } else {
             let mut operation = ListDirstateTrackedFiles::new(&root)
                 .map_err(map_dirstate_error)?;
             let files = operation.run().map_err(map_dirstate_error)?;
             self.display_files(ui, &root, files)
         }
     }
 }
 
 /// Convert `ListRevTrackedFilesErrorKind` to `CommandError`
 fn map_rev_error(rev: &str, err: ListRevTrackedFilesError) -> CommandError {
     CommandError {
         kind: match err.kind {
             ListRevTrackedFilesErrorKind::IoError(err) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!("abort: {}\n", err)).into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::InvalidRevision => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: invalid revision identifier {}\n",
                         rev
                     ))
                     .into(),
                 ))
             }
+            ListRevTrackedFilesErrorKind::AmbiguousPrefix => {
+                CommandErrorKind::Abort(Some(
+                    utf8_to_local(&format!(
+                        "abort: ambiguous revision identifier {}\n",
+                        rev
+                    ))
+                    .into(),
+                ))
+            }
             ListRevTrackedFilesErrorKind::UnsuportedRevlogVersion(version) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unsupported revlog version {}\n",
                         version
                     ))
                     .into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::CorruptedRevlog => {
                 CommandErrorKind::Abort(Some(
                     "abort: corrupted revlog\n".into(),
                 ))
             }
             ListRevTrackedFilesErrorKind::UnknowRevlogDataFormat(format) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!(
                         "abort: unknow revlog dataformat {:?}\n",
                         format
                     ))
                     .into(),
                 ))
             }
         },
     }
 }
 
 /// Convert `ListDirstateTrackedFilesError` to `CommandError`
 fn map_dirstate_error(err: ListDirstateTrackedFilesError) -> CommandError {
     CommandError {
         kind: match err.kind {
             ListDirstateTrackedFilesErrorKind::IoError(err) => {
                 CommandErrorKind::Abort(Some(
                     utf8_to_local(&format!("abort: {}\n", err)).into(),
                 ))
             }
             ListDirstateTrackedFilesErrorKind::ParseError(_) => {
                 CommandErrorKind::Abort(Some(
                     // TODO find a better error message
                     b"abort: parse error\n".to_vec(),
                 ))
             }
         },
     }
 }

tests/test-rhg.t

@@ -1,167 +1,165 b''
 #require rust
 
 Define an rhg function that will only run if rhg exists
   $ rhg() {
   > if [ -f "$RUNTESTDIR/../rust/target/debug/rhg" ]; then
   >   "$RUNTESTDIR/../rust/target/debug/rhg" "$@"
   > else
   >   echo "skipped: Cannot find rhg. Try to run cargo build in rust/rhg."
   >   exit 80
   > fi
   > }
 
 Unimplemented command
   $ rhg unimplemented-command
   error: Found argument 'unimplemented-command' which wasn't expected, or isn't valid in this context
   
   USAGE:
       rhg <SUBCOMMAND>
   
   For more information try --help
   [252]
 
 Finding root
   $ rhg root
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
 
   $ hg init repository
   $ cd repository
   $ rhg root
   $TESTTMP/repository
 
 Unwritable file descriptor
   $ rhg root > /dev/full
   abort: No space left on device (os error 28)
   [255]
 
 Deleted repository
   $ rm -rf `pwd`
   $ rhg root
   abort: error getting current working directory: $ENOENT$
   [255]
 
 Listing tracked files
   $ cd $TESTTMP
   $ hg init repository
   $ cd repository
   $ for i in 1 2 3; do
   >   echo $i >> file$i
   >   hg add file$i
   > done
   > hg commit -m "commit $i" -q
 
 Listing tracked files from root
   $ rhg files
   file1
   file2
   file3
 
 Listing tracked files from subdirectory
   $ mkdir -p path/to/directory
   $ cd path/to/directory
   $ rhg files
   ../../../file1
   ../../../file2
   ../../../file3
 
 Listing tracked files through broken pipe
   $ rhg files | head -n 1
   ../../../file1
 
 Debuging data in inline index
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg init repository
   $ cd repository
-  $ for i in 1 2 3; do
-  >   echo $i >> file$i
-  >   hg add file$i
-  >   hg commit -m "commit $i" -q
+  $ for i in 1 2 3 4 5 6; do
+  >   echo $i >> file-$i
+  >   hg add file-$i
+  >   hg commit -m "Commit $i" -q
   > done
   $ rhg debugdata -c 2
-  e36fa63d37a576b27a69057598351db6ee5746bd
+  8d0267cb034247ebfa5ee58ce59e22e57a492297
   test
   0 0
-  file3
+  file-3
   
-  commit 3 (no-eol)
+  Commit 3 (no-eol)
   $ rhg debugdata -m 2
-  file1\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
-  file2\x005d9299349fc01ddd25d0070d149b124d8f10411e (esc)
-  file3\x002661d26c649684b482d10f91960cc3db683c38b4 (esc)
+  file-1\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
+  file-2\x005d9299349fc01ddd25d0070d149b124d8f10411e (esc)
+  file-3\x002661d26c649684b482d10f91960cc3db683c38b4 (esc)
 
 Debuging with full node id
   $ rhg debugdata -c `hg log -r 0 -T '{node}'`
-  c8e64718e1ca0312eeee0f59d37f8dc612793856
+  d1d1c679d3053e8926061b6f45ca52009f011e3f
   test
   0 0
-  file1
+  file-1
   
-  commit 1 (no-eol)
+  Commit 1 (no-eol)
+
+Specifying revisions by changeset ID
+  $ hg log -T '{node}\n'
+  c6ad58c44207b6ff8a4fbbca7045a5edaa7e908b
+  d654274993d0149eecc3cc03214f598320211900
+  f646af7e96481d3a5470b695cf30ad8e3ab6c575
+  cf8b83f14ead62b374b6e91a0e9303b85dfd9ed7
+  91c6f6e73e39318534dc415ea4e8a09c99cd74d6
+  6ae9681c6d30389694d8701faf24b583cf3ccafe
+  $ rhg files -r cf8b83
+  file-1
+  file-2
+  file-3
+  $ rhg cat -r cf8b83 file-2
+  2
+  $ rhg cat -r c file-2
+  abort: invalid revision identifier c
+  [255]
 
 Cat files
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg init repository
   $ cd repository
   $ echo "original content" > original
   $ hg add original
   $ hg commit -m "add original" original
   $ rhg cat -r 0 original
   original content
 Cat copied file should not display copy metadata
   $ hg copy original copy_of_original
   $ hg commit -m "add copy of original"
   $ rhg cat -r 1 copy_of_original
   original content
 
-Specifying revisions by changeset ID
-  $ hg log
-  changeset:   1:41263439dc17
-  tag:         tip
-  user:        test
-  date:        Thu Jan 01 00:00:00 1970 +0000
-  summary:     add copy of original
-  
-  changeset:   0:1c9e69808da7
-  user:        test
-  date:        Thu Jan 01 00:00:00 1970 +0000
-  summary:     add original
-  
-  $ rhg files -r 41263439dc17
-  abort: invalid revision identifier 41263439dc17
-  [255]
-  $ rhg cat -r 41263439dc17 original
-  abort: invalid revision identifier 41263439dc17
-  [255]
-
 Requirements
   $ rhg debugrequirements
   dotencode
   fncache
   generaldelta
   revlogv1
   sparserevlog
   store
 
   $ echo indoor-pool >> .hg/requires
   $ rhg files
   [252]
 
   $ rhg cat -r 1 copy_of_original
   [252]
 
   $ rhg debugrequirements
   dotencode
   fncache
   generaldelta
   revlogv1
   sparserevlog
   store
   indoor-pool
 
   $ echo -e '\xFF' >> .hg/requires
   $ rhg debugrequirements
   abort: .hg/requires is corrupted
   [255]