This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9959

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

Authored by SimonSapin on Feb 5 2021, 4:26 AM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHG0d734c0ae1cf: rust: replace read_whole_file with std::fs::read
Summary

It does the same thing

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

SimonSapin created this revision.Feb 5 2021, 4:26 AM
Alphare accepted this revision.Feb 8 2021, 9:01 AM
Alphare added a subscriber: Alphare.

I think that this code predated an update to std::fs::read, I should have checked. :)

pulkit accepted this revision.Feb 10 2021, 7:04 AM
This revision is now accepted and ready to land.Feb 10 2021, 7:04 AM
SimonSapin added a commit: rHG0d734c0ae1cf: rust: replace read_whole_file with std::fs::read.Feb 10 2021, 8:07 AM
Closed by commit rHG0d734c0ae1cf: rust: replace read_whole_file with std::fs::read (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25526

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

// config.rs // config.rs
// //
// Copyright 2020 // Copyright 2020
// Valentin Gatien-Baron, // Valentin Gatien-Baron,
// Raphaël Gomès <rgomes@octobus.net> // 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 super::layer; use super::layer;
use crate::config::layer::{ use crate::config::layer::{
ConfigError, ConfigLayer, ConfigParseError, ConfigValue, ConfigError, ConfigLayer, ConfigParseError, ConfigValue,
}; };
use std::path::PathBuf; use std::path::PathBuf;
use crate::repo::Repo; use crate::repo::Repo;
use crate::utils::files::read_whole_file;
/// Holds the config values for the current repository /// Holds the config values for the current repository
/// TODO update this docstring once we support more sources /// TODO update this docstring once we support more sources
pub struct Config { pub struct Config {
layers: Vec<layer::ConfigLayer>, layers: Vec<layer::ConfigLayer>,
} }
impl std::fmt::Debug for Config { impl std::fmt::Debug for Config {
let mut layers = vec![]; let mut layers = vec![];
for source in sources.into_iter() { for source in sources.into_iter() {
match source { match source {
ConfigSource::Parsed(c) => layers.push(c), ConfigSource::Parsed(c) => layers.push(c),
ConfigSource::AbsPath(c) => { ConfigSource::AbsPath(c) => {
// TODO check if it should be trusted // TODO check if it should be trusted
// mercurial/ui.py:427 // 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 Err(_) => continue, // same as the python code
Ok(data) => data, Ok(data) => data,
}; };
layers.extend(ConfigLayer::parse(&c, &data)?) layers.extend(ConfigLayer::parse(&c, &data)?)
} }
} }
} }

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

// layer.rs // layer.rs
// //
// Copyright 2020 // Copyright 2020
// Valentin Gatien-Baron, // Valentin Gatien-Baron,
// Raphaël Gomès <rgomes@octobus.net> // 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::errors::{HgError, IoResultExt}; use crate::errors::{HgError, IoResultExt};
use crate::utils::files::{ use crate::utils::files::{get_bytes_from_path, get_path_from_bytes};
get_bytes_from_path, get_path_from_bytes, read_whole_file,
};
use format_bytes::format_bytes; use format_bytes::format_bytes;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use regex::bytes::Regex; use regex::bytes::Regex;
use std::collections::HashMap; use std::collections::HashMap;
use std::io; use std::io;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
lazy_static! { lazy_static! {
/// Includes are relative to the file they're defined in, unless they're /// Includes are relative to the file they're defined in, unless they're
/// absolute. /// absolute.
fn read_include( fn read_include(
old_src: &Path, old_src: &Path,
new_src: &Path, new_src: &Path,
) -> (PathBuf, io::Result<Vec<u8>>) { ) -> (PathBuf, io::Result<Vec<u8>>) {
if new_src.is_absolute() { 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 { } else {
let dir = old_src.parent().unwrap(); let dir = old_src.parent().unwrap();
let new_src = dir.join(&new_src); 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

hg_path::{path_to_hg_path_buf, HgPath, HgPathBuf, HgPathError}, hg_path::{path_to_hg_path_buf, HgPath, HgPathBuf, HgPathError},
path_auditor::PathAuditor, path_auditor::PathAuditor,
replace_slice, replace_slice,
}; };
use lazy_static::lazy_static; use lazy_static::lazy_static;
use same_file::is_same_file; use same_file::is_same_file;
use std::borrow::{Cow, ToOwned}; use std::borrow::{Cow, ToOwned};
use std::fs::Metadata; use std::fs::Metadata;
use std::io::Read;
use std::iter::FusedIterator; use std::iter::FusedIterator;
use std::ops::Deref; use std::ops::Deref;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
pub fn get_path_from_bytes(bytes: &[u8]) -> &Path { pub fn get_path_from_bytes(bytes: &[u8]) -> &Path {
let os_str; let os_str;
#[cfg(unix)] #[cfg(unix)]
{ {
need_sep = true need_sep = true
}; };
res.extend(c); res.extend(c);
} }
Cow::Owned(res) 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)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use pretty_assertions::assert_eq; use pretty_assertions::assert_eq;
#[test] #[test]
fn find_dirs_some() { fn find_dirs_some() {
let mut dirs = super::find_dirs(HgPath::new(b"foo/bar/baz")); let mut dirs = super::find_dirs(HgPath::new(b"foo/bar/baz"));