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

Revision Contents
Changeset List

Diff 30337

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,