This is an archive of the discontinued Mercurial Phabricator instance.

			Path	Packages
M			rust/hg-core/src/operations/list_tracked_files.rs (124 lines)
M			rust/hg-core/src/operations/mod.rs (4 lines)
M			rust/hg-core/src/revlog/index.rs (14 lines)
M			rust/hg-core/src/revlog/revlog.rs (7 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	22617		Sep 11 2020, 3:53 AM	★	★
Diff 2	22725		Sep 18 2020, 10:49 AM	★	★
Diff 3	22795	rHG639f33f22faf1bb7627169299fa03ab4fb54ac48	Sep 18 2020, 10:52 AM	★	★

Commit	Parents	Author	Summary	Date
a718b31ec2f5	0f036ed92118	Antoine Cezar		Sep 9 2020, 8:51 AM

Status	Author	Revision
Closed	acezar	D9052 rhg: add a limited `rhg cat -r` subcommand
Closed	acezar	D9051 hg-core: add a `CatRev` operation
Closed	acezar	D9050 hg-core: add `files_with_nodes` to `Manifest`
Closed	acezar	D9049 hg-core: add path_encode
Closed	acezar	D9048 hg-core: impl TryFrom<PathBuff> for HgPathBuf
Closed	acezar	D9015 rhg: add `--revision` argument to `rhg files`
Closed	acezar	D9014 hg-core: add a `ListRevTrackedFiles` operation
Closed	acezar	D9013 hg-core: simplify `list_tracked_files` operation
Closed	acezar	D9012 hg-core: add `Revlog.get_node_rev`
Closed	acezar	D9011 hg-core: add `Manifest` a specialized `Revlog`
Closed	acezar	D9010 hg-core: add `Changlog` a specialized `Revlog`
Closed	acezar	D9005 hg-core: check data integrity in `Revlog`
Closed	acezar	D8962 rhg: Add debug timing
Closed	acezar	D8961 rhg: add a limited `rhg debugdata` subcommand
Closed	acezar	D8960 rhg: add a `DebugData` `Command` to prepare the `rhg debugdata` subcommand
Closed	acezar	D8959 hg-core: define a `DebugData` `Operation`
Closed	acezar	D8958 hg-core: Add a limited read only `revlog` implementation
Closed	acezar	D8957 hg-core: fix some `clippy` warnings
Closed	acezar	D8956 rhg: print error message when argument parsing fails
Closed	acezar	D8955 rhg: fix `clippy` warnings
Closed	acezar	D8954 rhg: pass `ui` to `Command` `run`
Closed	acezar	D8953 documentation: add `zstd` compression to the internal `revlogs` documentation
Closed	acezar	D8873 rhg: add harness tests for rhg files
Closed	acezar	D8872 rhg: make output of `files` relative to the current directory and the root
Closed	acezar	D8871 rhg: handle broken pipe error for stderr
Closed	acezar	D8870 rhg: extract function handle_stdout_error
Closed	acezar	D8869 rhg: add a limited `rhg files` subcommand
Closed	acezar	D8868 rhg: add a `Files` `Command` to prepare the `rhg files` subcommand
Closed	acezar	D8867 rhg: simplify `FindRootError` handling
Closed	acezar	D8866 rhg: add buffered stdout writing possibility
Closed	acezar	D8865 rhg: ask the error message from `CommandError`
Closed	acezar	D8864 rhg: Do not return error when when we really mean ok in commands
Closed	acezar	D8863 hg-core: define a `ListTrackedFiles` `Operation`
Closed	acezar	D8862 hg-core: remove the `Operation` trait
Closed	acezar	D8861 hg-core: make parse_dirstate return references rather than update hashmaps

Diff 22617

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

	// list_tracked_files.rs			// list_tracked_files.rs
	//			//
	// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net>			// Copyright 2020 Antoine Cezar <antoine.cezar@octobus.net>
	//			//
	// This software may be used and distributed according to the terms of the			// This software may be used and distributed according to the terms of the
	// GNU General Public License version 2 or any later version.			// GNU General Public License version 2 or any later version.

	use crate::dirstate::parsers::parse_dirstate;			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::utils::hg_path::HgPath;
	use crate::{DirstateParseError, EntryState};			use crate::{DirstateParseError, EntryState};
	use rayon::prelude::*;			use rayon::prelude::*;
	use std::convert::From;			use std::convert::From;
	use std::fmt;
	use std::fs;			use std::fs;
	use std::ops::Deref;			use std::path::PathBuf;
	use std::path::{Path, PathBuf};

	/// Kind of error encountered by `ListDirstateTrackedFiles`			/// Kind of error encountered by `ListDirstateTrackedFiles`
	#[derive(Debug)]			#[derive(Debug)]
	pub enum ListDirstateTrackedFilesErrorKind {			pub enum ListDirstateTrackedFilesErrorKind {
	/// Error when reading the `dirstate` file			/// Error when reading the `dirstate` file
	IoError(std::io::Error),			IoError(std::io::Error),
	/// Error when parsing the `dirstate` file			/// Error when parsing the `dirstate` file
	ParseError(DirstateParseError),			ParseError(DirstateParseError),
	}			}

	/// A `ListDirstateTrackedFiles` error			/// A `ListDirstateTrackedFiles` error
	#[derive(Debug)]			#[derive(Debug)]
	pub struct ListDirstateTrackedFilesError {			pub struct ListDirstateTrackedFilesError {
	/// Kind of error encountered by `ListDirstateTrackedFiles`			/// Kind of error encountered by `ListDirstateTrackedFiles`
	pub kind: ListDirstateTrackedFilesErrorKind,			pub kind: ListDirstateTrackedFilesErrorKind,
	}			}

	impl std::error::Error for ListDirstateTrackedFilesError {}

	impl fmt::Display for ListDirstateTrackedFilesError {
	fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
	unimplemented!()
	}
	}

	impl From<ListDirstateTrackedFilesErrorKind>			impl From<ListDirstateTrackedFilesErrorKind>
	for ListDirstateTrackedFilesError			for ListDirstateTrackedFilesError
	{			{
	fn from(kind: ListDirstateTrackedFilesErrorKind) -> Self {			fn from(kind: ListDirstateTrackedFilesErrorKind) -> Self {
	ListDirstateTrackedFilesError { kind }			ListDirstateTrackedFilesError { kind }
	}			}
	}			}

	EntryState::Removed => None,			EntryState::Removed => None,
	_ => Some(path),			_ => Some(path),
	})			})
	.collect();			.collect();
	files.par_sort_unstable();			files.par_sort_unstable();
	Ok(files)			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,
				/// 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::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).map_err(\|_\| {
				ListRevTrackedFilesErrorKind::InvalidRevision
				})?;
				self.changelog.get_node(&changelog_node)?
				}
				};
				let manifest_node = hex::decode(&changelog_entry.manifest_node()?)
				.map_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/operations/mod.rs

	//! A distinction is made between operations and commands.			//! A distinction is made between operations and commands.
	//! An operation is what can be done whereas a command is what is exposed by			//! 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.			//! the cli. A single command can use several operations to achieve its goal.

	mod debugdata;			mod debugdata;
	mod dirstate_status;			mod dirstate_status;
	mod find_root;			mod find_root;
	mod list_tracked_files;			mod list_tracked_files;
	pub use debugdata::{			pub use debugdata::{
	DebugData, DebugDataError, DebugDataErrorKind, DebugDataKind,			DebugData, DebugDataError, DebugDataErrorKind, DebugDataKind,
	};			};
	pub use find_root::{FindRoot, FindRootError, FindRootErrorKind};			pub use find_root::{FindRoot, FindRootError, FindRootErrorKind};
	pub use list_tracked_files::{			pub use list_tracked_files::{
	ListDirstateTrackedFiles, ListDirstateTrackedFilesError,			ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
	ListDirstateTrackedFilesErrorKind,			ListDirstateTrackedFilesErrorKind,
	};			};
				pub use list_tracked_files::{
				ListRevTrackedFiles, ListRevTrackedFilesError,
				ListRevTrackedFilesErrorKind,
				};

	// TODO add an `Operation` trait when GAT have landed (rust #44265):			// TODO add an `Operation` trait when GAT have landed (rust #44265):
	// there is no way to currently define a trait which can both return			// there is no way to currently define a trait which can both return
	// references to `self` and to passed data, which is what we would need.			// references to `self` and to passed data, which is what we would need.
	// Generic Associated Types may fix this and allow us to have a unified			// Generic Associated Types may fix this and allow us to have a unified
	// interface.			// interface.

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

	} else {			} else {
	Self {			Self {
	bytes,			bytes,
	offsets: None,			offsets: None,
	}			}
	}			}
	}			}

				/// Return number of entries of the revlog index.
				pub fn len(&self) -> usize {
				if let Some(offsets) = &self.offsets {
				offsets.len()
				} else {
				self.bytes.len() / INDEX_ENTRY_SIZE
				}
				}

				/// Returns `true` if the `Index` has zero `entries`.
				pub fn is_empty(&self) -> bool {
				self.len() == 0
				}

	/// Return the index entry corresponding to the given revision if it			/// Return the index entry corresponding to the given revision if it
	/// exists.			/// exists.
	pub fn get_entry(&self, rev: Revision) -> Option<IndexEntry> {			pub fn get_entry(&self, rev: Revision) -> Option<IndexEntry> {
	if rev == NULL_REVISION {			if rev == NULL_REVISION {
	return None;			return None;
	}			}
	if let Some(offsets) = &self.offsets {			if let Some(offsets) = &self.offsets {
	self.get_entry_inline(rev, offsets)			self.get_entry_inline(rev, offsets)

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

	})			})
	}			}

	/// Return number of entries of the `Revlog`.			/// Return number of entries of the `Revlog`.
	pub fn len(&self) -> usize {			pub fn len(&self) -> usize {
	self.index().len()			self.index().len()
	}			}

				/// Returns `true` if the `Revlog` has zero `entries`.
				AlphareUnsubmitted Done Ha, I see that my comment on the ancestor patch is not useful anymore. Alphare: Ha, I see that my comment on the ancestor patch is not useful anymore.
				acezarAuthorUnsubmitted Done moved in the other commit acezar: moved in the other commit
				pub fn is_empty(&self) -> bool {
				self.index().is_empty()
				}

	/// Return the full data associated to a node.			/// Return the full data associated to a node.
	#[timed]			#[timed]
	pub fn get_node_rev(&self, node: &[u8]) -> Result<Revision, RevlogError> {			pub fn get_node_rev(&self, node: &[u8]) -> Result<Revision, RevlogError> {
	let index = self.index();			let index = self.index();
	for rev in (0..self.len() as Revision).rev() {			for rev in (0..self.len() as Revision).rev() {
	let index_entry =			let index_entry =
	index.get_entry(rev).ok_or_else(\|\| RevlogError::Corrupted)?;			index.get_entry(rev).ok_or_else(\|\| RevlogError::Corrupted)?;
	if node == index_entry.hash() {			if node == index_entry.hash() {
	.collect::<Result<Vec<Cow<'_, [u8]>>, RevlogError>>()?;			.collect::<Result<Vec<Cow<'_, [u8]>>, RevlogError>>()?;
	let patches: Vec<_> =			let patches: Vec<_> =
	deltas.iter().map(\|d\| patch::PatchList::new(d)).collect();			deltas.iter().map(\|d\| patch::PatchList::new(d)).collect();
	let patch = patch::fold_patch_lists(&patches);			let patch = patch::fold_patch_lists(&patches);
	Ok(patch.apply(&snapshot))			Ok(patch.apply(&snapshot))
	}			}

	/// Return the revlog index.			/// Return the revlog index.
	fn index(&self) -> Index {			pub fn index(&self) -> Index {
	let is_inline = self.data_bytes.is_none();			let is_inline = self.data_bytes.is_none();
	Index::new(&self.index_bytes, is_inline)			Index::new(&self.index_bytes, is_inline)
	}			}

	/// Return the revlog data.			/// Return the revlog data.
	fn data(&self) -> &[u8] {			fn data(&self) -> &[u8] {
	match self.data_bytes {			match self.data_bytes {
	Some(ref data_bytes) => &data_bytes,			Some(ref data_bytes) => &data_bytes,

This is an archive of the discontinued Mercurial Phabricator instance.

hg-core: add a `ListRevTrackedFiles` operationClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 22617

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

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

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

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

hg-core: add a `ListRevTrackedFiles` operation
ClosedPublic

Revision Contents
Changeset List