rust: run rfmt on all hg-core/hg-cpython code

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

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

@@ -1,355 +1,357 b''
 // dirs_multiset.rs
 //
 // Copyright 2019 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.
 
 //! A multiset of directory names.
 //!
 //! Used to counts the references to directories in a manifest or dirstate.
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::ops::Deref;
 use {DirsIterable, DirstateEntry, DirstateMapError};
 
 #[derive(PartialEq, Debug)]
 pub struct DirsMultiset {
     inner: HashMap<Vec<u8>, u32>,
 }
 
 impl Deref for DirsMultiset {
     type Target = HashMap<Vec<u8>, u32>;
 
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
 
 impl DirsMultiset {
     /// Initializes the multiset from a dirstate or a manifest.
     ///
     /// If `skip_state` is provided, skips dirstate entries with equal state.
     pub fn new(iterable: DirsIterable, skip_state: Option<i8>) -> Self {
         let mut multiset = DirsMultiset {
             inner: HashMap::new(),
         };
 
         match iterable {
             DirsIterable::Dirstate(vec) => {
                 for (ref filename, DirstateEntry { state, .. }) in vec {
                     // This `if` is optimized out of the loop
                     if let Some(skip) = skip_state {
                         if skip != state {
                             multiset.add_path(filename);
                         }
                     } else {
                         multiset.add_path(filename);
                     }
                 }
             }
             DirsIterable::Manifest(vec) => {
                 for ref filename in vec {
                     multiset.add_path(filename);
                 }
             }
         }
 
         multiset
     }
 
     /// Returns the slice up to the next directory name from right to left,
     /// without trailing slash
     fn find_dir(path: &[u8]) -> &[u8] {
         let mut path = path;
         loop {
             if let Some(new_pos) = path.len().checked_sub(1) {
                 if path[new_pos] == b'/' {
                     break &path[..new_pos];
                 }
                 path = &path[..new_pos];
             } else {
                 break &[];
             }
         }
     }
 
     /// Increases the count of deepest directory contained in the path.
     ///
     /// If the directory is not yet in the map, adds its parents.
     pub fn add_path(&mut self, path: &[u8]) {
         let mut pos = path.len();
 
         loop {
             let subpath = Self::find_dir(&path[..pos]);
             if let Some(val) = self.inner.get_mut(subpath) {
                 *val += 1;
                 break;
             }
             self.inner.insert(subpath.to_owned(), 1);
 
             pos = subpath.len();
             if pos == 0 {
                 break;
             }
         }
     }
 
     /// Decreases the count of deepest directory contained in the path.
     ///
     /// If it is the only reference, decreases all parents until one is
     /// removed.
     /// If the directory is not in the map, something horrible has happened.
     pub fn delete_path(
         &mut self,
         path: &[u8],
     ) -> Result<(), DirstateMapError> {
         let mut pos = path.len();
 
         loop {
             let subpath = Self::find_dir(&path[..pos]);
             match self.inner.entry(subpath.to_owned()) {
                 Entry::Occupied(mut entry) => {
                     let val = entry.get().clone();
                     if val > 1 {
                         entry.insert(val - 1);
                         break;
                     }
                     entry.remove();
                 }
                 Entry::Vacant(_) => {
-                    return Err(DirstateMapError::PathNotFound(path.to_owned()))
+                    return Err(DirstateMapError::PathNotFound(
+                        path.to_owned(),
+                    ))
                 }
             };
 
             pos = subpath.len();
             if pos == 0 {
                 break;
             }
         }
 
         Ok(())
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_delete_path_path_not_found() {
         let mut map = DirsMultiset::new(DirsIterable::Manifest(vec![]), None);
         let path = b"doesnotexist/";
         assert_eq!(
             Err(DirstateMapError::PathNotFound(path.to_vec())),
             map.delete_path(path)
         );
     }
 
     #[test]
     fn test_delete_path_empty_path() {
         let mut map =
             DirsMultiset::new(DirsIterable::Manifest(vec![vec![]]), None);
         let path = b"";
         assert_eq!(Ok(()), map.delete_path(path));
         assert_eq!(
             Err(DirstateMapError::PathNotFound(path.to_vec())),
             map.delete_path(path)
         );
     }
 
     #[test]
     fn test_delete_path_successful() {
         let mut map = DirsMultiset {
             inner: [("", 5), ("a", 3), ("a/b", 2), ("a/c", 1)]
                 .iter()
                 .map(|(k, v)| (k.as_bytes().to_vec(), *v))
                 .collect(),
         };
 
         assert_eq!(Ok(()), map.delete_path(b"a/b/"));
         assert_eq!(Ok(()), map.delete_path(b"a/b/"));
         assert_eq!(
             Err(DirstateMapError::PathNotFound(b"a/b/".to_vec())),
             map.delete_path(b"a/b/")
         );
 
         assert_eq!(2, *map.get(&b"a".to_vec()).unwrap());
         assert_eq!(1, *map.get(&b"a/c".to_vec()).unwrap());
         eprintln!("{:?}", map);
         assert_eq!(Ok(()), map.delete_path(b"a/"));
         eprintln!("{:?}", map);
 
         assert_eq!(Ok(()), map.delete_path(b"a/c/"));
         assert_eq!(
             Err(DirstateMapError::PathNotFound(b"a/c/".to_vec())),
             map.delete_path(b"a/c/")
         );
     }
 
     #[test]
     fn test_add_path_empty_path() {
         let mut map = DirsMultiset::new(DirsIterable::Manifest(vec![]), None);
         let path = b"";
         map.add_path(path);
 
         assert_eq!(1, map.len());
     }
 
     #[test]
     fn test_add_path_successful() {
         let mut map = DirsMultiset::new(DirsIterable::Manifest(vec![]), None);
 
         map.add_path(b"a/");
         assert_eq!(1, *map.get(&b"a".to_vec()).unwrap());
         assert_eq!(1, *map.get(&Vec::new()).unwrap());
         assert_eq!(2, map.len());
 
         // Non directory should be ignored
         map.add_path(b"a");
         assert_eq!(1, *map.get(&b"a".to_vec()).unwrap());
         assert_eq!(2, map.len());
 
         // Non directory will still add its base
         map.add_path(b"a/b");
         assert_eq!(2, *map.get(&b"a".to_vec()).unwrap());
         assert_eq!(2, map.len());
 
         // Duplicate path works
         map.add_path(b"a/");
         assert_eq!(3, *map.get(&b"a".to_vec()).unwrap());
 
         // Nested dir adds to its base
         map.add_path(b"a/b/");
         assert_eq!(4, *map.get(&b"a".to_vec()).unwrap());
         assert_eq!(1, *map.get(&b"a/b".to_vec()).unwrap());
 
         // but not its base's base, because it already existed
         map.add_path(b"a/b/c/");
         assert_eq!(4, *map.get(&b"a".to_vec()).unwrap());
         assert_eq!(2, *map.get(&b"a/b".to_vec()).unwrap());
 
         map.add_path(b"a/c/");
         assert_eq!(1, *map.get(&b"a/c".to_vec()).unwrap());
 
         let expected = DirsMultiset {
             inner: [("", 2), ("a", 5), ("a/b", 2), ("a/b/c", 1), ("a/c", 1)]
                 .iter()
                 .map(|(k, v)| (k.as_bytes().to_vec(), *v))
                 .collect(),
         };
         assert_eq!(map, expected);
     }
 
     #[test]
     fn test_dirsmultiset_new_empty() {
         use DirsIterable::{Dirstate, Manifest};
 
         let new = DirsMultiset::new(Manifest(vec![]), None);
         let expected = DirsMultiset {
             inner: HashMap::new(),
         };
         assert_eq!(expected, new);
 
         let new = DirsMultiset::new(Dirstate(vec![]), None);
         let expected = DirsMultiset {
             inner: HashMap::new(),
         };
         assert_eq!(expected, new);
     }
 
     #[test]
     fn test_dirsmultiset_new_no_skip() {
         use DirsIterable::{Dirstate, Manifest};
 
         let input_vec = ["a/", "b/", "a/c", "a/d/"]
             .iter()
             .map(|e| e.as_bytes().to_vec())
             .collect();
         let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)]
             .iter()
             .map(|(k, v)| (k.as_bytes().to_vec(), *v))
             .collect();
 
         let new = DirsMultiset::new(Manifest(input_vec), None);
         let expected = DirsMultiset {
             inner: expected_inner,
         };
         assert_eq!(expected, new);
 
         let input_map = ["a/", "b/", "a/c", "a/d/"]
             .iter()
             .map(|f| {
                 (
                     f.as_bytes().to_vec(),
                     DirstateEntry {
                         state: 0,
                         mode: 0,
                         mtime: 0,
                         size: 0,
                     },
                 )
             })
             .collect();
         let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)]
             .iter()
             .map(|(k, v)| (k.as_bytes().to_vec(), *v))
             .collect();
 
         let new = DirsMultiset::new(Dirstate(input_map), None);
         let expected = DirsMultiset {
             inner: expected_inner,
         };
         assert_eq!(expected, new);
     }
 
     #[test]
     fn test_dirsmultiset_new_skip() {
         use DirsIterable::{Dirstate, Manifest};
 
         let input_vec = ["a/", "b/", "a/c", "a/d/"]
             .iter()
             .map(|e| e.as_bytes().to_vec())
             .collect();
         let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)]
             .iter()
             .map(|(k, v)| (k.as_bytes().to_vec(), *v))
             .collect();
 
         let new = DirsMultiset::new(Manifest(input_vec), Some('n' as i8));
         let expected = DirsMultiset {
             inner: expected_inner,
         };
         // Skip does not affect a manifest
         assert_eq!(expected, new);
 
         let input_map =
             [("a/", 'n'), ("a/b/", 'n'), ("a/c", 'r'), ("a/d/", 'm')]
                 .iter()
                 .map(|(f, state)| {
                     (
                         f.as_bytes().to_vec(),
                         DirstateEntry {
                             state: *state as i8,
                             mode: 0,
                             mtime: 0,
                             size: 0,
                         },
                     )
                 })
                 .collect();
 
         // "a" incremented with "a/c" and "a/d/"
         let expected_inner = [("", 1), ("a", 2), ("a/d", 1)]
             .iter()
             .map(|(k, v)| (k.as_bytes().to_vec(), *v))
             .collect();
 
         let new = DirsMultiset::new(Dirstate(input_map), Some('n' as i8));
         let expected = DirsMultiset {
             inner: expected_inner,
         };
         assert_eq!(expected, new);
     }
 
 }

