|
|
use cpython::ObjectProtocol;
|
|
|
use cpython::PyBool;
|
|
|
use cpython::PyBytes;
|
|
|
use cpython::PyDict;
|
|
|
use cpython::PyList;
|
|
|
use cpython::PyModule;
|
|
|
use cpython::PyObject;
|
|
|
use cpython::PyResult;
|
|
|
use cpython::PyTuple;
|
|
|
use cpython::Python;
|
|
|
|
|
|
use hg::copy_tracing::combine_changeset_copies;
|
|
|
use hg::copy_tracing::ChangedFiles;
|
|
|
use hg::copy_tracing::RevInfo;
|
|
|
use hg::utils::hg_path::HgPathBuf;
|
|
|
use hg::Revision;
|
|
|
|
|
|
/// Combines copies information contained into revision `revs` to build a copy
|
|
|
/// map.
|
|
|
///
|
|
|
/// See mercurial/copies.py for details
|
|
|
pub fn combine_changeset_copies_wrapper(
|
|
|
py: Python,
|
|
|
revs: PyList,
|
|
|
children: PyDict,
|
|
|
target_rev: Revision,
|
|
|
rev_info: PyObject,
|
|
|
is_ancestor: PyObject,
|
|
|
) -> PyResult<PyDict> {
|
|
|
let revs: PyResult<_> =
|
|
|
revs.iter(py).map(|r| Ok(r.extract(py)?)).collect();
|
|
|
|
|
|
// Wrap the `is_ancestor` python callback as a Rust closure
|
|
|
//
|
|
|
// No errors are expected from the Python side, and they will should only
|
|
|
// happens in case of programing error or severe data corruption. Such
|
|
|
// errors will raise panic and the rust-cpython harness will turn them into
|
|
|
// Python exception.
|
|
|
let is_ancestor_wrap = |anc: Revision, desc: Revision| -> bool {
|
|
|
is_ancestor
|
|
|
.call(py, (anc, desc), None)
|
|
|
.expect(
|
|
|
"rust-copy-tracing: python call to `is_ancestor` \
|
|
|
failed",
|
|
|
)
|
|
|
.cast_into::<PyBool>(py)
|
|
|
.expect(
|
|
|
"rust-copy-tracing: python call to `is_ancestor` \
|
|
|
returned unexpected non-Bool value",
|
|
|
)
|
|
|
.is_true()
|
|
|
};
|
|
|
|
|
|
// Wrap the `rev_info_maker` python callback as a Rust closure
|
|
|
//
|
|
|
// No errors are expected from the Python side, and they will should only
|
|
|
// happens in case of programing error or severe data corruption. Such
|
|
|
// errors will raise panic and the rust-cpython harness will turn them into
|
|
|
// Python exception.
|
|
|
let rev_info_maker = |rev: Revision| -> RevInfo {
|
|
|
let res: PyTuple = rev_info
|
|
|
.call(py, (rev,), None)
|
|
|
.expect("rust-copy-tracing: python call to `rev_info` failed")
|
|
|
.cast_into(py)
|
|
|
.expect(
|
|
|
"rust-copy_tracing: python call to `rev_info` returned \
|
|
|
unexpected non-Tuple value",
|
|
|
);
|
|
|
let p1 = res.get_item(py, 0).extract(py).expect(
|
|
|
"rust-copy-tracing: \
|
|
|
rev_info return is invalid, first item is a not a revision",
|
|
|
);
|
|
|
let p2 = res.get_item(py, 1).extract(py).expect(
|
|
|
"rust-copy-tracing: \
|
|
|
rev_info return is invalid, second item is a not a revision",
|
|
|
);
|
|
|
|
|
|
let changes = res.get_item(py, 2);
|
|
|
|
|
|
let files;
|
|
|
if !changes
|
|
|
.hasattr(py, "copied_from_p1")
|
|
|
.expect("rust-copy-tracing: python call to `hasattr` failed")
|
|
|
{
|
|
|
files = ChangedFiles::new_empty();
|
|
|
} else {
|
|
|
let p1_copies: PyDict = changes
|
|
|
.getattr(py, "copied_from_p1")
|
|
|
.expect(
|
|
|
"rust-copy-tracing: retrieval of python attribute \
|
|
|
`copied_from_p1` failed",
|
|
|
)
|
|
|
.cast_into(py)
|
|
|
.expect(
|
|
|
"rust-copy-tracing: failed to convert `copied_from_p1` \
|
|
|
to PyDict",
|
|
|
);
|
|
|
let p1_copies: PyResult<_> = p1_copies
|
|
|
.items(py)
|
|
|
.iter()
|
|
|
.map(|(key, value)| {
|
|
|
let key = key.extract::<PyBytes>(py).expect(
|
|
|
"rust-copy-tracing: conversion of copy destination to\
|
|
|
PyBytes failed",
|
|
|
);
|
|
|
let key = key.data(py);
|
|
|
let value = value.extract::<PyBytes>(py).expect(
|
|
|
"rust-copy-tracing: conversion of copy source to \
|
|
|
PyBytes failed",
|
|
|
);
|
|
|
let value = value.data(py);
|
|
|
Ok((
|
|
|
HgPathBuf::from_bytes(key),
|
|
|
HgPathBuf::from_bytes(value),
|
|
|
))
|
|
|
})
|
|
|
.collect();
|
|
|
|
|
|
let p2_copies: PyDict = changes
|
|
|
.getattr(py, "copied_from_p2")
|
|
|
.expect(
|
|
|
"rust-copy-tracing: retrieval of python attribute \
|
|
|
`copied_from_p2` failed",
|
|
|
)
|
|
|
.cast_into(py)
|
|
|
.expect(
|
|
|
"rust-copy-tracing: failed to convert `copied_from_p2` \
|
|
|
to PyDict",
|
|
|
);
|
|
|
let p2_copies: PyResult<_> = p2_copies
|
|
|
.items(py)
|
|
|
.iter()
|
|
|
.map(|(key, value)| {
|
|
|
let key = key.extract::<PyBytes>(py).expect(
|
|
|
"rust-copy-tracing: conversion of copy destination to \
|
|
|
PyBytes failed");
|
|
|
let key = key.data(py);
|
|
|
let value = value.extract::<PyBytes>(py).expect(
|
|
|
"rust-copy-tracing: conversion of copy source to \
|
|
|
PyBytes failed",
|
|
|
);
|
|
|
let value = value.data(py);
|
|
|
Ok((
|
|
|
HgPathBuf::from_bytes(key),
|
|
|
HgPathBuf::from_bytes(value),
|
|
|
))
|
|
|
})
|
|
|
.collect();
|
|
|
|
|
|
let removed: PyObject = changes.getattr(py, "removed").expect(
|
|
|
"rust-copy-tracing: retrieval of python attribute \
|
|
|
`removed` failed",
|
|
|
);
|
|
|
let removed: PyResult<_> = removed
|
|
|
.iter(py)
|
|
|
.expect(
|
|
|
"rust-copy-tracing: getting a python iterator over the \
|
|
|
`removed` set failed",
|
|
|
)
|
|
|
.map(|filename| {
|
|
|
let filename = filename
|
|
|
.expect(
|
|
|
"rust-copy-tracing: python iteration over the \
|
|
|
`removed` set failed",
|
|
|
)
|
|
|
.extract::<PyBytes>(py)
|
|
|
.expect(
|
|
|
"rust-copy-tracing: \
|
|
|
conversion of `removed` item to PyBytes failed",
|
|
|
);
|
|
|
let filename = filename.data(py);
|
|
|
Ok(HgPathBuf::from_bytes(filename))
|
|
|
})
|
|
|
.collect();
|
|
|
|
|
|
let merged: PyObject = changes.getattr(py, "merged").expect(
|
|
|
"rust-copy-tracing: retrieval of python attribute \
|
|
|
`merged` failed",
|
|
|
);
|
|
|
let merged: PyResult<_> = merged
|
|
|
.iter(py)
|
|
|
.expect(
|
|
|
"rust-copy-tracing: getting a python iterator over the \
|
|
|
`merged` set failed",
|
|
|
)
|
|
|
.map(|filename| {
|
|
|
let filename = filename
|
|
|
.expect(
|
|
|
"rust-copy-tracing: python iteration over the \
|
|
|
`merged` set failed",
|
|
|
)
|
|
|
.extract::<PyBytes>(py)
|
|
|
.expect(
|
|
|
"rust-copy-tracing: \
|
|
|
conversion of `merged` item to PyBytes failed",
|
|
|
);
|
|
|
let filename = filename.data(py);
|
|
|
Ok(HgPathBuf::from_bytes(filename))
|
|
|
})
|
|
|
.collect();
|
|
|
|
|
|
let salvaged: PyObject = changes.getattr(py, "salvaged").expect(
|
|
|
"rust-copy-tracing: retrieval of python attribute \
|
|
|
`salvaged` failed",
|
|
|
);
|
|
|
let salvaged: PyResult<_> = salvaged
|
|
|
.iter(py)
|
|
|
.expect(
|
|
|
"rust-copy-tracing: getting a python iterator over the \
|
|
|
`salvaged` set failed",
|
|
|
)
|
|
|
.map(|filename| {
|
|
|
let filename = filename
|
|
|
.expect(
|
|
|
"rust-copy-tracing: python iteration over the \
|
|
|
`salvaged` set failed",
|
|
|
)
|
|
|
.extract::<PyBytes>(py)
|
|
|
.expect(
|
|
|
"rust-copy-tracing: \
|
|
|
conversion of `salvaged` item to PyBytes failed",
|
|
|
);
|
|
|
let filename = filename.data(py);
|
|
|
Ok(HgPathBuf::from_bytes(filename))
|
|
|
})
|
|
|
.collect();
|
|
|
files = ChangedFiles::new(
|
|
|
removed.unwrap(),
|
|
|
merged.unwrap(),
|
|
|
salvaged.unwrap(),
|
|
|
p1_copies.unwrap(),
|
|
|
p2_copies.unwrap(),
|
|
|
);
|
|
|
}
|
|
|
|
|
|
(p1, p2, files)
|
|
|
};
|
|
|
let children: PyResult<_> = children
|
|
|
.items(py)
|
|
|
.iter()
|
|
|
.map(|(k, v)| {
|
|
|
let v: &PyList = v.cast_as(py)?;
|
|
|
let v: PyResult<_> =
|
|
|
v.iter(py).map(|child| Ok(child.extract(py)?)).collect();
|
|
|
Ok((k.extract(py)?, v?))
|
|
|
})
|
|
|
.collect();
|
|
|
|
|
|
let res = combine_changeset_copies(
|
|
|
revs?,
|
|
|
children?,
|
|
|
target_rev,
|
|
|
&rev_info_maker,
|
|
|
&is_ancestor_wrap,
|
|
|
);
|
|
|
let out = PyDict::new(py);
|
|
|
for (dest, source) in res.into_iter() {
|
|
|
out.set_item(
|
|
|
py,
|
|
|
PyBytes::new(py, &dest.into_vec()),
|
|
|
PyBytes::new(py, &source.into_vec()),
|
|
|
)?;
|
|
|
}
|
|
|
Ok(out)
|
|
|
}
|
|
|
|
|
|
/// Create the module, with `__package__` given from parent
|
|
|
pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
|
|
|
let dotted_name = &format!("{}.copy_tracing", package);
|
|
|
let m = PyModule::new(py, dotted_name)?;
|
|
|
|
|
|
m.add(py, "__package__", package)?;
|
|
|
m.add(py, "__doc__", "Copy tracing - Rust implementation")?;
|
|
|
|
|
|
m.add(
|
|
|
py,
|
|
|
"combine_changeset_copies",
|
|
|
py_fn!(
|
|
|
py,
|
|
|
combine_changeset_copies_wrapper(
|
|
|
revs: PyList,
|
|
|
children: PyDict,
|
|
|
target_rev: Revision,
|
|
|
rev_info: PyObject,
|
|
|
is_ancestor: PyObject
|
|
|
)
|
|
|
),
|
|
|
)?;
|
|
|
|
|
|
let sys = PyModule::import(py, "sys")?;
|
|
|
let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
|
|
|
sys_modules.set_item(py, dotted_name, &m)?;
|
|
|
|
|
|
Ok(m)
|
|
|
}
|
|
|
|
