rust/hg-cpython/src/dirstate/status.rs
76	This should probably be a method on BadType.

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	19422		Jan 17 2020, 11:53 AM	★	★
Diff 2	19948		Feb 6 2020, 10:16 AM	★	★
Diff 3	20049		Feb 10 2020, 11:30 AM	★	★
Diff 4	20158		Feb 11 2020, 5:55 AM	★	★
Diff 5	20189		Feb 13 2020, 12:37 PM	★	★
Diff 6	20455		Mar 4 2020, 10:08 AM	★	★
Diff 7	20463		Mar 4 2020, 11:55 AM	★	★
Diff 8	20498		Mar 5 2020, 3:33 AM	★	★
Diff 9	20722	rHGf96b28aa4b7983bd12acd41cce50d0c942920583	Jan 17 2020, 9:09 AM	★	★

Commit	Parents	Author	Summary	Date
8a5ba5d15216	6445de741038	Raphaël Gomès		Jan 17 2020, 9:09 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 19422

rust/hg-cpython/src/dirstate.rs

	// dirstate.rs			// dirstate.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.

	//! Bindings for the `hg::dirstate` module provided by the			//! Bindings for the `hg::dirstate` module provided by the
	//! `hg-core` package.			//! `hg-core` package.
	//!			//!
	//! From Python, this will be seen as `mercurial.rustext.dirstate`			//! From Python, this will be seen as `mercurial.rustext.dirstate`
	mod copymap;			mod copymap;
	mod dirs_multiset;			mod dirs_multiset;
	mod dirstate_map;			mod dirstate_map;
	mod status;			mod status;
	use crate::dirstate::{			use crate::{
				dirstate::{
	dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper,			dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper,
				},
				exceptions,
	};			};
	use cpython::{			use cpython::{
	exc, PyBytes, PyDict, PyErr, PyModule, PyObject, PyResult, PySequence,			exc, PyBytes, PyDict, PyErr, PyList, PyModule, PyObject, PyResult,
	Python,			PySequence, Python,
	};			};
	use hg::{			use hg::{
	utils::hg_path::HgPathBuf, DirstateEntry, DirstateParseError, EntryState,			utils::hg_path::HgPathBuf, DirstateEntry, DirstateParseError, EntryState,
	StateMap,			StateMap,
	};			};
	use libc::{c_char, c_int};			use libc::{c_char, c_int};
	use std::convert::TryFrom;			use std::convert::TryFrom;

	/// Create the module, with `__package__` given from parent			/// Create the module, with `__package__` given from parent
	pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {			pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
	let dotted_name = &format!("{}.dirstate", package);			let dotted_name = &format!("{}.dirstate", package);
	let m = PyModule::new(py, dotted_name)?;			let m = PyModule::new(py, dotted_name)?;

	m.add(py, "__package__", package)?;			m.add(py, "__package__", package)?;
	m.add(py, "__doc__", "Dirstate - Rust implementation")?;			m.add(py, "__doc__", "Dirstate - Rust implementation")?;

				m.add(
				py,
				"FallbackError",
				py.get_type::<exceptions::FallbackError>(),
				)?;
	m.add_class::<Dirs>(py)?;			m.add_class::<Dirs>(py)?;
	m.add_class::<DirstateMap>(py)?;			m.add_class::<DirstateMap>(py)?;
	m.add(			m.add(
	py,			py,
	"status",			"status",
	py_fn!(			py_fn!(
	py,			py,
	status_wrapper(			status_wrapper(
	dmap: DirstateMap,			dmap: DirstateMap,
	root_dir: PyObject,			root_dir: PyObject,
	matcher: PyObject,			matcher: PyObject,
	list_clean: bool,			ignorefiles: PyList,
				check_exec: bool,
	last_normal_time: i64,			last_normal_time: i64,
	check_exec: bool			list_clean: bool,
				list_ignored: bool,
				list_unknown: bool
	)			)
	),			),
	)?;			)?;

	let sys = PyModule::import(py, "sys")?;			let sys = PyModule::import(py, "sys")?;
	let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;			let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
	sys_modules.set_item(py, dotted_name, &m)?;			sys_modules.set_item(py, dotted_name, &m)?;

	Ok(m)			Ok(m)
	}			}

