rust: replace read_whole_file with std::fs::read

It does the same thing

Differential Revision: https://phab.mercurial-scm.org/D9959

rust/hg-core/src/config/config.rs

@@ -1,198 +1,197 b''
 // config.rs
 //
 // Copyright 2020
 //      Valentin Gatien-Baron,
 //      Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use super::layer;
 use crate::config::layer::{
     ConfigError, ConfigLayer, ConfigParseError, ConfigValue,
 };
 use std::path::PathBuf;
 
 use crate::repo::Repo;
-use crate::utils::files::read_whole_file;
 
 /// Holds the config values for the current repository
 /// TODO update this docstring once we support more sources
 pub struct Config {
     layers: Vec<layer::ConfigLayer>,
 }
 
 impl std::fmt::Debug for Config {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         for (index, layer) in self.layers.iter().rev().enumerate() {
             write!(
                 f,
                 "==== Layer {} (trusted: {}) ====\n{:?}",
                 index, layer.trusted, layer
             )?;
         }
         Ok(())
     }
 }
 
 pub enum ConfigSource {
     /// Absolute path to a config file
     AbsPath(PathBuf),
     /// Already parsed (from the CLI, env, Python resources, etc.)
     Parsed(layer::ConfigLayer),
 }
 
 pub fn parse_bool(v: &[u8]) -> Option<bool> {
     match v.to_ascii_lowercase().as_slice() {
         b"1" | b"yes" | b"true" | b"on" | b"always" => Some(true),
         b"0" | b"no" | b"false" | b"off" | b"never" => Some(false),
         _ => None,
     }
 }
 
 impl Config {
     /// Loads in order, which means that the precedence is the same
     /// as the order of `sources`.
     pub fn load_from_explicit_sources(
         sources: Vec<ConfigSource>,
     ) -> Result<Self, ConfigError> {
         let mut layers = vec![];
 
         for source in sources.into_iter() {
             match source {
                 ConfigSource::Parsed(c) => layers.push(c),
                 ConfigSource::AbsPath(c) => {
                     // TODO check if it should be trusted
                     // mercurial/ui.py:427
-                    let data = match read_whole_file(&c) {
+                    let data = match std::fs::read(&c) {
                         Err(_) => continue, // same as the python code
                         Ok(data) => data,
                     };
                     layers.extend(ConfigLayer::parse(&c, &data)?)
                 }
             }
         }
 
         Ok(Config { layers })
     }
 
     /// Loads the local config. In a future version, this will also load the
     /// `$HOME/.hgrc` and more to mirror the Python implementation.
     pub fn load_for_repo(repo: &Repo) -> Result<Self, ConfigError> {
         Ok(Self::load_from_explicit_sources(vec![
             ConfigSource::AbsPath(repo.hg_vfs().join("hgrc")),
         ])?)
     }
 
     /// Returns an `Err` if the first value found is not a valid boolean.
     /// Otherwise, returns an `Ok(option)`, where `option` is the boolean if
     /// found, or `None`.
     pub fn get_option(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<bool>, ConfigParseError> {
         match self.get_inner(&section, &item) {
             Some((layer, v)) => match parse_bool(&v.bytes) {
                 Some(b) => Ok(Some(b)),
                 None => Err(ConfigParseError {
                     origin: layer.origin.to_owned(),
                     line: v.line,
                     bytes: v.bytes.to_owned(),
                 }),
             },
             None => Ok(None),
         }
     }
 
     /// Returns the corresponding boolean in the config. Returns `Ok(false)`
     /// if the value is not found, an `Err` if it's not a valid boolean.
     pub fn get_bool(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<bool, ConfigError> {
         Ok(self.get_option(section, item)?.unwrap_or(false))
     }
 
     /// Returns the raw value bytes of the first one found, or `None`.
     pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&[u8]> {
         self.get_inner(section, item)
             .map(|(_, value)| value.bytes.as_ref())
     }
 
     /// Returns the layer and the value of the first one found, or `None`.
     fn get_inner(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Option<(&ConfigLayer, &ConfigValue)> {
         for layer in self.layers.iter().rev() {
             if !layer.trusted {
                 continue;
             }
             if let Some(v) = layer.get(&section, &item) {
                 return Some((&layer, v));
             }
         }
         None
     }
 
     /// Get raw values bytes from all layers (even untrusted ones) in order
     /// of precedence.
     #[cfg(test)]
     fn get_all(&self, section: &[u8], item: &[u8]) -> Vec<&[u8]> {
         let mut res = vec![];
         for layer in self.layers.iter().rev() {
             if let Some(v) = layer.get(&section, &item) {
                 res.push(v.bytes.as_ref());
             }
         }
         res
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
     use std::fs::File;
     use std::io::Write;
 
     #[test]
     fn test_include_layer_ordering() {
         let tmpdir = tempfile::tempdir().unwrap();
         let tmpdir_path = tmpdir.path();
         let mut included_file =
             File::create(&tmpdir_path.join("included.rc")).unwrap();
 
         included_file.write_all(b"[section]\nitem=value1").unwrap();
         let base_config_path = tmpdir_path.join("base.rc");
         let mut config_file = File::create(&base_config_path).unwrap();
         let data =
             b"[section]\nitem=value0\n%include included.rc\nitem=value2";
         config_file.write_all(data).unwrap();
 
         let sources = vec![ConfigSource::AbsPath(base_config_path)];
         let config = Config::load_from_explicit_sources(sources)
             .expect("expected valid config");
 
         dbg!(&config);
 
         let (_, value) = config.get_inner(b"section", b"item").unwrap();
         assert_eq!(
             value,
             &ConfigValue {
                 bytes: b"value2".to_vec(),
                 line: Some(4)
             }
         );
 
         let value = config.get(b"section", b"item").unwrap();
         assert_eq!(value, b"value2",);
         assert_eq!(
             config.get_all(b"section", b"item"),
             [b"value2", b"value1", b"value0"]
         );
     }
 }

rust/hg-core/src/config/layer.rs

@@ -1,253 +1,251 b''
 // layer.rs
 //
 // Copyright 2020
 //      Valentin Gatien-Baron,
 //      Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::errors::{HgError, IoResultExt};
-use crate::utils::files::{
-    get_bytes_from_path, get_path_from_bytes, read_whole_file,
-};
+use crate::utils::files::{get_bytes_from_path, get_path_from_bytes};
 use format_bytes::format_bytes;
 use lazy_static::lazy_static;
 use regex::bytes::Regex;
 use std::collections::HashMap;
 use std::io;
 use std::path::{Path, PathBuf};
 
 lazy_static! {
     static ref SECTION_RE: Regex = make_regex(r"^\[([^\[]+)\]");
     static ref ITEM_RE: Regex = make_regex(r"^([^=\s][^=]*?)\s*=\s*((.*\S)?)");
     /// Continuation whitespace
     static ref CONT_RE: Regex = make_regex(r"^\s+(\S|\S.*\S)\s*$");
     static ref EMPTY_RE: Regex = make_regex(r"^(;|#|\s*$)");
     static ref COMMENT_RE: Regex = make_regex(r"^(;|#)");
     /// A directive that allows for removing previous entries
     static ref UNSET_RE: Regex = make_regex(r"^%unset\s+(\S+)");
     /// A directive that allows for including other config files
     static ref INCLUDE_RE: Regex = make_regex(r"^%include\s+(\S|\S.*\S)\s*$");
 }
 
 /// All config values separated by layers of precedence.
 /// Each config source may be split in multiple layers if `%include` directives
 /// are used.
 /// TODO detail the general precedence
 #[derive(Clone)]
 pub struct ConfigLayer {
     /// Mapping of the sections to their items
     sections: HashMap<Vec<u8>, ConfigItem>,
     /// All sections (and their items/values) in a layer share the same origin
     pub origin: ConfigOrigin,
     /// Whether this layer comes from a trusted user or group
     pub trusted: bool,
 }
 
 impl ConfigLayer {
     pub fn new(origin: ConfigOrigin) -> Self {
         ConfigLayer {
             sections: HashMap::new(),
             trusted: true, // TODO check
             origin,
         }
     }
 
     /// Add an entry to the config, overwriting the old one if already present.
     pub fn add(
         &mut self,
         section: Vec<u8>,
         item: Vec<u8>,
         value: Vec<u8>,
         line: Option<usize>,
     ) {
         self.sections
             .entry(section)
             .or_insert_with(|| HashMap::new())
             .insert(item, ConfigValue { bytes: value, line });
     }
 
     /// Returns the config value in `<section>.<item>` if it exists
     pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&ConfigValue> {
         Some(self.sections.get(section)?.get(item)?)
     }
 
     pub fn is_empty(&self) -> bool {
         self.sections.is_empty()
     }
 
     /// Returns a `Vec` of layers in order of precedence (so, in read order),
     /// recursively parsing the `%include` directives if any.
     pub fn parse(src: &Path, data: &[u8]) -> Result<Vec<Self>, ConfigError> {
         let mut layers = vec![];
 
         // Discard byte order mark if any
         let data = if data.starts_with(b"\xef\xbb\xbf") {
             &data[3..]
         } else {
             data
         };
 
         // TODO check if it's trusted
         let mut current_layer = Self::new(ConfigOrigin::File(src.to_owned()));
 
         let mut lines_iter =
             data.split(|b| *b == b'\n').enumerate().peekable();
         let mut section = b"".to_vec();
 
         while let Some((index, bytes)) = lines_iter.next() {
             if let Some(m) = INCLUDE_RE.captures(&bytes) {
                 let filename_bytes = &m[1];
                 let filename_to_include = get_path_from_bytes(&filename_bytes);
                 let (include_src, result) =
                     read_include(&src, &filename_to_include);
                 let data = result.for_file(filename_to_include)?;
                 layers.push(current_layer);
                 layers.extend(Self::parse(&include_src, &data)?);
                 current_layer = Self::new(ConfigOrigin::File(src.to_owned()));
             } else if let Some(_) = EMPTY_RE.captures(&bytes) {
             } else if let Some(m) = SECTION_RE.captures(&bytes) {
                 section = m[1].to_vec();
             } else if let Some(m) = ITEM_RE.captures(&bytes) {
                 let item = m[1].to_vec();
                 let mut value = m[2].to_vec();
                 loop {
                     match lines_iter.peek() {
                         None => break,
                         Some((_, v)) => {
                             if let Some(_) = COMMENT_RE.captures(&v) {
                             } else if let Some(_) = CONT_RE.captures(&v) {
                                 value.extend(b"\n");
                                 value.extend(&m[1]);
                             } else {
                                 break;
                             }
                         }
                     };
                     lines_iter.next();
                 }
                 current_layer.add(
                     section.clone(),
                     item,
                     value,
                     Some(index + 1),
                 );
             } else if let Some(m) = UNSET_RE.captures(&bytes) {
                 if let Some(map) = current_layer.sections.get_mut(&section) {
                     map.remove(&m[1]);
                 }
             } else {
                 return Err(ConfigParseError {
                     origin: ConfigOrigin::File(src.to_owned()),
                     line: Some(index + 1),
                     bytes: bytes.to_owned(),
                 }
                 .into());
             }
         }
         if !current_layer.is_empty() {
             layers.push(current_layer);
         }
         Ok(layers)
     }
 }
 
 impl std::fmt::Debug for ConfigLayer {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut sections: Vec<_> = self.sections.iter().collect();
         sections.sort_by(|e0, e1| e0.0.cmp(e1.0));
 
         for (section, items) in sections.into_iter() {
             let mut items: Vec<_> = items.into_iter().collect();
             items.sort_by(|e0, e1| e0.0.cmp(e1.0));
 
             for (item, config_entry) in items {
                 writeln!(
                     f,
                     "{}",
                     String::from_utf8_lossy(&format_bytes!(
                         b"{}.{}={} # {}",
                         section,
                         item,
                         &config_entry.bytes,
                         &self.origin.to_bytes(),
                     ))
                 )?
             }
         }
         Ok(())
     }
 }
 
 /// Mapping of section item to value.
 /// In the following:
 /// ```text
 /// [ui]
 /// paginate=no
 /// ```
 /// "paginate" is the section item and "no" the value.
 pub type ConfigItem = HashMap<Vec<u8>, ConfigValue>;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct ConfigValue {
     /// The raw bytes of the value (be it from the CLI, env or from a file)
     pub bytes: Vec<u8>,
     /// Only present if the value comes from a file, 1-indexed.
     pub line: Option<usize>,
 }
 
 #[derive(Clone, Debug)]
 pub enum ConfigOrigin {
     /// The value comes from a configuration file
     File(PathBuf),
     /// The value comes from the environment like `$PAGER` or `$EDITOR`
     Environment(Vec<u8>),
     /* TODO cli
      * TODO defaults (configitems.py)
      * TODO extensions
      * TODO Python resources?
      * Others? */
 }
 
 impl ConfigOrigin {
     /// TODO use some kind of dedicated trait?
     pub fn to_bytes(&self) -> Vec<u8> {
         match self {
             ConfigOrigin::File(p) => get_bytes_from_path(p),
             ConfigOrigin::Environment(e) => e.to_owned(),
         }
     }
 }
 
 #[derive(Debug)]
 pub struct ConfigParseError {
     pub origin: ConfigOrigin,
     pub line: Option<usize>,
     pub bytes: Vec<u8>,
 }
 
 #[derive(Debug, derive_more::From)]
 pub enum ConfigError {
     Parse(ConfigParseError),
     Other(HgError),
 }
 
 fn make_regex(pattern: &'static str) -> Regex {
     Regex::new(pattern).expect("expected a valid regex")
 }
 
 /// Includes are relative to the file they're defined in, unless they're
 /// absolute.
 fn read_include(
     old_src: &Path,
     new_src: &Path,
 ) -> (PathBuf, io::Result<Vec<u8>>) {
     if new_src.is_absolute() {
-        (new_src.to_path_buf(), read_whole_file(&new_src))
+        (new_src.to_path_buf(), std::fs::read(&new_src))
     } else {
         let dir = old_src.parent().unwrap();
         let new_src = dir.join(&new_src);
-        (new_src.to_owned(), read_whole_file(&new_src))
+        (new_src.to_owned(), std::fs::read(&new_src))
     }
 }

rust/hg-core/src/utils/files.rs

@@ -1,454 +1,442 b''
 // files.rs
 //
 // Copyright 2019
 // Raphaël Gomès <[e-mail]>,
 // Yuya Nishihara <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Functions for fiddling with files.
 
 use crate::utils::{
     hg_path::{path_to_hg_path_buf, HgPath, HgPathBuf, HgPathError},
     path_auditor::PathAuditor,
     replace_slice,
 };
 use lazy_static::lazy_static;
 use same_file::is_same_file;
 use std::borrow::{Cow, ToOwned};
 use std::fs::Metadata;
-use std::io::Read;
 use std::iter::FusedIterator;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
 pub fn get_path_from_bytes(bytes: &[u8]) -> &Path {
     let os_str;
     #[cfg(unix)]
     {
         use std::os::unix::ffi::OsStrExt;
         os_str = std::ffi::OsStr::from_bytes(bytes);
     }
     // TODO Handle other platforms
     // TODO: convert from WTF8 to Windows MBCS (ANSI encoding).
     // Perhaps, the return type would have to be Result<PathBuf>.
 
     Path::new(os_str)
 }
 
 // TODO: need to convert from WTF8 to MBCS bytes on Windows.
 // that's why Vec<u8> is returned.
 #[cfg(unix)]
 pub fn get_bytes_from_path(path: impl AsRef<Path>) -> Vec<u8> {
     use std::os::unix::ffi::OsStrExt;
     path.as_ref().as_os_str().as_bytes().to_vec()
 }
 
 /// An iterator over repository path yielding itself and its ancestors.
 #[derive(Copy, Clone, Debug)]
 pub struct Ancestors<'a> {
     next: Option<&'a HgPath>,
 }
 
 impl<'a> Iterator for Ancestors<'a> {
     type Item = &'a HgPath;
 
     fn next(&mut self) -> Option<Self::Item> {
         let next = self.next;
         self.next = match self.next {
             Some(s) if s.is_empty() => None,
             Some(s) => {
                 let p = s.bytes().rposition(|c| *c == b'/').unwrap_or(0);
                 Some(HgPath::new(&s.as_bytes()[..p]))
             }
             None => None,
         };
         next
     }
 }
 
 impl<'a> FusedIterator for Ancestors<'a> {}
 
 /// An iterator over repository path yielding itself and its ancestors.
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct AncestorsWithBase<'a> {
     next: Option<(&'a HgPath, &'a HgPath)>,
 }
 
 impl<'a> Iterator for AncestorsWithBase<'a> {
     type Item = (&'a HgPath, &'a HgPath);
 
     fn next(&mut self) -> Option<Self::Item> {
         let next = self.next;
         self.next = match self.next {
             Some((s, _)) if s.is_empty() => None,
             Some((s, _)) => Some(s.split_filename()),
             None => None,
         };
         next
     }
 }
 
 impl<'a> FusedIterator for AncestorsWithBase<'a> {}
 
 /// Returns an iterator yielding ancestor directories of the given repository
 /// path.
 ///
 /// The path is separated by '/', and must not start with '/'.
 ///
 /// The path itself isn't included unless it is b"" (meaning the root
 /// directory.)
 pub fn find_dirs(path: &HgPath) -> Ancestors {
     let mut dirs = Ancestors { next: Some(path) };
     if !path.is_empty() {
         dirs.next(); // skip itself
     }
     dirs
 }
 
 /// Returns an iterator yielding ancestor directories of the given repository
 /// path.
 ///
 /// The path is separated by '/', and must not start with '/'.
 ///
 /// The path itself isn't included unless it is b"" (meaning the root
 /// directory.)
 pub(crate) fn find_dirs_with_base(path: &HgPath) -> AncestorsWithBase {
     let mut dirs = AncestorsWithBase {
         next: Some((path, HgPath::new(b""))),
     };
     if !path.is_empty() {
         dirs.next(); // skip itself
     }
     dirs
 }
 
 /// TODO more than ASCII?
 pub fn normalize_case(path: &HgPath) -> HgPathBuf {
     #[cfg(windows)] // NTFS compares via upper()
     return path.to_ascii_uppercase();
     #[cfg(unix)]
     path.to_ascii_lowercase()
 }
 
 lazy_static! {
     static ref IGNORED_CHARS: Vec<Vec<u8>> = {
         [
             0x200c, 0x200d, 0x200e, 0x200f, 0x202a, 0x202b, 0x202c, 0x202d,
             0x202e, 0x206a, 0x206b, 0x206c, 0x206d, 0x206e, 0x206f, 0xfeff,
         ]
         .iter()
         .map(|code| {
             std::char::from_u32(*code)
                 .unwrap()
                 .encode_utf8(&mut [0; 3])
                 .bytes()
                 .collect()
         })
         .collect()
     };
 }
 
 fn hfs_ignore_clean(bytes: &[u8]) -> Vec<u8> {
     let mut buf = bytes.to_owned();
     let needs_escaping = bytes.iter().any(|b| *b == b'\xe2' || *b == b'\xef');
     if needs_escaping {
         for forbidden in IGNORED_CHARS.iter() {
             replace_slice(&mut buf, forbidden, &[])
         }
         buf
     } else {
         buf
     }
 }
 
 pub fn lower_clean(bytes: &[u8]) -> Vec<u8> {
     hfs_ignore_clean(&bytes.to_ascii_lowercase())
 }
 
 #[derive(Eq, PartialEq, Ord, PartialOrd, Copy, Clone)]
 pub struct HgMetadata {
     pub st_dev: u64,
     pub st_mode: u32,
     pub st_nlink: u64,
     pub st_size: u64,
     pub st_mtime: i64,
     pub st_ctime: i64,
 }
 
 // TODO support other plaforms
 #[cfg(unix)]
 impl HgMetadata {
     pub fn from_metadata(metadata: Metadata) -> Self {
         use std::os::unix::fs::MetadataExt;
         Self {
             st_dev: metadata.dev(),
             st_mode: metadata.mode(),
             st_nlink: metadata.nlink(),
             st_size: metadata.size(),
             st_mtime: metadata.mtime(),
             st_ctime: metadata.ctime(),
         }
     }
 }
 
 /// Returns the canonical path of `name`, given `cwd` and `root`
 pub fn canonical_path(
     root: impl AsRef<Path>,
     cwd: impl AsRef<Path>,
     name: impl AsRef<Path>,
 ) -> Result<PathBuf, HgPathError> {
     // TODO add missing normalization for other platforms
     let root = root.as_ref();
     let cwd = cwd.as_ref();
     let name = name.as_ref();
 
     let name = if !name.is_absolute() {
         root.join(&cwd).join(&name)
     } else {
         name.to_owned()
     };
     let auditor = PathAuditor::new(&root);
     if name != root && name.starts_with(&root) {
         let name = name.strip_prefix(&root).unwrap();
         auditor.audit_path(path_to_hg_path_buf(name)?)?;
         Ok(name.to_owned())
     } else if name == root {
         Ok("".into())
     } else {
         // Determine whether `name' is in the hierarchy at or beneath `root',
         // by iterating name=name.parent() until it returns `None` (can't
         // check name == '/', because that doesn't work on windows).
         let mut name = name.deref();
         let original_name = name.to_owned();
         loop {
             let same = is_same_file(&name, &root).unwrap_or(false);
             if same {
                 if name == original_name {
                     // `name` was actually the same as root (maybe a symlink)
                     return Ok("".into());
                 }
                 // `name` is a symlink to root, so `original_name` is under
                 // root
                 let rel_path = original_name.strip_prefix(&name).unwrap();
                 auditor.audit_path(path_to_hg_path_buf(&rel_path)?)?;
                 return Ok(rel_path.to_owned());
             }
             name = match name.parent() {
                 None => break,
                 Some(p) => p,
             };
         }
         // TODO hint to the user about using --cwd
         // Bubble up the responsibility to Python for now
         Err(HgPathError::NotUnderRoot {
             path: original_name.to_owned(),
             root: root.to_owned(),
         })
     }
 }
 
 /// Returns the representation of the path relative to the current working
 /// directory for display purposes.
 ///
 /// `cwd` is a `HgPath`, so it is considered relative to the root directory
 /// of the repository.
 ///
 /// # Examples
 ///
 /// ```
 /// use hg::utils::hg_path::HgPath;
 /// use hg::utils::files::relativize_path;
 /// use std::borrow::Cow;
 ///
 /// let file = HgPath::new(b"nested/file");
 /// let cwd = HgPath::new(b"");
 /// assert_eq!(relativize_path(file, cwd), Cow::Borrowed(b"nested/file"));
 ///
 /// let cwd = HgPath::new(b"nested");
 /// assert_eq!(relativize_path(file, cwd), Cow::Borrowed(b"file"));
 ///
 /// let cwd = HgPath::new(b"other");
 /// assert_eq!(relativize_path(file, cwd), Cow::Borrowed(b"../nested/file"));
 /// ```
 pub fn relativize_path(path: &HgPath, cwd: impl AsRef<HgPath>) -> Cow<[u8]> {
     if cwd.as_ref().is_empty() {
         Cow::Borrowed(path.as_bytes())
     } else {
         let mut res: Vec<u8> = Vec::new();
         let mut path_iter = path.as_bytes().split(|b| *b == b'/').peekable();
         let mut cwd_iter =
             cwd.as_ref().as_bytes().split(|b| *b == b'/').peekable();
         loop {
             match (path_iter.peek(), cwd_iter.peek()) {
                 (Some(a), Some(b)) if a == b => (),
                 _ => break,
             }
             path_iter.next();
             cwd_iter.next();
         }
         let mut need_sep = false;
         for _ in cwd_iter {
             if need_sep {
                 res.extend(b"/")
             } else {
                 need_sep = true
             };
             res.extend(b"..");
         }
         for c in path_iter {
             if need_sep {
                 res.extend(b"/")
             } else {
                 need_sep = true
             };
             res.extend(c);
         }
         Cow::Owned(res)
     }
 }
 
-/// Reads a file in one big chunk instead of doing multiple reads
-pub fn read_whole_file(filepath: &Path) -> std::io::Result<Vec<u8>> {
-    let mut file = std::fs::File::open(filepath)?;
-    let size = file.metadata()?.len();
-
-    let mut res = vec![0; size as usize];
-    file.read_exact(&mut res)?;
-
-    Ok(res)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
 
     #[test]
     fn find_dirs_some() {
         let mut dirs = super::find_dirs(HgPath::new(b"foo/bar/baz"));
         assert_eq!(dirs.next(), Some(HgPath::new(b"foo/bar")));
         assert_eq!(dirs.next(), Some(HgPath::new(b"foo")));
         assert_eq!(dirs.next(), Some(HgPath::new(b"")));
         assert_eq!(dirs.next(), None);
         assert_eq!(dirs.next(), None);
     }
 
     #[test]
     fn find_dirs_empty() {
         // looks weird, but mercurial.pathutil.finddirs(b"") yields b""
         let mut dirs = super::find_dirs(HgPath::new(b""));
         assert_eq!(dirs.next(), Some(HgPath::new(b"")));
         assert_eq!(dirs.next(), None);
         assert_eq!(dirs.next(), None);
     }
 
     #[test]
     fn test_find_dirs_with_base_some() {
         let mut dirs = super::find_dirs_with_base(HgPath::new(b"foo/bar/baz"));
         assert_eq!(
             dirs.next(),
             Some((HgPath::new(b"foo/bar"), HgPath::new(b"baz")))
         );
         assert_eq!(
             dirs.next(),
             Some((HgPath::new(b"foo"), HgPath::new(b"bar")))
         );
         assert_eq!(dirs.next(), Some((HgPath::new(b""), HgPath::new(b"foo"))));
         assert_eq!(dirs.next(), None);
         assert_eq!(dirs.next(), None);
     }
 
     #[test]
     fn test_find_dirs_with_base_empty() {
         let mut dirs = super::find_dirs_with_base(HgPath::new(b""));
         assert_eq!(dirs.next(), Some((HgPath::new(b""), HgPath::new(b""))));
         assert_eq!(dirs.next(), None);
         assert_eq!(dirs.next(), None);
     }
 
     #[test]
     fn test_canonical_path() {
         let root = Path::new("/repo");
         let cwd = Path::new("/dir");
         let name = Path::new("filename");
         assert_eq!(
             canonical_path(root, cwd, name),
             Err(HgPathError::NotUnderRoot {
                 path: PathBuf::from("/dir/filename"),
                 root: root.to_path_buf()
             })
         );
 
         let root = Path::new("/repo");
         let cwd = Path::new("/");
         let name = Path::new("filename");
         assert_eq!(
             canonical_path(root, cwd, name),
             Err(HgPathError::NotUnderRoot {
                 path: PathBuf::from("/filename"),
                 root: root.to_path_buf()
             })
         );
 
         let root = Path::new("/repo");
         let cwd = Path::new("/");
         let name = Path::new("repo/filename");
         assert_eq!(
             canonical_path(root, cwd, name),
             Ok(PathBuf::from("filename"))
         );
 
         let root = Path::new("/repo");
         let cwd = Path::new("/repo");
         let name = Path::new("filename");
         assert_eq!(
             canonical_path(root, cwd, name),
             Ok(PathBuf::from("filename"))
         );
 
         let root = Path::new("/repo");
         let cwd = Path::new("/repo/subdir");
         let name = Path::new("filename");
         assert_eq!(
             canonical_path(root, cwd, name),
             Ok(PathBuf::from("subdir/filename"))
         );
     }
 
     #[test]
     fn test_canonical_path_not_rooted() {
         use std::fs::create_dir;
         use tempfile::tempdir;
 
         let base_dir = tempdir().unwrap();
         let base_dir_path = base_dir.path();
         let beneath_repo = base_dir_path.join("a");
         let root = base_dir_path.join("a/b");
         let out_of_repo = base_dir_path.join("c");
         let under_repo_symlink = out_of_repo.join("d");
 
         create_dir(&beneath_repo).unwrap();
         create_dir(&root).unwrap();
 
         // TODO make portable
         std::os::unix::fs::symlink(&root, &out_of_repo).unwrap();
 
         assert_eq!(
             canonical_path(&root, Path::new(""), out_of_repo),
             Ok(PathBuf::from(""))
         );
         assert_eq!(
             canonical_path(&root, Path::new(""), &beneath_repo),
             Err(HgPathError::NotUnderRoot {
                 path: beneath_repo.to_owned(),
                 root: root.to_owned()
             })
         );
         assert_eq!(
             canonical_path(&root, Path::new(""), &under_repo_symlink),
             Ok(PathBuf::from("d"))
         );
     }
 }