| 1 |
// dirstate/item.rs |
| 2 |
// |
| 3 |
// Copyright 2019 Raphaël Gomès <[email protected]> |
| 4 |
// 2025 Georges Racinet <[email protected]> |
| 5 |
// |
| 6 |
// This software may be used and distributed according to the terms of the |
| 7 |
// GNU General Public License version 2 or any later version. |
| 8 |
//! Bindings for the `hg::dirstate::entry` module of the `hg-core` package. |
| 9 |
|
| 10 |
use std::sync::RwLock; |
| 11 |
use std::sync::RwLockReadGuard; |
| 12 |
use std::sync::RwLockWriteGuard; |
| 13 |
|
| 14 |
use hg::dirstate::entry::DirstateEntry; |
| 15 |
use hg::dirstate::entry::DirstateV2Data; |
| 16 |
use hg::dirstate::entry::TruncatedTimestamp; |
| 17 |
use pyo3::exceptions::PyValueError; |
| 18 |
use pyo3::prelude::*; |
| 19 |
use pyo3::types::PyBytes; |
| 20 |
|
| 21 |
use crate::exceptions::map_lock_error; |
| 22 |
|
| 23 |
#[pyclass] |
| 24 |
pub struct DirstateItem { |
| 25 |
entry: RwLock<DirstateEntry>, |
| 26 |
} |
| 27 |
|
| 28 |
/// Type alias to satisfy Clippy in `DirstateItem::new()` |
| 29 |
type UncheckedTruncatedTimeStamp = Option<(u32, u32, bool)>; |
| 30 |
|
| 31 |
#[pymethods] |
| 32 |
impl DirstateItem { |
| 33 |
#[new] |
| 34 |
#[allow(clippy::too_many_arguments)] |
| 35 |
#[pyo3(signature = (wc_tracked=false, |
| 36 |
p1_tracked=false, |
| 37 |
p2_info=false, |
| 38 |
has_meaningful_data=true, |
| 39 |
has_meaningful_mtime=true, |
| 40 |
parentfiledata=None, |
| 41 |
fallback_exec=None, |
| 42 |
fallback_symlink=None))] |
| 43 |
fn new( |
| 44 |
wc_tracked: bool, |
| 45 |
p1_tracked: bool, |
| 46 |
p2_info: bool, |
| 47 |
has_meaningful_data: bool, |
| 48 |
has_meaningful_mtime: bool, |
| 49 |
parentfiledata: Option<(u32, u32, UncheckedTruncatedTimeStamp)>, |
| 50 |
fallback_exec: Option<bool>, |
| 51 |
fallback_symlink: Option<bool>, |
| 52 |
) -> PyResult<Self> { |
| 53 |
let mut mode_size_opt = None; |
| 54 |
let mut mtime_opt = None; |
| 55 |
if let Some((mode, size, mtime)) = parentfiledata { |
| 56 |
if has_meaningful_data { |
| 57 |
mode_size_opt = Some((mode, size)) |
| 58 |
} |
| 59 |
if has_meaningful_mtime { |
| 60 |
if let Some(m) = mtime { |
| 61 |
mtime_opt = Some(timestamp(m)?); |
| 62 |
} |
| 63 |
} |
| 64 |
} |
| 65 |
Ok(Self { |
| 66 |
entry: DirstateEntry::from_v2_data(DirstateV2Data { |
| 67 |
wc_tracked, |
| 68 |
p1_tracked, |
| 69 |
p2_info, |
| 70 |
mode_size: mode_size_opt, |
| 71 |
mtime: mtime_opt, |
| 72 |
fallback_exec, |
| 73 |
fallback_symlink, |
| 74 |
}) |
| 75 |
.into(), |
| 76 |
}) |
| 77 |
} |
| 78 |
|
| 79 |
#[getter] |
| 80 |
fn state(&self, py: Python) -> PyResult<Py<PyBytes>> { |
| 81 |
let state_byte = self.read()?.state(); |
| 82 |
Ok(PyBytes::new(py, &[state_byte.into()]).unbind()) |
| 83 |
} |
| 84 |
|
| 85 |
#[getter] |
| 86 |
fn mode(&self) -> PyResult<i32> { |
| 87 |
Ok(self.read()?.mode()) |
| 88 |
} |
| 89 |
|
| 90 |
#[getter] |
| 91 |
fn size(&self) -> PyResult<i32> { |
| 92 |
Ok(self.read()?.size()) |
| 93 |
} |
| 94 |
|
| 95 |
#[getter] |
| 96 |
fn mtime(&self) -> PyResult<i32> { |
| 97 |
Ok(self.read()?.mtime()) |
| 98 |
} |
| 99 |
|
| 100 |
#[getter] |
| 101 |
fn has_fallback_exec(&self) -> PyResult<bool> { |
| 102 |
Ok(self.read()?.get_fallback_exec().is_some()) |
| 103 |
} |
| 104 |
|
| 105 |
#[getter] |
| 106 |
fn fallback_exec(&self) -> PyResult<Option<bool>> { |
| 107 |
Ok(self.read()?.get_fallback_exec()) |
| 108 |
} |
| 109 |
|
| 110 |
#[setter] |
| 111 |
fn set_fallback_exec( |
| 112 |
&self, |
| 113 |
value: Option<Bound<'_, PyAny>>, |
| 114 |
) -> PyResult<()> { |
| 115 |
let mut writable = self.write()?; |
| 116 |
match value { |
| 117 |
None => { |
| 118 |
writable.set_fallback_exec(None); |
| 119 |
} |
| 120 |
Some(value) => { |
| 121 |
if value.is_none() { |
| 122 |
// gracinet: this case probably cannot happen, |
| 123 |
// because PyO3 setters have a fixed signature, that |
| 124 |
// is not defaulting to kwargs, hence there is no |
| 125 |
// difference between an explicit None and a default |
| 126 |
// (kwarg) None. Still keeping it for safety, it could |
| 127 |
// be cleaned up afterwards. |
| 128 |
writable.set_fallback_exec(None); |
| 129 |
} else { |
| 130 |
writable.set_fallback_exec(Some(value.is_truthy()?)); |
| 131 |
} |
| 132 |
} |
| 133 |
} |
| 134 |
Ok(()) |
| 135 |
} |
| 136 |
|
| 137 |
#[getter] |
| 138 |
fn has_fallback_symlink(&self) -> PyResult<bool> { |
| 139 |
Ok(self.read()?.get_fallback_symlink().is_some()) |
| 140 |
} |
| 141 |
|
| 142 |
#[getter] |
| 143 |
fn fallback_symlink(&self) -> PyResult<Option<bool>> { |
| 144 |
Ok(self.read()?.get_fallback_symlink()) |
| 145 |
} |
| 146 |
|
| 147 |
#[getter] |
| 148 |
fn tracked(&self) -> PyResult<bool> { |
| 149 |
Ok(self.read()?.tracked()) |
| 150 |
} |
| 151 |
|
| 152 |
#[getter] |
| 153 |
fn p1_tracked(&self) -> PyResult<bool> { |
| 154 |
Ok(self.read()?.p1_tracked()) |
| 155 |
} |
| 156 |
|
| 157 |
#[getter] |
| 158 |
fn added(&self) -> PyResult<bool> { |
| 159 |
Ok(self.read()?.added()) |
| 160 |
} |
| 161 |
|
| 162 |
#[getter] |
| 163 |
fn modified(&self) -> PyResult<bool> { |
| 164 |
Ok(self.read()?.modified()) |
| 165 |
} |
| 166 |
|
| 167 |
#[getter] |
| 168 |
fn p2_info(&self) -> PyResult<bool> { |
| 169 |
Ok(self.read()?.p2_info()) |
| 170 |
} |
| 171 |
|
| 172 |
#[getter] |
| 173 |
fn removed(&self) -> PyResult<bool> { |
| 174 |
Ok(self.read()?.removed()) |
| 175 |
} |
| 176 |
|
| 177 |
#[getter] |
| 178 |
fn maybe_clean(&self) -> PyResult<bool> { |
| 179 |
Ok(self.read()?.maybe_clean()) |
| 180 |
} |
| 181 |
|
| 182 |
#[getter] |
| 183 |
fn any_tracked(&self) -> PyResult<bool> { |
| 184 |
Ok(self.read()?.any_tracked()) |
| 185 |
} |
| 186 |
|
| 187 |
fn mtime_likely_equal_to(&self, other: (u32, u32, bool)) -> PyResult<bool> { |
| 188 |
if let Some(mtime) = self.read()?.truncated_mtime() { |
| 189 |
Ok(mtime.likely_equal(timestamp(other)?)) |
| 190 |
} else { |
| 191 |
Ok(false) |
| 192 |
} |
| 193 |
} |
| 194 |
|
| 195 |
fn drop_merge_data(&self) -> PyResult<()> { |
| 196 |
self.write()?.drop_merge_data(); |
| 197 |
Ok(()) |
| 198 |
} |
| 199 |
|
| 200 |
fn set_clean( |
| 201 |
&self, |
| 202 |
mode: u32, |
| 203 |
size: u32, |
| 204 |
mtime: (u32, u32, bool), |
| 205 |
) -> PyResult<()> { |
| 206 |
self.write()?.set_clean(mode, size, timestamp(mtime)?); |
| 207 |
Ok(()) |
| 208 |
} |
| 209 |
|
| 210 |
fn set_possibly_dirty(&self) -> PyResult<()> { |
| 211 |
self.write()?.set_possibly_dirty(); |
| 212 |
Ok(()) |
| 213 |
} |
| 214 |
|
| 215 |
fn set_tracked(&self) -> PyResult<()> { |
| 216 |
self.write()?.set_tracked(); |
| 217 |
Ok(()) |
| 218 |
} |
| 219 |
|
| 220 |
fn set_untracked(&self) -> PyResult<()> { |
| 221 |
self.write()?.set_untracked(); |
| 222 |
Ok(()) |
| 223 |
} |
| 224 |
} |
| 225 |
|
| 226 |
impl DirstateItem { |
| 227 |
pub fn new_as_py(py: Python, entry: DirstateEntry) -> PyResult<Py<Self>> { |
| 228 |
Ok(Self { entry: entry.into() }.into_pyobject(py)?.unbind()) |
| 229 |
} |
| 230 |
|
| 231 |
fn read(&self) -> PyResult<RwLockReadGuard<DirstateEntry>> { |
| 232 |
self.entry.read().map_err(map_lock_error) |
| 233 |
} |
| 234 |
|
| 235 |
fn write(&self) -> PyResult<RwLockWriteGuard<DirstateEntry>> { |
| 236 |
self.entry.write().map_err(map_lock_error) |
| 237 |
} |
| 238 |
} |
| 239 |
|
| 240 |
pub(crate) fn timestamp( |
| 241 |
(s, ns, second_ambiguous): (u32, u32, bool), |
| 242 |
) -> PyResult<TruncatedTimestamp> { |
| 243 |
TruncatedTimestamp::from_already_truncated(s, ns, second_ambiguous).map_err( |
| 244 |
|_| PyValueError::new_err("expected mtime truncated to 31 bits"), |
| 245 |
) |
| 246 |
} |