( )⚙ D11383 pathutil: replace the `skip` argument of `dirs` with a boolean

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

Revision Contents
Changeset List

Diff 30173

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(