( )⚙ D10547 dirstate-tree: Add the new `status()` algorithm

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10547

dirstate-tree: Add the new `status()` algorithm
ClosedPublic

Authored by SimonSapin on May 3 2021, 6:25 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGbe579775c2d9: dirstate-tree: Add the new `status()` algorithm
rHG0e89f4b81c90: dirstate-tree: Add the new `status()` algorithm
Summary

With the dirstate organized in a tree that mirrors the structure of the
filesystem tree, we can traverse both trees at the same time in order to
compare them. This is hopefully more efficient that building multiple
big hashmaps for all of the repository’s contents.

Diff Detail

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

Event Timeline

SimonSapin created this revision.May 3 2021, 6:25 AM
Alphare added a subscriber: Alphare.May 3 2021, 10:37 AM
Alphare added inline comments.
rust/hg-core/src/dirstate_tree/status.rs
209

See https://bz.mercurial-scm.org/show_bug.cgi?id=6456 about adding the edge case for symlinks on an encrypted ext4.

243

I might expect the compiler to be clever enough to optimize the if out of the directory case, but maybe not?

359

Shouldn't there be a call to a sort_*() method somewhere in there? I know it's sorted after the call, but either the docstring or the code is wrong.

SimonSapin marked 2 inline comments as done.May 6 2021, 5:47 AM
SimonSapin added inline comments.
rust/hg-core/src/dirstate_tree/status.rs
243

Do you mean to avoid calling matches when dirstate_node_state is None? It’s possible if matches the optimizer manages to prove matches side-effect-free, but I wouldn’t count on it. I’ll change the code.

359

Good catch. The sort was initially here. I moved it to a caller (because the other caller doesn’t need sorting) and failed to update the doc-comment.