rust/hg-cpython/src/dagops.rs

@@ -1,53 +1,53 b''
 // dagops.rs
 //
 // Copyright 2019 Georges Racinet <[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.
 
 //! Bindings for the `hg::dagops` module provided by the
 //! `hg-core` package.
 //!
 //! From Python, this will be seen as `mercurial.rustext.dagop`
+use crate::conversion::{py_set, rev_pyiter_collect};
 use cindex::Index;
 use cpython::{PyDict, PyModule, PyObject, PyResult, Python};
-use crate::conversion::{py_set, rev_pyiter_collect};
 use exceptions::GraphError;
 use hg::dagops;
 use hg::Revision;
 use std::collections::HashSet;
 
 /// Using the the `index`, return heads out of any Python iterable of Revisions
 ///
 /// This is the Rust counterpart for `mercurial.dagop.headrevs`
 pub fn headrevs(
     py: Python,
     index: PyObject,
     revs: PyObject,
 ) -> PyResult<PyObject> {
     let mut as_set: HashSet<Revision> = rev_pyiter_collect(py, &revs)?;
     dagops::retain_heads(&Index::new(py, index)?, &mut as_set)
         .map_err(|e| GraphError::pynew(py, e))?;
     py_set(py, &as_set)
 }
 
 /// Create the module, with `__package__` given from parent
 pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
     let dotted_name = &format!("{}.dagop", package);
     let m = PyModule::new(py, dotted_name)?;
     m.add(py, "__package__", package)?;
     m.add(py, "__doc__", "DAG operations - Rust implementation")?;
     m.add(
         py,
         "headrevs",
         py_fn!(py, headrevs(index: PyObject, revs: PyObject)),
     )?;
 
     let sys = PyModule::import(py, "sys")?;
     let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
     sys_modules.set_item(py, dotted_name, &m)?;
     // Example C code (see pyexpat.c and import.c) will "give away the
     // reference", but we won't because it will be consumed once the
     // Rust PyObject is dropped.
     Ok(m)
 }

