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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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
76

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 20049

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 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 (i, path) in collection.iter().enumerate() {
list.insert( list.insert(
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 {})",
bad_type.to_string()
)
.to_py_object(py)
.into_object(),
};
list.insert_item(
py,
i,
kevincoxUnsubmitted
Done

This should probably be a method on BadType.

kevincox: This should probably be a method on BadType.
(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);