rust/hg-core/src/dirstate/status.rs
29–38	I am curious about where this changes comes from? did rust-format changed opinion or did we reached a threshold?
241	Does this TODO affect the "readiness" of this code to be used in production ? If not, can you clarify what that TODO implies ?
656	What's the implication of this comment ? (or rephrase, the consequence on not having that "done" yet?)

rust/hg-core/src/dirstate/status.rs
29–38	I was fixing conflicts and prefer this style. `rustfmt` does not nest already separate imports. If that's an issue I suppose I can change it.
241	Clarified in the updated inline comment. I mainly wanted to avoid even more code that had very little chance of being useful. If you disagree, please let me know.
656	Oops, it's "insensitive", not "sensitive".

rust/hg-core/src/dirstate/status.rs
29–38	This is not an issue, but this add noise that distract from the core of the patch. Consider doing this kind og small change in independant changesets.
241	It is still not very clear to me. Do we have BadType case where it would make sense to use somethign else than Unknown?
656	So, right now, the status code do now work on case insensitive file system. I assume the proper gards are in place at a higher level ?

rust/hg-core/src/dirstate/status.rs
241	We could check for block devices, character devices, etc. depending on the platform.
656	Yes, there is a check before the fast-path.

rust/hg-core/src/dirstate/status.rs
196	Please describe this parameter.
236	This seems like something that should be handled in the caller. It is trivial for the caller to separate files from directories if they wish to do so.
266	I believe these two can be replaced with `.flatten()`
443	Why was this changed when IIUC all of the returns are references? If a caller wants that I would prefer to do a map in the caller.
604	tx and rx are bad names, please indicate what is being sent and recieved.
605	Instead of creating a vec then extending use collect.
606	You are first collecting all of `results`, then collecting all of `work`. It looks like you intended to do this in parallel but I don't think that is what is happening. A better approach is to make walk_explicit return both items and partition them here.

rust/hg-core/src/dirstate/status.rs
443	`traverse` returns some `Cow::Owned`, I felt that it was simpler to share the same return signature for all functions, but I can map the output, I guess.

rust/hg-core/src/dirstate/status.rs
443	I can definitely see that this is a judgement call. However `.map(Cow::Borrowed)` is easy enough to write that I think it makes sense in this case. However both ways are acceptable.

rust/hg-core/src/dirstate/status.rs
443	I think your way is cleaner, so let's do that, also for `walk_explicit`.

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	19421		Jan 17 2020, 11:53 AM	★	★
Diff 2	19947		Feb 6 2020, 10:16 AM	★	★
Diff 3	20048		Feb 10 2020, 11:30 AM	★	★
Diff 4	20157		Feb 11 2020, 5:55 AM	★	★
Diff 5	20188		Feb 13 2020, 12:37 PM	★	★
Diff 6	20454		Mar 4 2020, 10:08 AM	★	★
Diff 7	20462		Mar 4 2020, 11:55 AM	★	★
Diff 8	20497		Mar 5 2020, 3:33 AM	★	★
Diff 9	20721	rHGc8891bca40fb9fd00c4f9a927ebe6b03789eb31e	Jan 17 2020, 9:43 AM	★	★

Commit	Parents	Author	Summary	Date
6445de741038	1c94b393f404	Raphaël Gomès		Jan 17 2020, 9:43 AM