baymax updated this revision to Diff 27623.May 6 2021, 12:03 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Alphare accepted this revision.May 6 2021, 12:09 PM
This revision is now accepted and ready to land.May 6 2021, 12:09 PM
SimonSapin marked an inline comment as done.May 6 2021, 12:54 PM
SimonSapin added a commit: rHG0e89f4b81c90: dirstate-tree: Add the new `status()` algorithm.
Closed by commit rHG0e89f4b81c90: dirstate-tree: Add the new `status()` algorithm (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 27322

rust/Cargo.lock

"bytes-cast", "bytes-cast",
"clap", "clap",
"crossbeam-channel 0.4.4", "crossbeam-channel 0.4.4",
"derive_more", "derive_more",
"flate2", "flate2",
"format-bytes", "format-bytes",
"home", "home",
"im-rc", "im-rc",
"itertools",
"lazy_static", "lazy_static",
"log", "log",
"memmap", "memmap",
"micro-timer", "micro-timer",
"pretty_assertions", "pretty_assertions",
"rand 0.7.3", "rand 0.7.3",
"rand_distr", "rand_distr",
"rand_pcg", "rand_pcg",

rust/hg-core/Cargo.toml

[package] [package]
name = "hg-core" name = "hg-core"
version = "0.1.0" version = "0.1.0"
authors = ["Georges Racinet <gracinet@anybox.fr>"] authors = ["Georges Racinet <gracinet@anybox.fr>"]
description = "Mercurial pure Rust core library, with no assumption on Python bindings (FFI)" description = "Mercurial pure Rust core library, with no assumption on Python bindings (FFI)"
edition = "2018" edition = "2018"
[lib] [lib]
name = "hg" name = "hg"
[dependencies] [dependencies]
bytes-cast = "0.2" bytes-cast = "0.2"
byteorder = "1.3.4" byteorder = "1.3.4"
derive_more = "0.99" derive_more = "0.99"
home = "0.5" home = "0.5"
im-rc = "15.0.*" im-rc = "15.0.*"
itertools = "0.9"
lazy_static = "1.4.0" lazy_static = "1.4.0"
rand = "0.7.3" rand = "0.7.3"
rand_pcg = "0.2.1" rand_pcg = "0.2.1"
rand_distr = "0.2.2" rand_distr = "0.2.2"
rayon = "1.3.0" rayon = "1.3.0"
regex = "1.3.9" regex = "1.3.9"
twox-hash = "1.5.0" twox-hash = "1.5.0"
same-file = "1.0.6" same-file = "1.0.6"

rust/hg-core/src/dirstate.rs

impl DirstateEntry { impl DirstateEntry {
pub fn is_non_normal(&self) -> bool { pub fn is_non_normal(&self) -> bool {
self.state != EntryState::Normal || self.mtime == MTIME_UNSET self.state != EntryState::Normal || self.mtime == MTIME_UNSET
} }
pub fn is_from_other_parent(&self) -> bool { pub fn is_from_other_parent(&self) -> bool {
self.state == EntryState::Normal && self.size == SIZE_FROM_OTHER_PARENT self.state == EntryState::Normal && self.size == SIZE_FROM_OTHER_PARENT
} }
// TODO: other platforms
#[cfg(unix)]
pub fn mode_changed(
&self,
filesystem_metadata: &std::fs::Metadata,
) -> bool {
use std::os::unix::fs::MetadataExt;
const EXEC_BIT_MASK: u32 = 0o100;
let dirstate_exec_bit = (self.mode as u32) & EXEC_BIT_MASK;
let fs_exec_bit = filesystem_metadata.mode() & EXEC_BIT_MASK;
dirstate_exec_bit != fs_exec_bit
}
} }
#[derive(BytesCast)] #[derive(BytesCast)]
#[repr(C)] #[repr(C)]
struct RawEntry { struct RawEntry {
state: u8, state: u8,
mode: unaligned::I32Be, mode: unaligned::I32Be,
size: unaligned::I32Be, size: unaligned::I32Be,

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

/// True if the directory used to be a file in the dmap so we can say /// True if the directory used to be a file in the dmap so we can say
/// that it's been removed. /// that it's been removed.
was_file: bool, was_file: bool,
}, },
} }
type IoResult<T> = std::io::Result<T>; type IoResult<T> = std::io::Result<T>;
/// `Box<dyn Trait>` is syntactic sugar for `Box<dyn Trait, 'static>`, so add /// `Box<dyn Trait>` is syntactic sugar for `Box<dyn Trait + 'static>`, so add
/// an explicit lifetime here to not fight `'static` bounds "out of nowhere". /// an explicit lifetime here to not fight `'static` bounds "out of nowhere".
pub type IgnoreFnType<'a> = pub type IgnoreFnType<'a> =
Box<dyn for<'r> Fn(&'r HgPath) -> bool + Sync + 'a>; Box<dyn for<'r> Fn(&'r HgPath) -> bool + Sync + 'a>;
/// We have a good mix of owned (from directory traversal) and borrowed (from /// We have a good mix of owned (from directory traversal) and borrowed (from
/// the dirstate/explicit) paths, this comes up a lot. /// the dirstate/explicit) paths, this comes up a lot.
pub type HgPathCow<'a> = Cow<'a, HgPath>; pub type HgPathCow<'a> = Cow<'a, HgPath>;
pub list_clean: bool, pub list_clean: bool,
pub list_unknown: bool, pub list_unknown: bool,
pub list_ignored: bool, pub list_ignored: bool,
/// Whether to collect traversed dirs for applying a callback later. /// Whether to collect traversed dirs for applying a callback later.
/// Used by `hg purge` for example. /// Used by `hg purge` for example.
pub collect_traversed_dirs: bool, pub collect_traversed_dirs: bool,
} }
#[derive(Debug)] #[derive(Debug, Default)]
pub struct DirstateStatus<'a> { pub struct DirstateStatus<'a> {
/// Tracked files whose contents have changed since the parent revision /// Tracked files whose contents have changed since the parent revision
pub modified: Vec<HgPathCow<'a>>, pub modified: Vec<HgPathCow<'a>>,
/// Newly-tracked files that were not present in the parent /// Newly-tracked files that were not present in the parent
pub added: Vec<HgPathCow<'a>>, pub added: Vec<HgPathCow<'a>>,
/// Previously-tracked files that have been (re)moved with an hg command /// Previously-tracked files that have been (re)moved with an hg command

rust/hg-core/src/dirstate_tree/dirstate_map.rs

use crate::PatternFileWarning; use crate::PatternFileWarning;
use crate::StateMapIter; use crate::StateMapIter;
use crate::StatusError; use crate::StatusError;
use crate::StatusOptions; use crate::StatusOptions;
pub struct DirstateMap { pub struct DirstateMap {
parents: Option<DirstateParents>, parents: Option<DirstateParents>,
dirty_parents: bool, dirty_parents: bool,
root: ChildNodes, pub(super) root: ChildNodes,
/// Number of nodes anywhere in the tree that have `.entry.is_some()`. /// Number of nodes anywhere in the tree that have `.entry.is_some()`.
nodes_with_entry_count: usize, nodes_with_entry_count: usize,
/// Number of nodes anywhere in the tree that have /// Number of nodes anywhere in the tree that have
/// `.copy_source.is_some()`. /// `.copy_source.is_some()`.
nodes_with_copy_source_count: usize, nodes_with_copy_source_count: usize,
} }
/// Using a plain `HgPathBuf` of the full path from the repository root as a /// Using a plain `HgPathBuf` of the full path from the repository root as a
/// map key would also work: all paths in a given map have the same parent /// map key would also work: all paths in a given map have the same parent
/// path, so comparing full paths gives the same result as comparing base /// path, so comparing full paths gives the same result as comparing base
/// names. However `BTreeMap` would waste time always re-comparing the same /// names. However `BTreeMap` would waste time always re-comparing the same
/// string prefix. /// string prefix.
type ChildNodes = BTreeMap<WithBasename<HgPathBuf>, Node>; pub(super) type ChildNodes = BTreeMap<WithBasename<HgPathBuf>, Node>;
/// Represents a file or a directory /// Represents a file or a directory
#[derive(Default)] #[derive(Default)]
struct Node { pub(super) struct Node {
/// `None` for directories /// `None` for directories
entry: Option<DirstateEntry>, pub(super) entry: Option<DirstateEntry>,
copy_source: Option<HgPathBuf>, pub(super) copy_source: Option<HgPathBuf>,
children: ChildNodes, pub(super) children: ChildNodes,
/// How many (non-inclusive) descendants of this node are tracked files /// How many (non-inclusive) descendants of this node are tracked files
tracked_descendants_count: usize, tracked_descendants_count: usize,
} }
impl Node { impl Node {
/// Whether this node has a `DirstateEntry` with `.state.is_tracked()` /// Whether this node has a `DirstateEntry` with `.state.is_tracked()`
fn is_tracked_file(&self) -> bool { fn is_tracked_file(&self) -> bool {
if let Some(entry) = &self.entry { if let Some(entry) = &self.entry {
entry.state.is_tracked() entry.state.is_tracked()
} else { } else {
false false
} }
} }
pub(super) fn state(&self) -> Option<EntryState> {
self.entry.as_ref().map(|entry| entry.state)
}
} }
/// `(full_path, entry, copy_source)` /// `(full_path, entry, copy_source)`
type NodeDataMut<'a> = ( type NodeDataMut<'a> = (
&'a WithBasename<HgPathBuf>, &'a WithBasename<HgPathBuf>,
&'a mut Option<DirstateEntry>, &'a mut Option<DirstateEntry>,
&'a mut Option<HgPathBuf>, &'a mut Option<HgPathBuf>,
); );

