rhg: strip copied files metadata from `cat` output

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

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

@@ -1,145 +1,158 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::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::hg_path::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,
     /// 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::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 encoded_bytes =
                             path_encode(manifest_file.as_bytes());
                         let revlog_index_string = format!(
                             ".hg/store/data/{}.i",
                             String::from_utf8_lossy(&encoded_bytes),
                         );
                         let revlog_index_path =
                             self.root.join(&revlog_index_string);
                         let file_log = Revlog::open(&revlog_index_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");
         }
     }
 }

tests/test-rhg.t

@@ -1,92 +1,108 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
   > done
   $ rhg debugdata -c 2
   e36fa63d37a576b27a69057598351db6ee5746bd
   test
   0 0
   file3
   
   commit 3 (no-eol)
   $ rhg debugdata -m 2
   file1\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   file2\x005d9299349fc01ddd25d0070d149b124d8f10411e (esc)
   file3\x002661d26c649684b482d10f91960cc3db683c38b4 (esc)
+
+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