( )⚙ D11463 debugsate: Change debug_iter() to yield tuples instead of DirstateItem

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11463

debugsate: Change debug_iter() to yield tuples instead of DirstateItem
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGcedfe2606adf: debugsate: Change debug_iter() to yield tuples instead of DirstateItem
Summary

This removes the need for DirstateItem to support the state == ' '
special case which represents dirstate tree nodes without an item.

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 30375

mercurial/debugcommands.py

"""show the contents of the current dirstate""" """show the contents of the current dirstate"""
nodates = not opts['dates'] nodates = not opts['dates']
if opts.get('nodates') is not None: if opts.get('nodates') is not None:
nodates = True nodates = True
datesort = opts.get('datesort') datesort = opts.get('datesort')
if datesort: if datesort:
keyfunc = lambda x: (
x[1].v1_mtime(), def keyfunc(entry):
x[0], filename, _state, _mode, _size, mtime = entry
) # sort by mtime, then by filename return (mtime, filename)
else: else:
keyfunc = None # sort by filename keyfunc = None # sort by filename
entries = list(repo.dirstate._map.debug_iter(all=opts['all'])) entries = list(repo.dirstate._map.debug_iter(all=opts['all']))
entries.sort(key=keyfunc) entries.sort(key=keyfunc)
for file_, ent in entries: for entry in entries:
if ent.v1_mtime() == -1: filename, state, mode, size, mtime = entry
if mtime == -1:
timestr = b'unset ' timestr = b'unset '
elif nodates: elif nodates:
timestr = b'set ' timestr = b'set '
else: else:
timestr = time.strftime( timestr = time.strftime("%Y-%m-%d %H:%M:%S ", time.localtime(mtime))
"%Y-%m-%d %H:%M:%S ", time.localtime(ent.v1_mtime())
)
timestr = encoding.strtolocal(timestr) timestr = encoding.strtolocal(timestr)
if ent.mode & 0o20000: if mode & 0o20000:
mode = b'lnk' mode = b'lnk'
else: else:
mode = b'%3o' % (ent.v1_mode() & 0o777 & ~util.umask) mode = b'%3o' % (mode & 0o777 & ~util.umask)
ui.write( ui.write(b"%c %s %10d %s%s\n" % (state, mode, size, timestr, filename))
b"%c %s %10d %s%s\n"
% (ent.v1_state(), mode, ent.v1_size(), timestr, file_)
)
for f in repo.dirstate.copies(): for f in repo.dirstate.copies():
ui.write(_(b"copy: %s -> %s\n") % (repo.dirstate.copied(f), f)) ui.write(_(b"copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
@command( @command(
b'debugdirstateignorepatternshash', b'debugdirstateignorepatternshash',
[], [],
_(b''), _(b''),

mercurial/dirstatemap.py

def items(self): def items(self):
return pycompat.iteritems(self._map) return pycompat.iteritems(self._map)
# forward for python2,3 compat # forward for python2,3 compat
iteritems = items iteritems = items
def debug_iter(self, all): def debug_iter(self, all):
""" """
Return an iterator of (filename, state, mode, size, mtime) tuples
`all` is unused when Rust is not enabled `all` is unused when Rust is not enabled
""" """
return self.item() for (filename, item) in self.items():
yield (filename, item.state, item.mode, item.size, item.mtime)
def __len__(self): def __len__(self):
return len(self._map) return len(self._map)
def __iter__(self): def __iter__(self):
return iter(self._map) return iter(self._map)
def get(self, key, default=None): def get(self, key, default=None):
def get(self, *args, **kwargs): def get(self, *args, **kwargs):
return self._rustmap.get(*args, **kwargs) return self._rustmap.get(*args, **kwargs)
@property @property
def copymap(self): def copymap(self):
return self._rustmap.copymap() return self._rustmap.copymap()
def debug_iter(self, all): def debug_iter(self, all):
"""
Return an iterator of (filename, state, mode, size, mtime) tuples
`all`: also include with `state == b' '` dirstate tree nodes that
don't have an associated `DirstateItem`.
"""
return self._rustmap.debug_iter(all) return self._rustmap.debug_iter(all)
def preload(self): def preload(self):
self._rustmap self._rustmap
def clear(self): def clear(self):
self._rustmap.clear() self._rustmap.clear()
self.setparents( self.setparents(

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

exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList,
PyObject, PyResult, PySet, PyString, Python, PythonObject, ToPyObject, PyObject, PyResult, PySet, PyString, Python, PythonObject, ToPyObject,
UnsafePyLeaked, UnsafePyLeaked,
}; };
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::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
pybytes_deref::PyBytesDeref, pybytes_deref::PyBytesDeref,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
dirstate::MTIME_UNSET, dirstate::MTIME_UNSET,
} }
def debug_iter(&self, all: bool) -> PyResult<PyList> { def debug_iter(&self, all: bool) -> PyResult<PyList> {
let dirs = PyList::new(py, &[]); let dirs = PyList::new(py, &[]);
for item in self.inner(py).borrow().debug_iter(all) { for item in self.inner(py).borrow().debug_iter(all) {
let (path, (state, mode, size, mtime)) = let (path, (state, mode, size, mtime)) =
item.map_err(|e| v2_error(py, e))?; item.map_err(|e| v2_error(py, e))?;
let path = PyBytes::new(py, path.as_bytes()); let path = PyBytes::new(py, path.as_bytes());
let item = make_dirstate_item_raw(py, state, mode, size, mtime)?; let item = (path, state, mode, size, mtime);
dirs.append(py, (path, item).to_py_object(py).into_object()) dirs.append(py, item.to_py_object(py).into_object())
} }
Ok(dirs) Ok(dirs)
} }
}); });
impl DirstateMap { impl DirstateMap {
pub fn get_inner_mut<'a>( pub fn get_inner_mut<'a>(
&'a self, &'a self,