This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7530

rust-dirstate-status: update bridge for new rust version of `dirstate.status`
ClosedPublic

Authored by Alphare on Nov 29 2019, 1:22 PM.

Details

Reviewers
kevincox
Group Reviewers
hg-reviewers
Commits
rHG6a88ced33c40: rust-dirstate-status: update bridge for new rust version of `dirstate.status`

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

Alphare created this revision.Nov 29 2019, 1:22 PM
Alphare updated this revision to Diff 18567.Dec 10 2019, 10:26 AM
kevincox accepted this revision.Dec 11 2019, 4:09 AM
Alphare updated this revision to Diff 18636.Dec 12 2019, 10:40 AM
Alphare added a commit: rHG6a88ced33c40: rust-dirstate-status: update bridge for new rust version of `dirstate.status`.Dec 17 2019, 9:49 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG6a88ced33c40: rust-dirstate-status: update bridge for new rust version of `dirstate.status` (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 18813

rust/hg-core/src/lib.rs

// Copyright 2018 Georges Racinet <gracinet@anybox.fr> // Copyright 2018 Georges Racinet <gracinet@anybox.fr>
// //
// 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, status::{status, StatusResult},
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 utils; pub mod utils;
use crate::utils::hg_path::HgPathBuf; use crate::utils::hg_path::HgPathBuf;

rust/hg-cpython/src/dirstate.rs

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,
list_clean: bool, list_clean: bool,
last_normal_time: i64, last_normal_time: i64,
check_exec: bool check_exec: 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;
use cpython::exc::ValueError; use cpython::exc::ValueError;
use cpython::{ use cpython::{
PyBytes, PyErr, PyList, PyObject, PyResult, Python, PythonObject, ObjectProtocol, PyBytes, PyErr, PyList, PyObject, PyResult, PyTuple,
ToPyObject, Python, PythonObject, ToPyObject,
}; };
use hg::utils::files::get_path_from_bytes; use hg::utils::hg_path::HgPathBuf;
use hg::{
use hg::matchers::AlwaysMatcher; matchers::{AlwaysMatcher, FileMatcher},
use hg::status; status,
use hg::utils::hg_path::HgPath; utils::{files::get_path_from_bytes, hg_path::HgPath},
StatusResult,
};
use std::borrow::Borrow;
/// 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<P: AsRef<HgPath>>(
py: Python, py: Python,
collection: &[P], collection: &[P],
) -> 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
} }
pub fn status_wrapper( pub fn status_wrapper(
py: Python, py: Python,
dmap: DirstateMap, dmap: DirstateMap,
matcher: PyObject,
root_dir: PyObject, root_dir: PyObject,
list_clean: bool, list_clean: bool,
last_normal_time: i64, last_normal_time: i64,
check_exec: bool, check_exec: bool,
) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> { ) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> {
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);
// TODO removed in the next patch to get the code to compile. This patch match matcher.get_type(py).name(py).borrow() {
// is part of a series and does not make real sense on its own. "alwaysmatcher" => {
let matcher = AlwaysMatcher; let matcher = AlwaysMatcher;
let (lookup, status_res) = status(
&dmap,
&matcher,
&root_dir,
list_clean,
last_normal_time,
check_exec,
)
.map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?;
build_response(lookup, status_res, py)
}
"exactmatcher" => {
let files = matcher.call_method(
py,
"files",
PyTuple::new(py, &[]),
None,
)?;
let files: PyList = files.cast_into(py)?;
let files: PyResult<Vec<HgPathBuf>> = files
.iter(py)
.map(|f| {
Ok(HgPathBuf::from_bytes(
f.extract::<PyBytes>(py)?.data(py),
))
})
.collect();
let files = files?;
let matcher = FileMatcher::new(&files)
.map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?;
let (lookup, status_res) = status( let (lookup, status_res) = status(
&dmap, &dmap,
&matcher, &matcher,
&root_dir, &root_dir,
list_clean, list_clean,
last_normal_time, last_normal_time,
check_exec, check_exec,
) )
.map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?; .map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?;
build_response(lookup, status_res, py)
}
e => {
return Err(PyErr::new::<ValueError, _>(
py,
format!("Unsupported matcher {}", e),
));
}
}
}
fn build_response(
lookup: Vec<&HgPath>,
status_res: StatusResult,
py: Python,
) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> {
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 lookup = collect_pybytes_list(py, lookup.as_ref()); let lookup = collect_pybytes_list(py, lookup.as_ref());
let unknown = PyList::new(py, &[]); let unknown = PyList::new(py, &[]);
Ok((lookup, modified, added, removed, deleted, unknown, clean)) Ok((lookup, modified, added, removed, deleted, unknown, clean))
} }