Status	Author	Revision
Closed	Alphare	D8253 hg-core: add function timing information
Closed	Alphare	D8252 rust: add logging utils
Closed	Alphare	D8251 rust-status: traverse working directory in parallel
Closed	Alphare	D8250 rust-status: wrap `stat_dmap_entries` to ease profiling
Closed	Alphare	D8249 rust-status: refactor handling of unknown files
Closed	Alphare	D8215 rust-status: move to recursive traversal to prepare for parallel traversal
Closed	Alphare	D8213 rust-pathauditor: use interior mutability for use in multi-threaded contexts
Closed	Alphare	D8212 rust-pathauditor: actually populate the `audited_dirs` cache
Closed	Alphare	D8211 rust-pathauditor: actually split Windows shortname aliases at `~`
Closed	Alphare	D8226 debuginstall: add entry about re2 Rust bindings when applicable
Closed	Alphare	D8225 rust-cpython: add `debug` module to expose debug information to Python
Closed	Alphare	D7931 rust-status: use bare hg status fastpath from Python
Closed	Alphare	D7930 rust-status: update rust-cpython bridge to account for the changes in core
Closed	Alphare	D7929 rust-status: add bare `hg status` support in hg-core
Closed	Alphare	D7928 rust-status: add function for sequential traversal of the working directory
Closed	Alphare	D8088 rust-status: add missing variants to `Dispatch` enum
Closed	Alphare	D8087 rust-status: rename `StatusResult` to `DirstateStatus`
Closed	Alphare	D8086 rust-status: refactor options into a `StatusOptions` struct
Closed	Alphare	D7927 rust-status: add util for listing a directory
Closed	Alphare	D7926 rust-dependencies: update rayon
Closed	Alphare	D7925 rust-matchers: add `IgnoreMatcher`
Closed	Alphare	D7924 rust-matchers: add `build_regex_match` function
Closed	Alphare	D7923 rust-matchers: add functions to get roots, dirs and parents from patterns
Closed	Alphare	D7922 rust-matchers: add function to generate a regex matcher function
Closed	Alphare	D8224 rust-format: cleanup ancestors.rs to make rustfmt happy

Diff 19421

