dirstate_map.rs
549 lines
| 16.4 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. | ||||
|
r47169 | use crate::errors::HgError; | ||
|
r47337 | use crate::revlog::node::NULL_NODE; | ||
|
r42998 | 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}, | ||||
}, | ||||
|
r46162 | CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError, | ||
|
r47169 | DirstateParents, FastHashMap, StateMap, | ||
|
r42998 | }; | ||
|
r46135 | use micro_timer::timed; | ||
|
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 | |||
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 { | ||
|
r46162 | fn from_iter<I: IntoIterator<Item = (HgPathBuf, DirstateEntry)>>( | ||
iter: I, | ||||
) -> Self { | ||||
|
r42998 | Self { | ||
state_map: iter.into_iter().collect(), | ||||
..Self::default() | ||||
} | ||||
} | ||||
} | ||||
impl DirstateMap { | ||||
pub fn new() -> Self { | ||||
Self::default() | ||||
} | ||||
pub fn clear(&mut self) { | ||||
|
r46185 | self.state_map = StateMap::default(); | ||
|
r42998 | 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 { | ||
|
r47337 | p1: NULL_NODE, | ||
p2: NULL_NODE, | ||||
|
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> { | ||
|
r46162 | if old_state == EntryState::Unknown || old_state == EntryState::Removed | ||
{ | ||||
|
r42998 | 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> { | ||||
|
r46162 | if old_state != EntryState::Unknown && old_state != EntryState::Removed | ||
{ | ||||
|
r42998 | 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) | ||||
} | ||||
|
r46162 | pub fn clear_ambiguous_times( | ||
&mut self, | ||||
filenames: Vec<HgPathBuf>, | ||||
now: i32, | ||||
) { | ||||
|
r42998 | for filename in filenames { | ||
let mut changed = false; | ||||
|
r46185 | if let Some(entry) = self.state_map.get_mut(&filename) { | ||
if entry.state == EntryState::Normal && entry.mtime == now { | ||||
changed = true; | ||||
*entry = DirstateEntry { | ||||
mtime: MTIME_UNSET, | ||||
..*entry | ||||
}; | ||||
} | ||||
} | ||||
|
r42998 | if changed { | ||
|
r44775 | self.get_non_normal_other_parent_entries() | ||
.0 | ||||
.insert(filename.to_owned()); | ||||
|
r42998 | } | ||
} | ||||
} | ||||
|
r46162 | pub fn non_normal_entries_remove( | ||
&mut self, | ||||
key: impl AsRef<HgPath>, | ||||
) -> bool { | ||||
|
r44775 | self.get_non_normal_other_parent_entries() | ||
.0 | ||||
.remove(key.as_ref()) | ||||
} | ||||
|
r46162 | pub fn non_normal_entries_union( | ||
&mut self, | ||||
other: HashSet<HgPathBuf>, | ||||
) -> Vec<HgPathBuf> { | ||||
|
r44775 | self.get_non_normal_other_parent_entries() | ||
.0 | ||||
.union(&other) | ||||
|
r45500 | .map(ToOwned::to_owned) | ||
|
r44775 | .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 | } | ||
|
r44903 | /// Useful to get immutable references to those sets in contexts where | ||
/// you only have an immutable reference to the `DirstateMap`, like when | ||||
/// sharing references with Python. | ||||
/// | ||||
/// TODO, get rid of this along with the other "setter/getter" stuff when | ||||
/// a nice typestate plan is defined. | ||||
/// | ||||
/// # Panics | ||||
/// | ||||
/// Will panic if either set is `None`. | ||||
pub fn get_non_normal_other_parent_entries_panic( | ||||
&self, | ||||
) -> (&HashSet<HgPathBuf>, &HashSet<HgPathBuf>) { | ||||
( | ||||
self.non_normal_set.as_ref().unwrap(), | ||||
self.other_parent_set.as_ref().unwrap(), | ||||
) | ||||
} | ||||
|
r46185 | #[cfg(not(feature = "dirstate-tree"))] | ||
|
r44775 | pub fn set_non_normal_other_parent_entries(&mut self, force: bool) { | ||
|
r46162 | if !force | ||
&& self.non_normal_set.is_some() | ||||
&& self.other_parent_set.is_some() | ||||
{ | ||||
|
r44775 | 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()); | ||||
} | ||||
|
r46162 | 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 | } | ||
|
r46185 | #[cfg(feature = "dirstate-tree")] | ||
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; | ||||
} | ||||
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()); | ||||
} | ||||
if state == EntryState::Normal && size == SIZE_FROM_OTHER_PARENT { | ||||
other_parent.insert(filename.to_owned()); | ||||
} | ||||
} | ||||
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() { | ||
|
r46162 | self.all_dirs = | ||
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 | } | ||
|
r46162 | pub fn has_tracked_dir( | ||
&mut self, | ||||
directory: &HgPath, | ||||
) -> Result<bool, DirstateMapError> { | ||||
|
r44315 | self.set_dirs()?; | ||
Ok(self.dirs.as_ref().unwrap().contains(directory)) | ||||
|
r42998 | } | ||
|
r46162 | pub fn has_dir( | ||
&mut self, | ||||
directory: &HgPath, | ||||
) -> Result<bool, DirstateMapError> { | ||||
|
r44315 | self.set_all_dirs()?; | ||
Ok(self.all_dirs.as_ref().unwrap().contains(directory)) | ||||
|
r42998 | } | ||
|
r46162 | pub fn parents( | ||
&mut self, | ||||
file_contents: &[u8], | ||||
) -> 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 { | ||||
|
r47337 | p1: NULL_NODE, | ||
p2: NULL_NODE, | ||||
|
r42998 | }; | ||
} else { | ||||
|
r47169 | return Err( | ||
HgError::corrupted("Dirstate appears to be damaged").into() | ||||
); | ||||
|
r42998 | } | ||
|
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; | ||||
} | ||||
|
r46135 | #[timed] | ||
|
r47336 | pub fn read<'a>( | ||
|
r46162 | &mut self, | ||
|
r47336 | file_contents: &'a [u8], | ||
) -> Result<Option<&'a DirstateParents>, DirstateError> { | ||||
|
r42998 | if file_contents.is_empty() { | ||
return Ok(None); | ||||
} | ||||
|
r45916 | let (parents, entries, copies) = parse_dirstate(file_contents)?; | ||
self.state_map.extend( | ||||
entries | ||||
.into_iter() | ||||
.map(|(path, entry)| (path.to_owned(), entry)), | ||||
); | ||||
self.copy_map.extend( | ||||
copies | ||||
.into_iter() | ||||
.map(|(path, copy)| (path.to_owned(), copy.to_owned())), | ||||
); | ||||
|
r42998 | |||
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> { | ||||
|
r46162 | let packed = | ||
pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?; | ||||
|
r42998 | |||
self.dirty_parents = false; | ||||
|
r44775 | self.set_non_normal_other_parent_entries(true); | ||
|
r42998 | Ok(packed) | ||
} | ||||
|
r46185 | #[cfg(not(feature = "dirstate-tree"))] | ||
|
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(); | ||
|
r46185 | |||
for (filename, DirstateEntry { state, .. }) in self.state_map.iter() { | ||||
|
r46844 | if *state != EntryState::Removed { | ||
|
r46162 | new_file_fold_map | ||
|
r46185 | .insert(normalize_case(&filename), filename.to_owned()); | ||
} | ||||
} | ||||
self.file_fold_map = Some(new_file_fold_map); | ||||
self.file_fold_map.as_ref().unwrap() | ||||
} | ||||
#[cfg(feature = "dirstate-tree")] | ||||
pub fn build_file_fold_map(&mut self) -> &FileFoldMap { | ||||
if let Some(ref file_fold_map) = self.file_fold_map { | ||||
return file_fold_map; | ||||
} | ||||
let mut new_file_fold_map = FileFoldMap::default(); | ||||
for (filename, DirstateEntry { state, .. }) in self.state_map.iter() { | ||||
|
r46844 | if state != EntryState::Removed { | ||
|
r46185 | 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 | |||
|
r46162 | assert_eq!( | ||
(&mut non_normal, &mut other_parent), | ||||
(entries.0, entries.1) | ||||
); | ||||
|
r42998 | } | ||
} | ||||