rust/hg-cpython/src/exceptions.rs

@@ -1,72 +1,67 b''
 // ancestors.rs
 //
 // Copyright 2018 Georges Racinet <[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.
 
 //! Bindings for Rust errors
 //!
 //! [`GraphError`] exposes `hg::GraphError` as a subclass of `ValueError`
 //! but some variants of `hg::GraphError` can be converted directly to other
 //! existing Python exceptions if appropriate.
 //!
 //! [`GraphError`]: struct.GraphError.html
-use cpython::exc::{ValueError, RuntimeError};
-use cpython::{PyErr, Python, exc};
+use cpython::exc::{RuntimeError, ValueError};
+use cpython::{exc, PyErr, Python};
 use hg;
 
 py_exception!(rustext, GraphError, ValueError);
 
 impl GraphError {
     pub fn pynew(py: Python, inner: hg::GraphError) -> PyErr {
         match inner {
             hg::GraphError::ParentOutOfRange(r) => {
                 GraphError::new(py, ("ParentOutOfRange", r))
             }
             hg::GraphError::WorkingDirectoryUnsupported => {
                 match py
                     .import("mercurial.error")
                     .and_then(|m| m.get(py, "WdirUnsupported"))
                     {
                         Err(e) => e,
                         Ok(cls) => PyErr::from_instance(py, cls),
                     }
             }
         }
     }
 }
 
 py_exception!(rustext, PatternError, RuntimeError);
 py_exception!(rustext, PatternFileError, RuntimeError);
 
 impl PatternError {
     pub fn pynew(py: Python, inner: hg::PatternError) -> PyErr {
         match inner {
             hg::PatternError::UnsupportedSyntax(m) => {
                 PatternError::new(py, ("PatternError", m))
             }
         }
     }
 }
 
