This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11383

pathutil: replace the `skip` argument of `dirs` with a boolean
ClosedPublic

Authored by marmoute on Sep 1 2021, 7:35 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGe02f9af7aed1: pathutil: replace the `skip` argument of `dirs` with a boolean
Summary

It is ever only used for r file. So we make it a boolean this will give use
more versatility later as we will stop storing the state explicitly.

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.

Revision Contents
Changeset List

Diff 30189

mercurial/cext/dirs.c

ret = 0; ret = 0;
bail: bail:
Py_XDECREF(key); Py_XDECREF(key);
return ret; return ret;
} }
static int dirs_fromdict(PyObject *dirs, PyObject *source, char skipchar) static int dirs_fromdict(PyObject *dirs, PyObject *source, bool only_tracked)
{ {
PyObject *key, *value; PyObject *key, *value;
Py_ssize_t pos = 0; Py_ssize_t pos = 0;
while (PyDict_Next(source, &pos, &key, &value)) { while (PyDict_Next(source, &pos, &key, &value)) {
if (!PyBytes_Check(key)) { if (!PyBytes_Check(key)) {
PyErr_SetString(PyExc_TypeError, "expected string key"); PyErr_SetString(PyExc_TypeError, "expected string key");
return -1; return -1;
} }
if (skipchar) { if (only_tracked) {
if (!dirstate_tuple_check(value)) { if (!dirstate_tuple_check(value)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"expected a dirstate tuple"); "expected a dirstate tuple");
return -1; return -1;
} }
if (((dirstateItemObject *)value)->state == skipchar) if (((dirstateItemObject *)value)->state == 'r')
continue; continue;
} }
if (_addpath(dirs, key) == -1) if (_addpath(dirs, key) == -1)
return -1; return -1;
} }
return 0; return 0;
Py_XDECREF(item); Py_XDECREF(item);
return ret; return ret;
} }
/* /*
* Calculate a refcounted set of directory names for the files in a * Calculate a refcounted set of directory names for the files in a
* dirstate. * dirstate.
*/ */
static int dirs_init(dirsObject *self, PyObject *args) static int dirs_init(dirsObject *self, PyObject *args, PyObject *kwargs)
{ {
PyObject *dirs = NULL, *source = NULL; PyObject *dirs = NULL, *source = NULL;
char skipchar = 0; int only_tracked = 0;
int ret = -1; int ret = -1;
static char *keywords_name[] = {"map", "only_tracked", NULL};
self->dict = NULL; self->dict = NULL;
if (!PyArg_ParseTuple(args, "|Oc:__init__", &source, &skipchar)) if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Oi:__init__",
keywords_name, &source, &only_tracked))
return -1; return -1;
dirs = PyDict_New(); dirs = PyDict_New();
if (dirs == NULL) if (dirs == NULL)
return -1; return -1;
if (source == NULL) if (source == NULL)
ret = 0; ret = 0;
else if (PyDict_Check(source)) else if (PyDict_Check(source))
ret = dirs_fromdict(dirs, source, skipchar); ret = dirs_fromdict(dirs, source, (bool)only_tracked);
else if (skipchar) else if (only_tracked)
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"skip character is only supported " "`only_tracked` is only supported "
"with a dict source"); "with a dict source");
else else
ret = dirs_fromiter(dirs, source); ret = dirs_fromiter(dirs, source);
if (ret == -1) if (ret == -1)
Py_XDECREF(dirs); Py_XDECREF(dirs);
else else
self->dict = dirs; self->dict = dirs;

mercurial/dirstatemap.py

""" """
Returns True if the dirstate contains a file (tracked or removed) Returns True if the dirstate contains a file (tracked or removed)
in this directory. in this directory.
""" """
return d in self._alldirs return d in self._alldirs
@propertycache @propertycache
def _dirs(self): def _dirs(self):
return pathutil.dirs(self._map, b'r') return pathutil.dirs(self._map, only_tracked=True)
@propertycache @propertycache
def _alldirs(self): def _alldirs(self):
return pathutil.dirs(self._map) return pathutil.dirs(self._map)
def _opendirstatefile(self): def _opendirstatefile(self):
fp, mode = txnutil.trypending(self._root, self._opener, self._filename) fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
if self._pendingmode is not None and self._pendingmode != mode: if self._pendingmode is not None and self._pendingmode != mode:

mercurial/pathutil.py