rust/hg-core/src/dirstate/status.rs

	// status.rs			// status.rs
	//			//
	// Copyright 2019 Raphaël Gomès <rgomes@octobus.net>			// Copyright 2019 Raphaël Gomès <rgomes@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.

	//! Rust implementation of dirstate.status (dirstate.py).			//! Rust implementation of dirstate.status (dirstate.py).
	//! It is currently missing a lot of functionality compared to the Python one			//! It is currently missing a lot of functionality compared to the Python one
	//! and will only be triggered in narrow cases.			//! and will only be triggered in narrow cases.

	use crate::{			use crate::{
	dirstate::SIZE_FROM_OTHER_PARENT,			dirstate::SIZE_FROM_OTHER_PARENT,
	matchers::{Matcher, VisitChildrenSet},			filepatterns::PatternFileWarning,
				matchers::{get_ignore_function, Matcher, VisitChildrenSet},
	utils::{			utils::{
	files::HgMetadata,			files::{find_dirs, HgMetadata},
	hg_path::{			hg_path::{
	hg_path_to_path_buf, os_string_to_hg_path_buf, HgPath, HgPathBuf,			hg_path_to_path_buf, os_string_to_hg_path_buf, HgPath, HgPathBuf,
				HgPathError,
	},			},
				path_auditor::PathAuditor,
	},			},
	CopyMap, DirstateEntry, DirstateMap, EntryState, FastHashMap,			CopyMap, DirstateEntry, DirstateMap, EntryState, FastHashMap,
				PatternError,
	};			};
				use lazy_static::lazy_static;
	use rayon::prelude::*;			use rayon::prelude::*;
	use std::borrow::Cow;			use std::collections::VecDeque;
	use std::collections::{HashSet, VecDeque};			use std::{
	use std::fs::{read_dir, DirEntry};			borrow::Cow,
	use std::io::ErrorKind;			collections::HashSet,
	use std::ops::Deref;			fs::{read_dir, DirEntry},
	use std::path::Path;			io::ErrorKind,
				ops::Deref,
				path::Path,
				sync::mpsc,
				};
				marmouteUnsubmitted Not Done I am curious about where this changes comes from? did rust-format changed opinion or did we reached a threshold? marmoute: I am curious about where this changes comes from? did rust-format changed opinion or did we…
				AlphareAuthorUnsubmitted Done I was fixing conflicts and prefer this style. `rustfmt` does not nest already separate imports. If that's an issue I suppose I can change it. Alphare: I was fixing conflicts and prefer this style. `rustfmt` does not nest already separate imports.
				marmouteUnsubmitted Not Done This is not an issue, but this add noise that distract from the core of the patch. Consider doing this kind og small change in independant changesets. marmoute: This is not an issue, but this add noise that distract from the core of the patch. Consider…

	#[derive(Debug)]			#[derive(Debug)]
	pub enum BadType {			pub enum BadType {
	CharacterDevice,			CharacterDevice,
	BlockDevice,			BlockDevice,
	FIFO,			FIFO,
	Socket,			Socket,
	Directory,			Directory,
	Unknown,			Unknown,
	}			}

	#[derive(Debug)]			#[derive(Debug)]
	pub enum BadMatch {			pub enum BadMatch {
	OsError(i32),			OsError(i32),
	BadType(BadType),			BadType(BadType),
	}			}

	/// Marker enum used to dispatch new status entries into the right collections.			/// Marker enum used to dispatch new status entries into the right collections.
	/// Is similar to `crate::EntryState`, but represents the transient state of			/// Is similar to `crate::EntryState`, but represents the transient state of
	/// entries during the lifetime of a command.			/// entries during the lifetime of a command.
				#[derive(Debug)]
	enum Dispatch {			enum Dispatch {
	Unsure,			Unsure,
	Modified,			Modified,
	Added,			Added,
	Removed,			Removed,
	Deleted,			Deleted,
	Clean,			Clean,
	Unknown,			Unknown,
	// it may have changed in the same second without			// it may have changed in the same second without
	// changing its size. This can happen if we quickly			// changing its size. This can happen if we quickly
	// do multiple commits. Force lookup, so we don't			// do multiple commits. Force lookup, so we don't
	// miss such a racy file change.			// miss such a racy file change.
	Dispatch::Unsure			Dispatch::Unsure
	} else if options.list_clean {			} else if options.list_clean {
	Dispatch::Clean			Dispatch::Clean
	} else {			} else {
	Dispatch::Unknown			Dispatch::None
	}			}
	}			}
	EntryState::Merged => Dispatch::Modified,			EntryState::Merged => Dispatch::Modified,
	EntryState::Added => Dispatch::Added,			EntryState::Added => Dispatch::Added,
	EntryState::Removed => Dispatch::Removed,			EntryState::Removed => Dispatch::Removed,
	EntryState::Unknown => Dispatch::Unknown,			EntryState::Unknown => Dispatch::Unknown,
	}			}
	}			}

	/// The file corresponding to this Dirstate entry is missing.			/// The file corresponding to this Dirstate entry is missing.
	fn dispatch_missing(state: EntryState) -> Dispatch {			fn dispatch_missing(state: EntryState) -> Dispatch {
	match state {			match state {
	// File was removed from the filesystem during commands			// File was removed from the filesystem during commands
	EntryState::Normal \| EntryState::Merged \| EntryState::Added => {			EntryState::Normal \| EntryState::Merged \| EntryState::Added => {
	Dispatch::Deleted			Dispatch::Deleted
	}			}
	// File was removed, everything is normal			// File was removed, everything is normal
	EntryState::Removed => Dispatch::Removed,			EntryState::Removed => Dispatch::Removed,
	// File is unknown to Mercurial, everything is normal			// File is unknown to Mercurial, everything is normal
	EntryState::Unknown => Dispatch::Unknown,			EntryState::Unknown => Dispatch::Unknown,
	}			}
	}			}

				lazy_static! {
				static ref DEFAULT_WORK: HashSet<&'static HgPath> = {
				let mut h = HashSet::new();
				h.insert(HgPath::new(b""));
				h
				};
				}

	/// Get stat data about the files explicitly specified by match.			/// Get stat data about the files explicitly specified by match.
	/// TODO subrepos			/// TODO subrepos
	fn walk_explicit<'a>(			fn walk_explicit<'a>(
	files: &'a HashSet<&HgPath>,			files: Option<&'a HashSet<&HgPath>>,
	dmap: &'a DirstateMap,			dmap: &'a DirstateMap,
	root_dir: impl AsRef<Path> + Sync + Send,			root_dir: impl AsRef<Path> + Sync + Send,
				work: mpsc::Sender<&'a HgPath>,
				kevincoxUnsubmitted Done Please describe this parameter. kevincox: Please describe this parameter.
	options: StatusOptions,			options: StatusOptions,
	) -> impl ParallelIterator<Item = IoResult<(&'a HgPath, Dispatch)>> {			) -> impl ParallelIterator<Item = IoResult<(Cow<'a, HgPath>, Dispatch)>> {
	files.par_iter().filter_map(move \|filename\| {			files
				.unwrap_or(&DEFAULT_WORK)
				.par_iter()
				.map_with(work, move \|work, filename\| {
	// TODO normalization			// TODO normalization
	let normalized = filename.as_ref();			let normalized = filename.as_ref();

	let buf = match hg_path_to_path_buf(normalized) {			let buf = match hg_path_to_path_buf(normalized) {
	Ok(x) => x,			Ok(x) => x,
	Err(e) => return Some(Err(e.into())),			Err(e) => return Some(Err(e.into())),
	};			};
	let target = root_dir.as_ref().join(buf);			let target = root_dir.as_ref().join(buf);
	let st = target.symlink_metadata();			let st = target.symlink_metadata();
				let in_dmap = dmap.get(normalized);
	match st {			match st {
	Ok(meta) => {			Ok(meta) => {
	let file_type = meta.file_type();			let file_type = meta.file_type();
	if file_type.is_file() \|\| file_type.is_symlink() {			if file_type.is_file() \|\| file_type.is_symlink() {
	if let Some(entry) = dmap.get(normalized) {			if let Some(entry) = in_dmap {
	return Some(Ok((			return Some(Ok((
	normalized,			Cow::Borrowed(normalized),
	dispatch_found(			dispatch_found(
	&normalized,			&normalized,
	*entry,			*entry,
	HgMetadata::from_metadata(meta),			HgMetadata::from_metadata(meta),
	&dmap.copy_map,			&dmap.copy_map,
	options,			options,
	),			),
	)));			)));
	}			}
				return Some(Ok((
				Cow::Borrowed(normalized),
				Dispatch::Unknown,
				)));
	} else {			} else {
	if dmap.contains_key(normalized) {			if file_type.is_dir() {
	return Some(Ok((normalized, Dispatch::Removed)));			// The channel always outlives the sender, unwrap
				work.send(normalized).unwrap()
				kevincoxUnsubmitted Done This seems like something that should be handled in the caller. It is trivial for the caller to separate files from directories if they wish to do so. kevincox: This seems like something that should be handled in the caller. It is trivial for the caller to…
				} else {
				return Some(Ok((
				Cow::Borrowed(normalized),
				Dispatch::Bad(BadMatch::BadType(
				// TODO do more than unknown
				marmouteUnsubmitted Not Done Does this TODO affect the "readiness" of this code to be used in production ? If not, can you clarify what that TODO implies ? marmoute: Does this TODO affect the "readiness" of this code to be used in production ? If not, can you…
				AlphareAuthorUnsubmitted Done Clarified in the updated inline comment. I mainly wanted to avoid even more code that had very little chance of being useful. If you disagree, please let me know. Alphare: Clarified in the updated inline comment. I mainly wanted to avoid even more code that had very…
				marmouteUnsubmitted Not Done It is still not very clear to me. Do we have BadType case where it would make sense to use somethign else than Unknown? marmoute: It is still not very clear to me. Do we have BadType case where it would make sense to use…
				AlphareAuthorUnsubmitted Done We could check for block devices, character devices, etc. depending on the platform. Alphare: We could check for block devices, character devices, etc. depending on the platform.
				BadType::Unknown,
				)),
				)));
				}
				if in_dmap.is_some() {
				return Some(Ok((
				Cow::Borrowed(normalized),
				Dispatch::Removed,
				)));
	}			}
	}			}
	}			}
	Err(_) => {			Err(_) => {
	if let Some(entry) = dmap.get(normalized) {			if let Some(entry) = in_dmap {
	return Some(Ok((			return Some(Ok((
	normalized,			Cow::Borrowed(normalized),
	dispatch_missing(entry.state),			dispatch_missing(entry.state),
	)));			)));
	}			}
	}			}
	};			};
	None			None
	})			})
				.filter(\|s\| s.is_some())
				.map(\|s\| s.unwrap())
				kevincoxUnsubmitted Done I believe these two can be replaced with `.flatten()` kevincox: I believe these two can be replaced with `.flatten()`
	}			}

	#[derive(Debug, Copy, Clone)]			#[derive(Debug, Copy, Clone)]
	pub struct StatusOptions {			pub struct StatusOptions {
	pub last_normal_time: i64,			pub last_normal_time: i64,
	pub check_exec: bool,			pub check_exec: bool,
	pub list_clean: bool,			pub list_clean: bool,
	pub list_ignored: bool,			pub list_ignored: bool,
	}			}
	}			}

	new_results.extend(old_results.into_iter());			new_results.extend(old_results.into_iter());

	Ok(new_results)			Ok(new_results)
	}			}

	/// Stat all entries in the `DirstateMap` and mark them for dispatch into			/// Stat all entries in the `DirstateMap` and mark them for dispatch.
	/// the relevant collections.
	fn stat_dmap_entries(			fn stat_dmap_entries(
	dmap: &DirstateMap,			dmap: &DirstateMap,
	root_dir: impl AsRef<Path> + Sync + Send,			root_dir: impl AsRef<Path> + Sync + Send,
	options: StatusOptions,			options: StatusOptions,
	) -> impl ParallelIterator<Item = IoResult<(&HgPath, Dispatch)>> {			) -> impl ParallelIterator<Item = IoResult<(Cow<HgPath>, Dispatch)>> {
				kevincoxUnsubmitted Not Done Why was this changed when IIUC all of the returns are references? If a caller wants that I would prefer to do a map in the caller. kevincox: Why was this changed when IIUC all of the returns are references? If a caller wants that I…
				AlphareAuthorUnsubmitted Done `traverse` returns some `Cow::Owned`, I felt that it was simpler to share the same return signature for all functions, but I can map the output, I guess. Alphare: `traverse` returns some `Cow::Owned`, I felt that it was simpler to share the same return…
				kevincoxUnsubmitted Not Done I can definitely see that this is a judgement call. However `.map(Cow::Borrowed)` is easy enough to write that I think it makes sense in this case. However both ways are acceptable. kevincox: I can definitely see that this is a judgement call. However `.map(Cow::Borrowed)` is easy…
				AlphareAuthorUnsubmitted Done I think your way is cleaner, so let's do that, also for `walk_explicit`. Alphare: I think your way is cleaner, so let's do that, also for `walk_explicit`.
	dmap.par_iter().map(move \|(filename, entry)\| {			dmap.par_iter().map(move \|(filename, entry)\| {
	let filename: &HgPath = filename;			let filename: &HgPath = filename;
	let filename_as_path = hg_path_to_path_buf(filename)?;			let filename_as_path = hg_path_to_path_buf(filename)?;
	let meta = root_dir.as_ref().join(filename_as_path).symlink_metadata();			let meta = root_dir.as_ref().join(filename_as_path).symlink_metadata();

	match meta {			match meta {
	Ok(ref m)			Ok(ref m)
	if !(m.file_type().is_file()			if !(m.file_type().is_file()
	\|\| m.file_type().is_symlink()) =>			\|\| m.file_type().is_symlink()) =>
	{			{
	Ok((filename, dispatch_missing(entry.state)))			Ok((Cow::Borrowed(filename), dispatch_missing(entry.state)))
	}			}
	Ok(m) => Ok((			Ok(m) => Ok((
	filename,			Cow::Borrowed(filename),
	dispatch_found(			dispatch_found(
	filename,			filename,
	*entry,			*entry,
	HgMetadata::from_metadata(m),			HgMetadata::from_metadata(m),
	&dmap.copy_map,			&dmap.copy_map,
	options,			options,
	),			),
	)),			)),
	Err(ref e)			Err(ref e)
	if e.kind() == std::io::ErrorKind::NotFound			if e.kind() == ErrorKind::NotFound
	\|\| e.raw_os_error() == Some(20) =>			\|\| e.raw_os_error() == Some(20) =>
	{			{
	// Rust does not yet have an `ErrorKind` for			// Rust does not yet have an `ErrorKind` for
	// `NotADirectory` (errno 20)			// `NotADirectory` (errno 20)
	// It happens if the dirstate contains `foo/bar` and			// It happens if the dirstate contains `foo/bar` and
	// foo is not a directory			// foo is not a directory
	Ok((filename, dispatch_missing(entry.state)))			Ok((Cow::Borrowed(filename), dispatch_missing(entry.state)))
	}			}
	Err(e) => Err(e),			Err(e) => Err(e),
	}			}
	})			})
	}			}

	pub struct DirstateStatus<'a> {			pub struct DirstateStatus<'a> {
	pub modified: Vec<&'a HgPath>,			pub modified: Vec<Cow<'a, HgPath>>,
	pub added: Vec<&'a HgPath>,			pub added: Vec<Cow<'a, HgPath>>,
	pub removed: Vec<&'a HgPath>,			pub removed: Vec<Cow<'a, HgPath>>,
	pub deleted: Vec<&'a HgPath>,			pub deleted: Vec<Cow<'a, HgPath>>,
	pub clean: Vec<&'a HgPath>,			pub clean: Vec<Cow<'a, HgPath>>,
	pub ignored: Vec<&'a HgPath>,			pub ignored: Vec<Cow<'a, HgPath>>,
	pub unknown: Vec<&'a HgPath>,			pub unknown: Vec<Cow<'a, HgPath>>,
	pub bad: Vec<(&'a HgPath, BadMatch)>,			pub bad: Vec<(Cow<'a, HgPath>, BadMatch)>,
	/* TODO ignored
	* TODO unknown */
	}			}

	fn build_response<'a>(			fn build_response<'a>(
	results: impl IntoIterator<Item = IoResult<(&'a HgPath, Dispatch)>>,			results: impl IntoIterator<Item = (Cow<'a, HgPath>, Dispatch)>,
	) -> IoResult<(Vec<&'a HgPath>, DirstateStatus<'a>)> {			) -> (Vec<Cow<'a, HgPath>>, DirstateStatus<'a>) {
	let mut lookup = vec![];			let mut lookup = vec![];
	let mut modified = vec![];			let mut modified = vec![];
	let mut added = vec![];			let mut added = vec![];
	let mut removed = vec![];			let mut removed = vec![];
	let mut deleted = vec![];			let mut deleted = vec![];
	let mut clean = vec![];			let mut clean = vec![];
	let mut ignored = vec![];			let mut ignored = vec![];
	let mut unknown = vec![];			let mut unknown = vec![];
	let mut bad = vec![];			let mut bad = vec![];

	for res in results.into_iter() {			for (filename, dispatch) in results.into_iter() {
	let (filename, dispatch) = res?;
	match dispatch {			match dispatch {
	Dispatch::Unknown => unknown.push(filename),			Dispatch::Unknown => unknown.push(filename),
	Dispatch::Unsure => lookup.push(filename),			Dispatch::Unsure => lookup.push(filename),
	Dispatch::Modified => modified.push(filename),			Dispatch::Modified => modified.push(filename),
	Dispatch::Added => added.push(filename),			Dispatch::Added => added.push(filename),
	Dispatch::Removed => removed.push(filename),			Dispatch::Removed => removed.push(filename),
	Dispatch::Deleted => deleted.push(filename),			Dispatch::Deleted => deleted.push(filename),
	Dispatch::Clean => clean.push(filename),			Dispatch::Clean => clean.push(filename),
	Dispatch::Ignored => ignored.push(filename),			Dispatch::Ignored => ignored.push(filename),
	Dispatch::None => {}			Dispatch::None => {}
	Dispatch::Bad(reason) => bad.push((filename, reason)),			Dispatch::Bad(reason) => bad.push((filename, reason)),
	}			}
	}			}

	Ok((			(
	lookup,			lookup,
	DirstateStatus {			DirstateStatus {
	modified,			modified,
	added,			added,
	removed,			removed,
	deleted,			deleted,
	clean,			clean,
	ignored,			ignored,
	unknown,			unknown,
	bad,			bad,
	},			},
	))			)
	}			}

				pub enum StatusError {
				IO(std::io::Error),
				Path(HgPathError),
				Pattern(PatternError),
				}

				pub type StatusResult<T> = Result<T, StatusError>;

				impl From<PatternError> for StatusError {
				fn from(e: PatternError) -> Self {
				StatusError::Pattern(e)
				}
				}
				impl From<HgPathError> for StatusError {
				fn from(e: HgPathError) -> Self {
				StatusError::Path(e)
				}
				}
				impl From<std::io::Error> for StatusError {
				fn from(e: std::io::Error) -> Self {
				StatusError::IO(e)
				}
				}

				impl ToString for StatusError {
				fn to_string(&self) -> String {
				match self {
				StatusError::IO(e) => e.to_string(),
				StatusError::Path(e) => e.to_string(),
				StatusError::Pattern(e) => e.to_string(),
				}
				}
				}

				/// Get the status of files in the working directory.
				///
				/// This is the current entry-point for `hg-core` and is realistically unusable
				/// outside of a Python context because its arguments need to provide a lot of
				/// information that will not be necessary in the future.
	pub fn status<'a: 'c, 'b: 'c, 'c>(			pub fn status<'a: 'c, 'b: 'c, 'c>(
	dmap: &'a DirstateMap,			dmap: &'a DirstateMap,
	matcher: &'b (impl Matcher),			matcher: &'b (impl Matcher + Sync),
	root_dir: impl AsRef<Path> + Sync + Send + Copy,			root_dir: impl AsRef<Path> + Sync + Send + Copy,
				ignore_files: &[impl AsRef<Path>],
	options: StatusOptions,			options: StatusOptions,
	) -> IoResult<(Vec<&'c HgPath>, DirstateStatus<'c>)> {			) -> StatusResult<(
				(Vec<Cow<'c, HgPath>>, DirstateStatus<'c>),
				Vec<PatternFileWarning>,
				)> {
				let (ignore_fn, warnings) = get_ignore_function(&ignore_files, root_dir)?;
				let dir_ignore_fn = \|dir: &_\| {
				if ignore_fn(dir) {
				true
				} else {
				for p in find_dirs(dir) {
				if ignore_fn(p) {
				return true;
				}
				}
				false
				}
				};

	let files = matcher.file_set();			let files = matcher.file_set();

	let mut results = vec![];			let mut results = vec![];
	if let Some(files) = files {			let mut work = vec![];
	results.par_extend(walk_explicit(&files, &dmap, root_dir, options));
				// Step 1: check the files explicitly mentioned by the user
				let (tx, rx) = mpsc::channel();
				kevincoxUnsubmitted Done tx and rx are bad names, please indicate what is being sent and recieved. kevincox: tx and rx are bad names, please indicate what is being sent and recieved.
				results.par_extend(walk_explicit(files, &dmap, root_dir, tx, options));
				kevincoxUnsubmitted Done Instead of creating a vec then extending use collect. kevincox: Instead of creating a vec then extending use collect.
				while let Ok(dir) = rx.recv() {
				kevincoxUnsubmitted Done You are first collecting all of `results`, then collecting all of `work`. It looks like you intended to do this in parallel but I don't think that is what is happening. A better approach is to make walk_explicit return both items and partition them here. kevincox: You are first collecting all of `results`, then collecting all of `work`. It looks like you…
				if options.list_ignored \|\| options.list_unknown && !dir_ignore_fn(dir)
				{
				work.push(dir)
				}
				}

				let mut results = results.into_iter().flatten().collect();

				// Step 2: recursively check the working directory for changes if needed
				for dir in work {
				if dir_ignore_fn(dir) {
				continue;
				}
				results = traverse(
				matcher, root_dir, &dmap, dir, results, &ignore_fn, options,
				)?;
	}			}

	if !matcher.is_exact() {			if !matcher.is_exact() {
				// Step 3: Check the remaining files from the dmap.
				// If a dmap file is not in results yet, it was either
				// a) not matched b) ignored, c) missing, or d) under a
				// symlink directory.

				let to_visit: Box<dyn Iterator<Item = (&HgPathBuf, &DirstateEntry)>> =
				if results.is_empty() && matcher.matches_everything() {
				Box::new(dmap.iter())
				} else {
				Box::new(dmap.iter().filter_map(\|(f, e)\| {
				if !results.contains_key(f.deref()) && matcher.matches(f) {
				Some((f, e))
				} else {
				None
				}
				}))
				};
				let mut to_visit: Vec<_> = to_visit.collect();
				to_visit.sort_by(\|a, b\| a.0.cmp(&b.0));

				if options.list_unknown {
				// We walked all dirs under the roots that weren't ignored, and
				// everything that matched was stat'ed and is already in results.
				// The rest must thus be ignored or under a symlink.
				let mut path_auditor = PathAuditor::new(root_dir);

				for (ref filename, entry) in to_visit {
				// Report ignored items in the dmap as long as they are not
				// under a symlink directory.
				if path_auditor.check(filename) {
				// TODO normalize for other case-sensitive fs
				marmouteUnsubmitted Not Done What's the implication of this comment ? (or rephrase, the consequence on not having that "done" yet?) marmoute: What's the implication of this comment ? (or rephrase, the consequence on not having that…
				AlphareAuthorUnsubmitted Done Oops, it's "insensitive", not "sensitive". Alphare: Oops, it's "insensitive", not "sensitive".
				marmouteUnsubmitted Done So, right now, the status code do now work on case insensitive file system. I assume the proper gards are in place at a higher level ? marmoute: So, right now, the status code do now work on case insensitive file system. I assume the proper…
				AlphareAuthorUnsubmitted Done Yes, there is a check before the fast-path. Alphare: Yes, there is a check before the fast-path.
				let buf = hg_path_to_path_buf(filename)?;
				results.insert(
				Cow::Borrowed(filename),
				match root_dir.as_ref().join(&buf).symlink_metadata() {
				// File was just ignored, no links, and exists
				Ok(meta) => {
				let metadata = HgMetadata::from_metadata(meta);
				dispatch_found(
				filename,
				*entry,
				metadata,
				&dmap.copy_map,
				options,
				)
				}
				// File doesn't exist
				Err(_) => dispatch_missing(entry.state),
				},
				);
				} else {
				// It's either missing or under a symlink directory which
				// we, in this case, report as missing.
				results.insert(
				Cow::Borrowed(filename),
				dispatch_missing(entry.state),
				);
				}
				}
				} else {
				// We may not have walked the full directory tree above, so stat
				// and check everything we missed.
	let stat_results = stat_dmap_entries(&dmap, root_dir, options);			let stat_results = stat_dmap_entries(&dmap, root_dir, options);
	results.par_extend(stat_results);			results.par_extend(stat_results.flatten());
				}
				}

				let results = results.into_iter().filter_map(\|(filename, dispatch)\| {
				match dispatch {
				Dispatch::Bad(_) => return Some((filename, dispatch)),
				_ => {}
				};
				// TODO do this in //, not at the end
				if !dmap.contains_key(filename.deref()) {
				if (options.list_ignored \|\| matcher.exact_match(&filename))
				&& dir_ignore_fn(&filename)
				{
				if options.list_ignored {
				return Some((filename.to_owned(), Dispatch::Ignored));
				}
				} else {
				if !ignore_fn(&filename) {
				return Some((filename.to_owned(), Dispatch::Unknown));
				}
				}
				return None;
	}			}
				Some((filename, dispatch))
				});

	build_response(results)			Ok((build_response(results), warnings))
	}			}

