cargo fmt

git-core/src/init.rs

@@ -32,8 +32,7 @@ const TPL_HOOKS_PREPARE_COMMIT_MSG: &'static [u8] =
     include_bytes!("../../tests/snapshots/cli/baseline-init/hooks/prepare-commit-msg.sample");
 const TPL_HOOKS_UPDATE: &'static [u8] =
     include_bytes!("../../tests/snapshots/cli/baseline-init/hooks/update.sample");
-const TPL_CONFIG: &'static [u8] =
-    include_bytes!("../../tests/snapshots/cli/baseline-init/config");
+const TPL_CONFIG: &'static [u8] = include_bytes!("../../tests/snapshots/cli/baseline-init/config");
 const TPL_DESCRIPTION: &'static [u8] =
     include_bytes!("../../tests/snapshots/cli/baseline-init/description");
 const TPL_HEAD: &'static [u8] = include_bytes!("../../tests/snapshots/cli/baseline-init/HEAD");

git-odb/examples/git-count.rs

@@ -3,7 +3,10 @@ extern crate failure;
 extern crate git_odb as odb;
 
 use failure::{Error, ResultExt};
-use std::{env, io::{stdout, Write}};
+use std::{
+    env,
+    io::{stdout, Write},
+};
 
 fn run() -> Result<(), Error> {
     let mut args = env::args().skip(1);
@@ -37,7 +40,8 @@ fn run() -> Result<(), Error> {
         blobs,
         tags,
         deltas,
-    ).map_err(Into::into)
+    )
+    .map_err(Into::into)
 }
 
 fn main() -> Result<(), Error> {

git-odb/src/lib.rs

@@ -11,11 +11,11 @@ extern crate walkdir;
 #[macro_use]
 extern crate itertools;
 
-mod zlib;
 mod types;
+mod zlib;
 
-pub mod object;
 pub mod loose;
+pub mod object;
 pub mod pack;
 
 pub use types::*;

git-odb/src/loose/db.rs

@@ -1,9 +1,9 @@
 use crate::object::Id;
 
-use walkdir::WalkDir;
 use failure::Error;
 use hex::FromHex;
 use std::path::PathBuf;
+use walkdir::WalkDir;
 
 pub struct Db {
     pub path: PathBuf,
@@ -21,7 +21,8 @@ impl Db {
                 let mut is_valid_path = false;
                 let e = e.map_err(Error::from).map(|e| {
                     let p = e.path();
-                    let (c1, c2) = p.components()
+                    let (c1, c2) = p
+                        .components()
                         .fold((None, None), |(_c1, c2), cn| (c2, Some(cn)));
                     if let (Some(Normal(c1)), Some(Normal(c2))) = (c1, c2) {
                         if c1.len() == 2 && c2.len() == 38 {

git-odb/src/loose/mod.rs

@@ -1,8 +1,8 @@
 const HEADER_READ_COMPRESSED_BYTES: usize = 512;
 const HEADER_READ_UNCOMPRESSED_BYTES: usize = 1024;
 
-mod object;
 mod db;
+mod object;
 
 pub use self::db::*;
 pub use self::object::*;

git-odb/src/loose/object.rs

@@ -1,25 +1,14 @@
 use crate::{
-    zlib,
-    object::{parsed, Kind},
-    loose::{HEADER_READ_COMPRESSED_BYTES, HEADER_READ_UNCOMPRESSED_BYTES},
     loose::Db,
-    object::Id
-};
-use failure::{
-    err_msg,
-    ResultExt,
-    Error
+    loose::{HEADER_READ_COMPRESSED_BYTES, HEADER_READ_UNCOMPRESSED_BYTES},
+    object::Id,
+    object::{parsed, Kind},
+    zlib,
 };
+use failure::{err_msg, Error, ResultExt};
 use hex::ToHex;
 use smallvec::SmallVec;
-use std::{
-    io::Cursor,
-    path::PathBuf,
-    str,
-    fs::File,
-    io::Read,
-    os::unix::fs::MetadataExt
-};
+use std::{fs::File, io::Cursor, io::Read, os::unix::fs::MetadataExt, path::PathBuf, str};
 
 pub struct Object {
     pub kind: Kind,

git-odb/src/object/parsed.rs

@@ -1,11 +1,10 @@
-use failure::{err_msg, Error, ResultExt};
 use crate::{
     object::{Id, Kind},
-    Sign,
-    Time
+    Sign, Time,
 };
-use std::str;
+use failure::{err_msg, Error, ResultExt};
 use hex::FromHex;
+use std::str;
 
 const PGP_SIGNATURE_BEGIN: &'static [u8] = b"-----BEGIN PGP SIGNATURE-----";
 const PGP_SIGNATURE_END: &'static [u8] = b"-----END PGP SIGNATURE-----";
@@ -80,7 +79,8 @@ fn parse_timezone_offset(d: &str) -> Result<(i32, Sign), Error> {
 
 fn parse_signature(d: &[u8]) -> Result<Signature, Error> {
     const ONE_SPACE: usize = 1;
-    let email_begin = d.iter()
+    let email_begin = d
+        .iter()
         .position(|&b| b == b'<')
         .ok_or_else(|| err_msg("Could not find beginning of email marked by '<'"))
         .and_then(|pos| {

git-odb/src/pack/index.rs

@@ -1,9 +1,9 @@
+use crate::object::{self, SHA1_SIZE};
+use byteorder::{BigEndian, ByteOrder};
 use failure::{Error, ResultExt};
-use std::path::Path;
 use filebuffer::FileBuffer;
-use byteorder::{BigEndian, ByteOrder};
-use crate::object::{self, SHA1_SIZE};
 use std::mem::size_of;
+use std::path::Path;
 
 const V2_SIGNATURE: &'static [u8] = b"\xfftOc";
 const FOOTER_SIZE: usize = SHA1_SIZE * 2;
@@ -95,20 +95,21 @@ impl File {
                 self.data[V2_SHA1_OFFSET..].chunks(SHA1_SIZE),
                 self.data[self.offset_crc32_v2()..].chunks(N32_SIZE),
                 self.data[self.offset_pack_offset_v2()..].chunks(N32_SIZE)
-            ).take(self.size as usize)
-                .map(move |(oid, crc32, ofs32)| Entry {
-                    oid: object::id_from_20_bytes(oid),
-                    offset: {
-                        let ofs32 = BigEndian::read_u32(ofs32);
-                        if ofs32 > MAX_N31 {
-                            let from = pack64_offset + (ofs32 as usize >> 1) * N64_SIZE;
-                            BigEndian::read_u64(&self.data[from..from + N64_SIZE])
-                        } else {
-                            ofs32 as u64
-                        }
-                    },
-                    crc32: Some(BigEndian::read_u32(crc32)),
-                }),
+            )
+            .take(self.size as usize)
+            .map(move |(oid, crc32, ofs32)| Entry {
+                oid: object::id_from_20_bytes(oid),
+                offset: {
+                    let ofs32 = BigEndian::read_u32(ofs32);
+                    if ofs32 > MAX_N31 {
+                        let from = pack64_offset + (ofs32 as usize >> 1) * N64_SIZE;
+                        BigEndian::read_u64(&self.data[from..from + N64_SIZE])
+                    } else {
+                        ofs32 as u64
+                    }
+                },
+                crc32: Some(BigEndian::read_u32(crc32)),
+            }),
             _ => bail!("Cannot use iter_v2() on index of type {:?}", self.kind),
         })
     }

git-odb/src/pack/pack.rs

@@ -1,8 +1,8 @@
 use failure::{Error, ResultExt};
 
 use byteorder::{BigEndian, ByteOrder};
-use std::{mem::size_of, path::Path};
 use filebuffer::FileBuffer;
+use std::{mem::size_of, path::Path};
 
 use crate::object::SHA1_SIZE;
 
@@ -62,8 +62,9 @@ impl File {
     }
 
     pub fn at(path: impl AsRef<Path>) -> Result<Self, Error> {
-        let data = FileBuffer::open(path.as_ref())
-            .with_context(|_| format!("Could not map pack file at '{}'", path.as_ref().display()))?;
+        let data = FileBuffer::open(path.as_ref()).with_context(|_| {
+            format!("Could not map pack file at '{}'", path.as_ref().display())
+        })?;
         let pack_len = data.len();
         if pack_len < N32_SIZE * 3 + SHA1_SIZE {
             bail!(
@@ -91,8 +92,8 @@ impl File {
 pub mod parsed {
     use crate::object;
 
-    use std::mem;
     use crate::object::SHA1_SIZE;
+    use std::mem;
 
     const _TYPE_EXT1: u8 = 0;
     const COMMIT: u8 = 1;

git-odb/src/zlib.rs

@@ -1,11 +1,16 @@
 use failure::Error;
 use miniz_oxide::inflate::core::DecompressorOxide;
+use miniz_oxide::inflate::{
+    core::{
+        decompress,
+        inflate_flags::{
+            TINFL_FLAG_HAS_MORE_INPUT, TINFL_FLAG_PARSE_ZLIB_HEADER,
+            TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF,
+        },
+    },
+    TINFLStatus,
+};
 use std::io::{self, Cursor};
-use miniz_oxide::inflate::{TINFLStatus,
-                           core::{decompress,
-                                  inflate_flags::{TINFL_FLAG_HAS_MORE_INPUT,
-                                                  TINFL_FLAG_PARSE_ZLIB_HEADER,
-                                                  TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF}}};
 
 pub struct Inflate {
     inner: DecompressorOxide,
@@ -64,7 +69,8 @@ impl Inflate {
             &mut self.inner,
             input,
             out,
-            TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_HAS_MORE_INPUT
+            TINFL_FLAG_PARSE_ZLIB_HEADER
+                | TINFL_FLAG_HAS_MORE_INPUT
                 | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF,
         );
 

git-odb/tests/loose.rs

@@ -5,10 +5,13 @@ mod utils;
 
 use utils::*;
 
-use std::{fs::File, io::Read};
-use odb::{loose::Db, object::{parsed, Kind}};
-use odb::Time;
 use odb::Sign;
+use odb::Time;
+use odb::{
+    loose::Db,
+    object::{parsed, Kind},
+};
+use std::{fs::File, io::Read};
 
 pub fn fixture_bytes(path: &str) -> Vec<u8> {
     let mut buf = Vec::new();

git-odb/tests/pack.rs

@@ -4,8 +4,8 @@ extern crate hex;
 mod utils;
 
 use odb::pack::{self, index};
-use utils::fixture;
 use utils::bin;
+use utils::fixture;
 
 const INDEX_V1: &'static str = "packs/pack-c0438c19fb16422b6bbcce24387b3264416d485b.idx";
 const PACK_FOR_INDEX_V1: &'static str = "packs/pack-c0438c19fb16422b6bbcce24387b3264416d485b.pack";

src/main.rs

@@ -4,8 +4,8 @@ extern crate failure_tools;
 extern crate clap;
 extern crate git_core as git;
 
-use failure_tools::ok_or_exit;
 use failure::{Error, ResultExt};
+use failure_tools::ok_or_exit;
 
 mod app {
     use clap::{App, AppSettings, SubCommand};
@@ -26,7 +26,8 @@ fn run() -> Result<(), Error> {
     match matches.subcommand() {
         ("init", Some(_args)) => git::init().with_context(|_| "Repository initialization failed"),
         _ => unreachable!(),
-    }.map_err(Into::into)
+    }
+    .map_err(Into::into)
 }
 
 fn main() {