( )⚙ 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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

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 20718

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))
} }