This is an archive of the discontinued Mercurial Phabricator instance.

rust/hg-cpython/src/dirstate/dirs_multiset.rs
35	let skip_state = skip.map(\|skip\| skip.extract::<PyBytes>(py)?.data(py)[0] as i8);
36	let dirs_map = if ...
69	.map(py.None())
rust/hg-cpython/src/dirstate/mod.rs
119 ↗	(On Diff #15839)	Should there be a check that this element exists?
178 ↗	(On Diff #15839)	I think I would find it more readable as `for (filename, dirstate) in ...`. If you want to unpack it I would do that in the first line of the loop body. However it might also be best just to use `dirstate.state`. I guess the downside there is you don't get a compile error if a new field is added.

Most of those will be taken care of in a follow-up patch, since they're cosmetic, plus this change just moves code around.

Alphare updated this revision to Diff 16044.Jul 24 2019, 11:22 AM

Alphare added a commit: rHG85cb54e76d48: rust-dirstate: create dirstate submodule in hg-cpython.Aug 14 2019, 4:38 PM

This revision was not accepted when it landed; it landed in state Needs Review.

Closed by commit rHG85cb54e76d48: rust-dirstate: create dirstate submodule in hg-cpython (authored by Alphare). · Explain Why

This revision was automatically updated to reflect the committed changes.

Alphare added a commit: rHGb3518b0baa47: rust-dirstate: create dirstate submodule in hg-cpython.Aug 17 2019, 2:50 AM

Revision Contents
Changeset List

			Path	Packages
M			rust/hg-cpython/src/dirstate.rs (104 lines)
A	M		rust/hg-cpython/src/dirstate/dirs_multiset.rs (110 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	15839		Jul 10 2019, 7:46 AM	★	★
Diff 2	16044		Jul 24 2019, 11:22 AM	★	★
Diff 3	16195	rHG85cb54e76d48a91e647dbc18ee261d12881892c6	Jul 8 2019, 12:01 PM	★	★

Commit	Parents	Author	Summary	Date
		Raphaël Gomès		Jul 8 2019, 12:01 PM

Status	Author	Revision
Closed	Alphare	D6634 rust-dirstate: call rust dirstatemap from Python
Closed	Alphare	D6633 rust-dirstate: rust-cpython bridge for dirstatemap
Closed	Alphare	D6632 rust-dirstate: rust implementation of dirstatemap
Closed	Alphare	D6631 rust-cpython: add macro for sharing references
Closed	Alphare	D6630 rust-docstrings: add missing module docstrings
Closed	Alphare	D6690 rust-dirstate: improve API of `DirsMultiset`
Closed	Alphare	D6629 rust-dirstate: use EntryState enum instead of literals
Closed	Alphare	D6628 rust-parsers: switch to parse/pack_dirstate to mutate-on-loop
Closed	Alphare	D6627 rust-parsers: move parser bindings to their own file and Python module
Closed	Alphare	D6626 rust-dirstate: create dirstate submodule in hg-cpython
Abandoned	Alphare	D6625 rust-cargo: reorder dependencies

Diff 16044

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 dirs_multiset;
				use crate::dirstate::dirs_multiset::Dirs;
	use cpython::{			use cpython::{
	exc, ObjectProtocol, PyBytes, PyDict, PyErr, PyInt, PyModule, PyObject,			exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyObject, PyResult,
	PyResult, PySequence, PyTuple, Python, PythonObject, ToPyObject,			PySequence, PyTuple, Python, PythonObject, ToPyObject,
	};			};
	use hg::{			use hg::{
	pack_dirstate, parse_dirstate, CopyVecEntry, DirsIterable, DirsMultiset,			pack_dirstate, parse_dirstate, CopyVecEntry, DirstateEntry,
	DirstateEntry, DirstateMapError, DirstatePackError, DirstateParents,			DirstatePackError, DirstateParents, DirstateParseError, DirstateVec,
	DirstateParseError, DirstateVec,
	};			};
	use libc::{c_char, c_int};			use libc::{c_char, c_int};
	#[cfg(feature = "python27")]			#[cfg(feature = "python27")]
	use python27_sys::PyCapsule_Import;			use python27_sys::PyCapsule_Import;
	#[cfg(feature = "python3")]			#[cfg(feature = "python3")]
	use python3_sys::PyCapsule_Import;			use python3_sys::PyCapsule_Import;
	use std::cell::RefCell;
	use std::collections::HashMap;			use std::collections::HashMap;
	use std::ffi::CStr;			use std::ffi::CStr;
	use std::mem::transmute;			use std::mem::transmute;

	/// C code uses a custom `dirstate_tuple` type, checks in multiple instances			/// C code uses a custom `dirstate_tuple` type, checks in multiple instances
	/// for this type, and raises a Python `Exception` if the check does not pass.			/// for this type, and raises a Python `Exception` if the check does not pass.
	/// Because this type differs only in name from the regular Python tuple, it			/// Because this type differs only in name from the regular Python tuple, it
	/// would be a good idea in the near future to remove it entirely to allow			/// would be a good idea in the near future to remove it entirely to allow
	DirstatePackError::BadSize(expected, actual) => {			DirstatePackError::BadSize(expected, actual) => {
	format!("bad dirstate size: {} != {}", actual, expected)			format!("bad dirstate size: {} != {}", actual, expected)
	}			}
	},			},
	)),			)),
	}			}
	}			}

	py_class!(pub class Dirs \|py\| {
	data dirs_map: RefCell<DirsMultiset>;

	// `map` is either a `dict` or a flat iterator (usually a `set`, sometimes
	// a `list`)
	def __new__(
	_cls,
	map: PyObject,
	skip: Option<PyObject> = None
	) -> PyResult<Self> {
	let mut skip_state: Option<i8> = None;
	if let Some(skip) = skip {
	skip_state = Some(skip.extract::<PyBytes>(py)?.data(py)[0] as i8);
	}
	let dirs_map;

	if let Ok(map) = map.cast_as::<PyDict>(py) {
	let dirstate_vec = extract_dirstate_vec(py, &map)?;
	dirs_map = DirsMultiset::new(
	DirsIterable::Dirstate(dirstate_vec),
	skip_state,
	)
	} else {
	let map: Result<Vec<Vec<u8>>, PyErr> = map
	.iter(py)?
	.map(\|o\| Ok(o?.extract::<PyBytes>(py)?.data(py).to_owned()))
	.collect();
	dirs_map = DirsMultiset::new(
	DirsIterable::Manifest(map?),
	skip_state,
	)
	}

	Self::create_instance(py, RefCell::new(dirs_map))
	}

	def addpath(&self, path: PyObject) -> PyResult<PyObject> {
	self.dirs_map(py).borrow_mut().add_path(
	path.extract::<PyBytes>(py)?.data(py),
	);
	Ok(py.None())
	}

	def delpath(&self, path: PyObject) -> PyResult<PyObject> {
	self.dirs_map(py).borrow_mut().delete_path(
	path.extract::<PyBytes>(py)?.data(py),
	)
	.and(Ok(py.None()))
	.or_else(\|e\| {
	match e {
	DirstateMapError::PathNotFound(_p) => {
	Err(PyErr::new::<exc::ValueError, _>(
	py,
	"expected a value, found none".to_string(),
	))
	}
	DirstateMapError::EmptyPath => {
	Ok(py.None())
	}
	}
	})
	}

	// This is really inefficient on top of being ugly, but it's an easy way
	// of having it work to continue working on the rest of the module
	// hopefully bypassing Python entirely pretty soon.
	def __iter__(&self) -> PyResult<PyObject> {
	let dict = PyDict::new(py);

	for (key, value) in self.dirs_map(py).borrow().iter() {
	dict.set_item(
	py,
	PyBytes::new(py, &key[..]),
	value.to_py_object(py),
	)?;
	}

	let locals = PyDict::new(py);
	locals.set_item(py, "obj", dict)?;

	py.eval("iter(obj)", None, Some(&locals))
	}

	def __contains__(&self, item: PyObject) -> PyResult<bool> {
	Ok(self
	.dirs_map(py)
	.borrow()
	.contains_key(item.extract::<PyBytes>(py)?.data(py).as_ref()))
	}
	});

	/// 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(			m.add(

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