rust/hg-cpython/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.

	//! Bindings for the `hg::status` module provided by the			//! Bindings for the `hg::status` module provided by the
	//! `hg-core` crate. From Python, this will be seen as			//! `hg-core` crate. From Python, this will be seen as
	//! `rustext.dirstate.status`.			//! `rustext.dirstate.status`.

	use crate::dirstate::DirstateMap;			use crate::{dirstate::DirstateMap, exceptions::FallbackError};
	use cpython::exc::ValueError;
	use cpython::{			use cpython::{
	ObjectProtocol, PyBytes, PyErr, PyList, PyObject, PyResult, PyTuple,			exc::ValueError, ObjectProtocol, PyBytes, PyErr, PyList, PyObject,
	Python, PythonObject, ToPyObject,			PyResult, PyTuple, Python, PythonObject, ToPyObject,
	};			};
	use hg::utils::hg_path::HgPathBuf;
	use hg::{			use hg::{
	matchers::{AlwaysMatcher, FileMatcher},			matchers::{AlwaysMatcher, FileMatcher, IncludeMatcher},
	status,			parse_pattern_syntax, status,
	utils::{files::get_path_from_bytes, hg_path::HgPath},			utils::{
	DirstateStatus,			files::{get_bytes_from_path, get_path_from_bytes},
				hg_path::{HgPath, HgPathBuf},
				},
				BadMatch, BadType, DirstateStatus, IgnorePattern, PatternFileWarning,
				StatusError, StatusOptions,
	};			};
	use std::borrow::Borrow;			use std::borrow::{Borrow, Cow};

	/// This will be useless once trait impls for collection are added to `PyBytes`			/// This will be useless once trait impls for collection are added to `PyBytes`
	/// upstream.			/// upstream.
	fn collect_pybytes_list<P: AsRef<HgPath>>(			fn collect_pybytes_list(
	py: Python,			py: Python,
	collection: &[P],			collection: &[impl AsRef<HgPath>],
	) -> PyList {			) -> PyList {
	let list = PyList::new(py, &[]);			let list = PyList::new(py, &[]);

	for (i, path) in collection.iter().enumerate() {			for (i, path) in collection.iter().enumerate() {
	list.insert_item(			list.insert_item(
	py,			py,
	i,			i,
	PyBytes::new(py, path.as_ref().as_bytes()).into_object(),			PyBytes::new(py, path.as_ref().as_bytes()).into_object(),
	)			)
	}			}

	list			list
	}			}

				fn collect_bad_matches(
				py: Python,
				collection: &[(impl AsRef<HgPath>, BadMatch)],
				) -> PyResult<PyList> {
				let list = PyList::new(py, &[]);

				let os = py.import("os")?;
				let get_error_message = \|code: i32\| -> PyResult<_> {
				os.call(
				py,
				"strerror",
				PyTuple::new(py, &[code.to_py_object(py).into_object()]),
				None,
				)
				};

				for (i, (path, bad_match)) in collection.iter().enumerate() {
				let message = match bad_match {
				BadMatch::OsError(code) => get_error_message(*code)?,
				BadMatch::BadType(bad_type) => format!(
				"unsupported file type (type is {})",
				match bad_type {
				BadType::CharacterDevice => "character device",
				BadType::BlockDevice => "block device",
				BadType::FIFO => "fifo",
				BadType::Socket => "socket",
				BadType::Directory => "directory",
				BadType::Unknown => "unknown",
				}
				kevincoxUnsubmitted Done This should probably be a method on BadType. kevincox: This should probably be a method on BadType.
				)
				.to_py_object(py)
				.into_object(),
				};
				list.insert_item(
				py,
				i,
				(PyBytes::new(py, path.as_ref().as_bytes()), message)
				.to_py_object(py)
				.into_object(),
				)
				}

				Ok(list)
				}

				fn handle_fallback(py: Python, err: StatusError) -> PyErr {
				match err {
				StatusError::Pattern(e) => {
				PyErr::new::<FallbackError, _>(py, e.to_string())
				}
				e => PyErr::new::<ValueError, _>(py, e.to_string()),
				}
				}

	pub fn status_wrapper(			pub fn status_wrapper(
	py: Python,			py: Python,
	dmap: DirstateMap,			dmap: DirstateMap,
	matcher: PyObject,			matcher: PyObject,
	root_dir: PyObject,			root_dir: PyObject,
	list_clean: bool,			ignore_files: PyList,
	last_normal_time: i64,
	check_exec: bool,			check_exec: bool,
	) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> {			last_normal_time: i64,
				list_clean: bool,
				list_ignored: bool,
				list_unknown: bool,
				) -> PyResult<PyTuple> {
	let bytes = root_dir.extract::<PyBytes>(py)?;			let bytes = root_dir.extract::<PyBytes>(py)?;
	let root_dir = get_path_from_bytes(bytes.data(py));			let root_dir = get_path_from_bytes(bytes.data(py));

	let dmap: DirstateMap = dmap.to_py_object(py);			let dmap: DirstateMap = dmap.to_py_object(py);
	let dmap = dmap.get_inner(py);			let dmap = dmap.get_inner(py);

				let ignore_files: PyResult<Vec<_>> = ignore_files
				.iter(py)
				.map(\|b\| {
				let file = b.extract::<PyBytes>(py)?;
				Ok(get_path_from_bytes(file.data(py)).to_owned())
				})
				.collect();
				let ignore_files = ignore_files?;

	match matcher.get_type(py).name(py).borrow() {			match matcher.get_type(py).name(py).borrow() {
	"alwaysmatcher" => {			"alwaysmatcher" => {
	let matcher = AlwaysMatcher;			let matcher = AlwaysMatcher;
	let (lookup, status_res) = status(			let ((lookup, status_res), warnings) = status(
	&dmap,			&dmap,
	&matcher,			&matcher,
	&root_dir,			&root_dir,
	list_clean,			&ignore_files,
	last_normal_time,			StatusOptions {
	check_exec,			check_exec,
				last_normal_time,
				list_clean,
				list_ignored,
				list_unknown,
				},
	)			)
	.map_err(\|e\| PyErr::new::<ValueError, _>(py, e.to_string()))?;			.map_err(\|e\| handle_fallback(py, e))?;
	build_response(lookup, status_res, py)			build_response(py, lookup, status_res, warnings)
	}			}
	"exactmatcher" => {			"exactmatcher" => {
	let files = matcher.call_method(			let files = matcher.call_method(
	py,			py,
	"files",			"files",
	PyTuple::new(py, &[]),			PyTuple::new(py, &[]),
	None,			None,
	)?;			)?;
	let files: PyList = files.cast_into(py)?;			let files: PyList = files.cast_into(py)?;
	let files: PyResult<Vec<HgPathBuf>> = files			let files: PyResult<Vec<HgPathBuf>> = files
	.iter(py)			.iter(py)
	.map(\|f\| {			.map(\|f\| {
	Ok(HgPathBuf::from_bytes(			Ok(HgPathBuf::from_bytes(
	f.extract::<PyBytes>(py)?.data(py),			f.extract::<PyBytes>(py)?.data(py),
	))			))
	})			})
	.collect();			.collect();

	let files = files?;			let files = files?;
	let matcher = FileMatcher::new(&files)			let matcher = FileMatcher::new(&files)
	.map_err(\|e\| PyErr::new::<ValueError, _>(py, e.to_string()))?;			.map_err(\|e\| PyErr::new::<ValueError, _>(py, e.to_string()))?;
	let (lookup, status_res) = status(			let ((lookup, status_res), warnings) = status(
	&dmap,			&dmap,
	&matcher,			&matcher,
	&root_dir,			&root_dir,
	list_clean,			&ignore_files,
				StatusOptions {
				check_exec,
	last_normal_time,			last_normal_time,
				list_clean,
				list_ignored,
				list_unknown,
				},
				)
				.map_err(\|e\| handle_fallback(py, e))?;
				build_response(py, lookup, status_res, warnings)
				}
				"includematcher" => {
				// Get the patterns from Python even though most of them are
				// redundant with those we will parse later on, as they include
				// those passed from the command line.
				let ignore_patterns: PyResult<Vec<_>> = matcher
				.getattr(py, "_kindpats")?
				.iter(py)?
				.map(\|k\| {
				let k = k?;
				let syntax = parse_pattern_syntax(
				&[
				k.get_item(py, 0)?
				.extract::<PyBytes>(py)?
				.data(py),
				&b":"[..],
				]
				.concat(),
				)
				.map_err(\|e\| {
				handle_fallback(py, StatusError::Pattern(e))
				})?;
				let pattern = k.get_item(py, 1)?.extract::<PyBytes>(py)?;
				let pattern = pattern.data(py);
				let source = k.get_item(py, 2)?.extract::<PyBytes>(py)?;
				let source = get_path_from_bytes(source.data(py));
				let new = IgnorePattern::new(syntax, pattern, source);
				Ok(new)
				})
				.collect();

				let ignore_patterns = ignore_patterns?;
				let mut all_warnings = vec![];

				let (matcher, warnings) =
				IncludeMatcher::new(ignore_patterns, &root_dir)
				.map_err(\|e\| handle_fallback(py, e.into()))?;
				all_warnings.extend(warnings);

				let ((lookup, status_res), warnings) = status(
				&dmap,
				&matcher,
				&root_dir,
				&ignore_files,
				StatusOptions {
	check_exec,			check_exec,
				last_normal_time,
				list_clean,
				list_ignored,
				list_unknown,
				},
	)			)
	.map_err(\|e\| PyErr::new::<ValueError, _>(py, e.to_string()))?;			.map_err(\|e\| handle_fallback(py, e))?;
	build_response(lookup, status_res, py)
				all_warnings.extend(warnings);

				build_response(py, lookup, status_res, all_warnings)
	}			}
	e => {			e => {
	return Err(PyErr::new::<ValueError, _>(			return Err(PyErr::new::<ValueError, _>(
	py,			py,
	format!("Unsupported matcher {}", e),			format!("Unsupported matcher {}", e),
	));			));
	}			}
	}			}
	}			}

	fn build_response(			fn build_response(
	lookup: Vec<&HgPath>,
	status_res: DirstateStatus,
	py: Python,			py: Python,
	) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> {			lookup: Vec<Cow<HgPath>>,
				status_res: DirstateStatus,
				warnings: Vec<PatternFileWarning>,
				) -> PyResult<PyTuple> {
	let modified = collect_pybytes_list(py, status_res.modified.as_ref());			let modified = collect_pybytes_list(py, status_res.modified.as_ref());
	let added = collect_pybytes_list(py, status_res.added.as_ref());			let added = collect_pybytes_list(py, status_res.added.as_ref());
	let removed = collect_pybytes_list(py, status_res.removed.as_ref());			let removed = collect_pybytes_list(py, status_res.removed.as_ref());
	let deleted = collect_pybytes_list(py, status_res.deleted.as_ref());			let deleted = collect_pybytes_list(py, status_res.deleted.as_ref());
	let clean = collect_pybytes_list(py, status_res.clean.as_ref());			let clean = collect_pybytes_list(py, status_res.clean.as_ref());
				let ignored = collect_pybytes_list(py, status_res.ignored.as_ref());
				let unknown = collect_pybytes_list(py, status_res.unknown.as_ref());
	let lookup = collect_pybytes_list(py, lookup.as_ref());			let lookup = collect_pybytes_list(py, lookup.as_ref());
	let unknown = PyList::new(py, &[]);			let bad = collect_bad_matches(py, status_res.bad.as_ref())?;
				let py_warnings = PyList::new(py, &[]);
				for (i, warning) in warnings.iter().enumerate() {
				// We use duck-typing on the Python side for dispatch, good enough for
				// now.
				match warning {
				PatternFileWarning::InvalidSyntax(file, syn) => {
				py_warnings.insert_item(
				py,
				i,
				(
				PyBytes::new(py, &get_bytes_from_path(&file)),
				PyBytes::new(py, syn),
				)
				.to_py_object(py)
				.into_object(),
				);
				}
				PatternFileWarning::NoSuchFile(file) => py_warnings.insert_item(
				py,
				i,
				PyBytes::new(py, &get_bytes_from_path(&file)).into_object(),
				),
				}
				}

	Ok((lookup, modified, added, removed, deleted, unknown, clean))			Ok(PyTuple::new(
				py,
				&[
				lookup.into_object(),
				modified.into_object(),
				added.into_object(),
				removed.into_object(),
				deleted.into_object(),
				clean.into_object(),
				ignored.into_object(),
				unknown.into_object(),
				py_warnings.into_object(),
				bad.into_object(),
				][..],
				))
	}			}

