Fix formatting with cargo fmt

src/commands.rs

@@ -35,8 +35,8 @@ crate mod pick;
 crate mod plugin;
 crate mod prev;
 crate mod ps;
-crate mod reverse;
 crate mod reject;
+crate mod reverse;
 crate mod rm;
 crate mod save;
 crate mod shells;

src/commands/from_bson.rs

@@ -2,7 +2,7 @@ use crate::commands::WholeStreamCommand;
 use crate::object::base::OF64;
 use crate::object::{Primitive, TaggedDictBuilder, Value};
 use crate::prelude::*;
-use bson::{decode_document, Bson, spec::BinarySubtype};
+use bson::{decode_document, spec::BinarySubtype, Bson};
 
 pub struct FromBSON;
 
@@ -47,71 +47,72 @@ fn convert_bson_value_to_nu_value(v: &Bson, tag: impl Into<Tag>) -> Tagged<Value
         Bson::Boolean(b) => Value::Primitive(Primitive::Boolean(*b)).tagged(tag),
         Bson::Null => Value::Primitive(Primitive::String(String::from(""))).tagged(tag),
         Bson::RegExp(r, opts) => {
-             let mut collected = TaggedDictBuilder::new(tag);
-             collected.insert_tagged(
-                 "$regex".to_string(),
-                 Value::Primitive(Primitive::String(String::from(r))).tagged(tag),
-             );
-             collected.insert_tagged(
-                 "$options".to_string(),
-                 Value::Primitive(Primitive::String(String::from(opts))).tagged(tag),
-             );
-             collected.into_tagged_value()
+            let mut collected = TaggedDictBuilder::new(tag);
+            collected.insert_tagged(
+                "$regex".to_string(),
+                Value::Primitive(Primitive::String(String::from(r))).tagged(tag),
+            );
+            collected.insert_tagged(
+                "$options".to_string(),
+                Value::Primitive(Primitive::String(String::from(opts))).tagged(tag),
+            );
+            collected.into_tagged_value()
         }
         Bson::I32(n) => Value::Primitive(Primitive::Int(*n as i64)).tagged(tag),
         Bson::I64(n) => Value::Primitive(Primitive::Int(*n as i64)).tagged(tag),
         Bson::JavaScriptCode(js) => {
-             let mut collected = TaggedDictBuilder::new(tag);
-             collected.insert_tagged(
-                 "$javascript".to_string(),
-                 Value::Primitive(Primitive::String(String::from(js))).tagged(tag),
-             );
-             collected.into_tagged_value()
+            let mut collected = TaggedDictBuilder::new(tag);
+            collected.insert_tagged(
+                "$javascript".to_string(),
+                Value::Primitive(Primitive::String(String::from(js))).tagged(tag),
+            );
+            collected.into_tagged_value()
         }
         Bson::JavaScriptCodeWithScope(js, doc) => {
-             let mut collected = TaggedDictBuilder::new(tag);
-             collected.insert_tagged(
-                 "$javascript".to_string(),
-                 Value::Primitive(Primitive::String(String::from(js))).tagged(tag),
-             );
-             collected.insert_tagged(
-                 "$scope".to_string(),
-                 convert_bson_value_to_nu_value(&Bson::Document(doc.to_owned()), tag),
-             );
-             collected.into_tagged_value()
+            let mut collected = TaggedDictBuilder::new(tag);
+            collected.insert_tagged(
+                "$javascript".to_string(),
+                Value::Primitive(Primitive::String(String::from(js))).tagged(tag),
+            );
+            collected.insert_tagged(
+                "$scope".to_string(),
+                convert_bson_value_to_nu_value(&Bson::Document(doc.to_owned()), tag),
+            );
+            collected.into_tagged_value()
         }
         Bson::TimeStamp(ts) => {
-             let mut collected = TaggedDictBuilder::new(tag);
-             collected.insert_tagged(
-                 "$timestamp".to_string(),
-                 Value::Primitive(Primitive::Int(*ts as i64)).tagged(tag),
-             );
-             collected.into_tagged_value()
+            let mut collected = TaggedDictBuilder::new(tag);
+            collected.insert_tagged(
+                "$timestamp".to_string(),
+                Value::Primitive(Primitive::Int(*ts as i64)).tagged(tag),
+            );
+            collected.into_tagged_value()
         }
         Bson::Binary(bst, bytes) => {
-             let mut collected = TaggedDictBuilder::new(tag);
-             collected.insert_tagged(
-                 "$binary_subtype".to_string(),
-                 match bst {
-                     BinarySubtype::UserDefined(u) => Value::Primitive(Primitive::Int(*u as i64)),
-                     _ => Value::Primitive(Primitive::String(binary_subtype_to_string(*bst))),
-                 }.tagged(tag)
-             );
-             collected.insert_tagged(
-                 "$binary".to_string(),
-                 Value::Binary(bytes.to_owned()).tagged(tag),
-             );
-             collected.into_tagged_value()
+            let mut collected = TaggedDictBuilder::new(tag);
+            collected.insert_tagged(
+                "$binary_subtype".to_string(),
+                match bst {
+                    BinarySubtype::UserDefined(u) => Value::Primitive(Primitive::Int(*u as i64)),
+                    _ => Value::Primitive(Primitive::String(binary_subtype_to_string(*bst))),
+                }
+                .tagged(tag),
+            );
+            collected.insert_tagged(
+                "$binary".to_string(),
+                Value::Binary(bytes.to_owned()).tagged(tag),
+            );
+            collected.into_tagged_value()
         }
         Bson::ObjectId(obj_id) => Value::Primitive(Primitive::String(obj_id.to_hex())).tagged(tag),
         Bson::UtcDatetime(dt) => Value::Primitive(Primitive::Date(*dt)).tagged(tag),
         Bson::Symbol(s) => {
-             let mut collected = TaggedDictBuilder::new(tag);
-             collected.insert_tagged(
-                 "$symbol".to_string(),
-                 Value::Primitive(Primitive::String(String::from(s))).tagged(tag),
-             );
-             collected.into_tagged_value()
+            let mut collected = TaggedDictBuilder::new(tag);
+            collected.insert_tagged(
+                "$symbol".to_string(),
+                Value::Primitive(Primitive::String(String::from(s))).tagged(tag),
+            );
+            collected.into_tagged_value()
         }
     }
 }
