( )⚙ D7523 rust-hg-path: implement `Display` for `HgPath` and `HgPathBuf`

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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 18421

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