( )⚙ D11485 rust: Add Python bindings for DirstateEntry as rustext.dirstate.DirstateItem

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11485

rust: Add Python bindings for DirstateEntry as rustext.dirstate.DirstateItem
ClosedPublic

Authored by SimonSapin on Sep 22 2021, 4:55 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG3e69bef2031a: rust: Add Python bindings for DirstateEntry as rustext.dirstate.DirstateItem

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

Diff 30379

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

pub struct DirstateEntry { pub struct DirstateEntry {
flags: Flags, flags: Flags,
mode: i32, mode: i32,
size: i32, size: i32,
mtime: i32, mtime: i32,
} }
bitflags! { bitflags! {
struct Flags: u8 { pub struct Flags: u8 {
const WDIR_TRACKED = 1 << 0; const WDIR_TRACKED = 1 << 0;
const P1_TRACKED = 1 << 1; const P1_TRACKED = 1 << 1;
const P2_TRACKED = 1 << 2; const P2_TRACKED = 1 << 2;
const POSSIBLY_DIRTY = 1 << 3; const POSSIBLY_DIRTY = 1 << 3;
const MERGED = 1 << 4; const MERGED = 1 << 4;
const CLEAN_P1 = 1 << 5; const CLEAN_P1 = 1 << 5;
const CLEAN_P2 = 1 << 6; const CLEAN_P2 = 1 << 6;
const ENTRYLESS_TREE_NODE = 1 << 7; const ENTRYLESS_TREE_NODE = 1 << 7;
} }
} }
pub const V1_RANGEMASK: i32 = 0x7FFFFFFF; pub const V1_RANGEMASK: i32 = 0x7FFFFFFF;
pub const MTIME_UNSET: i32 = -1; pub const MTIME_UNSET: i32 = -1;
/// A `DirstateEntry` with a size of `-2` means that it was merged from the /// A `DirstateEntry` with a size of `-2` means that it was merged from the
/// other parent. This allows revert to pick the right status back during a /// other parent. This allows revert to pick the right status back during a
/// merge. /// merge.
pub const SIZE_FROM_OTHER_PARENT: i32 = -2; pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
/// A special value used for internal representation of special case in /// A special value used for internal representation of special case in
/// dirstate v1 format. /// dirstate v1 format.
pub const SIZE_NON_NORMAL: i32 = -1; pub const SIZE_NON_NORMAL: i32 = -1;
impl DirstateEntry { impl DirstateEntry {
pub fn new(
flags: Flags,
mode_size_mtime: Option<(i32, i32, i32)>,
) -> Self {
let (mode, size, mtime) =
mode_size_mtime.unwrap_or((0, SIZE_NON_NORMAL, MTIME_UNSET));
Self {
flags,
mode,
size,
mtime,
}
}
pub fn from_v1_data( pub fn from_v1_data(
state: EntryState, state: EntryState,
mode: i32, mode: i32,
size: i32, size: i32,
mtime: i32, mtime: i32,
) -> Self { ) -> Self {
match state { match state {
EntryState::Normal => { EntryState::Normal => {
/// TODO: refactor `DirstateMap::add_file` to not take a `DirstateEntry` /// TODO: refactor `DirstateMap::add_file` to not take a `DirstateEntry`
/// parameter and remove this constructor /// parameter and remove this constructor
pub fn new_for_add_file(mode: i32, size: i32, mtime: i32) -> Self { pub fn new_for_add_file(mode: i32, size: i32, mtime: i32) -> Self {
// XXX Arbitrary default value since the value is determined later // XXX Arbitrary default value since the value is determined later
let state = EntryState::Normal; let state = EntryState::Normal;
Self::from_v1_data(state, mode, size, mtime) Self::from_v1_data(state, mode, size, mtime)
} }
pub fn tracked(&self) -> bool {
self.flags.contains(Flags::WDIR_TRACKED)
}
fn tracked_in_any_parent(&self) -> bool { fn tracked_in_any_parent(&self) -> bool {
self.flags.intersects(Flags::P1_TRACKED | Flags::P2_TRACKED) self.flags.intersects(Flags::P1_TRACKED | Flags::P2_TRACKED)
} }
fn removed(&self) -> bool { pub fn removed(&self) -> bool {
self.tracked_in_any_parent() self.tracked_in_any_parent()
&& !self.flags.contains(Flags::WDIR_TRACKED) && !self.flags.contains(Flags::WDIR_TRACKED)
} }
fn merged_removed(&self) -> bool { pub fn merged_removed(&self) -> bool {
self.removed() && self.flags.contains(Flags::MERGED) self.removed() && self.flags.contains(Flags::MERGED)
} }
fn from_p2_removed(&self) -> bool { pub fn from_p2_removed(&self) -> bool {
self.removed() && self.flags.contains(Flags::CLEAN_P2) self.removed() && self.flags.contains(Flags::CLEAN_P2)
} }
fn merged(&self) -> bool { pub fn merged(&self) -> bool {
self.flags.contains(Flags::WDIR_TRACKED | Flags::MERGED) self.flags.contains(Flags::WDIR_TRACKED | Flags::MERGED)
} }
fn added(&self) -> bool { pub fn added(&self) -> bool {
self.flags.contains(Flags::WDIR_TRACKED) self.flags.contains(Flags::WDIR_TRACKED)
&& !self.tracked_in_any_parent() && !self.tracked_in_any_parent()
} }
fn from_p2(&self) -> bool { pub fn from_p2(&self) -> bool {
self.flags.contains(Flags::WDIR_TRACKED | Flags::CLEAN_P2) self.flags.contains(Flags::WDIR_TRACKED | Flags::CLEAN_P2)
} }
pub fn state(&self) -> EntryState { pub fn state(&self) -> EntryState {
if self.removed() { if self.removed() {
EntryState::Removed EntryState::Removed
} else if self.merged() { } else if self.merged() {
EntryState::Merged EntryState::Merged
MTIME_UNSET MTIME_UNSET
} else if self.from_p2() { } else if self.from_p2() {
MTIME_UNSET MTIME_UNSET
} else { } else {
self.mtime self.mtime
} }
} }
pub fn set_possibly_dirty(&mut self) {
self.flags.insert(Flags::POSSIBLY_DIRTY)
}
pub fn set_clean(&mut self, mode: i32, size: i32, mtime: i32) {
self.flags.insert(Flags::WDIR_TRACKED | Flags::P1_TRACKED);
self.flags.remove(
Flags::P2_TRACKED // This might be wrong
| Flags::MERGED
| Flags::CLEAN_P2
| Flags::POSSIBLY_DIRTY,
);
self.mode = mode;
self.size = size;
self.mtime = mtime;
}
pub fn set_tracked(&mut self) {
self.flags
.insert(Flags::WDIR_TRACKED | Flags::POSSIBLY_DIRTY);
// size = None on the python size turn into size = NON_NORMAL when
// accessed. So the next line is currently required, but a some future
// clean up would be welcome.
self.size = SIZE_NON_NORMAL;
}
pub fn set_untracked(&mut self) {
self.flags.remove(Flags::WDIR_TRACKED);
self.mode = 0;
self.size = 0;
self.mtime = 0;
}
/// Returns `(state, mode, size, mtime)` for the puprose of serialization /// Returns `(state, mode, size, mtime)` for the puprose of serialization
/// in the dirstate-v1 format. /// in the dirstate-v1 format.
/// ///
/// This includes marker values such as `mtime == -1`. In the future we may /// This includes marker values such as `mtime == -1`. In the future we may
/// want to not represent these cases that way in memory, but serialization /// want to not represent these cases that way in memory, but serialization
/// will need to keep the same format. /// will need to keep the same format.
pub fn v1_data(&self) -> (u8, i32, i32, i32) { pub fn v1_data(&self) -> (u8, i32, i32, i32) {
(self.state().into(), self.mode(), self.size(), self.mtime()) (self.state().into(), self.mode(), self.size(), self.mtime())

rust/hg-cpython/src/dirstate.rs

// dirstate.rs // dirstate.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` module provided by the //! Bindings for the `hg::dirstate` module provided by the
//! `hg-core` package. //! `hg-core` package.
//! //!
//! From Python, this will be seen as `mercurial.rustext.dirstate` //! From Python, this will be seen as `mercurial.rustext.dirstate`
mod copymap; mod copymap;
mod dirs_multiset; mod dirs_multiset;
mod dirstate_map; mod dirstate_map;
mod item;
mod non_normal_entries; mod non_normal_entries;
mod status; mod status;
use self::item::DirstateItem;
use crate::{ use crate::{
dirstate::{ dirstate::{
dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper, dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper,
}, },
exceptions, exceptions,
}; };
use cpython::{ use cpython::{
PyBytes, PyDict, PyErr, PyList, PyModule, PyObject, PyResult, Python, PyBytes, PyDict, PyErr, PyList, PyModule, PyObject, PyResult, Python,
m.add( m.add(
py, py,
"FallbackError", "FallbackError",
py.get_type::<exceptions::FallbackError>(), py.get_type::<exceptions::FallbackError>(),
)?; )?;
m.add_class::<Dirs>(py)?; m.add_class::<Dirs>(py)?;
m.add_class::<DirstateMap>(py)?; m.add_class::<DirstateMap>(py)?;
m.add_class::<DirstateItem>(py)?;
m.add(py, "V2_FORMAT_MARKER", PyBytes::new(py, V2_FORMAT_MARKER))?; m.add(py, "V2_FORMAT_MARKER", PyBytes::new(py, V2_FORMAT_MARKER))?;
m.add( m.add(
py, py,
"status", "status",
py_fn!( py_fn!(
py, py,
status_wrapper( status_wrapper(
dmap: DirstateMap, dmap: DirstateMap,

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

  • This file was added.
use cpython::exc;
use cpython::PyBytes;
use cpython::PyErr;
use cpython::PyNone;
use cpython::PyObject;
use cpython::PyResult;
use cpython::Python;
use cpython::PythonObject;
use hg::dirstate::entry::Flags;
use hg::dirstate::DirstateEntry;
use hg::dirstate::EntryState;
use std::cell::Cell;
use std::convert::TryFrom;
py_class!(pub class DirstateItem |py| {
data entry: Cell<DirstateEntry>;
def __new__(
_cls,
wc_tracked: bool = false,
p1_tracked: bool = false,
p2_tracked: bool = false,
merged: bool = false,
clean_p1: bool = false,
clean_p2: bool = false,
possibly_dirty: bool = false,
parentfiledata: Option<(i32, i32, i32)> = None,
) -> PyResult<DirstateItem> {
let mut flags = Flags::empty();
flags.set(Flags::WDIR_TRACKED, wc_tracked);
flags.set(Flags::P1_TRACKED, p1_tracked);
flags.set(Flags::P2_TRACKED, p2_tracked);
flags.set(Flags::MERGED, merged);
flags.set(Flags::CLEAN_P1, clean_p1);
flags.set(Flags::CLEAN_P2, clean_p2);
flags.set(Flags::POSSIBLY_DIRTY, possibly_dirty);
let entry = DirstateEntry::new(flags, parentfiledata);
DirstateItem::create_instance(py, Cell::new(entry))
}
@property
def state(&self) -> PyResult<PyBytes> {
let state_byte: u8 = self.entry(py).get().state().into();
Ok(PyBytes::new(py, &[state_byte]))
}
@property
def mode(&self) -> PyResult<i32> {
Ok(self.entry(py).get().mode())
}
@property
def size(&self) -> PyResult<i32> {
Ok(self.entry(py).get().size())
}
@property
def mtime(&self) -> PyResult<i32> {
Ok(self.entry(py).get().mtime())
}
@property
def tracked(&self) -> PyResult<bool> {
Ok(self.entry(py).get().tracked())
}
@property
def added(&self) -> PyResult<bool> {
Ok(self.entry(py).get().added())
}
@property
def merged(&self) -> PyResult<bool> {
Ok(self.entry(py).get().merged())
}
@property
def removed(&self) -> PyResult<bool> {
Ok(self.entry(py).get().removed())
}
@property
def from_p2(&self) -> PyResult<bool> {
Ok(self.entry(py).get().from_p2())
}
@property
def merged_removed(&self) -> PyResult<bool> {
Ok(self.entry(py).get().merged_removed())
}
@property
def from_p2_removed(&self) -> PyResult<bool> {
Ok(self.entry(py).get().from_p2_removed())
}
@property
def dm_nonnormal(&self) -> PyResult<bool> {
Ok(self.entry(py).get().is_non_normal())
}
@property
def dm_otherparent(&self) -> PyResult<bool> {
Ok(self.entry(py).get().is_from_other_parent())
}
def v1_state(&self) -> PyResult<PyBytes> {
let (state, _mode, _size, _mtime) = self.entry(py).get().v1_data();
let state_byte: u8 = state.into();
Ok(PyBytes::new(py, &[state_byte]))
}
def v1_mode(&self) -> PyResult<i32> {
let (_state, mode, _size, _mtime) = self.entry(py).get().v1_data();
Ok(mode)
}
def v1_size(&self) -> PyResult<i32> {
let (_state, _mode, size, _mtime) = self.entry(py).get().v1_data();
Ok(size)
}
def v1_mtime(&self) -> PyResult<i32> {
let (_state, _mode, _size, mtime) = self.entry(py).get().v1_data();
Ok(mtime)
}
def need_delay(&self, now: i32) -> PyResult<bool> {
Ok(self.entry(py).get().mtime_is_ambiguous(now))
}
@classmethod
def from_v1_data(
_cls,
state: PyBytes,
mode: i32,
size: i32,
mtime: i32,
) -> PyResult<Self> {
let state = <[u8; 1]>::try_from(state.data(py))
.ok()
.and_then(|state| EntryState::try_from(state[0]).ok())
.ok_or_else(|| PyErr::new::<exc::ValueError, _>(py, "invalid state"))?;
let entry = DirstateEntry::from_v1_data(state, mode, size, mtime);
DirstateItem::create_instance(py, Cell::new(entry))
}
def set_clean(
&self,
mode: i32,
size: i32,
mtime: i32,
) -> PyResult<PyNone> {
self.update(py, |entry| entry.set_clean(mode, size, mtime));
Ok(PyNone)
}
def set_possibly_dirty(&self) -> PyResult<PyNone> {
self.update(py, |entry| entry.set_possibly_dirty());
Ok(PyNone)
}
def set_tracked(&self) -> PyResult<PyNone> {
self.update(py, |entry| entry.set_tracked());
Ok(PyNone)
}
def set_untracked(&self) -> PyResult<PyNone> {
self.update(py, |entry| entry.set_untracked());
Ok(PyNone)
}
});
impl DirstateItem {
pub fn new_as_pyobject(
py: Python<'_>,
entry: DirstateEntry,
) -> PyResult<PyObject> {
Ok(DirstateItem::create_instance(py, Cell::new(entry))?.into_object())
}
// TODO: Use https://doc.rust-lang.org/std/cell/struct.Cell.html#method.update instead when it’s stable
pub fn update(&self, py: Python<'_>, f: impl FnOnce(&mut DirstateEntry)) {
let mut entry = self.entry(py).get();
f(&mut entry);
self.entry(py).set(entry)
}
}