yield path[:pos] yield path[:pos]
pos = path.rfind(b'/', 0, pos) pos = path.rfind(b'/', 0, pos)
yield b'' yield b''
class dirs(object): class dirs(object):
'''a multiset of directory names from a set of file paths''' '''a multiset of directory names from a set of file paths'''
def __init__(self, map, skip=None): def __init__(self, map, only_tracked=False):
""" """
a dict map indicates a dirstate while a list indicates a manifest a dict map indicates a dirstate while a list indicates a manifest
""" """
self._dirs = {} self._dirs = {}
addpath = self.addpath addpath = self.addpath
if isinstance(map, dict) and skip is not None: if isinstance(map, dict) and only_tracked:
for f, s in pycompat.iteritems(map): for f, s in pycompat.iteritems(map):
if s.state != skip: if s.state != b'r':
addpath(f) addpath(f)
elif skip is not None: elif only_tracked:
raise error.ProgrammingError( msg = b"`only_tracked` is only supported with a dict source"
b"skip character is only supported with a dict source" raise error.ProgrammingError(msg)
)
else: else:
for f in map: for f in map:
addpath(f) addpath(f)
def addpath(self, path): def addpath(self, path):
# type: (bytes) -> None # type: (bytes) -> None
dirs = self._dirs dirs = self._dirs
for base in finddirs(path): for base in finddirs(path):

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

} }
impl DirsMultiset { impl DirsMultiset {
/// Initializes the multiset from a dirstate. /// Initializes the multiset from a dirstate.
/// ///
/// If `skip_state` is provided, skips dirstate entries with equal state. /// If `skip_state` is provided, skips dirstate entries with equal state.
pub fn from_dirstate<I, P>( pub fn from_dirstate<I, P>(
dirstate: I, dirstate: I,
skip_state: Option<EntryState>, only_tracked: bool,
) -> Result<Self, DirstateError> ) -> Result<Self, DirstateError>
where where
I: IntoIterator< I: IntoIterator<
Item = Result<(P, DirstateEntry), DirstateV2ParseError>, Item = Result<(P, DirstateEntry), DirstateV2ParseError>,
>, >,
P: AsRef<HgPath>, P: AsRef<HgPath>,
{ {
let mut multiset = DirsMultiset { let mut multiset = DirsMultiset {
inner: FastHashMap::default(), inner: FastHashMap::default(),
}; };
for item in dirstate { for item in dirstate {
let (filename, entry) = item?; let (filename, entry) = item?;
let filename = filename.as_ref(); let filename = filename.as_ref();
// This `if` is optimized out of the loop // This `if` is optimized out of the loop
if let Some(skip) = skip_state { if only_tracked {
if skip != entry.state { if entry.state != EntryState::Removed {
multiset.add_path(filename)?; multiset.add_path(filename)?;
} }
} else { } else {
multiset.add_path(filename)?; multiset.add_path(filename)?;
} }
} }
Ok(multiset) Ok(multiset)
let new = DirsMultiset::from_manifest(&manifest).unwrap(); let new = DirsMultiset::from_manifest(&manifest).unwrap();
let expected = DirsMultiset { let expected = DirsMultiset {
inner: FastHashMap::default(), inner: FastHashMap::default(),
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
let new = DirsMultiset::from_dirstate( let new = DirsMultiset::from_dirstate(
StateMap::default().into_iter().map(Ok), StateMap::default().into_iter().map(Ok),
None, false,
) )
.unwrap(); .unwrap();
let expected = DirsMultiset { let expected = DirsMultiset {
inner: FastHashMap::default(), inner: FastHashMap::default(),
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
} }
}, },
)) ))
}); });
let expected_inner = [("", 2), ("a", 2), ("b", 1), ("a/d", 1)] let expected_inner = [("", 2), ("a", 2), ("b", 1), ("a/d", 1)]
.iter() .iter()
.map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v)) .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
.collect(); .collect();
let new = DirsMultiset::from_dirstate(input_map, None).unwrap(); let new = DirsMultiset::from_dirstate(input_map, false).unwrap();
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
} }
#[test] #[test]
fn test_dirsmultiset_new_skip() { fn test_dirsmultiset_new_skip() {
mode: 0, mode: 0,
mtime: 0, mtime: 0,
size: 0, size: 0,
}, },
)) ))
}); });
// "a" incremented with "a/c" and "a/d/" // "a" incremented with "a/c" and "a/d/"
let expected_inner = [("", 1), ("a", 2)] let expected_inner = [("", 1), ("a", 3)]
.iter() .iter()
.map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v)) .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
.collect(); .collect();
let new = let new = DirsMultiset::from_dirstate(input_map, true).unwrap();
DirsMultiset::from_dirstate(input_map, Some(EntryState::Normal))
.unwrap();
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
} }
} }

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

