This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11459

rust: Remove the `rustext.parsers` module
ClosedPublic

Authored by SimonSapin on Sep 20 2021, 6:16 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG1194394510ba: rust: Remove the `rustext.parsers` module
Summary

It only exported Rust implementations of the parse_dirstate and pack_dirtate
functions, which are only used (anymore) when Rust is not enabled.

fakedirstatewritetime.py was detecting the presence of rustext.parsers
but what it really wants to know is whether the Rust implementation of
dirstatemap is used. This changes it to detect rustext.dirstate instead.

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

SimonSapin created this revision.Sep 20 2021, 6:16 PM
Alphare accepted this revision.Sep 22 2021, 3:59 AM
Alphare added a subscriber: Alphare.

I'm glad that's gone!

This revision is now accepted and ready to land.Sep 22 2021, 3:59 AM
SimonSapin added a commit: rHG1194394510ba: rust: Remove the `rustext.parsers` module.Sep 22 2021, 4:54 AM
Closed by commit rHG1194394510ba: rust: Remove the `rustext.parsers` module (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30371

rust/hg-cpython/src/dirstate/dirstate_map.rs

use crate::{ use crate::{
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::make_dirstate_item, dirstate::make_dirstate_item,
dirstate::make_dirstate_item_raw, dirstate::make_dirstate_item_raw,
dirstate::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
parsers::dirstate_parents_to_pytuple,
pybytes_deref::PyBytesDeref, pybytes_deref::PyBytesDeref,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
dirstate::MTIME_UNSET, dirstate::MTIME_UNSET,
dirstate::SIZE_NON_NORMAL, dirstate::SIZE_NON_NORMAL,
dirstate_tree::dirstate_map::DirstateMap as TreeDirstateMap, dirstate_tree::dirstate_map::DirstateMap as TreeDirstateMap,
dirstate_tree::dispatch::DirstateMapMethods, dirstate_tree::dispatch::DirstateMapMethods,
(Box::new(map) as _, parents) (Box::new(map) as _, parents)
} else { } else {
let bytes = on_disk.data(py); let bytes = on_disk.data(py);
let mut map = RustDirstateMap::default(); let mut map = RustDirstateMap::default();
let parents = map.read(bytes).map_err(|e| dirstate_error(py, e))?; let parents = map.read(bytes).map_err(|e| dirstate_error(py, e))?;
(Box::new(map) as _, parents) (Box::new(map) as _, parents)
}; };
let map = Self::create_instance(py, inner)?; let map = Self::create_instance(py, inner)?;
let parents = parents.map(|p| dirstate_parents_to_pytuple(py, &p)); let parents = parents.map(|p| {
let p1 = PyBytes::new(py, p.p1.as_bytes());
let p2 = PyBytes::new(py, p.p2.as_bytes());
(p1, p2)
});
Ok((map, parents).to_py_object(py).into_object()) Ok((map, parents).to_py_object(py).into_object())
} }
/// Returns a DirstateMap /// Returns a DirstateMap
@staticmethod @staticmethod
def new_v2( def new_v2(
on_disk: PyBytes, on_disk: PyBytes,
data_size: usize, data_size: usize,

rust/hg-cpython/src/lib.rs

#[macro_use] #[macro_use]
pub mod ref_sharing; pub mod ref_sharing;
pub mod copy_tracing; pub mod copy_tracing;
pub mod dagops; pub mod dagops;
pub mod debug; pub mod debug;
pub mod dirstate; pub mod dirstate;
pub mod discovery; pub mod discovery;
pub mod exceptions; pub mod exceptions;
pub mod parsers;
mod pybytes_deref; mod pybytes_deref;
pub mod revlog; pub mod revlog;
pub mod utils; pub mod utils;
py_module_initializer!(rustext, initrustext, PyInit_rustext, |py, m| { py_module_initializer!(rustext, initrustext, PyInit_rustext, |py, m| {
m.add( m.add(
py, py,
"__doc__", "__doc__",
"Mercurial core concepts - Rust implementation", "Mercurial core concepts - Rust implementation",
)?; )?;
let dotted_name: String = m.get(py, "__name__")?.extract(py)?; let dotted_name: String = m.get(py, "__name__")?.extract(py)?;
m.add(py, "ancestor", ancestors::init_module(py, &dotted_name)?)?; m.add(py, "ancestor", ancestors::init_module(py, &dotted_name)?)?;
m.add(py, "dagop", dagops::init_module(py, &dotted_name)?)?; m.add(py, "dagop", dagops::init_module(py, &dotted_name)?)?;
m.add(py, "debug", debug::init_module(py, &dotted_name)?)?; m.add(py, "debug", debug::init_module(py, &dotted_name)?)?;
m.add( m.add(
py, py,
"copy_tracing", "copy_tracing",
copy_tracing::init_module(py, &dotted_name)?, copy_tracing::init_module(py, &dotted_name)?,
)?; )?;
m.add(py, "discovery", discovery::init_module(py, &dotted_name)?)?; m.add(py, "discovery", discovery::init_module(py, &dotted_name)?)?;
m.add(py, "dirstate", dirstate::init_module(py, &dotted_name)?)?; m.add(py, "dirstate", dirstate::init_module(py, &dotted_name)?)?;
m.add(py, "revlog", revlog::init_module(py, &dotted_name)?)?; m.add(py, "revlog", revlog::init_module(py, &dotted_name)?)?;
m.add(
py,
"parsers",
parsers::init_parsers_module(py, &dotted_name)?,
)?;
m.add(py, "GraphError", py.get_type::<exceptions::GraphError>())?; m.add(py, "GraphError", py.get_type::<exceptions::GraphError>())?;
Ok(()) Ok(())
}); });
#[cfg(not(any(feature = "python27-bin", feature = "python3-bin")))] #[cfg(not(any(feature = "python27-bin", feature = "python3-bin")))]
#[test] #[test]
#[ignore] #[ignore]
fn libpython_must_be_linked_to_run_tests() { fn libpython_must_be_linked_to_run_tests() {
// stub function to tell that some tests wouldn't run // stub function to tell that some tests wouldn't run
} }

rust/hg-cpython/src/parsers.rs

  • This file was deleted.
// parsers.rs
//
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.
//! Bindings for the `hg::dirstate::parsers` module provided by the
//! `hg-core` package.
//!
//! From Python, this will be seen as `mercurial.rustext.parsers`
use cpython::{
exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyResult, PyTuple, Python,
PythonObject, ToPyObject,
};
use hg::{
dirstate::parsers::Timestamp, pack_dirstate, parse_dirstate,
utils::hg_path::HgPathBuf, DirstateEntry, DirstateParents, FastHashMap,
PARENT_SIZE,
};
use std::convert::TryInto;
use crate::dirstate::{extract_dirstate, make_dirstate_item};
fn parse_dirstate_wrapper(
py: Python,
dmap: PyDict,
copymap: PyDict,
st: PyBytes,
) -> PyResult<PyTuple> {
match parse_dirstate(st.data(py)) {
Ok((parents, entries, copies)) => {
let dirstate_map: FastHashMap<HgPathBuf, DirstateEntry> = entries
.into_iter()
.map(|(path, entry)| (path.to_owned(), entry))
.collect();
let copy_map: FastHashMap<HgPathBuf, HgPathBuf> = copies
.into_iter()
.map(|(path, copy)| (path.to_owned(), copy.to_owned()))
.collect();
for (filename, entry) in &dirstate_map {
dmap.set_item(
py,
PyBytes::new(py, filename.as_bytes()),
make_dirstate_item(py, entry)?,
)?;
}
for (path, copy_path) in copy_map {
copymap.set_item(
py,
PyBytes::new(py, path.as_bytes()),
PyBytes::new(py, copy_path.as_bytes()),
)?;
}
Ok(dirstate_parents_to_pytuple(py, parents))
}
Err(e) => Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())),
}
}
fn pack_dirstate_wrapper(
py: Python,
dmap: PyDict,
copymap: PyDict,
pl: PyTuple,
now: PyInt,
) -> PyResult<PyBytes> {
let p1 = pl.get_item(py, 0).extract::<PyBytes>(py)?;
let p1: &[u8] = p1.data(py);
let p2 = pl.get_item(py, 1).extract::<PyBytes>(py)?;
let p2: &[u8] = p2.data(py);
let mut dirstate_map = extract_dirstate(py, &dmap)?;
let copies: Result<FastHashMap<HgPathBuf, HgPathBuf>, PyErr> = copymap
.items(py)
.iter()
.map(|(key, value)| {
Ok((
HgPathBuf::from_bytes(key.extract::<PyBytes>(py)?.data(py)),
HgPathBuf::from_bytes(value.extract::<PyBytes>(py)?.data(py)),
))
})
.collect();
if p1.len() != PARENT_SIZE || p2.len() != PARENT_SIZE {
return Err(PyErr::new::<exc::ValueError, _>(
py,
"expected a 20-byte hash".to_string(),
));
}
match pack_dirstate(
&mut dirstate_map,
&copies?,
DirstateParents {
p1: p1.try_into().unwrap(),
p2: p2.try_into().unwrap(),
},
Timestamp(now.as_object().extract::<i64>(py)?),
) {
Ok(packed) => {
for (filename, entry) in dirstate_map.iter() {
dmap.set_item(
py,
PyBytes::new(py, filename.as_bytes()),
make_dirstate_item(py, &entry)?,
)?;
}
Ok(PyBytes::new(py, &packed))
}
Err(error) => {
Err(PyErr::new::<exc::ValueError, _>(py, error.to_string()))
}
}
}
/// Create the module, with `__package__` given from parent
pub fn init_parsers_module(py: Python, package: &str) -> PyResult<PyModule> {
let dotted_name = &format!("{}.parsers", package);
let m = PyModule::new(py, dotted_name)?;
m.add(py, "__package__", package)?;
m.add(py, "__doc__", "Parsers - Rust implementation")?;
m.add(
py,
"parse_dirstate",
py_fn!(
py,
parse_dirstate_wrapper(dmap: PyDict, copymap: PyDict, st: PyBytes)
),
)?;
m.add(
py,
"pack_dirstate",
py_fn!(
py,
pack_dirstate_wrapper(
dmap: PyDict,
copymap: PyDict,
pl: PyTuple,
now: PyInt
)
),
)?;
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)
}
pub(crate) fn dirstate_parents_to_pytuple(
py: Python,
parents: &DirstateParents,
) -> PyTuple {
let p1 = PyBytes::new(py, parents.p1.as_bytes());
let p2 = PyBytes::new(py, parents.p2.as_bytes());
(p1, p2).to_py_object(py)
}

