( )⚙ D8087 rust-status: rename `StatusResult` to `DirstateStatus`

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8087

rust-status: rename `StatusResult` to `DirstateStatus`
ClosedPublic

Authored by Alphare on Feb 6 2020, 10:15 AM.

Details

Reviewers
kevincox
marmoute
Group Reviewers
hg-reviewers
Commits
rHGf13d19549efd: rust-status: rename `StatusResult` to `DirstateStatus`
Summary

"Result" has a special meaning in the Rust world, this should be clearer.

Diff Detail

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

Event Timeline

Alphare created this revision.Feb 6 2020, 10:15 AM
Alphare updated this revision to Diff 20045.Feb 10 2020, 11:30 AM
kevincox accepted this revision.Feb 10 2020, 1:16 PM
Alphare updated this revision to Diff 20156.Feb 11 2020, 5:55 AM
Alphare updated this revision to Diff 20185.Feb 13 2020, 12:37 PM
marmoute accepted this revision.Feb 14 2020, 6:52 AM
marmoute added a subscriber: marmoute.

Simple clear effective. Thanks for splitting

Alphare added a commit: rHGf13d19549efd: rust-status: rename `StatusResult` to `DirstateStatus`.Mar 11 2020, 12:23 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGf13d19549efd: rust-status: rename `StatusResult` to `DirstateStatus` (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 20185

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

// foo is not a directory // foo is not a directory
Ok((filename, dispatch_missing(entry.state))) Ok((filename, dispatch_missing(entry.state)))
} }
Err(e) => Err(e), Err(e) => Err(e),
} }
}) })
} }
pub struct StatusResult<'a> { pub struct DirstateStatus<'a> {
pub modified: Vec<&'a HgPath>, pub modified: Vec<&'a HgPath>,
pub added: Vec<&'a HgPath>, pub added: Vec<&'a HgPath>,
pub removed: Vec<&'a HgPath>, pub removed: Vec<&'a HgPath>,
pub deleted: Vec<&'a HgPath>, pub deleted: Vec<&'a HgPath>,
pub clean: Vec<&'a HgPath>, pub clean: Vec<&'a HgPath>,
/* TODO ignored /* TODO ignored
* TODO unknown */ * TODO unknown */
} }
fn build_response<'a>( fn build_response<'a>(
results: impl IntoIterator<Item = IoResult<(&'a HgPath, Dispatch)>>, results: impl IntoIterator<Item = IoResult<(&'a HgPath, Dispatch)>>,
) -> IoResult<(Vec<&'a HgPath>, StatusResult<'a>)> { ) -> IoResult<(Vec<&'a HgPath>, DirstateStatus<'a>)> {
let mut lookup = vec![]; let mut lookup = vec![];
let mut modified = vec![]; let mut modified = vec![];
let mut added = vec![]; let mut added = vec![];
let mut removed = vec![]; let mut removed = vec![];
let mut deleted = vec![]; let mut deleted = vec![];
let mut clean = vec![]; let mut clean = vec![];
for res in results.into_iter() { for res in results.into_iter() {
let (filename, dispatch) = res?; let (filename, dispatch) = res?;
match dispatch { match dispatch {
Dispatch::Unknown => {} Dispatch::Unknown => {}
Dispatch::Unsure => lookup.push(filename), Dispatch::Unsure => lookup.push(filename),
Dispatch::Modified => modified.push(filename), Dispatch::Modified => modified.push(filename),
Dispatch::Added => added.push(filename), Dispatch::Added => added.push(filename),
Dispatch::Removed => removed.push(filename), Dispatch::Removed => removed.push(filename),
Dispatch::Deleted => deleted.push(filename), Dispatch::Deleted => deleted.push(filename),
Dispatch::Clean => clean.push(filename), Dispatch::Clean => clean.push(filename),
} }
} }
Ok(( Ok((
lookup, lookup,
StatusResult { DirstateStatus {
modified, modified,
added, added,
removed, removed,
deleted, deleted,
clean, clean,
}, },
)) ))
} }
pub fn status<'a: 'c, 'b: 'c, 'c>( pub fn status<'a: 'c, 'b: 'c, 'c>(
dmap: &'a DirstateMap, dmap: &'a DirstateMap,
matcher: &'b impl Matcher, matcher: &'b impl Matcher,
root_dir: impl AsRef<Path> + Sync + Send + Copy, root_dir: impl AsRef<Path> + Sync + Send + Copy,
options: StatusOptions, options: StatusOptions,
) -> IoResult<(Vec<&'c HgPath>, StatusResult<'c>)> { ) -> IoResult<(Vec<&'c HgPath>, DirstateStatus<'c>)> {
let files = matcher.file_set(); let files = matcher.file_set();
let mut results = vec![]; let mut results = vec![];
if let Some(files) = files { if let Some(files) = files {
results.par_extend(walk_explicit(&files, &dmap, root_dir, options)); results.par_extend(walk_explicit(&files, &dmap, root_dir, options));
} }
if !matcher.is_exact() { if !matcher.is_exact() {
let stat_results = stat_dmap_entries(&dmap, root_dir, options); let stat_results = stat_dmap_entries(&dmap, root_dir, options);
results.par_extend(stat_results); results.par_extend(stat_results);
} }
build_response(results) build_response(results)
} }