This file was added.

				// dirs_multiset.rs
				//
				// Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
				//
				// This software may be used and distributed according to the terms of the
				// GNU General Public License version 2 or any later version.

				//! Bindings for the `hg::dirstate::dirs_multiset` file provided by the
				//! `hg-core` package.

				use std::cell::RefCell;

				use cpython::{
				exc, ObjectProtocol, PyBytes, PyDict, PyErr, PyObject, PyResult,
				ToPyObject,
				};

				use crate::dirstate::extract_dirstate_vec;
				use hg::{DirsIterable, DirsMultiset, DirstateMapError};

				py_class!(pub class Dirs \|py\| {
				data dirs_map: RefCell<DirsMultiset>;

				// `map` is either a `dict` or a flat iterator (usually a `set`, sometimes
				// a `list`)
				def __new__(
				_cls,
				map: PyObject,
				skip: Option<PyObject> = None
				) -> PyResult<Self> {
				let mut skip_state: Option<i8> = None;
				if let Some(skip) = skip {
				skip_state = Some(skip.extract::<PyBytes>(py)?.data(py)[0] as i8);
				}
				let dirs_map;
				kevincoxUnsubmitted Not Done let skip_state = skip.map(\|skip\| skip.extract::<PyBytes>(py)?.data(py)[0] as i8); kevincox: ``` let skip_state = skip.map(\|skip\| skip.extract::<PyBytes>(py)?.data(py)[0] as i8); ```

				kevincoxUnsubmitted Not Done let dirs_map = if ... kevincox: ``` let dirs_map = if ... ```
				if let Ok(map) = map.cast_as::<PyDict>(py) {
				let dirstate_vec = extract_dirstate_vec(py, &map)?;
				dirs_map = DirsMultiset::new(
				DirsIterable::Dirstate(dirstate_vec),
				skip_state,
				)
				} else {
				let map: Result<Vec<Vec<u8>>, PyErr> = map
				.iter(py)?
				.map(\|o\| Ok(o?.extract::<PyBytes>(py)?.data(py).to_owned()))
				.collect();
				dirs_map = DirsMultiset::new(
				DirsIterable::Manifest(map?),
				skip_state,
				)
				}

				Self::create_instance(py, RefCell::new(dirs_map))
				}

				def addpath(&self, path: PyObject) -> PyResult<PyObject> {
				self.dirs_map(py).borrow_mut().add_path(
				path.extract::<PyBytes>(py)?.data(py),
				);
				Ok(py.None())
				}

				def delpath(&self, path: PyObject) -> PyResult<PyObject> {
				self.dirs_map(py).borrow_mut().delete_path(
				path.extract::<PyBytes>(py)?.data(py),
				)
				.and(Ok(py.None()))
				.or_else(\|e\| {
				kevincoxUnsubmitted Not Done .map(py.None()) kevincox: ``` .map(py.None()) ```
				match e {
				DirstateMapError::PathNotFound(_p) => {
				Err(PyErr::new::<exc::ValueError, _>(
				py,
				"expected a value, found none".to_string(),
				))
				}
				DirstateMapError::EmptyPath => {
				Ok(py.None())
				}
				}
				})
				}

				// This is really inefficient on top of being ugly, but it's an easy way
				// of having it work to continue working on the rest of the module
				// hopefully bypassing Python entirely pretty soon.
				def __iter__(&self) -> PyResult<PyObject> {
				let dict = PyDict::new(py);

				for (key, value) in self.dirs_map(py).borrow().iter() {
				dict.set_item(
				py,
				PyBytes::new(py, &key[..]),
				value.to_py_object(py),
				)?;
				}

				let locals = PyDict::new(py);
				locals.set_item(py, "obj", dict)?;

				py.eval("iter(obj)", None, Some(&locals))
				}

				def __contains__(&self, item: PyObject) -> PyResult<bool> {
				Ok(self
				.dirs_map(py)
				.borrow()
				.contains_key(item.extract::<PyBytes>(py)?.data(py).as_ref()))
				}
				});

This is an archive of the discontinued Mercurial Phabricator instance.

rust-dirstate: create dirstate submodule in hg-cpythonClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 16044

rust/hg-cpython/src/dirstate.rs

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

rust-dirstate: create dirstate submodule in hg-cpython
ClosedPublic

Revision Contents
Changeset List