dirstate_map.rs
478 lines
| 13.9 KiB
| application/rls-services+xml
|
RustLexer
|
r42998 | // dirstate_map.rs | ||
// | ||||
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> | ||||
// | ||||
// This software may be used and distributed according to the terms of the | ||||
// GNU General Public License version 2 or any later version. | ||||
use crate::{ | ||||
|
r44003 | dirstate::{parsers::PARENT_SIZE, EntryState, SIZE_FROM_OTHER_PARENT}, | ||
|
r43108 | pack_dirstate, parse_dirstate, | ||
|
r44003 | utils::{ | ||
files::normalize_case, | ||||
hg_path::{HgPath, HgPathBuf}, | ||||
}, | ||||
|
r43108 | CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError, | ||
|
r44278 | DirstateParents, DirstateParseError, FastHashMap, StateMap, | ||
|
r42998 | }; | ||
use core::borrow::Borrow; | ||||
|
r44278 | use std::collections::HashSet; | ||
|
r43067 | use std::convert::TryInto; | ||
|
r42998 | use std::iter::FromIterator; | ||
use std::ops::Deref; | ||||
use std::time::Duration; | ||||
|
r44278 | pub type FileFoldMap = FastHashMap<HgPathBuf, HgPathBuf>; | ||
|
r42998 | |||
|
r43065 | const NULL_ID: [u8; 20] = [0; 20]; | ||
|
r42998 | const MTIME_UNSET: i32 = -1; | ||
#[derive(Default)] | ||||
pub struct DirstateMap { | ||||
state_map: StateMap, | ||||
pub copy_map: CopyMap, | ||||
file_fold_map: Option<FileFoldMap>, | ||||
pub dirs: Option<DirsMultiset>, | ||||
pub all_dirs: Option<DirsMultiset>, | ||||
|
r44775 | non_normal_set: Option<HashSet<HgPathBuf>>, | ||
other_parent_set: Option<HashSet<HgPathBuf>>, | ||||
|
r42998 | parents: Option<DirstateParents>, | ||
dirty_parents: bool, | ||||
} | ||||
/// Should only really be used in python interface code, for clarity | ||||
impl Deref for DirstateMap { | ||||
type Target = StateMap; | ||||
fn deref(&self) -> &Self::Target { | ||||
&self.state_map | ||||
} | ||||
} | ||||
|
r43227 | impl FromIterator<(HgPathBuf, DirstateEntry)> for DirstateMap { | ||
fn from_iter<I: IntoIterator<Item = (HgPathBuf, DirstateEntry)>>( | ||||
|
r42998 | iter: I, | ||
) -> Self { | ||||
Self { | ||||
state_map: iter.into_iter().collect(), | ||||
..Self::default() | ||||
} | ||||
} | ||||
} | ||||
impl DirstateMap { | ||||
pub fn new() -> Self { | ||||
Self::default() | ||||
} | ||||
pub fn clear(&mut self) { | ||||
self.state_map.clear(); | ||||
self.copy_map.clear(); | ||||
self.file_fold_map = None; | ||||
|
r44775 | self.non_normal_set = None; | ||
self.other_parent_set = None; | ||||
|
r43069 | self.set_parents(&DirstateParents { | ||
|
r43065 | p1: NULL_ID, | ||
p2: NULL_ID, | ||||
|
r42998 | }) | ||
} | ||||
/// Add a tracked file to the dirstate | ||||
pub fn add_file( | ||||
&mut self, | ||||
|
r43227 | filename: &HgPath, | ||
|
r42998 | old_state: EntryState, | ||
entry: DirstateEntry, | ||||
|
r44227 | ) -> Result<(), DirstateMapError> { | ||
|
r42998 | if old_state == EntryState::Unknown || old_state == EntryState::Removed | ||
{ | ||||
if let Some(ref mut dirs) = self.dirs { | ||||
|
r44227 | dirs.add_path(filename)?; | ||
|
r42998 | } | ||
} | ||||
if old_state == EntryState::Unknown { | ||||
if let Some(ref mut all_dirs) = self.all_dirs { | ||||
|
r44227 | all_dirs.add_path(filename)?; | ||
|
r42998 | } | ||
} | ||||
self.state_map.insert(filename.to_owned(), entry.to_owned()); | ||||
if entry.state != EntryState::Normal || entry.mtime == MTIME_UNSET { | ||||
|
r44775 | self.get_non_normal_other_parent_entries() | ||
.0 | ||||
.insert(filename.to_owned()); | ||||
|
r42998 | } | ||
|
r44003 | if entry.size == SIZE_FROM_OTHER_PARENT { | ||
|
r44775 | self.get_non_normal_other_parent_entries() | ||
.1 | ||||
.insert(filename.to_owned()); | ||||
|
r42998 | } | ||
|
r44227 | Ok(()) | ||
|
r42998 | } | ||
/// Mark a file as removed in the dirstate. | ||||
/// | ||||
/// The `size` parameter is used to store sentinel values that indicate | ||||
/// the file's previous state. In the future, we should refactor this | ||||
/// to be more explicit about what that state is. | ||||
pub fn remove_file( | ||||
&mut self, | ||||
|
r43227 | filename: &HgPath, | ||
|
r42998 | old_state: EntryState, | ||
size: i32, | ||||
) -> Result<(), DirstateMapError> { | ||||
if old_state != EntryState::Unknown && old_state != EntryState::Removed | ||||
{ | ||||
if let Some(ref mut dirs) = self.dirs { | ||||
dirs.delete_path(filename)?; | ||||
} | ||||
} | ||||
if old_state == EntryState::Unknown { | ||||
if let Some(ref mut all_dirs) = self.all_dirs { | ||||
|
r44315 | all_dirs.add_path(filename)?; | ||
|
r42998 | } | ||
} | ||||
if let Some(ref mut file_fold_map) = self.file_fold_map { | ||||
|
r43108 | file_fold_map.remove(&normalize_case(filename)); | ||
|
r42998 | } | ||
self.state_map.insert( | ||||
filename.to_owned(), | ||||
DirstateEntry { | ||||
state: EntryState::Removed, | ||||
mode: 0, | ||||
size, | ||||
mtime: 0, | ||||
}, | ||||
); | ||||
|
r44775 | self.get_non_normal_other_parent_entries() | ||
.0 | ||||
.insert(filename.to_owned()); | ||||
|
r42998 | Ok(()) | ||
} | ||||
/// Remove a file from the dirstate. | ||||
/// Returns `true` if the file was previously recorded. | ||||
pub fn drop_file( | ||||
&mut self, | ||||
|
r43227 | filename: &HgPath, | ||
|
r42998 | old_state: EntryState, | ||
) -> Result<bool, DirstateMapError> { | ||||
|
r43063 | let exists = self.state_map.remove(filename).is_some(); | ||
|
r42998 | |||
if exists { | ||||
if old_state != EntryState::Removed { | ||||
if let Some(ref mut dirs) = self.dirs { | ||||
dirs.delete_path(filename)?; | ||||
} | ||||
} | ||||
if let Some(ref mut all_dirs) = self.all_dirs { | ||||
all_dirs.delete_path(filename)?; | ||||
} | ||||
} | ||||
if let Some(ref mut file_fold_map) = self.file_fold_map { | ||||
|
r43108 | file_fold_map.remove(&normalize_case(filename)); | ||
|
r42998 | } | ||
|
r44775 | self.get_non_normal_other_parent_entries() | ||
.0 | ||||
.remove(filename); | ||||
|
r42998 | |||
Ok(exists) | ||||
} | ||||
pub fn clear_ambiguous_times( | ||||
&mut self, | ||||
|
r43227 | filenames: Vec<HgPathBuf>, | ||
|
r42998 | now: i32, | ||
) { | ||||
for filename in filenames { | ||||
let mut changed = false; | ||||
self.state_map | ||||
.entry(filename.to_owned()) | ||||
.and_modify(|entry| { | ||||
if entry.state == EntryState::Normal && entry.mtime == now | ||||
{ | ||||
changed = true; | ||||
*entry = DirstateEntry { | ||||
mtime: MTIME_UNSET, | ||||
..*entry | ||||
}; | ||||
} | ||||
}); | ||||
if changed { | ||||
|
r44775 | self.get_non_normal_other_parent_entries() | ||
.0 | ||||
.insert(filename.to_owned()); | ||||
|
r42998 | } | ||
} | ||||
} | ||||
|
r44775 | pub fn non_normal_entries_remove( | ||
&mut self, | ||||
key: impl AsRef<HgPath>, | ||||
) -> bool { | ||||
self.get_non_normal_other_parent_entries() | ||||
.0 | ||||
.remove(key.as_ref()) | ||||
} | ||||
pub fn non_normal_entries_union( | ||||
&mut self, | ||||
other: HashSet<HgPathBuf>, | ||||
) -> Vec<HgPathBuf> { | ||||
self.get_non_normal_other_parent_entries() | ||||
.0 | ||||
.union(&other) | ||||
.map(|e| e.to_owned()) | ||||
.collect() | ||||
} | ||||
pub fn get_non_normal_other_parent_entries( | ||||
&mut self, | ||||
|
r44842 | ) -> (&mut HashSet<HgPathBuf>, &mut HashSet<HgPathBuf>) { | ||
|
r44775 | self.set_non_normal_other_parent_entries(false); | ||
|
r44842 | ( | ||
self.non_normal_set.as_mut().unwrap(), | ||||
self.other_parent_set.as_mut().unwrap(), | ||||
) | ||||
|
r44775 | } | ||
pub fn set_non_normal_other_parent_entries(&mut self, force: bool) { | ||||
if !force | ||||
&& self.non_normal_set.is_some() | ||||
&& self.other_parent_set.is_some() | ||||
{ | ||||
return; | ||||
} | ||||
|
r42998 | let mut non_normal = HashSet::new(); | ||
let mut other_parent = HashSet::new(); | ||||
for ( | ||||
filename, | ||||
DirstateEntry { | ||||
state, size, mtime, .. | ||||
}, | ||||
) in self.state_map.iter() | ||||
{ | ||||
if *state != EntryState::Normal || *mtime == MTIME_UNSET { | ||||
non_normal.insert(filename.to_owned()); | ||||
} | ||||
|
r44003 | if *state == EntryState::Normal && *size == SIZE_FROM_OTHER_PARENT | ||
{ | ||||
|
r42998 | other_parent.insert(filename.to_owned()); | ||
} | ||||
} | ||||
|
r44775 | self.non_normal_set = Some(non_normal); | ||
self.other_parent_set = Some(other_parent); | ||||
|
r42998 | } | ||
/// 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. | ||||
/// TODO One day, rewriting this struct using the typestate might be a | ||||
/// good idea. | ||||
|
r44315 | pub fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> { | ||
|
r42998 | if self.all_dirs.is_none() { | ||
|
r43070 | self.all_dirs = | ||
|
r44315 | Some(DirsMultiset::from_dirstate(&self.state_map, None)?); | ||
|
r42998 | } | ||
|
r44315 | Ok(()) | ||
|
r42998 | } | ||
|
r44315 | pub fn set_dirs(&mut self) -> Result<(), DirstateMapError> { | ||
|
r42998 | if self.dirs.is_none() { | ||
|
r43070 | self.dirs = Some(DirsMultiset::from_dirstate( | ||
&self.state_map, | ||||
|
r42998 | Some(EntryState::Removed), | ||
|
r44315 | )?); | ||
|
r42998 | } | ||
|
r44315 | Ok(()) | ||
|
r42998 | } | ||
|
r44315 | pub fn has_tracked_dir( | ||
&mut self, | ||||
directory: &HgPath, | ||||
) -> Result<bool, DirstateMapError> { | ||||
self.set_dirs()?; | ||||
Ok(self.dirs.as_ref().unwrap().contains(directory)) | ||||
|
r42998 | } | ||
|
r44315 | pub fn has_dir( | ||
&mut self, | ||||
directory: &HgPath, | ||||
) -> Result<bool, DirstateMapError> { | ||||
self.set_all_dirs()?; | ||||
Ok(self.all_dirs.as_ref().unwrap().contains(directory)) | ||||
|
r42998 | } | ||
pub fn parents( | ||||
&mut self, | ||||
file_contents: &[u8], | ||||
|
r43069 | ) -> Result<&DirstateParents, DirstateError> { | ||
|
r42998 | if let Some(ref parents) = self.parents { | ||
|
r43069 | return Ok(parents); | ||
|
r42998 | } | ||
let parents; | ||||
|
r43066 | if file_contents.len() == PARENT_SIZE * 2 { | ||
|
r42998 | parents = DirstateParents { | ||
|
r43067 | p1: file_contents[..PARENT_SIZE].try_into().unwrap(), | ||
p2: file_contents[PARENT_SIZE..PARENT_SIZE * 2] | ||||
.try_into() | ||||
.unwrap(), | ||||
|
r42998 | }; | ||
} else if file_contents.is_empty() { | ||||
parents = DirstateParents { | ||||
|
r43065 | p1: NULL_ID, | ||
p2: NULL_ID, | ||||
|
r42998 | }; | ||
} else { | ||||
return Err(DirstateError::Parse(DirstateParseError::Damaged)); | ||||
} | ||||
|
r43069 | self.parents = Some(parents); | ||
Ok(self.parents.as_ref().unwrap()) | ||||
|
r42998 | } | ||
|
r43069 | pub fn set_parents(&mut self, parents: &DirstateParents) { | ||
|
r42998 | self.parents = Some(parents.clone()); | ||
self.dirty_parents = true; | ||||
} | ||||
pub fn read( | ||||
&mut self, | ||||
file_contents: &[u8], | ||||
) -> Result<Option<DirstateParents>, DirstateError> { | ||||
if file_contents.is_empty() { | ||||
return Ok(None); | ||||
} | ||||
let parents = parse_dirstate( | ||||
&mut self.state_map, | ||||
&mut self.copy_map, | ||||
file_contents, | ||||
)?; | ||||
if !self.dirty_parents { | ||||
|
r43069 | self.set_parents(&parents); | ||
|
r42998 | } | ||
Ok(Some(parents)) | ||||
} | ||||
pub fn pack( | ||||
&mut self, | ||||
parents: DirstateParents, | ||||
now: Duration, | ||||
) -> Result<Vec<u8>, DirstateError> { | ||||
let packed = | ||||
pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?; | ||||
self.dirty_parents = false; | ||||
|
r44775 | self.set_non_normal_other_parent_entries(true); | ||
|
r42998 | Ok(packed) | ||
} | ||||
|
r43069 | pub fn build_file_fold_map(&mut self) -> &FileFoldMap { | ||
|
r42998 | if let Some(ref file_fold_map) = self.file_fold_map { | ||
|
r43069 | return file_fold_map; | ||
|
r42998 | } | ||
|
r44278 | let mut new_file_fold_map = FileFoldMap::default(); | ||
|
r42998 | for (filename, DirstateEntry { state, .. }) in self.state_map.borrow() | ||
{ | ||||
if *state == EntryState::Removed { | ||||
|
r43108 | new_file_fold_map | ||
.insert(normalize_case(filename), filename.to_owned()); | ||||
|
r42998 | } | ||
} | ||||
self.file_fold_map = Some(new_file_fold_map); | ||||
|
r43069 | self.file_fold_map.as_ref().unwrap() | ||
|
r42998 | } | ||
} | ||||
#[cfg(test)] | ||||
mod tests { | ||||
use super::*; | ||||
#[test] | ||||
fn test_dirs_multiset() { | ||||
let mut map = DirstateMap::new(); | ||||
assert!(map.dirs.is_none()); | ||||
assert!(map.all_dirs.is_none()); | ||||
|
r44315 | assert_eq!(map.has_dir(HgPath::new(b"nope")).unwrap(), false); | ||
|
r42998 | assert!(map.all_dirs.is_some()); | ||
assert!(map.dirs.is_none()); | ||||
|
r44315 | assert_eq!(map.has_tracked_dir(HgPath::new(b"nope")).unwrap(), false); | ||
|
r42998 | assert!(map.dirs.is_some()); | ||
} | ||||
#[test] | ||||
fn test_add_file() { | ||||
let mut map = DirstateMap::new(); | ||||
assert_eq!(0, map.len()); | ||||
map.add_file( | ||||
|
r43227 | HgPath::new(b"meh"), | ||
|
r42998 | EntryState::Normal, | ||
DirstateEntry { | ||||
state: EntryState::Normal, | ||||
mode: 1337, | ||||
mtime: 1337, | ||||
size: 1337, | ||||
}, | ||||
|
r44342 | ) | ||
.unwrap(); | ||||
|
r42998 | |||
assert_eq!(1, map.len()); | ||||
|
r44842 | assert_eq!(0, map.get_non_normal_other_parent_entries().0.len()); | ||
assert_eq!(0, map.get_non_normal_other_parent_entries().1.len()); | ||||
|
r42998 | } | ||
#[test] | ||||
fn test_non_normal_other_parent_entries() { | ||||
|
r44775 | let mut map: DirstateMap = [ | ||
|
r42998 | (b"f1", (EntryState::Removed, 1337, 1337, 1337)), | ||
(b"f2", (EntryState::Normal, 1337, 1337, -1)), | ||||
(b"f3", (EntryState::Normal, 1337, 1337, 1337)), | ||||
(b"f4", (EntryState::Normal, 1337, -2, 1337)), | ||||
(b"f5", (EntryState::Added, 1337, 1337, 1337)), | ||||
(b"f6", (EntryState::Added, 1337, 1337, -1)), | ||||
(b"f7", (EntryState::Merged, 1337, 1337, -1)), | ||||
(b"f8", (EntryState::Merged, 1337, 1337, 1337)), | ||||
(b"f9", (EntryState::Merged, 1337, -2, 1337)), | ||||
(b"fa", (EntryState::Added, 1337, -2, 1337)), | ||||
(b"fb", (EntryState::Removed, 1337, -2, 1337)), | ||||
] | ||||
.iter() | ||||
.map(|(fname, (state, mode, size, mtime))| { | ||||
( | ||||
|
r43227 | HgPathBuf::from_bytes(fname.as_ref()), | ||
|
r42998 | DirstateEntry { | ||
state: *state, | ||||
mode: *mode, | ||||
size: *size, | ||||
mtime: *mtime, | ||||
}, | ||||
) | ||||
}) | ||||
.collect(); | ||||
|
r44842 | let mut non_normal = [ | ||
|
r42998 | b"f1", b"f2", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa", b"fb", | ||
] | ||||
.iter() | ||||
|
r43227 | .map(|x| HgPathBuf::from_bytes(x.as_ref())) | ||
|
r42998 | .collect(); | ||
let mut other_parent = HashSet::new(); | ||||
|
r43227 | other_parent.insert(HgPathBuf::from_bytes(b"f4")); | ||
|
r44775 | let entries = map.get_non_normal_other_parent_entries(); | ||
|
r42998 | |||
assert_eq!( | ||||
|
r44842 | (&mut non_normal, &mut other_parent), | ||
(entries.0, entries.1) | ||||
|
r42998 | ); | ||
} | ||||
} | ||||