This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7930

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

Authored by Alphare on Jan 17 2020, 11:53 AM.

Details

Reviewers
kevincox
Group Reviewers
hg-reviewers
Commits
rHGf96b28aa4b79: rust-status: update rust-cpython bridge to account for the changes in core

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.Jan 17 2020, 11:53 AM
Alphare updated this revision to Diff 19948.Feb 6 2020, 10:16 AM
kevincox accepted this revision.Feb 10 2020, 10:58 AM
kevincox added inline comments.
rust/hg-cpython/src/dirstate/status.rs
75

This should probably be a method on BadType.

Alphare marked an inline comment as done.Feb 10 2020, 11:25 AM
Alphare updated this revision to Diff 20049.Feb 10 2020, 11:30 AM
Alphare updated this revision to Diff 20158.Feb 11 2020, 5:55 AM
Alphare updated this revision to Diff 20189.Feb 13 2020, 12:37 PM
Alphare updated this revision to Diff 20455.Mar 4 2020, 10:08 AM
Alphare updated this revision to Diff 20463.Mar 4 2020, 11:55 AM
Alphare updated this revision to Diff 20498.Mar 5 2020, 3:33 AM
Alphare added a commit: rHGf96b28aa4b79: rust-status: update rust-cpython bridge to account for the changes in core.Mar 11 2020, 12:24 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGf96b28aa4b79: rust-status: update rust-cpython bridge to account for the changes in core (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 20722

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

CharacterDevice, CharacterDevice,
BlockDevice, BlockDevice,
FIFO, FIFO,
Socket, Socket,
Directory, Directory,
Unknown, Unknown,
} }
impl ToString for BadType {
fn to_string(&self) -> String {
match self {
BadType::CharacterDevice => "character device",
BadType::BlockDevice => "block device",
BadType::FIFO => "fifo",
BadType::Socket => "socket",
BadType::Directory => "directory",
BadType::Unknown => "unknown",
}
.to_string()
}
}
/// Was explicitly matched but cannot be found/accessed /// Was explicitly matched but cannot be found/accessed
#[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.

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 non_normal_entries; mod non_normal_entries;
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, 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 path in collection.iter() {
list.insert( list.append(
py, py,
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 (path, bad_match) in collection.iter() {
let message = match bad_match {
BadMatch::OsError(code) => get_error_message(*code)?,
BadMatch::BadType(bad_type) => format!(
"unsupported file type (type is {})",
bad_type.to_string()
)
.to_py_object(py)
.into_object(),
};
list.append(
py,
(PyBytes::new(py, path.as_ref().as_bytes()), message)
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(),
)
}
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 warning in warnings.iter() {
// We use duck-typing on the Python side for dispatch, good enough for
// now.
match warning {
PatternFileWarning::InvalidSyntax(file, syn) => {
py_warnings.append(
py,
(
PyBytes::new(py, &get_bytes_from_path(&file)),
PyBytes::new(py, syn),
)
.to_py_object(py)
.into_object(),
);
}
PatternFileWarning::NoSuchFile(file) => py_warnings.append(
py,
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);