This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8862

hg-core: remove the `Operation` trait
ClosedPublic

Authored by acezar on Aug 3 2020, 10:25 AM.

Details

Reviewers
Alphare
indygreg
Group Reviewers
hg-reviewers
Commits
rHG452ece5654c5: hg-core: remove the `Operation` trait
Summary

There is no way to currently define a trait which can both return references
to self and to passed data, which is what we would need.
Generic Associated Types may fix this and allow us to have a unified interface.
See: rust #44265

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

acezar created this revision.Aug 3 2020, 10:25 AM
Alphare accepted this revision.Aug 3 2020, 11:00 AM
Alphare added a subscriber: Alphare.

To add to this change, it's also entirely possible that we may never need the trait altogether.

acezar updated this revision to Diff 22246.Aug 4 2020, 4:57 AM
indygreg accepted this revision.Aug 8 2020, 3:44 PM
This revision is now accepted and ready to land.Aug 8 2020, 3:44 PM
acezar added a commit: rHG452ece5654c5: hg-core: remove the `Operation` trait.Aug 8 2020, 4:29 PM
Closed by commit rHG452ece5654c5: hg-core: remove the `Operation` trait (authored by acezar). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 22357

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

// status.rs // status.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.
//! Rust implementation of dirstate.status (dirstate.py). //! Rust implementation of dirstate.status (dirstate.py).
//! It is currently missing a lot of functionality compared to the Python one //! It is currently missing a lot of functionality compared to the Python one
//! and will only be triggered in narrow cases. //! and will only be triggered in narrow cases.
use crate::{ use crate::{
dirstate::SIZE_FROM_OTHER_PARENT, dirstate::SIZE_FROM_OTHER_PARENT,
filepatterns::PatternFileWarning, filepatterns::PatternFileWarning,
matchers::{get_ignore_function, Matcher, VisitChildrenSet}, matchers::{get_ignore_function, Matcher, VisitChildrenSet},
operations::Operation,
utils::{ utils::{
files::{find_dirs, HgMetadata}, files::{find_dirs, HgMetadata},
hg_path::{ hg_path::{
hg_path_to_path_buf, os_string_to_hg_path_buf, HgPath, HgPathBuf, hg_path_to_path_buf, os_string_to_hg_path_buf, HgPath, HgPathBuf,
HgPathError, HgPathError,
}, },
path_auditor::PathAuditor, path_auditor::PathAuditor,
}, },

rust/hg-core/src/operations/dirstate_status.rs

// dirstate_status.rs // dirstate_status.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 crate::dirstate::status::{build_response, Dispatch, HgPathCow, Status}; use crate::dirstate::status::{build_response, Dispatch, HgPathCow, Status};
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::operations::Operation;
use crate::{DirstateStatus, StatusError}; use crate::{DirstateStatus, StatusError};
/// A tuple of the paths that need to be checked in the filelog because it's /// A tuple of the paths that need to be checked in the filelog because it's
/// ambiguous whether they've changed, and the rest of the already dispatched /// ambiguous whether they've changed, and the rest of the already dispatched
/// files. /// files.
pub type LookupAndStatus<'a> = (Vec<HgPathCow<'a>>, DirstateStatus<'a>); pub type LookupAndStatus<'a> = (Vec<HgPathCow<'a>>, DirstateStatus<'a>);
impl<'a, M: Matcher + Sync> Operation<LookupAndStatus<'a>> for Status<'a, M> { impl<'a, M: Matcher + Sync> Status<'a, M> {
type Error = StatusError; pub(crate) fn run(&self) -> Result<LookupAndStatus<'a>, StatusError> {
fn run(&self) -> Result<LookupAndStatus<'a>, Self::Error> {
let (traversed_sender, traversed_receiver) = let (traversed_sender, traversed_receiver) =
crossbeam::channel::unbounded(); crossbeam::channel::unbounded();
// Step 1: check the files explicitly mentioned by the user // Step 1: check the files explicitly mentioned by the user
let (work, mut results) = self.walk_explicit(traversed_sender.clone()); let (work, mut results) = self.walk_explicit(traversed_sender.clone());
if !work.is_empty() { if !work.is_empty() {
// Hashmaps are quite a bit slower to build than vecs, so only // Hashmaps are quite a bit slower to build than vecs, so only

rust/hg-core/src/operations/find_root.rs

use super::Operation;
use std::fmt; use std::fmt;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
/// Kind of error encoutered by FindRoot /// Kind of error encoutered by FindRoot
#[derive(Debug)] #[derive(Debug)]
pub enum FindRootErrorKind { pub enum FindRootErrorKind {
/// Root of the repository has not been found /// Root of the repository has not been found
/// Contains the current directory used by FindRoot /// Contains the current directory used by FindRoot
Self { current_dir: None } Self { current_dir: None }
} }
pub fn new_from_path(current_dir: &'a Path) -> Self { pub fn new_from_path(current_dir: &'a Path) -> Self {
Self { Self {
current_dir: Some(current_dir), current_dir: Some(current_dir),
} }
} }
}
impl<'a> Operation<PathBuf> for FindRoot<'a> {
type Error = FindRootError;
fn run(&self) -> Result<PathBuf, Self::Error> { pub fn run(&self) -> Result<PathBuf, FindRootError> {
let current_dir = match self.current_dir { let current_dir = match self.current_dir {
None => std::env::current_dir().or_else(|e| { None => std::env::current_dir().or_else(|e| {
Err(FindRootError { Err(FindRootError {
kind: FindRootErrorKind::GetCurrentDirError(e), kind: FindRootErrorKind::GetCurrentDirError(e),
}) })
})?, })?,
Some(path) => path.into(), Some(path) => path.into(),
}; };

rust/hg-core/src/operations/mod.rs

//! A distinction is made between operations and commands.
//! An operation is what can be done whereas a command is what is exposed by
//! the cli. A single command can use several operations to achieve its goal.
mod dirstate_status; mod dirstate_status;
mod find_root; mod find_root;
pub use find_root::{FindRoot, FindRootError, FindRootErrorKind}; pub use find_root::{FindRoot, FindRootError, FindRootErrorKind};
/// An interface for high-level hg operations. // TODO add an `Operation` trait when GAT have landed (rust #44265):
/// // there is no way to currently define a trait which can both return
/// A distinction is made between operation and commands. // references to `self` and to passed data, which is what we would need.
/// An operation is what can be done whereas a command is what is exposed by // Generic Associated Types may fix this and allow us to have a unified
/// the cli. A single command can use several operations to achieve its goal. // interface.
pub trait Operation<T> {
type Error;
fn run(&self) -> Result<T, Self::Error>;
}

rust/rhg/src/commands/root.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::{CommandError, CommandErrorKind};
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::{FindRoot, FindRootError, FindRootErrorKind, Operation}; use hg::operations::{FindRoot, FindRootError, FindRootErrorKind};
use hg::utils::files::get_bytes_from_path; use hg::utils::files::get_bytes_from_path;
use std::path::PathBuf; use std::path::PathBuf;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
Print the root directory of the current repository. Print the root directory of the current repository.
Returns 0 on success. Returns 0 on success.
"; ";