This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7523

rust-hg-path: implement `Display` for `HgPath` and `HgPathBuf`
ClosedPublic

Authored by Alphare on Nov 29 2019, 12:56 PM.

Details

Reviewers
kevincox
pulkit
Group Reviewers
hg-reviewers
Commits
rHGc27e688fcdc3: rust-hg-path: implement `Display` for `HgPath` and `HgPathBuf`
Summary

This is useful when debugging, to get a human readable output instead of an
array of u8.

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.Nov 29 2019, 12:56 PM
kevincox requested changes to this revision.Dec 2 2019, 8:04 AM
kevincox added inline comments.
rust/hg-core/src/utils/hg_path.rs
168

This looks more like a Debug format than a Display format. For Display I would just do write!(f, "{}", String::from_utf8_lossy(&self.inner))`

This revision now requires changes to proceed.Dec 2 2019, 8:04 AM
Alphare marked an inline comment as done.Dec 2 2019, 9:20 AM
Alphare updated this revision to Diff 18421.
kevincox accepted this revision.Dec 2 2019, 10:24 AM
pulkit accepted this revision.Dec 10 2019, 10:09 AM
This revision is now accepted and ready to land.Dec 10 2019, 10:09 AM

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/utils/hg_path.rs (13 lines)

Diff 18578

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::ffi::{OsStr, OsString}; use std::ffi::{OsStr, OsString};
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 {
/// Bytes from the invalid `HgPath` /// Bytes from the invalid `HgPath`
LeadingSlash(Vec<u8>), LeadingSlash(Vec<u8>),
/// Bytes and index of the second slash /// Bytes and index of the second slash
#[cfg(test)] #[cfg(test)]
/// Only usable during tests to force developers to handle invalid states /// Only usable during tests to force developers to handle invalid states
fn is_valid(&self) -> bool { fn is_valid(&self) -> bool {
self.check_state().is_ok() self.check_state().is_ok()
} }
} }
impl fmt::Display for HgPath {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", String::from_utf8_lossy(&self.inner))
kevincoxUnsubmitted
Done

This looks more like a Debug format than a Display format. For Display I would just do write!(f, "{}", String::from_utf8_lossy(&self.inner))`

kevincox: This looks more like a `Debug` format than a `Display` format. For `Display I would just do…
}
}
#[derive(Eq, Ord, Clone, PartialEq, PartialOrd, Debug, Hash)] #[derive(Eq, Ord, Clone, PartialEq, PartialOrd, Debug, Hash)]
pub struct HgPathBuf { pub struct HgPathBuf {
inner: Vec<u8>, inner: Vec<u8>,
} }
impl HgPathBuf { impl HgPathBuf {
pub fn new() -> Self { pub fn new() -> Self {
Self { inner: Vec::new() } Self { inner: Vec::new() }
} }
pub fn push(&mut self, byte: u8) { pub fn push(&mut self, byte: u8) {
self.inner.push(byte); self.inner.push(byte);
} }
pub fn from_bytes(s: &[u8]) -> HgPathBuf { pub fn from_bytes(s: &[u8]) -> HgPathBuf {
HgPath::new(s).to_owned() HgPath::new(s).to_owned()
} }
pub fn into_vec(self) -> Vec<u8> { pub fn into_vec(self) -> Vec<u8> {
self.inner self.inner
} }
pub fn as_ref(&self) -> &[u8] { pub fn as_ref(&self) -> &[u8] {
self.inner.as_ref() self.inner.as_ref()
} }
} }
impl fmt::Display for HgPathBuf {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", String::from_utf8_lossy(&self.inner))
}
}
impl Deref for HgPathBuf { impl Deref for HgPathBuf {
type Target = HgPath; type Target = HgPath;
#[inline] #[inline]
fn deref(&self) -> &HgPath { fn deref(&self) -> &HgPath {
&HgPath::new(&self.inner) &HgPath::new(&self.inner)
} }
} }