This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6756

rust-utils: add normalize_case util to mirror Python one
ClosedPublic

Authored by Alphare on Aug 22 2019, 8:54 AM.

Details

Reviewers
kevincox
Group Reviewers
hg-reviewers
Commits
rHGb1b984f9c01d: rust-utils: add normalize_case util to mirror Python one
rHG6edca369d242: rust-utils: add normalize_case util to mirror Python one
Summary

While we still don't handle filenames properly cross-platform, this at least
sticks closer to the Python behavior.

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.Aug 22 2019, 8:54 AM
kevincox accepted this revision.Aug 28 2019, 5:21 AM
Alphare added a commit: rHG6edca369d242: rust-utils: add normalize_case util to mirror Python one.Aug 31 2019, 6:59 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG6edca369d242: rust-utils: add normalize_case util to mirror Python one (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.
yuja added a subscriber: yuja.Aug 31 2019, 11:02 PM

+/ TODO improve handling of utf8 file names. Our overall strategy for
+/ filenames has to be revisited anyway, since Windows is UTF-16.
+pub fn normalize_case(bytes: &[u8]) -> Vec<u8> {
+ #[cfg(windows)] // NTFS compares via upper()
+ return bytes.to_ascii_uppercase();
+ #[cfg(unix)]
+ bytes.to_ascii_lowercase()
+}

HFS+ has more complex rules, and some were the source of security issue.

Revision Contents
Changeset List

Diff 16355

rust/hg-core/src/dirstate/dirstate_map.rs

// dirstate_map.rs // dirstate_map.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 crate::{ use crate::{
dirstate::{parsers::PARENT_SIZE, EntryState}, dirstate::{parsers::PARENT_SIZE, EntryState},
pack_dirstate, parse_dirstate, CopyMap, DirsMultiset, DirstateEntry, pack_dirstate, parse_dirstate,
DirstateError, DirstateMapError, DirstateParents, DirstateParseError, utils::files::normalize_case,
StateMap, CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError,
DirstateParents, DirstateParseError, StateMap,
}; };
use core::borrow::Borrow; use core::borrow::Borrow;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::convert::TryInto; use std::convert::TryInto;
use std::iter::FromIterator; use std::iter::FromIterator;
use std::ops::Deref; use std::ops::Deref;
use std::time::Duration; use std::time::Duration;
} }
if old_state == EntryState::Unknown { if old_state == EntryState::Unknown {
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
all_dirs.add_path(filename); all_dirs.add_path(filename);
} }
} }
if let Some(ref mut file_fold_map) = self.file_fold_map { if let Some(ref mut file_fold_map) = self.file_fold_map {
file_fold_map.remove(&filename.to_ascii_uppercase()); file_fold_map.remove(&normalize_case(filename));
} }
self.state_map.insert( self.state_map.insert(
filename.to_owned(), filename.to_owned(),
DirstateEntry { DirstateEntry {
state: EntryState::Removed, state: EntryState::Removed,
mode: 0, mode: 0,
size, size,
mtime: 0, mtime: 0,
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
} }
} }
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
all_dirs.delete_path(filename)?; all_dirs.delete_path(filename)?;
} }
} }
if let Some(ref mut file_fold_map) = self.file_fold_map { if let Some(ref mut file_fold_map) = self.file_fold_map {
file_fold_map.remove(&filename.to_ascii_uppercase()); file_fold_map.remove(&normalize_case(filename));
} }
self.non_normal_set.remove(filename); self.non_normal_set.remove(filename);
Ok(exists) Ok(exists)
} }
pub fn clear_ambiguous_times( pub fn clear_ambiguous_times(
&mut self, &mut self,
pub fn build_file_fold_map(&mut self) -> &FileFoldMap { pub fn build_file_fold_map(&mut self) -> &FileFoldMap {
if let Some(ref file_fold_map) = self.file_fold_map { if let Some(ref file_fold_map) = self.file_fold_map {
return file_fold_map; return file_fold_map;
} }
let mut new_file_fold_map = FileFoldMap::new(); let mut new_file_fold_map = FileFoldMap::new();
for (filename, DirstateEntry { state, .. }) in self.state_map.borrow() for (filename, DirstateEntry { state, .. }) in self.state_map.borrow()
{ {
if *state == EntryState::Removed { if *state == EntryState::Removed {
new_file_fold_map.insert( new_file_fold_map
filename.to_ascii_uppercase().to_owned(), .insert(normalize_case(filename), filename.to_owned());
filename.to_owned(),
);
} }
} }
self.file_fold_map = Some(new_file_fold_map); self.file_fold_map = Some(new_file_fold_map);
self.file_fold_map.as_ref().unwrap() self.file_fold_map.as_ref().unwrap()
} }
} }
#[cfg(test)] #[cfg(test)]

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

pub fn find_dirs<'a>(path: &'a [u8]) -> Ancestors<'a> { pub fn find_dirs<'a>(path: &'a [u8]) -> Ancestors<'a> {
let mut dirs = Ancestors { next: Some(path) }; let mut dirs = Ancestors { next: Some(path) };
if !path.is_empty() { if !path.is_empty() {
dirs.next(); // skip itself dirs.next(); // skip itself
} }
dirs dirs
} }
/// TODO improve handling of utf8 file names. Our overall strategy for
/// filenames has to be revisited anyway, since Windows is UTF-16.
pub fn normalize_case(bytes: &[u8]) -> Vec<u8> {
#[cfg(windows)] // NTFS compares via upper()
return bytes.to_ascii_uppercase();
#[cfg(unix)]
bytes.to_ascii_lowercase()
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
#[test] #[test]
fn find_dirs_some() { fn find_dirs_some() {
let mut dirs = super::find_dirs(b"foo/bar/baz"); let mut dirs = super::find_dirs(b"foo/bar/baz");
assert_eq!(dirs.next(), Some(b"foo/bar".as_ref())); assert_eq!(dirs.next(), Some(b"foo/bar".as_ref()));
assert_eq!(dirs.next(), Some(b"foo".as_ref())); assert_eq!(dirs.next(), Some(b"foo".as_ref()));
assert_eq!(dirs.next(), Some(b"".as_ref())); assert_eq!(dirs.next(), Some(b"".as_ref()));