rust/hg-cpython/src/exceptions.rs

	Ok(cls) => PyErr::from_instance(py, cls),			Ok(cls) => PyErr::from_instance(py, cls),
	}			}
	}			}
	}			}
	}			}
	}			}

	py_exception!(rustext, HgPathPyError, RuntimeError);			py_exception!(rustext, HgPathPyError, RuntimeError);
				py_exception!(rustext, FallbackError, RuntimeError);

	py_exception!(shared_ref, AlreadyBorrowed, RuntimeError);			py_exception!(shared_ref, AlreadyBorrowed, RuntimeError);

			Path	Packages
M			rust/hg-cpython/src/dirstate.rs (23 lines)
M			rust/hg-cpython/src/dirstate/status.rs (240 lines)
M			rust/hg-cpython/src/exceptions.rs (1 line)

This is an archive of the discontinued Mercurial Phabricator instance.

rust-status: update rust-cpython bridge to account for the changes in core
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents
Changeset List

Diff 19422

rust/hg-cpython/src/dirstate.rs

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

rust/hg-cpython/src/exceptions.rs

This is an archive of the discontinued Mercurial Phabricator instance.

rust-status: update rust-cpython bridge to account for the changes in coreClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 19422

rust/hg-cpython/src/dirstate.rs

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

rust/hg-cpython/src/exceptions.rs

rust-status: update rust-cpython bridge to account for the changes in core
ClosedPublic

Revision Contents
Changeset List