rustfmt before editing

Summary: Code format.

Reviewed By: StanislavGlebik

Differential Revision: D14131431

fbshipit-source-id: 1b6f89382bbbe8b5bb033e3ecf7620d161d587e8

mercurial/src/changeset/mod.rs

@@ -10,8 +10,9 @@ use std::str::{self, FromStr};
 
 use bytes::Bytes;
 use errors::*;
-use mercurial_types::{HgBlob, HgBlobNode, HgChangesetEnvelope, HgManifestId, HgNodeHash,
-                      HgParents, MPath, NULL_HASH};
+use mercurial_types::{
+    HgBlob, HgBlobNode, HgChangesetEnvelope, HgManifestId, HgNodeHash, HgParents, MPath, NULL_HASH,
+};
 use mononoke_types::DateTime;
 
 #[cfg(test)]

mercurial/src/errors.rs

@@ -8,11 +8,18 @@ pub use failure::{Error, Result, ResultExt};
 
 #[derive(Debug, Fail)]
 pub enum ErrorKind {
-    #[fail(display = "Bundle2Decode: {}", _0)] Bundle2Decode(String),
-    #[fail(display = "Revlog: {}", _0)] Revlog(String),
-    #[fail(display = "Repo: {}", _0)] Repo(String),
-    #[fail(display = "Path: {}", _0)] Path(String),
-    #[fail(display = "Unknown requirement: {}", _0)] UnknownReq(String),
-    #[fail(display = "invalid Thrift structure '{}': {}", _0, _1)] InvalidThrift(String, String),
-    #[fail(display = "Incorrect LFS file content {}", _0)] IncorrectLfsFileContent(String),
+    #[fail(display = "Bundle2Decode: {}", _0)]
+    Bundle2Decode(String),
+    #[fail(display = "Revlog: {}", _0)]
+    Revlog(String),
+    #[fail(display = "Repo: {}", _0)]
+    Repo(String),
+    #[fail(display = "Path: {}", _0)]
+    Path(String),
+    #[fail(display = "Unknown requirement: {}", _0)]
+    UnknownReq(String),
+    #[fail(display = "invalid Thrift structure '{}': {}", _0, _1)]
+    InvalidThrift(String, String),
+    #[fail(display = "Incorrect LFS file content {}", _0)]
+    IncorrectLfsFileContent(String),
 }

mercurial/src/lib.rs

@@ -15,35 +15,26 @@ extern crate flate2;
 extern crate futures;
 #[macro_use]
 extern crate futures_ext;
-
 #[macro_use]
 extern crate failure_ext as failure;
-
 extern crate heapsize;
-
 #[macro_use]
 extern crate nom;
-
 #[macro_use]
 extern crate bitflags;
-
 #[cfg(test)]
 #[macro_use]
 extern crate assert_matches;
-
 extern crate itertools;
 extern crate memmap;
-
-#[cfg_attr(test, macro_use)]
-extern crate quickcheck;
-
-extern crate serde;
-
 extern crate mercurial_types;
 extern crate mercurial_types_mocks;
 extern crate mononoke_types;
 extern crate mononoke_types_thrift;
 extern crate pylz4;
+#[cfg_attr(test, macro_use)]
+extern crate quickcheck;
+extern crate serde;
 
 pub mod changeset;
 mod errors;
@@ -52,9 +43,9 @@ pub mod manifest;
 pub mod revlog;
 pub mod revlogrepo;
 pub mod stockbookmarks;
-pub use errors::*;
 
 pub use changeset::RevlogChangeset;
+pub use errors::*;
 pub use manifest::{EntryContent, RevlogEntry};
 pub use revlogrepo::{RevlogManifest, RevlogRepo, RevlogRepoOptions};
 

mercurial/src/manifest/manifest_utils.rs

@@ -14,8 +14,8 @@ use futures_ext::{BoxStream, StreamExt};
 
 use mercurial_types::{MPath, MPathElement, Type};
 
-use super::{RevlogEntry, RevlogManifest};
 use super::revlog::EntryContent;
+use super::{RevlogEntry, RevlogManifest};
 
 use errors::*;
 
@@ -201,7 +201,8 @@ fn recursive_changed_entry_stream(changed_entry: ChangedEntry) -> BoxStream<Chan
                             MPath::join_element_opt(path.as_ref(), entry_path.as_ref()),
                             &to_manifest,
                             &from_manifest,
-                        ).map(recursive_changed_entry_stream)
+                        )
+                        .map(recursive_changed_entry_stream)
                     })
                     .flatten_stream()
                     .flatten();

mercurial/src/manifest/revlog.rs

@@ -9,16 +9,17 @@ use std::io::{self, Write};
 use std::str;
 use std::vec;
 
-use futures::{Async, Poll};
 use futures::future::{self, Future, IntoFuture};
 use futures::stream::{self, Stream};
+use futures::{Async, Poll};
 use futures_ext::{BoxFuture, BoxStream, FutureExt, StreamExt};
 
 use errors::*;
 use file;