@@ -125,7 +126,8 @@ fn binary_subtype_to_string(bst: BinarySubtype) -> String {
         BinarySubtype::Uuid => "uuid",
         BinarySubtype::Md5 => "md5",
         _ => unreachable!(),
-    }.to_string()
+    }
+    .to_string()
 }
 
 #[derive(Debug)]

src/commands/last.rs

@@ -44,7 +44,7 @@ fn last(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, S
             "Value is too low",
             "expected a positive integer",
             args.expect_nth(0)?.span(),
-        ))
+        ));
     }
 
     let stream = async_stream_block! {

src/commands/open.rs

@@ -426,14 +426,16 @@ pub fn parse_string_as_value(
     name_span: Span,
 ) -> Result<Tagged<Value>, ShellError> {
     match extension {
-        Some(x) if x == "csv" => crate::commands::from_csv::from_csv_string_to_value(
-            contents,
-            false,
-            contents_tag,
-        )
-        .map_err(move |_| {
-            ShellError::labeled_error("Could not open as CSV", "could not open as CSV", name_span)
-        }),
+        Some(x) if x == "csv" => {
+            crate::commands::from_csv::from_csv_string_to_value(contents, false, contents_tag)
+                .map_err(move |_| {
+                    ShellError::labeled_error(
+                        "Could not open as CSV",
+                        "could not open as CSV",
+                        name_span,
+                    )
+                })
+        }
         Some(x) if x == "toml" => {
             crate::commands::from_toml::from_toml_string_to_value(contents, contents_tag).map_err(
                 move |_| {
@@ -507,9 +509,9 @@ pub fn parse_binary_as_value(
             crate::commands::from_bson::from_bson_bytes_to_value(contents, contents_tag).map_err(
                 move |_| {
                     ShellError::labeled_error(
-                       "Could not open as BSON",
-                       "could not open as BSON",
-                       name_span,
+                        "Could not open as BSON",
+                        "could not open as BSON",
+                        name_span,
                     )
                 },
             )

src/commands/sort_by.rs

@@ -46,9 +46,7 @@ fn sort_by(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream
                 .collect::<Vec<Option<Tagged<Value>>>>()
         };
         if reverse {
-            vec.sort_by_cached_key(|item| {
-                std::cmp::Reverse(calc_key(item))
-            });
+            vec.sort_by_cached_key(|item| std::cmp::Reverse(calc_key(item)));
         } else {
             vec.sort_by_cached_key(calc_key);
         }

src/git.rs

@@ -7,15 +7,13 @@ pub fn current_branch() -> Option<String> {
         Ok(repo) => {
             let r = repo.head();
             match r {
-                Ok(r) => {
-                    match r.shorthand() {
-                        Some(s) => Some(s.to_string()),
-                        None => None,
-                    }
+                Ok(r) => match r.shorthand() {
+                    Some(s) => Some(s.to_string()),
+                    None => None,
                 },
-                _ => None
+                _ => None,
             }
-        },
-        _ => None
+        }
+        _ => None,
     }
 }

src/object/base.rs

@@ -122,10 +122,8 @@ impl Primitive {
     pub fn style(&self) -> &'static str {
         match self {
             Primitive::Bytes(0) => "c", // centre 'missing' indicator
-            Primitive::Int(_) |
-            Primitive::Bytes(_) |
-            Primitive::Float(_) => "r",
-            _ => ""
+            Primitive::Int(_) | Primitive::Bytes(_) | Primitive::Float(_) => "r",
+            _ => "",
         }
     }
 }
@@ -472,7 +470,7 @@ impl Value {
     crate fn style_leaf(&self) -> &'static str {
         match self {
             Value::Primitive(p) => p.style(),
-            _ => ""
+            _ => "",
         }
     }
 

src/utils.rs

@@ -105,7 +105,10 @@ impl FileStructure {
         self.root = path.to_path_buf();
     }
 
-    pub fn paths_applying_with<F>(&mut self, to: F) -> Result<Vec<(PathBuf, PathBuf)>, Box<dyn std::error::Error>>
+    pub fn paths_applying_with<F>(
+        &mut self,
+        to: F,
+    ) -> Result<Vec<(PathBuf, PathBuf)>, Box<dyn std::error::Error>>
     where
         F: Fn((PathBuf, usize)) -> Result<(PathBuf, PathBuf), Box<dyn std::error::Error>>,
     {
@@ -175,7 +178,8 @@ mod tests {
     fn prepares_and_decorates_source_files_for_copying() {
         let mut res = FileStructure::new();
 
-        res.walk_decorate(fixtures().as_path()).expect("Can not decorate files traversal.");
+        res.walk_decorate(fixtures().as_path())
+            .expect("Can not decorate files traversal.");
 
         assert_eq!(
             res.resources,