tests/fakedirstatewritetime.py

configitem( configitem(
b'fakedirstatewritetime', b'fakedirstatewritetime',
b'fakenow', b'fakenow',
default=None, default=None,
) )
parsers = policy.importmod('parsers') parsers = policy.importmod('parsers')
rustmod = policy.importrust('parsers') has_rust_dirstate = policy.importrust('dirstate') is not None
def pack_dirstate(fakenow, orig, dmap, copymap, pl, now): def pack_dirstate(fakenow, orig, dmap, copymap, pl, now):
# execute what original parsers.pack_dirstate should do actually # execute what original parsers.pack_dirstate should do actually
# for consistency # for consistency
actualnow = int(now) actualnow = int(now)
for f, e in dmap.items(): for f, e in dmap.items():
if e.need_delay(actualnow): if e.need_delay(actualnow):
# because replacing 'parsers.pack_dirstate' is also effective # because replacing 'parsers.pack_dirstate' is also effective
# in subrepos. # in subrepos.
return func() return func()
# parsing 'fakenow' in YYYYmmddHHMM format makes comparison between # parsing 'fakenow' in YYYYmmddHHMM format makes comparison between
# 'fakenow' value and 'touch -t YYYYmmddHHMM' argument easy # 'fakenow' value and 'touch -t YYYYmmddHHMM' argument easy
fakenow = dateutil.parsedate(fakenow, [b'%Y%m%d%H%M'])[0] fakenow = dateutil.parsedate(fakenow, [b'%Y%m%d%H%M'])[0]
if rustmod is not None: if has_rust_dirstate:
# The Rust implementation does not use public parse/pack dirstate # The Rust implementation does not use public parse/pack dirstate
# to prevent conversion round-trips # to prevent conversion round-trips
orig_dirstatemap_write = dirstatemapmod.dirstatemap.write orig_dirstatemap_write = dirstatemapmod.dirstatemap.write
wrapper = lambda self, tr, st, now: orig_dirstatemap_write( wrapper = lambda self, tr, st, now: orig_dirstatemap_write(
self, tr, st, fakenow self, tr, st, fakenow
) )
dirstatemapmod.dirstatemap.write = wrapper dirstatemapmod.dirstatemap.write = wrapper
orig_dirstate_getfsnow = dirstate._getfsnow orig_dirstate_getfsnow = dirstate._getfsnow
wrapper = lambda *args: pack_dirstate(fakenow, orig_pack_dirstate, *args) wrapper = lambda *args: pack_dirstate(fakenow, orig_pack_dirstate, *args)
orig_module = parsers orig_module = parsers
orig_pack_dirstate = parsers.pack_dirstate orig_pack_dirstate = parsers.pack_dirstate
orig_module.pack_dirstate = wrapper orig_module.pack_dirstate = wrapper
dirstate._getfsnow = lambda *args: fakenow dirstate._getfsnow = lambda *args: fakenow
try: try:
return func() return func()
finally: finally:
orig_module.pack_dirstate = orig_pack_dirstate orig_module.pack_dirstate = orig_pack_dirstate
dirstate._getfsnow = orig_dirstate_getfsnow dirstate._getfsnow = orig_dirstate_getfsnow
if rustmod is not None: if has_rust_dirstate:
dirstatemapmod.dirstatemap.write = orig_dirstatemap_write dirstatemapmod.dirstatemap.write = orig_dirstatemap_write
def _poststatusfixup(orig, workingctx, status, fixup): def _poststatusfixup(orig, workingctx, status, fixup):
ui = workingctx.repo().ui ui = workingctx.repo().ui
return fakewrite(ui, lambda: orig(workingctx, status, fixup)) return fakewrite(ui, lambda: orig(workingctx, status, fixup))
rust/hg-cpython/src/lib.rs