This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9594

rust: change &PathBuf parameters to &Path
ClosedPublic

Authored by SimonSapin on Dec 14 2020, 11:27 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGcc6faec62cb7: rust: change &PathBuf parameters to &Path
Summary

This is just as useful in function bodies, and a less strict requirement for callers.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Dec 14 2020, 11:27 AM
pulkit accepted this revision.Dec 17 2020, 5:50 AM
This revision is now accepted and ready to land.Dec 17 2020, 5:50 AM
SimonSapin added a commit: rHGcc6faec62cb7: rust: change &PathBuf parameters to &Path.Dec 17 2020, 6:56 AM
Closed by commit rHGcc6faec62cb7: rust: change &PathBuf parameters to &Path (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 24257

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

} }
} }
.into() .into()
} }
} }
/// List files under Mercurial control at a given revision. /// List files under Mercurial control at a given revision.
pub struct CatRev<'a> { pub struct CatRev<'a> {
root: &'a PathBuf, root: &'a Path,
/// The revision to cat the files from. /// The revision to cat the files from.
rev: &'a str, rev: &'a str,
/// The files to output. /// The files to output.
files: &'a [HgPathBuf], files: &'a [HgPathBuf],
/// The changelog file /// The changelog file
changelog: Changelog, changelog: Changelog,
/// The manifest file /// The manifest file
manifest: Manifest, manifest: Manifest,
/// The manifest entry corresponding to the revision. /// The manifest entry corresponding to the revision.
/// ///
/// Used to hold the owner of the returned references. /// Used to hold the owner of the returned references.
manifest_entry: Option<ManifestEntry>, manifest_entry: Option<ManifestEntry>,
} }
impl<'a> CatRev<'a> { impl<'a> CatRev<'a> {
pub fn new( pub fn new(
root: &'a PathBuf, root: &'a Path,
rev: &'a str, rev: &'a str,
files: &'a [HgPathBuf], files: &'a [HgPathBuf],
) -> Result<Self, CatRevError> { ) -> Result<Self, CatRevError> {
let changelog = Changelog::open(&root)?; let changelog = Changelog::open(&root)?;
let manifest = Manifest::open(&root)?; let manifest = Manifest::open(&root)?;
let manifest_entry = None; let manifest_entry = None;
Ok(Self { Ok(Self {

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

use crate::revlog::node::{Node, NodePrefix}; use crate::revlog::node::{Node, NodePrefix};
use crate::revlog::revlog::RevlogError; use crate::revlog::revlog::RevlogError;
use crate::revlog::Revision; use crate::revlog::Revision;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::{DirstateParseError, EntryState}; use crate::{DirstateParseError, EntryState};
use rayon::prelude::*; use rayon::prelude::*;
use std::convert::From; use std::convert::From;
use std::fs; use std::fs;
use std::path::PathBuf; use std::path::Path;
/// Kind of error encountered by `ListDirstateTrackedFiles` /// Kind of error encountered by `ListDirstateTrackedFiles`
#[derive(Debug)] #[derive(Debug)]
pub enum ListDirstateTrackedFilesErrorKind { pub enum ListDirstateTrackedFilesErrorKind {
/// Error when reading the `dirstate` file /// Error when reading the `dirstate` file
IoError(std::io::Error), IoError(std::io::Error),
/// Error when parsing the `dirstate` file /// Error when parsing the `dirstate` file
ParseError(DirstateParseError), ParseError(DirstateParseError),
/// List files under Mercurial control in the working directory /// List files under Mercurial control in the working directory
/// by reading the dirstate /// by reading the dirstate
pub struct ListDirstateTrackedFiles { pub struct ListDirstateTrackedFiles {
/// The `dirstate` content. /// The `dirstate` content.
content: Vec<u8>, content: Vec<u8>,
} }
impl ListDirstateTrackedFiles { impl ListDirstateTrackedFiles {
pub fn new(root: &PathBuf) -> Result<Self, ListDirstateTrackedFilesError> { pub fn new(root: &Path) -> Result<Self, ListDirstateTrackedFilesError> {
let dirstate = root.join(".hg/dirstate"); let dirstate = root.join(".hg/dirstate");
let content = fs::read(&dirstate)?; let content = fs::read(&dirstate)?;
Ok(Self { content }) Ok(Self { content })
} }
pub fn run( pub fn run(
&mut self, &mut self,
) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> { ) -> Result<Vec<&HgPath>, ListDirstateTrackedFilesError> {
/// The manifest entry corresponding to the revision. /// The manifest entry corresponding to the revision.
/// ///
/// Used to hold the owner of the returned references. /// Used to hold the owner of the returned references.
manifest_entry: Option<ManifestEntry>, manifest_entry: Option<ManifestEntry>,
} }
impl<'a> ListRevTrackedFiles<'a> { impl<'a> ListRevTrackedFiles<'a> {
pub fn new( pub fn new(
root: &PathBuf, root: &Path,
rev: &'a str, rev: &'a str,
) -> Result<Self, ListRevTrackedFilesError> { ) -> Result<Self, ListRevTrackedFilesError> {
let changelog = Changelog::open(&root)?; let changelog = Changelog::open(root)?;
let manifest = Manifest::open(&root)?; let manifest = Manifest::open(root)?;
Ok(Self { Ok(Self {
rev, rev,
changelog, changelog,
manifest, manifest,
manifest_entry: None, manifest_entry: None,
}) })
} }

rust/hg-core/src/revlog/changelog.rs

use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefixRef; use crate::revlog::NodePrefixRef;
use crate::revlog::Revision; use crate::revlog::Revision;
use std::path::PathBuf; use std::path::Path;
/// A specialized `Revlog` to work with `changelog` data format. /// A specialized `Revlog` to work with `changelog` data format.
pub struct Changelog { pub struct Changelog {
/// The generic `revlog` format. /// The generic `revlog` format.
revlog: Revlog, revlog: Revlog,
} }
impl Changelog { impl Changelog {
/// Open the `changelog` of a repository given by its root. /// Open the `changelog` of a repository given by its root.
pub fn open(root: &PathBuf) -> Result<Self, RevlogError> { pub fn open(root: &Path) -> Result<Self, RevlogError> {
let index_file = root.join(".hg/store/00changelog.i"); let index_file = root.join(".hg/store/00changelog.i");
let revlog = Revlog::open(&index_file, None)?; let revlog = Revlog::open(&index_file, None)?;
Ok(Self { revlog }) Ok(Self { revlog })
} }
/// Return the `ChangelogEntry` a given node id. /// Return the `ChangelogEntry` a given node id.
pub fn get_node( pub fn get_node(
&self, &self,

rust/hg-core/src/revlog/manifest.rs

use crate::revlog::revlog::{Revlog, RevlogError}; use crate::revlog::revlog::{Revlog, RevlogError};
use crate::revlog::NodePrefixRef; use crate::revlog::NodePrefixRef;
use crate::revlog::Revision; use crate::revlog::Revision;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use std::path::PathBuf; use std::path::Path;
/// A specialized `Revlog` to work with `manifest` data format. /// A specialized `Revlog` to work with `manifest` data format.
pub struct Manifest { pub struct Manifest {
/// The generic `revlog` format. /// The generic `revlog` format.
revlog: Revlog, revlog: Revlog,
} }
impl Manifest { impl Manifest {
/// Open the `manifest` of a repository given by its root. /// Open the `manifest` of a repository given by its root.
pub fn open(root: &PathBuf) -> Result<Self, RevlogError> { pub fn open(root: &Path) -> Result<Self, RevlogError> {
let index_file = root.join(".hg/store/00manifest.i"); let index_file = root.join(".hg/store/00manifest.i");
let revlog = Revlog::open(&index_file, None)?; let revlog = Revlog::open(&index_file, None)?;
Ok(Self { revlog }) Ok(Self { revlog })
} }
/// Return the `ManifestEntry` of a given node id. /// Return the `ManifestEntry` of a given node id.
pub fn get_node( pub fn get_node(
&self, &self,

rust/rhg/src/commands/files.rs

use crate::commands::Command; use crate::commands::Command;
use crate::error::{CommandError, CommandErrorKind}; use crate::error::{CommandError, CommandErrorKind};
use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::Ui; use crate::ui::Ui;
use hg::operations::FindRoot; use hg::operations::FindRoot;
use hg::operations::{ use hg::operations::{
ListDirstateTrackedFiles, ListDirstateTrackedFilesError, ListDirstateTrackedFiles, ListDirstateTrackedFilesError,
ListDirstateTrackedFilesErrorKind, ListDirstateTrackedFilesErrorKind,
}; };
use hg::operations::{ use hg::operations::{
ListRevTrackedFiles, ListRevTrackedFilesError, ListRevTrackedFiles, ListRevTrackedFilesError,
ListRevTrackedFilesErrorKind, ListRevTrackedFilesErrorKind,
}; };
use hg::requirements; use hg::requirements;
use hg::utils::files::{get_bytes_from_path, relativize_path}; use hg::utils::files::{get_bytes_from_path, relativize_path};
use hg::utils::hg_path::{HgPath, HgPathBuf}; use hg::utils::hg_path::{HgPath, HgPathBuf};
use std::path::PathBuf; use std::path::Path;
pub const HELP_TEXT: &str = " pub const HELP_TEXT: &str = "
List tracked files. List tracked files.
Returns 0 on success. Returns 0 on success.
"; ";
pub struct FilesCommand<'a> { pub struct FilesCommand<'a> {
rev: Option<&'a str>, rev: Option<&'a str>,
} }
impl<'a> FilesCommand<'a> { impl<'a> FilesCommand<'a> {
pub fn new(rev: Option<&'a str>) -> Self { pub fn new(rev: Option<&'a str>) -> Self {
FilesCommand { rev } FilesCommand { rev }
} }
fn display_files( fn display_files(
&self, &self,
ui: &Ui, ui: &Ui,
root: &PathBuf, root: &Path,
files: impl IntoIterator<Item = &'a HgPath>, files: impl IntoIterator<Item = &'a HgPath>,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let cwd = std::env::current_dir() let cwd = std::env::current_dir()
.or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?; .or_else(|e| Err(CommandErrorKind::CurrentDirNotFound(e)))?;
let rooted_cwd = cwd let rooted_cwd = cwd
.strip_prefix(&root) .strip_prefix(root)
.expect("cwd was already checked within the repository"); .expect("cwd was already checked within the repository");
let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd)); let rooted_cwd = HgPathBuf::from(get_bytes_from_path(rooted_cwd));
let mut stdout = ui.stdout_buffer(); let mut stdout = ui.stdout_buffer();
for file in files { for file in files {
stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?; stdout.write_all(relativize_path(file, &rooted_cwd).as_ref())?;
stdout.write_all(b"\n")?; stdout.write_all(b"\n")?;