This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8156

rust-nodemap: add utils for propagating errors
ClosedPublic

Authored by Alphare on Feb 26 2020, 12:36 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG26dd35ac59b8: rust-nodemap: add utils for propagating errors
Summary

This also updates the copyright notice

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.Feb 26 2020, 12:36 PM
Alphare updated this revision to Diff 20655.Mar 10 2020, 6:51 AM
gracinet added a commit: rHG26dd35ac59b8: rust-nodemap: add utils for propagating errors.Mar 11 2020, 11:42 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG26dd35ac59b8: rust-nodemap: add utils for propagating errors (authored by gracinet). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/hg-cpython/src/revlog.rs (45 lines)

Diff 20694

rust/hg-cpython/src/revlog.rs

// revlog.rs // revlog.rs
// //
// Copyright 2019 Georges Racinet <georges.racinet@octobus.net> // Copyright 2019-2020 Georges Racinet <georges.racinet@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.
use crate::cindex; use crate::cindex;
use cpython::{ use cpython::{
ObjectProtocol, PyClone, PyDict, PyModule, PyObject, PyResult, PyTuple, exc::ValueError, ObjectProtocol, PyClone, PyDict, PyErr, PyModule,
Python, PythonObject, ToPyObject, PyObject, PyResult, PyTuple, Python, PythonObject, ToPyObject,
}; };
use hg::Revision; use hg::{nodemap::NodeMapError, NodeError, Revision};
use std::cell::RefCell; use std::cell::RefCell;
/// Return a Struct implementing the Graph trait /// Return a Struct implementing the Graph trait
pub(crate) fn pyindex_to_graph( pub(crate) fn pyindex_to_graph(
py: Python, py: Python,
index: PyObject, index: PyObject,
) -> PyResult<cindex::Index> { ) -> PyResult<cindex::Index> {
match index.extract::<MixedIndex>(py) { match index.extract::<MixedIndex>(py) {
.call_method(py, name, args, kwargs) .call_method(py, name, args, kwargs)
} }
pub fn clone_cindex(&self, py: Python) -> cindex::Index { pub fn clone_cindex(&self, py: Python) -> cindex::Index {
self.cindex(py).borrow().clone_ref(py) self.cindex(py).borrow().clone_ref(py)
} }
} }
fn revlog_error(py: Python) -> PyErr {
match py
.import("mercurial.error")
.and_then(|m| m.get(py, "RevlogError"))
{
Err(e) => e,
Ok(cls) => PyErr::from_instance(py, cls),
}
}
fn rev_not_in_index(py: Python, rev: Revision) -> PyErr {
PyErr::new::<ValueError, _>(
py,
format!(
"Inconsistency: Revision {} found in nodemap \
is not in revlog index",
rev
),
)
}
/// Standard treatment of NodeMapError
fn nodemap_error(py: Python, err: NodeMapError) -> PyErr {
match err {
NodeMapError::MultipleResults => revlog_error(py),
NodeMapError::RevisionNotInIndex(r) => rev_not_in_index(py, r),
NodeMapError::InvalidNodePrefix(s) => invalid_node_prefix(py, &s),
}
}
fn invalid_node_prefix(py: Python, ne: &NodeError) -> PyErr {
PyErr::new::<ValueError, _>(
py,
format!("Invalid node or prefix: {:?}", ne),
)
}
/// 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!("{}.revlog", package); let dotted_name = &format!("{}.revlog", 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__", "RevLog - Rust implementations")?; m.add(py, "__doc__", "RevLog - Rust implementations")?;
m.add_class::<MixedIndex>(py)?; m.add_class::<MixedIndex>(py)?;
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)
} }