-use mercurial_types::{FileType, HgBlob, HgBlobNode, HgEntryId, HgNodeHash, HgParents, MPath,
-                      MPathElement, RepoPath};
 use mercurial_types::manifest::Type;
+use mercurial_types::{
+    FileType, HgBlob, HgBlobNode, HgEntryId, HgNodeHash, HgParents, MPath, MPathElement, RepoPath,
+};
 use mononoke_types::FileContents;
 
 use RevlogRepo;
@@ -172,7 +173,8 @@ impl RevlogManifest {
             Some(ref repo) => repo.clone(),
             None => return future::ok(None).boxify(),
         };
-        let res = self.content
+        let res = self
+            .content
             .files
             .get(path)
             .map(|details| RevlogEntry::new(repo, path.clone(), *details));
@@ -188,7 +190,8 @@ impl RevlogManifest {
             Some(ref repo) => repo.clone(),
             None => return stream::empty().boxify(),
         };
-        let v: Vec<_> = self.manifest()
+        let v: Vec<_> = self
+            .manifest()
             .into_iter()
             .map(|(p, d)| (p.clone(), *d))
             .collect();
@@ -224,10 +227,7 @@ impl Details {
             }
         };
 
-        Ok(Details {
-            entryid: entryid,
-            flag: flag,
-        })
+        Ok(Details { entryid, flag })
     }
 
     fn generate<W: Write>(&self, out: &mut W) -> io::Result<()> {
@@ -488,17 +488,15 @@ mod test {
         ) {
             Ok(m) => {
                 assert_eq!(m.parents(), &HgParents::One(THREES_HASH));
-                let expect = vec![
-                    (
-                        MPath::new(b"hello123").unwrap(),
-                        Details {
-                            entryid: HgEntryId::new(
-                                "da39a3ee5e6b4b0d3255bfef95601890afd80709".parse().unwrap(),
-                            ),
-                            flag: Type::File(FileType::Symlink),
-                        },
-                    ),
-                ];
+                let expect = vec![(
+                    MPath::new(b"hello123").unwrap(),
+                    Details {
+                        entryid: HgEntryId::new(
+                            "da39a3ee5e6b4b0d3255bfef95601890afd80709".parse().unwrap(),
+                        ),
+                        flag: Type::File(FileType::Symlink),
+                    },
+                )];
                 assert_eq!(m.content.files.into_iter().collect::<Vec<_>>(), expect);
             }
             Err(e) => println!("got expected error: {}", e),

mercurial/src/revlog/mod.rs

@@ -20,19 +20,19 @@ use failure;
 use memmap::Mmap;
 use nom::IResult;
 
-pub use mercurial_types::{delta, HgBlob, HgBlobNode, HgEntryId, HgNodeHash, HgParents};
 pub use mercurial_types::bdiff::{self, Delta};
+pub use mercurial_types::{delta, HgBlob, HgBlobNode, HgEntryId, HgNodeHash, HgParents};
 
 // Submodules
+mod lz4;
 mod parser;
 mod revidx;
-mod lz4;
 
 #[cfg(test)]
 mod test;
 
-use self::parser::{Header, IdxFlags, Version};
 pub use self::parser::Entry;
+use self::parser::{Header, IdxFlags, Version};
 pub use self::revidx::RevIdx;
 
 #[derive(Debug)]
@@ -117,8 +117,8 @@ impl Revlog {
 
         let mut inner = RevlogInner {
             header: hdr,
-            idx: idx,
-            data: data,
+            idx,
+            data,
             idxoff: BTreeMap::new(),
             nodeidx: HashMap::new(),
         };

mercurial/src/revlog/parser.rs

@@ -10,9 +10,9 @@ use std::fmt::Debug;
 use std::io::Read;
 
 use flate2::read::ZlibDecoder;
-use nom::{Err, ErrorKind, IResult, Needed, be_u16, be_u32};
+use nom::{be_u16, be_u32, Err, ErrorKind, IResult, Needed};
 
-use mercurial_types::{HgNodeHash, bdiff::Delta};
+use mercurial_types::{bdiff::Delta, HgNodeHash};
 
 use revlog::revidx::RevIdx;
 
@@ -269,8 +269,12 @@ fn be_u48(i: &[u8]) -> IResult<&[u8], u64> {
     if i.len() < 6 {
         IResult::Incomplete(Needed::Size(6))
     } else {
-        let res = ((i[0] as u64) << 40) + ((i[1] as u64) << 32) + ((i[2] as u64) << 24)
-            + ((i[3] as u64) << 16) + ((i[4] as u64) << 8) + ((i[5] as u64) << 0);
+        let res = ((i[0] as u64) << 40)
+            + ((i[1] as u64) << 32)
+            + ((i[2] as u64) << 24)
+            + ((i[3] as u64) << 16)
+            + ((i[4] as u64) << 8)
+            + ((i[5] as u64) << 0);
         IResult::Done(&i[6..], res)
     }
 }

mercurial/src/revlogrepo.rs

@@ -6,8 +6,8 @@
 
 extern crate bytes;
 
-use std::collections::HashSet;
 use std::collections::hash_map::{Entry, HashMap};
+use std::collections::HashSet;
 use std::fmt::{self, Display};
 use std::fs;
 use std::io::{BufRead, BufReader};
@@ -15,13 +15,15 @@ use std::path::PathBuf;
 use std::str::FromStr;
 use std::sync::{Arc, RwLock};
 
-use futures::{Async, IntoFuture, Poll, Stream};
 use futures::future;
 use futures::stream;
+use futures::{Async, IntoFuture, Poll, Stream};
 use futures_ext::{BoxFuture, BoxStream, FutureExt, StreamExt};
 
-use mercurial_types::{fncache_fsencode, simple_fsencode, HgChangesetId, HgManifestId, HgNodeHash,
-                      MPath, MPathElement, RepoPath};
+use mercurial_types::{
+    fncache_fsencode, simple_fsencode, HgChangesetId, HgManifestId, HgNodeHash, MPath,
+    MPathElement, RepoPath,
+};
 use stockbookmarks::StockBookmarks;
 
 pub use changeset::RevlogChangeset;
@@ -106,8 +108,7 @@ impl FromStr for Required {
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum StoreRequired {
-}
+pub enum StoreRequired {}
 
 impl Display for StoreRequired {
     fn fmt(&self, _fmt: &mut fmt::Formatter) -> fmt::Result {
@@ -163,7 +164,8 @@ struct RevlogInner {
 
 impl PartialEq<Self> for RevlogRepo {
     fn eq(&self, other: &Self) -> bool {
-        self.basepath == other.basepath && self.requirements == other.requirements
+        self.basepath == other.basepath
+            && self.requirements == other.requirements
             && Arc::ptr_eq(&self.inner, &other.inner)
     }
 }
@@ -198,8 +200,8 @@ impl RevlogRepo {
             let store_requirements_file = store.join("requires");
             // A missing store/requires files is the same as an empty one.
             if store_requirements_file.exists() {
-                let file =
-                    fs::File::open(store_requirements_file).context("Can't open `store/requires`")?;
+                let file = fs::File::open(store_requirements_file)
+                    .context("Can't open `store/requires`")?;
                 for line in BufReader::new(file).lines() {
                     store_requirements.insert(line.context("Line read failed")?.parse()?);
                 }

mercurial/src/stockbookmarks.rs

@@ -10,18 +10,19 @@ use std::io::{self, BufRead, BufReader, Read};
 use std::path::PathBuf;
 
 use ascii::AsciiStr;
-use failure::{Error, Result, chain::*};
+use failure::{chain::*, Error, Result};
 use futures::future;
 use futures::stream::{self, Stream};
 use futures_ext::{BoxFuture, BoxStream, StreamExt};
 
 use mercurial_types::HgChangesetId;
 
-
 #[derive(Debug, Fail)]
 pub enum ErrorKind {
-    #[fail(display = "invalid bookmarks line: {}", _0)] InvalidBookmarkLine(String),
-    #[fail(display = "invalid hash: {}", _0)] InvalidHash(String),
+    #[fail(display = "invalid bookmarks line: {}", _0)]
+    InvalidBookmarkLine(String),
+    #[fail(display = "invalid hash: {}", _0)]
+    InvalidHash(String),
 }
 
 /// Implementation of bookmarks as they exist in stock Mercurial inside `.hg/bookmarks`.
@@ -104,8 +105,9 @@ impl StockBookmarks {
                 .keys()
                 .map(|k| Ok(k.to_vec()))
                 .collect::<Vec<_>>(),
-        ).and_then(|x| x)
-            .boxify()
+        )
+        .and_then(|x| x)
+        .boxify()
     }
 }
 

repo_client/remotefilelog/src/lib.rs

@@ -6,28 +6,24 @@
 
 #![deny(warnings)]
 
-use std::collections::{HashMap, HashSet, VecDeque};
-use std::io::{Cursor, Write};
-
+use blobrepo::BlobRepo;
 use bytes::{Bytes, BytesMut};
 use cloned::cloned;
+use context::CoreContext;
 use failure::{Error, Fail, Fallible};
+use filenodes::FilenodeInfo;
 use futures::{future::ok, stream, Future, IntoFuture, Stream};
 use futures_ext::{BoxFuture, BoxStream, FutureExt, StreamExt};
-use pylz4;
-
-use blobrepo::BlobRepo;
-use filenodes::FilenodeInfo;
-
-use context::CoreContext;
 use mercurial::file::File;
 use mercurial_types::{
     HgBlobNode, HgFileHistoryEntry, HgFileNodeId, HgParents, MPath, RepoPath, RevFlags, NULL_CSID,
     NULL_HASH,
 };
-use tracing::trace_args;
-
 use metaconfig_types::LfsParams;
+use pylz4;
+use std::collections::{HashMap, HashSet, VecDeque};
+use std::io::{Cursor, Write};
+use tracing::trace_args;
 use tracing::Traced;
 
 const METAKEYFLAG: &str = "f";