rust/hg-core/src/dirstate_tree/status.rs

use crate::dirstate::status::IgnoreFnType;
use crate::dirstate_tree::dirstate_map::ChildNodes;
use crate::dirstate_tree::dirstate_map::DirstateMap; use crate::dirstate_tree::dirstate_map::DirstateMap;
use crate::dirstate_tree::dirstate_map::Node;
use crate::matchers::get_ignore_function;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::utils::files::get_bytes_from_os_string;
use crate::utils::hg_path::HgPath;
use crate::DirstateStatus; use crate::DirstateStatus;
use crate::EntryState;
use crate::HgPathBuf;
use crate::PatternFileWarning; use crate::PatternFileWarning;
use crate::StatusError; use crate::StatusError;
use crate::StatusOptions; use crate::StatusOptions;
use std::borrow::Cow;
use std::io;
use std::path::Path;
use std::path::PathBuf; use std::path::PathBuf;
pub fn status<'a>( /// Returns the status of the working directory compared to its parent
_dmap: &'a mut DirstateMap, /// changeset.
_matcher: &'a (dyn Matcher + Sync), ///
_root_dir: PathBuf, /// This algorithm is based on traversing the filesystem tree (`fs` in function
_ignore_files: Vec<PathBuf>, /// and variable names) and dirstate tree at the same time. The core of this
_options: StatusOptions, /// traversal is the recursive `traverse_fs_directory_and_dirstate` function
) -> Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError> { /// and its use of `itertools::merge_join_by`. When reaching a path that only
todo!() /// exists in one of the two trees, depending on information requested by
/// `options` we may need to traverse the remaining subtree.
pub fn status<'tree>(
dmap: &'tree mut DirstateMap,
matcher: &(dyn Matcher + Sync),
root_dir: PathBuf,
ignore_files: Vec<PathBuf>,
options: StatusOptions,
) -> Result<(DirstateStatus<'tree>, Vec<PatternFileWarning>), StatusError> {
let (ignore_fn, warnings): (IgnoreFnType, _) =
if options.list_ignored || options.list_unknown {
get_ignore_function(ignore_files, &root_dir)?
} else {
(Box::new(|&_| true), vec![])
};
let mut common = StatusCommon {
options,
matcher,
ignore_fn,
outcome: DirstateStatus::default(),
};
let is_at_repo_root = true;
let hg_path = HgPath::new("");
let has_ignored_ancestor = false;
common.traverse_fs_directory_and_dirstate(
has_ignored_ancestor,
&mut dmap.root,
hg_path,
&root_dir,
is_at_repo_root,
);
Ok((common.outcome, warnings))
}
/// Bag of random things needed by various parts of the algorithm. Reduces the
/// number of parameters passed to functions.
struct StatusCommon<'tree, 'a> {
options: StatusOptions,
matcher: &'a (dyn Matcher + Sync),
ignore_fn: IgnoreFnType<'a>,
outcome: DirstateStatus<'tree>,
}
impl<'tree, 'a> StatusCommon<'tree, 'a> {
fn traverse_fs_directory_and_dirstate(
&mut self,
has_ignored_ancestor: bool,
dirstate_nodes: &'tree mut ChildNodes,
directory_hg_path: &HgPath,
fs_path: &Path,
is_at_repo_root: bool,
) {
// TODO: handle I/O errors
let mut fs_entries =
DirEntry::read_dir(fs_path, is_at_repo_root).unwrap();
// `sort_unstable_by_key` doesn’t allow keys borrowing from the value:
// https://github.com/rust-lang/rust/issues/34162
fs_entries.sort_unstable_by(|e1, e2| e1.base_name.cmp(&e2.base_name));
// `merge_join_by` requires both its input iterators to be sorted.
// * `BTreeMap` iterates according to keys’ ordering by definition
// * `DirEntry::read_dir` sorts explicitly for this reason
for pair in itertools::merge_join_by(
dirstate_nodes,
&fs_entries,
|(full_path, _node), fs_entry| {
full_path.base_name().cmp(&fs_entry.base_name)
},
) {
use itertools::EitherOrBoth::*;
match pair {
Both((hg_path, dirstate_node), fs_entry) => {
self.traverse_fs_and_dirstate(
fs_entry,
hg_path.full_path(),
dirstate_node,
has_ignored_ancestor,
);
}
Left((hg_path, dirstate_node)) => self.traverse_dirstate_only(
hg_path.full_path(),
dirstate_node,
),
Right(fs_entry) => self.traverse_fs_only(
has_ignored_ancestor,
directory_hg_path,
fs_entry,
),
}
}
}
fn traverse_fs_and_dirstate(
&mut self,
fs_entry: &DirEntry,
hg_path: &'tree HgPath,
dirstate_node: &'tree mut Node,
has_ignored_ancestor: bool,
) {
if fs_entry.metadata.is_dir() {
if self.options.collect_traversed_dirs {
self.outcome.traversed.push(hg_path.into())
}
// If we previously had a file here, it was removed (with
// `hg rm` or similar) or deleted before it could be
// replaced by a directory.
self.mark_removed_or_deleted_if_file(
hg_path,
dirstate_node.state(),
);
let is_ignored = has_ignored_ancestor || (self.ignore_fn)(hg_path);
let is_at_repo_root = false;
self.traverse_fs_directory_and_dirstate(
is_ignored,
&mut dirstate_node.children,
hg_path,
&fs_entry.full_path,
is_at_repo_root,
);
} else {
if self.matcher.matches(hg_path) {
let full_path = Cow::from(hg_path);
if let Some(entry) = &dirstate_node.entry {
match entry.state {
EntryState::Added => {
self.outcome.added.push(full_path)
}
EntryState::Removed => {
self.outcome.removed.push(full_path)
}
EntryState::Merged => {
self.outcome.modified.push(full_path)
}
EntryState::Normal => {
self.handle_normal_file(
full_path,
dirstate_node,
entry,
fs_entry,
);
}
// This variant is not used in DirstateMap
// nodes
EntryState::Unknown => unreachable!(),
}
} else {
// `node.entry.is_none()` indicates a "directory"
// node, but the filesystem has a file
self.mark_unknown_or_ignored(
has_ignored_ancestor,
full_path,
)
}
}
for (child_hg_path, child_node) in &mut dirstate_node.children {
self.traverse_dirstate_only(
child_hg_path.full_path(),
child_node,
)
}
}
}
/// A file with `EntryState::Normal` in the dirstate was found in the
/// filesystem
fn handle_normal_file(
&mut self,
full_path: Cow<'tree, HgPath>,
dirstate_node: &Node,
entry: &crate::DirstateEntry,
fs_entry: &DirEntry,
) {
if dirstate_node.copy_source.is_some()
|| entry.is_from_other_parent()
|| (entry.size >= 0
&& (entry.size as u32 != fs_entry.metadata.len() as u32
|| (self.options.check_exec
&& entry.mode_changed(&fs_entry.metadata))))
{
self.outcome.modified.push(full_path)
AlphareUnsubmitted
Done

See https://bz.mercurial-scm.org/show_bug.cgi?id=6456 about adding the edge case for symlinks on an encrypted ext4.

Alphare: See https://bz.mercurial-scm.org/show_bug.cgi?id=6456 about adding the edge case for symlinks…
} else {
let mtime = mtime_seconds(&fs_entry.metadata);
if mtime as i32 != entry.mtime
|| mtime == self.options.last_normal_time
{
self.outcome.unsure.push(full_path)
} else if self.options.list_clean {
self.outcome.clean.push(full_path)
}
}
}
/// A node in the dirstate tree has no corresponding filesystem entry
fn traverse_dirstate_only(
&mut self,
hg_path: &'tree HgPath,
dirstate_node: &'tree mut Node,
) {
self.mark_removed_or_deleted_if_file(hg_path, dirstate_node.state());
for (child_hg_path, child_node) in &mut dirstate_node.children {
self.traverse_dirstate_only(child_hg_path.full_path(), child_node)
}
}
/// A node in the dirstate tree has no corresponding *file* on the
/// filesystem
///
/// Does nothing on a "directory" node
fn mark_removed_or_deleted_if_file(
&mut self,
hg_path: &'tree HgPath,
dirstate_node_state: Option<EntryState>,
) {
if self.matcher.matches(hg_path) {
AlphareUnsubmitted
Not Done

I might expect the compiler to be clever enough to optimize the if out of the directory case, but maybe not?

Alphare: I might expect the compiler to be clever enough to optimize the if out of the directory case…
SimonSapinAuthorUnsubmitted
Done

Do you mean to avoid calling matches when dirstate_node_state is None? It’s possible if matches the optimizer manages to prove matches side-effect-free, but I wouldn’t count on it. I’ll change the code.

SimonSapin: Do you mean to avoid calling `matches` when `dirstate_node_state` is `None`? It’s possible if…
match dirstate_node_state {
Some(EntryState::Removed) => {
self.outcome.removed.push(hg_path.into())
}
Some(_) => self.outcome.deleted.push(hg_path.into()),
None => {}
}
}
}
/// Something in the filesystem has no corresponding dirstate node
fn traverse_fs_only(
&mut self,
has_ignored_ancestor: bool,
directory_hg_path: &HgPath,
fs_entry: &DirEntry,
) {
let hg_path = directory_hg_path.join(&fs_entry.base_name);
if fs_entry.metadata.is_dir() {
let is_ignored =
has_ignored_ancestor || (self.ignore_fn)(&hg_path);
let traverse_children = if is_ignored {
// Descendants of an ignored directory are all ignored
self.options.list_ignored
} else {
// Descendants of an unknown directory may be either unknown or
// ignored
self.options.list_unknown || self.options.list_ignored
};
if traverse_children {
let is_at_repo_root = false;
// TODO: handle I/O errors
let children_fs_entries =
DirEntry::read_dir(&fs_entry.full_path, is_at_repo_root)
.unwrap();
for child_fs_entry in children_fs_entries {
self.traverse_fs_only(
is_ignored,
&hg_path,
&child_fs_entry,
)
}
}
if self.options.collect_traversed_dirs {
self.outcome.traversed.push(hg_path.into())
}
} else if self.matcher.matches(&hg_path) {
self.mark_unknown_or_ignored(has_ignored_ancestor, hg_path.into())
}
}
fn mark_unknown_or_ignored(
&mut self,
has_ignored_ancestor: bool,
hg_path: Cow<'tree, HgPath>,
) {
let is_ignored = has_ignored_ancestor || (self.ignore_fn)(&hg_path);
if is_ignored {
if self.options.list_ignored {
self.outcome.ignored.push(hg_path)
}
} else {
if self.options.list_unknown {
self.outcome.unknown.push(hg_path)
}
}
}
}
#[cfg(unix)] // TODO
fn mtime_seconds(metadata: &std::fs::Metadata) -> i64 {
// Going through `Metadata::modified()` would be portable, but would take
// care to construct a `SystemTime` value with sub-second precision just
// for us to throw that away here.
use std::os::unix::fs::MetadataExt;
metadata.mtime()
}
struct DirEntry {
base_name: HgPathBuf,
full_path: PathBuf,
metadata: std::fs::Metadata,
}
impl DirEntry {
/// Returns sorted names and metadata of entries in the given directory.
///
/// If a `.hg` sub-directory is encountered:
///
/// * At the repository root, ignore that sub-directory
/// * Elsewhere, we’re listing the content of a sub-repo. Return an empty
/// list instead.
fn read_dir(path: &Path, is_at_repo_root: bool) -> io::Result<Vec<Self>> {
let mut results = Vec::new();
for entry in path.read_dir()? {
let entry = entry?;
let metadata = entry.metadata()?;
let name = get_bytes_from_os_string(entry.file_name());
// FIXME don't do this when cached
if name == b".hg" {
if is_at_repo_root {
// Skip the repo’s own .hg (might be a symlink)
continue;
} else if metadata.is_dir() {
// A .hg sub-directory at another location means a subrepo,
// skip it entirely.
return Ok(Vec::new());
}
}
results.push(DirEntry {
base_name: name.into(),
full_path: entry.path(),
metadata,
})
}
Ok(results)
AlphareUnsubmitted
Done

Shouldn't there be a call to a sort_*() method somewhere in there? I know it's sorted after the call, but either the docstring or the code is wrong.

Alphare: Shouldn't there be a call to a `sort_*()` method somewhere in there? I know it's sorted after…
SimonSapinAuthorUnsubmitted
Done

Good catch. The sort was initially here. I moved it to a caller (because the other caller doesn’t need sorting) and failed to update the doc-comment.

SimonSapin: Good catch. The sort was initially here. I moved it to a caller (because the other caller…
}
} }