/// Both of these setters and their uses appear to be the simplest way to /// Both of these setters and their uses appear to be the simplest way to
/// emulate a Python lazy property, but it is ugly and unidiomatic. /// emulate a Python lazy property, but it is ugly and unidiomatic.
/// TODO One day, rewriting this struct using the typestate might be a /// TODO One day, rewriting this struct using the typestate might be a
/// good idea. /// good idea.
pub fn set_all_dirs(&mut self) -> Result<(), DirstateError> { pub fn set_all_dirs(&mut self) -> Result<(), DirstateError> {
if self.all_dirs.is_none() { if self.all_dirs.is_none() {
self.all_dirs = Some(DirsMultiset::from_dirstate( self.all_dirs = Some(DirsMultiset::from_dirstate(
self.state_map.iter().map(|(k, v)| Ok((k, *v))), self.state_map.iter().map(|(k, v)| Ok((k, *v))),
None, false,
)?); )?);
} }
Ok(()) Ok(())
} }
pub fn set_dirs(&mut self) -> Result<(), DirstateError> { pub fn set_dirs(&mut self) -> Result<(), DirstateError> {
if self.dirs.is_none() { if self.dirs.is_none() {
self.dirs = Some(DirsMultiset::from_dirstate( self.dirs = Some(DirsMultiset::from_dirstate(
self.state_map.iter().map(|(k, v)| Ok((k, *v))), self.state_map.iter().map(|(k, v)| Ok((k, *v))),
Some(EntryState::Removed), true,
)?); )?);
} }
Ok(()) Ok(())
} }
pub fn has_tracked_dir( pub fn has_tracked_dir(
&mut self, &mut self,
directory: &HgPath, directory: &HgPath,

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

// dirs_multiset.rs // dirs_multiset.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::dirs_multiset` file provided by the //! Bindings for the `hg::dirstate::dirs_multiset` file provided by the
//! `hg-core` package. //! `hg-core` package.
use std::cell::RefCell; use std::cell::RefCell;
use std::convert::TryInto;
use cpython::{ use cpython::{
exc, ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyObject, PyResult, exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyObject,
Python, UnsafePyLeaked, PyResult, Python, UnsafePyLeaked,
}; };
use crate::dirstate::extract_dirstate; use crate::dirstate::extract_dirstate;
use hg::{ use hg::{
errors::HgError,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirsMultiset, DirsMultisetIter, DirstateError, DirstateMapError, DirsMultiset, DirsMultisetIter, DirstateError, DirstateMapError,
EntryState,
}; };
py_class!(pub class Dirs |py| { py_class!(pub class Dirs |py| {
@shared data inner: DirsMultiset; @shared data inner: DirsMultiset;
// `map` is either a `dict` or a flat iterator (usually a `set`, sometimes // `map` is either a `dict` or a flat iterator (usually a `set`, sometimes
// a `list`) // a `list`)
def __new__( def __new__(
_cls, _cls,
map: PyObject, map: PyObject,
skip: Option<PyObject> = None only_tracked: Option<PyObject> = None
) -> PyResult<Self> { ) -> PyResult<Self> {
let mut skip_state: Option<EntryState> = None; let only_tracked_b = if let Some(only_tracked) = only_tracked {
if let Some(skip) = skip { only_tracked.extract::<PyBool>(py)?.is_true()
skip_state = Some( } else {
skip.extract::<PyBytes>(py)?.data(py)[0] false
.try_into() };
.map_err(|e: HgError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?,
);
}
let inner = if let Ok(map) = map.cast_as::<PyDict>(py) { let inner = if let Ok(map) = map.cast_as::<PyDict>(py) {
let dirstate = extract_dirstate(py, &map)?; let dirstate = extract_dirstate(py, &map)?;
let dirstate = dirstate.iter().map(|(k, v)| Ok((k, *v))); let dirstate = dirstate.iter().map(|(k, v)| Ok((k, *v)));
DirsMultiset::from_dirstate(dirstate, skip_state) DirsMultiset::from_dirstate(dirstate, only_tracked_b)
.map_err(|e: DirstateError| { .map_err(|e: DirstateError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})? })?
} else { } else {
let map: Result<Vec<HgPathBuf>, PyErr> = map let map: Result<Vec<HgPathBuf>, PyErr> = map
.iter(py)? .iter(py)?
.map(|o| { .map(|o| {
Ok(HgPathBuf::from_bytes( Ok(HgPathBuf::from_bytes(