rust/hg-core/src/lib.rs

	// Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net>			// Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net>
	// and Mercurial contributors			// and Mercurial contributors
	//			//
	// 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.
	mod ancestors;			mod ancestors;
	pub mod dagops;			pub mod dagops;
	pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors};			pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors};
	mod dirstate;			mod dirstate;
	pub mod discovery;			pub mod discovery;
	pub mod testing; // unconditionally built, for use from integration tests			pub mod testing; // unconditionally built, for use from integration tests
	pub use dirstate::{			pub use dirstate::{
	dirs_multiset::{DirsMultiset, DirsMultisetIter},			dirs_multiset::{DirsMultiset, DirsMultisetIter},
	dirstate_map::DirstateMap,			dirstate_map::DirstateMap,
	parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE},			parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE},
	status::{status, DirstateStatus},			status::{
				status, BadMatch, BadType, DirstateStatus, StatusError, StatusOptions,
				},
	CopyMap, CopyMapIter, DirstateEntry, DirstateParents, EntryState,			CopyMap, CopyMapIter, DirstateEntry, DirstateParents, EntryState,
	StateMap, StateMapIter,			StateMap, StateMapIter,
	};			};
	mod filepatterns;			mod filepatterns;
	pub mod matchers;			pub mod matchers;
	pub mod revlog;			pub mod revlog;
	pub use revlog::*;			pub use revlog::*;
	#[cfg(feature = "with-re2")]			#[cfg(feature = "with-re2")]

			Path	Packages
M			rust/hg-core/src/dirstate/status.rs (362 lines)
M			rust/hg-core/src/lib.rs (4 lines)

This is an archive of the discontinued Mercurial Phabricator instance.

rust-status: add bare `hg status` support in hg-core
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents
Changeset List

Diff 19421

rust/hg-core/src/dirstate/status.rs

rust/hg-core/src/lib.rs

This is an archive of the discontinued Mercurial Phabricator instance.

rust-status: add bare `hg status` support in hg-coreClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 19421

rust/hg-core/src/dirstate/status.rs

rust/hg-core/src/lib.rs

rust-status: add bare `hg status` support in hg-core
ClosedPublic

Revision Contents
Changeset List