rust/hg-core/src/utils/files.rs

use crate::utils::{ use crate::utils::{
hg_path::{path_to_hg_path_buf, HgPath, HgPathBuf, HgPathError}, hg_path::{path_to_hg_path_buf, HgPath, HgPathBuf, HgPathError},
path_auditor::PathAuditor, path_auditor::PathAuditor,
replace_slice, replace_slice,
}; };
use lazy_static::lazy_static; use lazy_static::lazy_static;
use same_file::is_same_file; use same_file::is_same_file;
use std::borrow::{Cow, ToOwned}; use std::borrow::{Cow, ToOwned};
use std::ffi::OsStr; use std::ffi::{OsStr, OsString};
use std::fs::Metadata; use std::fs::Metadata;
use std::iter::FusedIterator; use std::iter::FusedIterator;
use std::ops::Deref; use std::ops::Deref;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
pub fn get_os_str_from_bytes(bytes: &[u8]) -> &OsStr { pub fn get_os_str_from_bytes(bytes: &[u8]) -> &OsStr {
let os_str; let os_str;
#[cfg(unix)] #[cfg(unix)]
} }
#[cfg(unix)] #[cfg(unix)]
pub fn get_bytes_from_os_str(str: impl AsRef<OsStr>) -> Vec<u8> { pub fn get_bytes_from_os_str(str: impl AsRef<OsStr>) -> Vec<u8> {
use std::os::unix::ffi::OsStrExt; use std::os::unix::ffi::OsStrExt;
str.as_ref().as_bytes().to_vec() str.as_ref().as_bytes().to_vec()
} }
#[cfg(unix)]
pub fn get_bytes_from_os_string(str: OsString) -> Vec<u8> {
use std::os::unix::ffi::OsStringExt;
str.into_vec()
}
/// An iterator over repository path yielding itself and its ancestors. /// An iterator over repository path yielding itself and its ancestors.
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]
pub struct Ancestors<'a> { pub struct Ancestors<'a> {
next: Option<&'a HgPath>, next: Option<&'a HgPath>,
} }
impl<'a> Iterator for Ancestors<'a> { impl<'a> Iterator for Ancestors<'a> {
type Item = &'a HgPath; type Item = &'a HgPath;

rust/hg-core/src/utils/hg_path.rs

// hg_path.rs // hg_path.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.
use std::borrow::Borrow; use std::borrow::Borrow;
use std::borrow::Cow;
use std::convert::TryFrom; use std::convert::TryFrom;
use std::ffi::{OsStr, OsString}; use std::ffi::{OsStr, OsString};
use std::fmt; use std::fmt;
use std::ops::Deref; use std::ops::Deref;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
#[derive(Debug, Eq, PartialEq)] #[derive(Debug, Eq, PartialEq)]
pub enum HgPathError { pub enum HgPathError {
impl TryFrom<PathBuf> for HgPathBuf { impl TryFrom<PathBuf> for HgPathBuf {
type Error = HgPathError; type Error = HgPathError;
fn try_from(path: PathBuf) -> Result<Self, Self::Error> { fn try_from(path: PathBuf) -> Result<Self, Self::Error> {
path_to_hg_path_buf(path) path_to_hg_path_buf(path)
} }
} }
impl From<HgPathBuf> for Cow<'_, HgPath> {
fn from(path: HgPathBuf) -> Self {
Cow::Owned(path)
}
}
impl<'a> From<&'a HgPath> for Cow<'a, HgPath> {
fn from(path: &'a HgPath) -> Self {
Cow::Borrowed(path)
}
}
impl<'a> From<&'a HgPathBuf> for Cow<'a, HgPath> {
fn from(path: &'a HgPathBuf) -> Self {
Cow::Borrowed(&**path)
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use pretty_assertions::assert_eq; use pretty_assertions::assert_eq;
#[test] #[test]
fn test_path_states() { fn test_path_states() {
assert_eq!( assert_eq!(