rust/hg-core/src/lib.rs

// Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net> // Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net>
// and Mercurial contributors // and Mercurial contributors
// //
// 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.
mod ancestors; mod ancestors;
pub mod dagops; pub mod dagops;
pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors}; pub use ancestors::{AncestorsIterator, LazyAncestors, MissingAncestors};
mod dirstate; mod dirstate;
pub mod discovery; pub mod discovery;
pub mod testing; // unconditionally built, for use from integration tests pub mod testing; // unconditionally built, for use from integration tests
pub use dirstate::{ pub use dirstate::{
dirs_multiset::{DirsMultiset, DirsMultisetIter}, dirs_multiset::{DirsMultiset, DirsMultisetIter},
dirstate_map::DirstateMap, dirstate_map::DirstateMap,
parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE}, parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE},
status::{status, StatusOptions, StatusResult}, status::{status, DirstateStatus, StatusOptions},
CopyMap, CopyMapIter, DirstateEntry, DirstateParents, EntryState, CopyMap, CopyMapIter, DirstateEntry, DirstateParents, EntryState,
StateMap, StateMapIter, StateMap, StateMapIter,
}; };
mod filepatterns; mod filepatterns;
pub mod matchers; pub mod matchers;
pub mod revlog; pub mod revlog;
pub use revlog::*; pub use revlog::*;
#[cfg(feature = "with-re2")] #[cfg(feature = "with-re2")]

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

ObjectProtocol, PyBytes, PyErr, PyList, PyObject, PyResult, PyTuple, ObjectProtocol, PyBytes, PyErr, PyList, PyObject, PyResult, PyTuple,
Python, PythonObject, ToPyObject, Python, PythonObject, ToPyObject,
}; };
use hg::utils::hg_path::HgPathBuf; use hg::utils::hg_path::HgPathBuf;
use hg::{ use hg::{
matchers::{AlwaysMatcher, FileMatcher}, matchers::{AlwaysMatcher, FileMatcher},
status, status,
utils::{files::get_path_from_bytes, hg_path::HgPath}, utils::{files::get_path_from_bytes, hg_path::HgPath},
StatusResult, DirstateStatus,
}; };
use std::borrow::Borrow; use std::borrow::Borrow;
/// This will be useless once trait impls for collection are added to `PyBytes` /// This will be useless once trait impls for collection are added to `PyBytes`
/// upstream. /// upstream.
fn collect_pybytes_list<P: AsRef<HgPath>>( fn collect_pybytes_list<P: AsRef<HgPath>>(
py: Python, py: Python,
collection: &[P], collection: &[P],
format!("Unsupported matcher {}", e), format!("Unsupported matcher {}", e),
)); ));
} }
} }
} }
fn build_response( fn build_response(
lookup: Vec<&HgPath>, lookup: Vec<&HgPath>,
status_res: StatusResult, status_res: DirstateStatus,
py: Python, py: Python,
) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> { ) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> {
let modified = collect_pybytes_list(py, status_res.modified.as_ref()); let modified = collect_pybytes_list(py, status_res.modified.as_ref());
let added = collect_pybytes_list(py, status_res.added.as_ref()); let added = collect_pybytes_list(py, status_res.added.as_ref());
let removed = collect_pybytes_list(py, status_res.removed.as_ref()); let removed = collect_pybytes_list(py, status_res.removed.as_ref());
let deleted = collect_pybytes_list(py, status_res.deleted.as_ref()); let deleted = collect_pybytes_list(py, status_res.deleted.as_ref());
let clean = collect_pybytes_list(py, status_res.clean.as_ref()); let clean = collect_pybytes_list(py, status_res.clean.as_ref());
let lookup = collect_pybytes_list(py, lookup.as_ref()); let lookup = collect_pybytes_list(py, lookup.as_ref());
let unknown = PyList::new(py, &[]); let unknown = PyList::new(py, &[]);
Ok((lookup, modified, added, removed, deleted, unknown, clean)) Ok((lookup, modified, added, removed, deleted, unknown, clean))
} }