-
 impl PatternFileError {
     pub fn pynew(py: Python, inner: hg::PatternFileError) -> PyErr {
         match inner {
             hg::PatternFileError::IO(e) => {
-                let value = (
-                    e.raw_os_error().unwrap_or(2),
-                    e.to_string()
-                );
+                let value = (e.raw_os_error().unwrap_or(2), e.to_string());
                 PyErr::new::<exc::IOError, _>(py, value)
             }
-            hg::PatternFileError::Pattern(e, l) => {
-                match e {
-                    hg::PatternError::UnsupportedSyntax(m) =>
+            hg::PatternFileError::Pattern(e, l) => match e {
+                hg::PatternError::UnsupportedSyntax(m) => {
                         PatternFileError::new(py, ("PatternFileError", m, l))
                 }
+            },
+        }
             }
         }
-    }
-}

rust/hg-cpython/src/lib.rs

@@ -1,53 +1,65 b''
 // lib.rs
 //
 // Copyright 2018 Georges Racinet <[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.
 
 //! Python bindings of `hg-core` objects using the `cpython` crate.
 //! Once compiled, the resulting single shared library object can be placed in
 //! the `mercurial` package directly as `rustext.so` or `rustext.dll`.
 //! It holds several modules, so that from the point of view of Python,
 //! it behaves as the `cext` package.
 //!
 //! Example:
 //!
 //! ```text
 //! >>> from mercurial.rustext import ancestor
 //! >>> ancestor.__doc__
 //! 'Generic DAG ancestor algorithms - Rust implementation'
 //! ```
 
 #[macro_use]
 extern crate cpython;
 extern crate hg;
 extern crate libc;
 
 pub mod ancestors;
 mod cindex;
 mod conversion;
 pub mod dagops;
+pub mod dirstate;
 pub mod discovery;
 pub mod exceptions;
-pub mod dirstate;
 pub mod filepatterns;
 
 py_module_initializer!(rustext, initrustext, PyInit_rustext, |py, m| {
     m.add(
         py,
         "__doc__",
         "Mercurial core concepts - Rust implementation",
     )?;
 
     let dotted_name: String = m.get(py, "__name__")?.extract(py)?;
     m.add(py, "ancestor", ancestors::init_module(py, &dotted_name)?)?;
     m.add(py, "dagop", dagops::init_module(py, &dotted_name)?)?;
     m.add(py, "discovery", discovery::init_module(py, &dotted_name)?)?;
     m.add(py, "dirstate", dirstate::init_module(py, &dotted_name)?)?;
-    m.add(py, "filepatterns", filepatterns::init_module(py, &dotted_name)?)?;
+    m.add(
+        py,
+        "filepatterns",
+        filepatterns::init_module(py, &dotted_name)?,
+    )?;
     m.add(py, "GraphError", py.get_type::<exceptions::GraphError>())?;
-    m.add(py, "PatternFileError", py.get_type::<exceptions::PatternFileError>())?;
-    m.add(py, "PatternError", py.get_type::<exceptions::PatternError>())?;
+    m.add(
+        py,
+        "PatternFileError",
+        py.get_type::<exceptions::PatternFileError>(),
+    )?;
+    m.add(
+        py,
+        "PatternError",
+        py.get_type::<exceptions::PatternError>(),
+    )?;
     Ok(())
 });