Fix warnings for Rust 1.51 (#3214)

* Fix warnings for Rust 1.51

* More fixes

* More fixes

crates/nu-ansi-term/examples/rgb_colors.rs

@@ -15,7 +15,7 @@ fn main() {
             let g = (col * 255 / WIDTH) as u8;
             let b = 128;
 
-            print!("{}", Style::default().on(Color::RGB(r, g, b)).paint(" "));
+            print!("{}", Style::default().on(Color::Rgb(r, g, b)).paint(" "));
         }
 
         println!();

crates/nu-ansi-term/src/ansi.rs

@@ -103,7 +103,7 @@ impl Color {
             Color::Cyan => write!(f, "36"),
             Color::White => write!(f, "37"),
             Color::Fixed(num) => write!(f, "38;5;{}", &num),
-            Color::RGB(r, g, b) => write!(f, "38;2;{};{};{}", &r, &g, &b),
+            Color::Rgb(r, g, b) => write!(f, "38;2;{};{};{}", &r, &g, &b),
             Color::DarkGray => write!(f, "90"),
             Color::LightRed => write!(f, "91"),
             Color::LightGreen => write!(f, "92"),
@@ -128,7 +128,7 @@ impl Color {
             Color::Cyan => write!(f, "46"),
             Color::White => write!(f, "47"),
             Color::Fixed(num) => write!(f, "48;5;{}", &num),
-            Color::RGB(r, g, b) => write!(f, "48;2;{};{};{}", &r, &g, &b),
+            Color::Rgb(r, g, b) => write!(f, "48;2;{};{};{}", &r, &g, &b),
             Color::DarkGray => write!(f, "100"),
             Color::LightRed => write!(f, "101"),
             Color::LightGreen => write!(f, "102"),
@@ -372,10 +372,10 @@ mod test {
     test!(fixed:                 Fixed(100);                        "hi" => "\x1B[38;5;100mhi\x1B[0m");
     test!(fixed_on_purple:       Fixed(100).on(Purple);             "hi" => "\x1B[45;38;5;100mhi\x1B[0m");
     test!(fixed_on_fixed:        Fixed(100).on(Fixed(200));         "hi" => "\x1B[48;5;200;38;5;100mhi\x1B[0m");
-    test!(rgb:                   RGB(70,130,180);                   "hi" => "\x1B[38;2;70;130;180mhi\x1B[0m");
+    test!(rgb:                   Rgb(70,130,180);                   "hi" => "\x1B[38;2;70;130;180mhi\x1B[0m");
-    test!(rgb_on_blue:           RGB(70,130,180).on(Blue);          "hi" => "\x1B[44;38;2;70;130;180mhi\x1B[0m");
+    test!(rgb_on_blue:           Rgb(70,130,180).on(Blue);          "hi" => "\x1B[44;38;2;70;130;180mhi\x1B[0m");
-    test!(blue_on_rgb:           Blue.on(RGB(70,130,180));          "hi" => "\x1B[48;2;70;130;180;34mhi\x1B[0m");
+    test!(blue_on_rgb:           Blue.on(Rgb(70,130,180));          "hi" => "\x1B[48;2;70;130;180;34mhi\x1B[0m");
-    test!(rgb_on_rgb:            RGB(70,130,180).on(RGB(5,10,15));  "hi" => "\x1B[48;2;5;10;15;38;2;70;130;180mhi\x1B[0m");
+    test!(rgb_on_rgb:            Rgb(70,130,180).on(Rgb(5,10,15));  "hi" => "\x1B[48;2;5;10;15;38;2;70;130;180mhi\x1B[0m");
     test!(bold:                  Style::new().bold();               "hi" => "\x1B[1mhi\x1B[0m");
     test!(underline:             Style::new().underline();          "hi" => "\x1B[4mhi\x1B[0m");
     test!(bunderline:            Style::new().bold().underline();   "hi" => "\x1B[1;4mhi\x1B[0m");

crates/nu-ansi-term/src/debug.rs

@@ -112,7 +112,7 @@ mod test {
     test!(both:    style().bold().italic()  => "Style { bold, italic }");
 
     test!(red:     Red.normal()                     => "Style { fg(Red) }");
-    test!(redblue: Red.normal().on(RGB(3, 2, 4))    => "Style { fg(Red), on(RGB(3, 2, 4)) }");
+    test!(redblue: Red.normal().on(Rgb(3, 2, 4))    => "Style { fg(Red), on(Rgb(3, 2, 4)) }");
 
     test!(everything:
             Red.on(Blue).blink().bold().dimmed().hidden().italic().reverse().strikethrough().underline() =>

crates/nu-ansi-term/src/display.rs

@@ -11,7 +11,7 @@ use std::ops::Deref;
 /// display that string.  `ANSIString` and `ANSIByteString` are aliases for
 /// this type on `str` and `\[u8]`, respectively.
 #[derive(PartialEq, Debug)]
-pub struct ANSIGenericString<'a, S: 'a + ToOwned + ?Sized>
+pub struct AnsiGenericString<'a, S: 'a + ToOwned + ?Sized>
 where
     <S as ToOwned>::Owned: fmt::Debug,
 {
@@ -30,12 +30,12 @@ where
 /// let clone_string = plain_string.clone();
 /// assert_eq!(clone_string, plain_string);
 /// ```
-impl<'a, S: 'a + ToOwned + ?Sized> Clone for ANSIGenericString<'a, S>
+impl<'a, S: 'a + ToOwned + ?Sized> Clone for AnsiGenericString<'a, S>
 where
     <S as ToOwned>::Owned: fmt::Debug,
 {
-    fn clone(&self) -> ANSIGenericString<'a, S> {
+    fn clone(&self) -> AnsiGenericString<'a, S> {
-        ANSIGenericString {
+        AnsiGenericString {
             style: self.style,
             string: self.string.clone(),
         }
@@ -85,26 +85,26 @@ where
 /// let plain_string = ANSIString::from("a plain string");
 /// assert_eq!(&*plain_string, "a plain string");
 /// ```
-pub type ANSIString<'a> = ANSIGenericString<'a, str>;
+pub type AnsiString<'a> = AnsiGenericString<'a, str>;
 
-/// An `ANSIByteString` represents a formatted series of bytes.  Use
+/// An `AnsiByteString` represents a formatted series of bytes.  Use
-/// `ANSIByteString` when styling text with an unknown encoding.
+/// `AnsiByteString` when styling text with an unknown encoding.
-pub type ANSIByteString<'a> = ANSIGenericString<'a, [u8]>;
+pub type AnsiByteString<'a> = AnsiGenericString<'a, [u8]>;
 
-impl<'a, I, S: 'a + ToOwned + ?Sized> From<I> for ANSIGenericString<'a, S>
+impl<'a, I, S: 'a + ToOwned + ?Sized> From<I> for AnsiGenericString<'a, S>
 where
     I: Into<Cow<'a, S>>,
     <S as ToOwned>::Owned: fmt::Debug,
 {
-    fn from(input: I) -> ANSIGenericString<'a, S> {
+    fn from(input: I) -> AnsiGenericString<'a, S> {
-        ANSIGenericString {
+        AnsiGenericString {
             string: input.into(),
             style: Style::default(),
         }
     }
 }
 
-impl<'a, S: 'a + ToOwned + ?Sized> ANSIGenericString<'a, S>
+impl<'a, S: 'a + ToOwned + ?Sized> AnsiGenericString<'a, S>
 where
     <S as ToOwned>::Owned: fmt::Debug,
 {
@@ -119,7 +119,7 @@ where
     }
 }
 
-impl<'a, S: 'a + ToOwned + ?Sized> Deref for ANSIGenericString<'a, S>
+impl<'a, S: 'a + ToOwned + ?Sized> Deref for AnsiGenericString<'a, S>
 where
     <S as ToOwned>::Owned: fmt::Debug,
 {
@@ -130,32 +130,32 @@ where
     }
 }
 
-/// A set of `ANSIGenericString`s collected together, in order to be
+/// A set of `AnsiGenericStrings`s collected together, in order to be
 /// written with a minimum of control characters.
 #[derive(Debug, PartialEq)]
-pub struct ANSIGenericStrings<'a, S: 'a + ToOwned + ?Sized>(pub &'a [ANSIGenericString<'a, S>])
+pub struct AnsiGenericStrings<'a, S: 'a + ToOwned + ?Sized>(pub &'a [AnsiGenericString<'a, S>])
 where
     <S as ToOwned>::Owned: fmt::Debug,
     S: PartialEq;
 
-/// A set of `ANSIString`s collected together, in order to be written with a
+/// A set of `AnsiString`s collected together, in order to be written with a
 /// minimum of control characters.
-pub type ANSIStrings<'a> = ANSIGenericStrings<'a, str>;
+pub type AnsiStrings<'a> = AnsiGenericStrings<'a, str>;
 
-/// A function to construct an `ANSIStrings` instance.
+/// A function to construct an `AnsiStrings` instance.
 #[allow(non_snake_case)]
-pub fn ANSIStrings<'a>(arg: &'a [ANSIString<'a>]) -> ANSIStrings<'a> {
+pub fn AnsiStrings<'a>(arg: &'a [AnsiString<'a>]) -> AnsiStrings<'a> {
-    ANSIGenericStrings(arg)
+    AnsiGenericStrings(arg)
 }
 
-/// A set of `ANSIByteString`s collected together, in order to be
+/// A set of `AnsiByteString`s collected together, in order to be
 /// written with a minimum of control characters.
-pub type ANSIByteStrings<'a> = ANSIGenericStrings<'a, [u8]>;
+pub type AnsiByteStrings<'a> = AnsiGenericStrings<'a, [u8]>;
 
 /// A function to construct an `ANSIByteStrings` instance.
 #[allow(non_snake_case)]
-pub fn ANSIByteStrings<'a>(arg: &'a [ANSIByteString<'a>]) -> ANSIByteStrings<'a> {
+pub fn ANSIByteStrings<'a>(arg: &'a [AnsiByteString<'a>]) -> AnsiByteStrings<'a> {
-    ANSIGenericStrings(arg)
+    AnsiGenericStrings(arg)
 }
 
 // ---- paint functions ----
@@ -163,12 +163,12 @@ pub fn ANSIByteStrings<'a>(arg: &'a [ANSIByteString<'a>]) -> ANSIByteStrings<'a>
 impl Style {
     /// Paints the given text with this color, returning an ANSI string.
     #[must_use]
-    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> ANSIGenericString<'a, S>
+    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> AnsiGenericString<'a, S>
     where
         I: Into<Cow<'a, S>>,
         <S as ToOwned>::Owned: fmt::Debug,
     {
-        ANSIGenericString {
+        AnsiGenericString {
             string: input.into(),
             style: self,
         }
@@ -185,12 +185,12 @@ impl Color {
     /// println!("{}", Blue.paint("da ba dee"));
     /// ```
     #[must_use]
-    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> ANSIGenericString<'a, S>
+    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> AnsiGenericString<'a, S>
     where
         I: Into<Cow<'a, S>>,
         <S as ToOwned>::Owned: fmt::Debug,
     {
-        ANSIGenericString {
+        AnsiGenericString {
             string: input.into(),
             style: self.normal(),
         }
@@ -199,14 +199,14 @@ impl Color {
 
 // ---- writers for individual ANSI strings ----
 
-impl<'a> fmt::Display for ANSIString<'a> {
+impl<'a> fmt::Display for AnsiString<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let w: &mut dyn fmt::Write = f;
         self.write_to_any(w)
     }
 }
 
-impl<'a> ANSIByteString<'a> {
+impl<'a> AnsiByteString<'a> {
     /// Write an `ANSIByteString` to an `io::Write`.  This writes the escape
     /// sequences for the associated `Style` around the bytes.
     pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
@@ -215,7 +215,7 @@ impl<'a> ANSIByteString<'a> {
     }
 }
 
-impl<'a, S: 'a + ToOwned + ?Sized> ANSIGenericString<'a, S>
+impl<'a, S: 'a + ToOwned + ?Sized> AnsiGenericString<'a, S>
 where
     <S as ToOwned>::Owned: fmt::Debug,
     &'a S: AsRef<[u8]>,
@@ -229,14 +229,14 @@ where
 
 // ---- writers for combined ANSI strings ----
 
-impl<'a> fmt::Display for ANSIStrings<'a> {
+impl<'a> fmt::Display for AnsiStrings<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let f: &mut dyn fmt::Write = f;
         self.write_to_any(f)
     }
 }
 
-impl<'a> ANSIByteStrings<'a> {
+impl<'a> AnsiByteStrings<'a> {
     /// Write `ANSIByteStrings` to an `io::Write`.  This writes the minimal
     /// escape sequences for the associated `Style`s around each set of
     /// bytes.
@@ -246,7 +246,7 @@ impl<'a> ANSIByteStrings<'a> {
     }
 }
 
-impl<'a, S: 'a + ToOwned + ?Sized + PartialEq> ANSIGenericStrings<'a, S>
+impl<'a, S: 'a + ToOwned + ?Sized + PartialEq> AnsiGenericStrings<'a, S>
 where
     <S as ToOwned>::Owned: fmt::Debug,
     &'a S: AsRef<[u8]>,
@@ -289,7 +289,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    pub use super::super::ANSIStrings;
+    pub use super::super::AnsiStrings;
     pub use crate::style::Color::*;
     pub use crate::style::Style;
 
@@ -297,7 +297,7 @@ mod tests {
     fn no_control_codes_for_plain() {
         let one = Style::default().paint("one");
         let two = Style::default().paint("two");
-        let output = format!("{}", ANSIStrings(&[one, two]));
+        let output = format!("{}", AnsiStrings(&[one, two]));
         assert_eq!(&*output, "onetwo");
     }
 }

crates/nu-ansi-term/src/style.rs

@@ -365,7 +365,7 @@ pub enum Color {
     Fixed(u8),
 
     /// A 24-bit RGB color, as specified by ISO-8613-3.
-    RGB(u8, u8, u8),
+    Rgb(u8, u8, u8),
 }
 
 impl Color {

crates/nu-ansi-term/src/util.rs

@@ -1,12 +1,12 @@
-use crate::display::{ANSIString, ANSIStrings};
+use crate::display::{AnsiString, AnsiStrings};
 use std::ops::Deref;
 
 /// Return a substring of the given ANSIStrings sequence, while keeping the formatting.
 pub fn sub_string<'a>(
     start: usize,
     len: usize,
-    strs: &ANSIStrings<'a>,
+    strs: &AnsiStrings<'a>,
-) -> Vec<ANSIString<'static>> {
+) -> Vec<AnsiString<'static>> {
     let mut vec = Vec::new();
     let mut pos = start;
     let mut len_rem = len;
@@ -39,7 +39,7 @@ pub fn sub_string<'a>(
 }
 
 /// Return a concatenated copy of `strs` without the formatting, as an allocated `String`.
-pub fn unstyle(strs: &ANSIStrings) -> String {
+pub fn unstyle(strs: &AnsiStrings) -> String {
     let mut s = String::new();
 
     for i in strs.0.iter() {
@@ -50,7 +50,7 @@ pub fn unstyle(strs: &ANSIStrings) -> String {
 }
 
 /// Return the unstyled length of ANSIStrings. This is equaivalent to `unstyle(strs).len()`.
-pub fn unstyled_len(strs: &ANSIStrings) -> usize {
+pub fn unstyled_len(strs: &AnsiStrings) -> usize {
     let mut l = 0;
     for i in strs.0.iter() {
         l += i.deref().len();
@@ -70,7 +70,7 @@ mod test {
             Red.paint("-second"),
             White.paint("-third"),
         ];
-        let a = ANSIStrings(&l);
+        let a = AnsiStrings(&l);
         assert_eq!(unstyle(&a), "first-second-third");
         assert_eq!(unstyled_len(&a), 18);
 

crates/nu-command/src/commands.rs

@@ -184,21 +184,21 @@ pub(crate) use first::First;
 pub(crate) use flatten::Command as Flatten;
 pub(crate) use format::{FileSize, Format};
 pub(crate) use from::From;
-pub(crate) use from_csv::FromCSV;
+pub(crate) use from_csv::FromCsv;
-pub(crate) use from_eml::FromEML;
+pub(crate) use from_eml::FromEml;
 pub(crate) use from_ics::FromIcs;
-pub(crate) use from_ini::FromINI;
+pub(crate) use from_ini::FromIni;
-pub(crate) use from_json::FromJSON;
+pub(crate) use from_json::FromJson;
-pub(crate) use from_ods::FromODS;
+pub(crate) use from_ods::FromOds;
-pub(crate) use from_ssv::FromSSV;
+pub(crate) use from_ssv::FromSsv;
-pub(crate) use from_toml::FromTOML;
+pub(crate) use from_toml::FromToml;
-pub(crate) use from_tsv::FromTSV;
+pub(crate) use from_tsv::FromTsv;
-pub(crate) use from_url::FromURL;
+pub(crate) use from_url::FromUrl;
 pub(crate) use from_vcf::FromVcf;
-pub(crate) use from_xlsx::FromXLSX;
+pub(crate) use from_xlsx::FromXlsx;
-pub(crate) use from_xml::FromXML;
+pub(crate) use from_xml::FromXml;
-pub(crate) use from_yaml::FromYAML;
+pub(crate) use from_yaml::FromYaml;
-pub(crate) use from_yaml::FromYML;
+pub(crate) use from_yaml::FromYml;
 pub(crate) use get::Command as Get;
 pub(crate) use group_by::Command as GroupBy;
 pub(crate) use group_by_date::GroupByDate;
@@ -272,15 +272,15 @@ pub(crate) use table::Table;
 pub(crate) use tags::Tags;
 pub(crate) use termsize::TermSize;
 pub(crate) use to::To;
-pub(crate) use to_csv::ToCSV;
+pub(crate) use to_csv::ToCsv;
-pub(crate) use to_html::ToHTML;
+pub(crate) use to_html::ToHtml;
-pub(crate) use to_json::ToJSON;
+pub(crate) use to_json::ToJson;
 pub(crate) use to_md::Command as ToMarkdown;
-pub(crate) use to_toml::ToTOML;
+pub(crate) use to_toml::ToToml;
-pub(crate) use to_tsv::ToTSV;
+pub(crate) use to_tsv::ToTsv;
-pub(crate) use to_url::ToURL;
+pub(crate) use to_url::ToUrl;
-pub(crate) use to_xml::ToXML;
+pub(crate) use to_xml::ToXml;
-pub(crate) use to_yaml::ToYAML;
+pub(crate) use to_yaml::ToYaml;
 pub(crate) use touch::Touch;
 pub(crate) use uniq::Uniq;
 pub(crate) use url_::{UrlCommand, UrlHost, UrlPath, UrlQuery, UrlScheme};

crates/nu-command/src/commands/default_context.rs

@@ -190,30 +190,30 @@ pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Bo
             whole_stream_command(MathCeil),
             // File format output
             whole_stream_command(To),
-            whole_stream_command(ToCSV),
+            whole_stream_command(ToCsv),
-            whole_stream_command(ToHTML),
+            whole_stream_command(ToHtml),
-            whole_stream_command(ToJSON),
+            whole_stream_command(ToJson),
             whole_stream_command(ToMarkdown),
-            whole_stream_command(ToTOML),
+            whole_stream_command(ToToml),
-            whole_stream_command(ToTSV),
+            whole_stream_command(ToTsv),
-            whole_stream_command(ToURL),
+            whole_stream_command(ToUrl),
-            whole_stream_command(ToYAML),
+            whole_stream_command(ToYaml),
-            whole_stream_command(ToXML),
+            whole_stream_command(ToXml),
             // File format input
             whole_stream_command(From),
-            whole_stream_command(FromCSV),
+            whole_stream_command(FromCsv),
-            whole_stream_command(FromEML),
+            whole_stream_command(FromEml),
-            whole_stream_command(FromTSV),
+            whole_stream_command(FromTsv),
-            whole_stream_command(FromSSV),
+            whole_stream_command(FromSsv),
-            whole_stream_command(FromINI),
+            whole_stream_command(FromIni),
-            whole_stream_command(FromJSON),
+            whole_stream_command(FromJson),
-            whole_stream_command(FromODS),
+            whole_stream_command(FromOds),
-            whole_stream_command(FromTOML),
+            whole_stream_command(FromToml),
-            whole_stream_command(FromURL),
+            whole_stream_command(FromUrl),
-            whole_stream_command(FromXLSX),
+            whole_stream_command(FromXlsx),
-            whole_stream_command(FromXML),
+            whole_stream_command(FromXml),
-            whole_stream_command(FromYAML),
+            whole_stream_command(FromYaml),
-            whole_stream_command(FromYML),
+            whole_stream_command(FromYml),
             whole_stream_command(FromIcs),
             whole_stream_command(FromVcf),
             // "Private" commands (not intended to be accessed directly)

crates/nu-command/src/commands/from_csv.rs

@@ -4,16 +4,16 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{Primitive, Signature, SyntaxShape, UntaggedValue, Value};
 
-pub struct FromCSV;
+pub struct FromCsv;
 
 #[derive(Deserialize)]
-pub struct FromCSVArgs {
+pub struct FromCsvArgs {
     noheaders: bool,
     separator: Option<Value>,
 }
 
 #[async_trait]
-impl WholeStreamCommand for FromCSV {
+impl WholeStreamCommand for FromCsv {
     fn name(&self) -> &str {
         "from csv"
     }
@@ -71,7 +71,7 @@ async fn from_csv(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
 
     let (
-        FromCSVArgs {
+        FromCsvArgs {
             noheaders,
             separator,
         },
@@ -105,13 +105,13 @@ async fn from_csv(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
 #[cfg(test)]
 mod tests {
-    use super::FromCSV;
+    use super::FromCsv;
     use super::ShellError;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromCSV {})
+        test_examples(FromCsv {})
     }
 }

crates/nu-command/src/commands/from_eml.rs

@@ -6,18 +6,18 @@ use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue};
 use nu_source::Tagged;
 
-pub struct FromEML;
+pub struct FromEml;
 
 const DEFAULT_BODY_PREVIEW: usize = 50;
 
 #[derive(Deserialize, Clone)]
-pub struct FromEMLArgs {
+pub struct FromEmlArgs {
     #[serde(rename(deserialize = "preview-body"))]
     preview_body: Option<Tagged<usize>>,
 }
 
 #[async_trait]
-impl WholeStreamCommand for FromEML {
+impl WholeStreamCommand for FromEml {
     fn name(&self) -> &str {
         "from eml"
     }
@@ -75,7 +75,7 @@ fn headerfieldvalue_to_value(tag: &Tag, value: &HeaderFieldValue) -> UntaggedVal
 
 async fn from_eml(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
-    let (eml_args, input): (FromEMLArgs, _) = args.process().await?;
+    let (eml_args, input): (FromEmlArgs, _) = args.process().await?;
     let value = input.collect_string(tag.clone()).await?;
 
     let body_preview = eml_args
@@ -121,13 +121,13 @@ async fn from_eml(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
 #[cfg(test)]
 mod tests {
-    use super::FromEML;
+    use super::FromEml;
     use super::ShellError;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromEML {})
+        test_examples(FromEml {})
     }
 }

crates/nu-command/src/commands/from_ini.rs

@@ -4,10 +4,10 @@ use nu_errors::ShellError;
 use nu_protocol::{Primitive, Signature, TaggedDictBuilder, UntaggedValue, Value};
 use std::collections::HashMap;
 
-pub struct FromINI;
+pub struct FromIni;
 
 #[async_trait]
-impl WholeStreamCommand for FromINI {
+impl WholeStreamCommand for FromIni {
     fn name(&self) -> &str {
         "from ini"
     }
@@ -86,13 +86,13 @@ async fn from_ini(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
 #[cfg(test)]
 mod tests {
-    use super::FromINI;
+    use super::FromIni;
     use super::ShellError;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromINI {})
+        test_examples(FromIni {})
     }
 }

crates/nu-command/src/commands/from_json.rs

@@ -3,15 +3,15 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
 
-pub struct FromJSON;
+pub struct FromJson;
 
 #[derive(Deserialize)]
-pub struct FromJSONArgs {
+pub struct FromJsonArgs {
     objects: bool,
 }
 
 #[async_trait]
-impl WholeStreamCommand for FromJSON {
+impl WholeStreamCommand for FromJson {
     fn name(&self) -> &str {
         "from json"
     }
@@ -71,7 +71,7 @@ pub fn from_json_string_to_value(s: String, tag: impl Into<Tag>) -> nu_json::Res
 async fn from_json(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name_tag = args.call_info.name_tag.clone();
 
-    let (FromJSONArgs { objects }, input) = args.process().await?;
+    let (FromJsonArgs { objects }, input) = args.process().await?;
     let concat_string = input.collect_string(name_tag.clone()).await?;
 
     let string_clone: Vec<_> = concat_string.item.lines().map(|x| x.to_string()).collect();
@@ -135,13 +135,13 @@ async fn from_json(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
 #[cfg(test)]
 mod tests {
-    use super::FromJSON;
+    use super::FromJson;
     use super::ShellError;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromJSON {})
+        test_examples(FromJson {})
     }
 }

crates/nu-command/src/commands/from_ods.rs

@@ -6,15 +6,15 @@ use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue};
 use std::io::Cursor;
 
-pub struct FromODS;
+pub struct FromOds;
 
 #[derive(Deserialize)]
-pub struct FromODSArgs {
+pub struct FromOdsArgs {
     noheaders: bool,
 }
 
 #[async_trait]
-impl WholeStreamCommand for FromODS {
+impl WholeStreamCommand for FromOds {
     fn name(&self) -> &str {
         "from ods"
     }
@@ -41,7 +41,7 @@ async fn from_ods(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let span = tag.span;
 
     let (
-        FromODSArgs {
+        FromOdsArgs {
             noheaders: _noheaders,
         },
         input,
@@ -93,13 +93,13 @@ async fn from_ods(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
 #[cfg(test)]
 mod tests {
-    use super::FromODS;
+    use super::FromOds;
     use super::ShellError;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromODS {})
+        test_examples(FromOds {})
     }
 }

crates/nu-command/src/commands/from_ssv.rs

@@ -6,10 +6,10 @@ use nu_protocol::{
 };
 use nu_source::Tagged;
 
-pub struct FromSSV;
+pub struct FromSsv;
 
 #[derive(Deserialize)]
-pub struct FromSSVArgs {
+pub struct FromSsvArgs {
     noheaders: bool,
     #[serde(rename(deserialize = "aligned-columns"))]
     aligned_columns: bool,
@@ -21,7 +21,7 @@ const STRING_REPRESENTATION: &str = "from ssv";
 const DEFAULT_MINIMUM_SPACES: usize = 2;
 
 #[async_trait]
-impl WholeStreamCommand for FromSSV {
+impl WholeStreamCommand for FromSsv {
     fn name(&self) -> &str {
         STRING_REPRESENTATION
     }
@@ -250,7 +250,7 @@ fn from_ssv_string_to_value(
 async fn from_ssv(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
     let (
-        FromSSVArgs {
+        FromSsvArgs {
             noheaders,
             aligned_columns,
             minimum_spaces,
@@ -489,9 +489,9 @@ mod tests {
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
-        use super::FromSSV;
+        use super::FromSsv;
         use crate::examples::test as test_examples;
 
-        test_examples(FromSSV {})
+        test_examples(FromSsv {})
     }
 }

crates/nu-command/src/commands/from_toml.rs

@@ -3,10 +3,10 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
 
-pub struct FromTOML;
+pub struct FromToml;
 
 #[async_trait]
-impl WholeStreamCommand for FromTOML {
+impl WholeStreamCommand for FromToml {
     fn name(&self) -> &str {
         "from toml"
     }
@@ -92,13 +92,13 @@ pub async fn from_toml(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
 #[cfg(test)]
 mod tests {
-    use super::FromTOML;
+    use super::FromToml;
     use super::ShellError;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromTOML {})
+        test_examples(FromToml {})
     }
 }

crates/nu-command/src/commands/from_tsv.rs

@@ -4,15 +4,15 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::Signature;
 
-pub struct FromTSV;
+pub struct FromTsv;
 
 #[derive(Deserialize)]
-pub struct FromTSVArgs {
+pub struct FromTsvArgs {
     noheaders: bool,
 }
 
 #[async_trait]
-impl WholeStreamCommand for FromTSV {
+impl WholeStreamCommand for FromTsv {
     fn name(&self) -> &str {
         "from tsv"
     }
@@ -36,20 +36,20 @@ impl WholeStreamCommand for FromTSV {
 
 async fn from_tsv(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
-    let (FromTSVArgs { noheaders }, input) = args.process().await?;
+    let (FromTsvArgs { noheaders }, input) = args.process().await?;
 
     from_delimited_data(noheaders, '\t', "TSV", input, name).await
 }
 
 #[cfg(test)]
 mod tests {
-    use super::FromTSV;
+    use super::FromTsv;
     use super::ShellError;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromTSV {})
+        test_examples(FromTsv {})
     }
 }

crates/nu-command/src/commands/from_url.rs

@@ -3,10 +3,10 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue};
 
-pub struct FromURL;
+pub struct FromUrl;
 
 #[async_trait]
-impl WholeStreamCommand for FromURL {
+impl WholeStreamCommand for FromUrl {
     fn name(&self) -> &str {
         "from url"
     }
@@ -55,13 +55,13 @@ async fn from_url(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
 #[cfg(test)]
 mod tests {
-    use super::FromURL;
+    use super::FromUrl;
     use super::ShellError;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromURL {})
+        test_examples(FromUrl {})
     }
 }

crates/nu-command/src/commands/from_xlsx.rs

@@ -6,15 +6,15 @@ use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue};
 use std::io::Cursor;
 
-pub struct FromXLSX;
+pub struct FromXlsx;
 
 #[derive(Deserialize)]
-pub struct FromXLSXArgs {
+pub struct FromXlsxArgs {
     noheaders: bool,
 }
 
 #[async_trait]
-impl WholeStreamCommand for FromXLSX {
+impl WholeStreamCommand for FromXlsx {
     fn name(&self) -> &str {
         "from xlsx"
     }
@@ -40,7 +40,7 @@ async fn from_xlsx(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
     let span = tag.span;
     let (
-        FromXLSXArgs {
+        FromXlsxArgs {
             noheaders: _noheaders,
         },
         input,
@@ -93,13 +93,13 @@ async fn from_xlsx(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
 #[cfg(test)]
 mod tests {
-    use super::FromXLSX;
+    use super::FromXlsx;
     use super::ShellError;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromXLSX {})
+        test_examples(FromXlsx {})
     }
 }

crates/nu-command/src/commands/from_xml.rs

@@ -3,10 +3,10 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
 
-pub struct FromXML;
+pub struct FromXml;
 
 #[async_trait]
-impl WholeStreamCommand for FromXML {
+impl WholeStreamCommand for FromXml {
     fn name(&self) -> &str {
         "from xml"
     }
@@ -298,9 +298,9 @@ mod tests {
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
-        use super::FromXML;
+        use super::FromXml;
         use crate::examples::test as test_examples;
 
-        test_examples(FromXML {})
+        test_examples(FromXml {})
     }
 }

crates/nu-command/src/commands/from_yaml.rs

@@ -3,10 +3,10 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{Primitive, Signature, TaggedDictBuilder, UntaggedValue, Value};
 
-pub struct FromYAML;
+pub struct FromYaml;
 
 #[async_trait]
-impl WholeStreamCommand for FromYAML {
+impl WholeStreamCommand for FromYaml {
     fn name(&self) -> &str {
         "from yaml"
     }
@@ -24,10 +24,10 @@ impl WholeStreamCommand for FromYAML {
     }
 }
 
-pub struct FromYML;
+pub struct FromYml;
 
 #[async_trait]
-impl WholeStreamCommand for FromYML {
+impl WholeStreamCommand for FromYml {
     fn name(&self) -> &str {
         "from yml"
     }
@@ -169,7 +169,7 @@ mod tests {
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromYAML {})
+        test_examples(FromYaml {})
     }
 
     #[test]

crates/nu-command/src/commands/to_csv.rs

@@ -4,16 +4,16 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{Primitive, Signature, SyntaxShape, UntaggedValue, Value};
 
-pub struct ToCSV;
+pub struct ToCsv;
 
 #[derive(Deserialize)]
-pub struct ToCSVArgs {
+pub struct ToCsvArgs {
     noheaders: bool,
     separator: Option<Value>,
 }
 
 #[async_trait]
-impl WholeStreamCommand for ToCSV {
+impl WholeStreamCommand for ToCsv {
     fn name(&self) -> &str {
         "to csv"
     }
@@ -45,7 +45,7 @@ impl WholeStreamCommand for ToCSV {
 async fn to_csv(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
     let (
-        ToCSVArgs {
+        ToCsvArgs {
             separator,
             noheaders,
         },
@@ -80,12 +80,12 @@ async fn to_csv(args: CommandArgs) -> Result<OutputStream, ShellError> {
 #[cfg(test)]
 mod tests {
     use super::ShellError;
-    use super::ToCSV;
+    use super::ToCsv;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(ToCSV {})
+        test_examples(ToCsv {})
     }
 }

crates/nu-command/src/commands/to_html.rs

@@ -79,10 +79,10 @@ impl Default for HtmlTheme {
 #[folder = "assets/"]
 struct Assets;
 
-pub struct ToHTML;
+pub struct ToHtml;
 
 #[derive(Deserialize)]
-pub struct ToHTMLArgs {
+pub struct ToHtmlArgs {
     html_color: bool,
     no_color: bool,
     dark: bool,
@@ -92,7 +92,7 @@ pub struct ToHTMLArgs {
 }
 
 #[async_trait]
-impl WholeStreamCommand for ToHTML {
+impl WholeStreamCommand for ToHtml {
     fn name(&self) -> &str {
         "to html"
     }
@@ -271,7 +271,7 @@ fn get_list_of_theme_names() -> Vec<String> {
 async fn to_html(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name_tag = args.call_info.name_tag.clone();
     let (
-        ToHTMLArgs {
+        ToHtmlArgs {
             html_color,
             no_color,
             dark,
@@ -758,6 +758,6 @@ mod tests {
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(ToHTML {})
+        test_examples(ToHtml {})
     }
 }

crates/nu-command/src/commands/to_json.rs

@@ -7,15 +7,15 @@ use nu_protocol::{
 use serde::Serialize;
 use serde_json::json;
 
-pub struct ToJSON;
+pub struct ToJson;
 
 #[derive(Deserialize)]
-pub struct ToJSONArgs {
+pub struct ToJsonArgs {
     pretty: Option<Value>,
 }
 
 #[async_trait]
-impl WholeStreamCommand for ToJSON {
+impl WholeStreamCommand for ToJson {
     fn name(&self) -> &str {
         "to json"
     }
@@ -160,7 +160,7 @@ fn json_list(input: &[Value]) -> Result<Vec<serde_json::Value>, ShellError> {
 
 async fn to_json(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name_tag = args.call_info.name_tag.clone();
-    let (ToJSONArgs { pretty }, input) = args.process().await?;
+    let (ToJsonArgs { pretty }, input) = args.process().await?;
     let name_span = name_tag.span;
     let input: Vec<Value> = input.collect().await;
 
@@ -256,12 +256,12 @@ async fn to_json(args: CommandArgs) -> Result<OutputStream, ShellError> {
 #[cfg(test)]
 mod tests {
     use super::ShellError;
-    use super::ToJSON;
+    use super::ToJson;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(ToJSON {})
+        test_examples(ToJson {})
     }
 }

crates/nu-command/src/commands/to_toml.rs

@@ -3,10 +3,10 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::{CoerceInto, ShellError};
 use nu_protocol::{Primitive, ReturnSuccess, Signature, UnspannedPathMember, UntaggedValue, Value};
 
-pub struct ToTOML;
+pub struct ToToml;
 
 #[async_trait]
-impl WholeStreamCommand for ToTOML {
+impl WholeStreamCommand for ToToml {
     fn name(&self) -> &str {
         "to toml"
     }
@@ -195,7 +195,7 @@ mod tests {
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(ToTOML {})
+        test_examples(ToToml {})
     }
 
     #[test]

crates/nu-command/src/commands/to_tsv.rs

@@ -4,15 +4,15 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::Signature;
 
-pub struct ToTSV;
+pub struct ToTsv;
 
 #[derive(Deserialize)]
-pub struct ToTSVArgs {
+pub struct ToTsvArgs {
     noheaders: bool,
 }
 
 #[async_trait]
-impl WholeStreamCommand for ToTSV {
+impl WholeStreamCommand for ToTsv {
     fn name(&self) -> &str {
         "to tsv"
     }
@@ -36,7 +36,7 @@ impl WholeStreamCommand for ToTSV {
 
 async fn to_tsv(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
-    let (ToTSVArgs { noheaders }, input) = args.process().await?;
+    let (ToTsvArgs { noheaders }, input) = args.process().await?;
 
     to_delimited_data(noheaders, '\t', "TSV", input, name).await
 }
@@ -44,12 +44,12 @@ async fn to_tsv(args: CommandArgs) -> Result<OutputStream, ShellError> {
 #[cfg(test)]
 mod tests {
     use super::ShellError;
-    use super::ToTSV;
+    use super::ToTsv;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(ToTSV {})
+        test_examples(ToTsv {})
     }
 }

crates/nu-command/src/commands/to_url.rs

@@ -3,10 +3,10 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, UntaggedValue, Value};
 
-pub struct ToURL;
+pub struct ToUrl;
 
 #[async_trait]
-impl WholeStreamCommand for ToURL {
+impl WholeStreamCommand for ToUrl {
     fn name(&self) -> &str {
         "to url"
     }
@@ -76,12 +76,12 @@ async fn to_url(args: CommandArgs) -> Result<OutputStream, ShellError> {
 #[cfg(test)]
 mod tests {
     use super::ShellError;
-    use super::ToURL;
+    use super::ToUrl;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(ToURL {})
+        test_examples(ToUrl {})
     }
 }

crates/nu-command/src/commands/to_xml.rs

@@ -8,15 +8,15 @@ use std::collections::HashSet;
 use std::io::Cursor;
 use std::io::Write;
 
-pub struct ToXML;
+pub struct ToXml;
 
 #[derive(Deserialize)]
-pub struct ToXMLArgs {
+pub struct ToXmlArgs {
     pretty: Option<Value>,
 }
 
 #[async_trait]
-impl WholeStreamCommand for ToXML {
+impl WholeStreamCommand for ToXml {
     fn name(&self) -> &str {
         "to xml"
     }
@@ -135,7 +135,7 @@ pub fn write_xml_events<W: Write>(
 async fn to_xml(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name_tag = args.call_info.name_tag.clone();
     let name_span = name_tag.span;
-    let (ToXMLArgs { pretty }, input) = args.process().await?;
+    let (ToXmlArgs { pretty }, input) = args.process().await?;
     let input: Vec<Value> = input.collect().await;
 
     let to_process_input = match input.len() {
@@ -189,12 +189,12 @@ async fn to_xml(args: CommandArgs) -> Result<OutputStream, ShellError> {
 #[cfg(test)]
 mod tests {
     use super::ShellError;
-    use super::ToXML;
+    use super::ToXml;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(ToXML {})
+        test_examples(ToXml {})
     }
 }

crates/nu-command/src/commands/to_yaml.rs

@@ -3,10 +3,10 @@ use nu_engine::WholeStreamCommand;
 use nu_errors::{CoerceInto, ShellError};
 use nu_protocol::{Primitive, ReturnSuccess, Signature, UnspannedPathMember, UntaggedValue, Value};
 
-pub struct ToYAML;
+pub struct ToYaml;
 
 #[async_trait]
-impl WholeStreamCommand for ToYAML {
+impl WholeStreamCommand for ToYaml {
     fn name(&self) -> &str {
         "to yaml"
     }
@@ -164,12 +164,12 @@ async fn to_yaml(args: CommandArgs) -> Result<OutputStream, ShellError> {
 #[cfg(test)]
 mod tests {
     use super::ShellError;
-    use super::ToYAML;
+    use super::ToYaml;
 
     #[test]
     fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(ToYAML {})
+        test_examples(ToYaml {})
     }
 }

crates/nu-command/tests/commands/get.rs

@@ -151,24 +151,12 @@ fn errors_fetching_by_column_not_present() {
             "#
         ));
 
-        assert!(
+        assert!(actual.err.contains("Unknown column"),);
-            actual.err.contains("Unknown column"),
+        assert!(actual.err.contains("There isn't a column named 'taco'"),);
-            format!("actual: {:?}", actual.err)
+        assert!(actual.err.contains("Perhaps you meant 'taconushell'?"),);
-        );
+        assert!(actual
-        assert!(
+            .err
-            actual.err.contains("There isn't a column named 'taco'"),
+            .contains("Columns available: pizzanushell, taconushell"),);
-            format!("actual: {:?}", actual.err)
-        );
-        assert!(
-            actual.err.contains("Perhaps you meant 'taconushell'?"),
-            format!("actual: {:?}", actual.err)
-        );
-        assert!(
-            actual
-                .err
-                .contains("Columns available: pizzanushell, taconushell"),
-            format!("actual: {:?}", actual.err)
-        );
     })
 }
 
@@ -191,20 +179,11 @@ fn errors_fetching_by_column_using_a_number() {
             "#
         ));
 
-        assert!(
+        assert!(actual.err.contains("No rows available"),);
-            actual.err.contains("No rows available"),
+        assert!(actual.err.contains("A row at '0' can't be indexed."),);
-            format!("actual: {:?}", actual.err)
+        assert!(actual
-        );
+            .err
-        assert!(
+            .contains("Appears to contain columns. Columns available: 0"),)
-            actual.err.contains("A row at '0' can't be indexed."),
-            format!("actual: {:?}", actual.err)
-        );
-        assert!(
-            actual
-                .err
-                .contains("Appears to contain columns. Columns available: 0"),
-            format!("actual: {:?}", actual.err)
-        )
     })
 }
 #[test]
@@ -226,18 +205,9 @@ fn errors_fetching_by_index_out_of_bounds() {
             "#
         ));
 
-        assert!(
+        assert!(actual.err.contains("Row not found"),);
-            actual.err.contains("Row not found"),
+        assert!(actual.err.contains("There isn't a row indexed at 3"),);
-            format!("actual: {:?}", actual.err)
+        assert!(actual.err.contains("The table only has 3 rows (0 to 2)"),)
-        );
-        assert!(
-            actual.err.contains("There isn't a row indexed at 3"),
-            format!("actual: {:?}", actual.err)
-        );
-        assert!(
-            actual.err.contains("The table only has 3 rows (0 to 2)"),
-            format!("actual: {:?}", actual.err)
-        )
     })
 }
 

crates/nu-command/tests/commands/rename.rs

@@ -83,13 +83,7 @@ fn errors_if_no_columns_present() {
                 "#
         ));
 
-        assert!(
+        assert!(actual.err.contains("no column names available"));
-            actual.err.contains("no column names available"),
+        assert!(actual.err.contains("can't rename"));
-            format!("actual: {:?}", actual.err)
-        );
-        assert!(
-            actual.err.contains("can't rename"),
-            format!("actual: {:?}", actual.err)
-        );
     })
 }

crates/nu-data/src/primitive.rs

@@ -146,7 +146,7 @@ pub fn get_color_config() -> HashMap<String, Style> {
     hm.insert("index_color".to_string(), Color::Green.bold());
     hm.insert(
         "leading_trailing_space_bg".to_string(),
-        Style::default().on(Color::RGB(128, 128, 128)),
+        Style::default().on(Color::Rgb(128, 128, 128)),
     );
 
     // populate hashmap from config values

crates/nu-engine/src/shell/palette.rs

@@ -241,7 +241,7 @@ impl ThemeColor {
         let r = ThemeColor::xtoi(&mut bytes)?;
         let g = ThemeColor::xtoi(&mut bytes)?;
         let b = ThemeColor::xtoi(&mut bytes)?;
-        Ok(ThemeColor(Color::RGB(r, g, b)))
+        Ok(ThemeColor(Color::Rgb(r, g, b)))
     }
 
     fn xtoi<E>(b: &mut Bytes) -> Result<u8, E>
@@ -329,7 +329,7 @@ mod tests {
         assert_eq!(
             styled[0],
             Spanned {
-                item: Color::RGB(163, 89, 204).bold(),
+                item: Color::Rgb(163, 89, 204).bold(),
                 span: Span::new(4, 9),
             },
         );

crates/nu-json/src/de.rs

@@ -105,7 +105,7 @@ where
                 return visitor.visit_str(s);
             } else if ch <= b' ' {
                 if ch == 0 {
-                    return Err(self.rdr.error(ErrorCode::EOFWhileParsingObject));
+                    return Err(self.rdr.error(ErrorCode::EofWhileParsingObject));
                 } else if space.is_none() {
                     space = Some(self.str_buf.len());
                 }
@@ -124,7 +124,7 @@ where
         self.rdr.parse_whitespace()?;
 
         if self.rdr.eof()? {
-            return Err(self.rdr.error(ErrorCode::EOFWhileParsingValue));
+            return Err(self.rdr.error(ErrorCode::EofWhileParsingValue));
         }
 
         match self.state {
@@ -162,7 +162,7 @@ where
                 match self.rdr.next_char()? {
                     Some(b']') => Ok(ret),
                     Some(_) => Err(self.rdr.error(ErrorCode::TrailingCharacters)),
-                    None => Err(self.rdr.error(ErrorCode::EOFWhileParsingList)),
+                    None => Err(self.rdr.error(ErrorCode::EofWhileParsingList)),
                 }
             }
             b'{' => {
@@ -193,7 +193,7 @@ where
                 if root {
                     Ok(ret)
                 } else {
-                    Err(self.rdr.error(ErrorCode::EOFWhileParsingObject))
+                    Err(self.rdr.error(ErrorCode::EofWhileParsingObject))
                 }
             }
         }
@@ -374,7 +374,7 @@ where
         // When parsing multiline string values, we must look for ' characters.
         loop {
             if self.rdr.eof()? {
-                return Err(self.rdr.error(ErrorCode::EOFWhileParsingString));
+                return Err(self.rdr.error(ErrorCode::EofWhileParsingString));
             } // todo error("Bad multiline string");
             let ch = self.rdr.next_char_or_null()?;
 
@@ -413,7 +413,7 @@ where
             let ch = match self.rdr.next_char()? {
                 Some(ch) => ch,
                 None => {
-                    return Err(self.rdr.error(ErrorCode::EOFWhileParsingString));
+                    return Err(self.rdr.error(ErrorCode::EofWhileParsingString));
                 }
             };
 
@@ -425,7 +425,7 @@ where
                     let ch = match self.rdr.next_char()? {
                         Some(ch) => ch,
                         None => {
-                            return Err(self.rdr.error(ErrorCode::EOFWhileParsingString));
+                            return Err(self.rdr.error(ErrorCode::EofWhileParsingString));
                         }
                     };
 
@@ -509,7 +509,7 @@ where
         match self.rdr.next_char()? {
             Some(b':') => Ok(()),
             Some(_) => Err(self.rdr.error(ErrorCode::ExpectedColon)),
-            None => Err(self.rdr.error(ErrorCode::EOFWhileParsingObject)),
+            None => Err(self.rdr.error(ErrorCode::EofWhileParsingObject)),
         }
     }
 }
@@ -592,7 +592,7 @@ where
             }
             Some(_) => {}
             None => {
-                return Err(self.de.rdr.error(ErrorCode::EOFWhileParsingList));
+                return Err(self.de.rdr.error(ErrorCode::EofWhileParsingList));
             }
         }
 
@@ -652,7 +652,7 @@ where
                 if self.root {
                     return Ok(None);
                 } else {
-                    return Err(self.de.rdr.error(ErrorCode::EOFWhileParsingObject));
+                    return Err(self.de.rdr.error(ErrorCode::EofWhileParsingObject));
                 }
             }
         }
@@ -666,7 +666,7 @@ where
                 };
                 Ok(Some(seed.deserialize(&mut *self.de)?))
             }
-            None => Err(self.de.rdr.error(ErrorCode::EOFWhileParsingValue)),
+            None => Err(self.de.rdr.error(ErrorCode::EofWhileParsingValue)),
         }
     }
 
@@ -676,7 +676,7 @@ where
     {
         self.de.parse_object_colon()?;
 
-        Ok(seed.deserialize(&mut *self.de)?)
+        seed.deserialize(&mut *self.de)
     }
 }
 

crates/nu-json/src/error.rs

@@ -19,16 +19,16 @@ pub enum ErrorCode {
     Custom(String),
 
     /// EOF while parsing a list.
-    EOFWhileParsingList,
+    EofWhileParsingList,
 
     /// EOF while parsing an object.
-    EOFWhileParsingObject,
+    EofWhileParsingObject,
 
     /// EOF while parsing a string.
-    EOFWhileParsingString,
+    EofWhileParsingString,
 
     /// EOF while parsing a JSON value.
-    EOFWhileParsingValue,
+    EofWhileParsingValue,
 
     /// Expected this character to be a `':'`.
     ExpectedColon,
@@ -76,10 +76,10 @@ impl fmt::Debug for ErrorCode {
 
         match *self {
             ErrorCode::Custom(ref msg) => write!(f, "{}", msg),
-            ErrorCode::EOFWhileParsingList => "EOF while parsing a list".fmt(f),
+            ErrorCode::EofWhileParsingList => "EOF while parsing a list".fmt(f),
-            ErrorCode::EOFWhileParsingObject => "EOF while parsing an object".fmt(f),
+            ErrorCode::EofWhileParsingObject => "EOF while parsing an object".fmt(f),
-            ErrorCode::EOFWhileParsingString => "EOF while parsing a string".fmt(f),
+            ErrorCode::EofWhileParsingString => "EOF while parsing a string".fmt(f),
-            ErrorCode::EOFWhileParsingValue => "EOF while parsing a value".fmt(f),
+            ErrorCode::EofWhileParsingValue => "EOF while parsing a value".fmt(f),
             ErrorCode::ExpectedColon => "expected `:`".fmt(f),
             ErrorCode::ExpectedListCommaOrEnd => "expected `,` or `]`".fmt(f),
             ErrorCode::ExpectedObjectCommaOrEnd => "expected `,` or `}`".fmt(f),

crates/nu-json/src/value.rs

@@ -1092,7 +1092,7 @@ impl<'de, 'a> de::MapAccess<'de> for MapDeserializer {
         V: de::DeserializeSeed<'de>,
     {
         let value = self.value.take().expect("value is missing");
-        Ok(seed.deserialize(value)?)
+        seed.deserialize(value)
     }
 
     fn size_hint(&self) -> Option<usize> {
@@ -1150,18 +1150,18 @@ mod test {
 
         let v: Value = from_str("{\"a\":1.1}").unwrap();
         let vo = v.as_object().unwrap();
-        assert_eq!(vo["a"].as_f64().unwrap(), 1.1);
+        assert!(vo["a"].as_f64().unwrap() - 1.1 < std::f64::EPSILON);
 
         let v: Value = from_str("{\"a\":-1.1}").unwrap();
         let vo = v.as_object().unwrap();
-        assert_eq!(vo["a"].as_f64().unwrap(), -1.1);
+        assert!(vo["a"].as_f64().unwrap() + 1.1 > -(std::f64::EPSILON));
 
         let v: Value = from_str("{\"a\":1e6}").unwrap();
         let vo = v.as_object().unwrap();
-        assert_eq!(vo["a"].as_f64().unwrap(), 1e6);
+        assert!(vo["a"].as_f64().unwrap() - 1e6 < std::f64::EPSILON);
 
         let v: Value = from_str("{\"a\":-1e6}").unwrap();
         let vo = v.as_object().unwrap();
-        assert_eq!(vo["a"].as_f64().unwrap(), -1e6);
+        assert!(vo["a"].as_f64().unwrap() + 1e6 > -(std::f64::EPSILON));
     }
 }

crates/nu-json/tests/main.rs

@@ -115,7 +115,7 @@ fn fix_pass1(json: String) -> String {
 fn test_hjson() {
     let mut done: Vec<String> = Vec::new();
 
-    println!("");
+    println!();
     run_test!(charset, done, std_fix);
     run_test!(comments, done, std_fix);
     run_test!(empty, done, std_fix);
@@ -197,18 +197,17 @@ fn test_hjson() {
 
     let all = paths
         .map(|item| String::from(item.unwrap().path().file_stem().unwrap().to_str().unwrap()))
-        .filter(|x| x.contains("_test"))
+        .filter(|x| x.contains("_test"));
-        .collect::<Vec<String>>();
 
     let missing = all
         .into_iter()
         .filter(|x| done.iter().find(|y| &x == y) == None)
         .collect::<Vec<String>>();
 
-    if missing.len() > 0 {
+    if !missing.is_empty() {
         for item in missing {
             println!("missing: {}", item);
         }
-        assert!(false);
+        panic!();
     }
 }

crates/nu-parser/src/lex/lexer.rs

@@ -360,12 +360,12 @@ pub fn parse_block(tokens: Vec<Token>) -> (LiteBlock, Option<ParseError>) {
     // - semicolon
     while let Some(token) = tokens.next() {
         match &token.contents {
-            TokenContents::EOL => {
+            TokenContents::Eol => {
                 // If we encounter two newline characters in a row, use a special eoleol event,
                 // which allows the parser to discard comments that shouldn't be treated as
                 // documentation for the following item.
                 if let Some(Token {
-                    contents: TokenContents::EOL,
+                    contents: TokenContents::Eol,
                     ..
                 }) = tokens.peek()
                 {
@@ -480,7 +480,7 @@ pub fn lex(input: &str, span_offset: usize) -> (Vec<Token>, Option<ParseError>)
             let idx = *idx;
             let _ = char_indices.next();
             output.push(Token::new(
-                TokenContents::EOL,
+                TokenContents::Eol,
                 Span::new(span_offset + idx, span_offset + idx + 1),
             ));
         } else if *c == '#' {

crates/nu-parser/src/lex/tokens.rs

@@ -19,7 +19,7 @@ pub enum TokenContents {
     Comment(LiteComment),
     Pipe,
     Semicolon,
-    EOL,
+    Eol,
 }
 
 impl fmt::Display for TokenContents {
@@ -29,7 +29,7 @@ impl fmt::Display for TokenContents {
             TokenContents::Comment(comm) => write!(f, "{}", comm),
             TokenContents::Pipe => write!(f, "|"),
             TokenContents::Semicolon => write!(f, ";"),
-            TokenContents::EOL => write!(f, "\\n"),
+            TokenContents::Eol => write!(f, "\\n"),
         }
     }
 }

crates/nu-plugin/src/test_helpers.rs

@@ -71,10 +71,7 @@ impl<'a, T: Plugin> PluginTest<'a, T> {
                 for flag in flags {
                     assert!(
                         flags_configured.iter().any(|f| *f == flag),
-                        format!(
+                        "The flag you passed is not configured in the plugin.",
-                            "The flag you passed ({}) is not configured in the plugin.",
-                            flag
-                        )
                     );
                 }
             }
@@ -143,7 +140,7 @@ pub fn expect_return_value_at(
     for (idx, item) in return_values.iter().enumerate() {
         let item = match item {
             Ok(return_value) => return_value,
-            Err(reason) => panic!(format!("{}", reason)),
+            Err(_) => panic!("Unexpected value"),
         };
 
         if idx == at {
@@ -155,9 +152,5 @@ pub fn expect_return_value_at(
         }
     }
 
-    panic!(format!(
+    panic!("Couldn't get return value from stream.")
-        "Couldn't get return value from stream at {}. (There are {} items)",
-        at,
-        return_values.len() - 1
-    ))
 }

crates/nu-table/src/main.rs

@@ -31,37 +31,39 @@ fn main() {
 }
 
 fn make_table_data() -> (Vec<&'static str>, Vec<&'static str>) {
-    let mut table_headers = vec![];
+    let table_headers = vec![
-    table_headers.push("category");
+        "category",
-    table_headers.push("description");
+        "description",
-    table_headers.push("emoji");
+        "emoji",
-    table_headers.push("ios_version");
+        "ios_version",
-    table_headers.push("unicode_version");
+        "unicode_version",
-    table_headers.push("aliases");
+        "aliases",
-    table_headers.push("tags");
+        "tags",
-    table_headers.push("category2");
+        "category2",
-    table_headers.push("description2");
+        "description2",
-    table_headers.push("emoji2");
+        "emoji2",
-    table_headers.push("ios_version2");
+        "ios_version2",
-    table_headers.push("unicode_version2");
+        "unicode_version2",
-    table_headers.push("aliases2");
+        "aliases2",
-    table_headers.push("tags2");
+        "tags2",
+    ];
 
-    let mut row_data = vec![];
+    let row_data = vec![
-    row_data.push("Smileys & Emotion");
+        "Smileys & Emotion",
-    row_data.push("grinning face");
+        "grinning face",
-    row_data.push("😀");
+        "😀",
-    row_data.push("6");
+        "6",
-    row_data.push("6.1");
+        "6.1",
-    row_data.push("grinning");
+        "grinning",
-    row_data.push("smile");
+        "smile",
-    row_data.push("Smileys & Emotion");
+        "Smileys & Emotion",
-    row_data.push("grinning face");
+        "grinning face",
-    row_data.push("😀");
+        "😀",
-    row_data.push("6");
+        "6",
-    row_data.push("6.1");
+        "6.1",
-    row_data.push("grinning");
+        "grinning",
-    row_data.push("smile");
+        "smile",
+    ];
 
     (table_headers, row_data)
 }

crates/nu-test-support/src/fs.rs

@@ -196,8 +196,8 @@ pub fn delete_file_at(full_path: impl AsRef<Path>) {
 pub fn create_file_at(full_path: impl AsRef<Path>) -> Result<(), std::io::Error> {
     let full_path = full_path.as_ref();
 
-    if let Some(parent) = full_path.parent() {
+    if full_path.parent().is_some() {
-        panic!(format!("{:?} exists", parent.display()));
+        panic!("path exists");
     }
 
     std::fs::write(full_path, b"fake data")

crates/nu_plugin_binaryview/src/binaryview.rs

@@ -63,7 +63,7 @@ impl RenderContext {
                 Some(c) => {
                     print!(
                         "{}",
-                        nu_ansi_term::Color::RGB(c.0, c.1, c.2)
+                        nu_ansi_term::Color::Rgb(c.0, c.1, c.2)
                             .paint((0..prev_count).map(|_| "█").collect::<String>())
                     );
                     prev_color = Some(*pixel);
@@ -80,7 +80,7 @@ impl RenderContext {
             if let Some(color) = prev_color {
                 print!(
                     "{}",
-                    nu_ansi_term::Color::RGB(color.0, color.1, color.2)
+                    nu_ansi_term::Color::Rgb(color.0, color.1, color.2)
                         .paint((0..prev_count).map(|_| "█").collect::<String>())
                 );
             }
@@ -108,8 +108,8 @@ impl RenderContext {
                 (Some(c), Some(d)) => {
                     print!(
                         "{}",
-                        nu_ansi_term::Color::RGB(c.0, c.1, c.2)
+                        nu_ansi_term::Color::Rgb(c.0, c.1, c.2)
-                            .on(nu_ansi_term::Color::RGB(d.0, d.1, d.2,))
+                            .on(nu_ansi_term::Color::Rgb(d.0, d.1, d.2,))
                             .paint((0..prev_count).map(|_| "▀").collect::<String>())
                     );
                     prev_fg = Some(top_pixel);
@@ -131,8 +131,8 @@ impl RenderContext {
             if let (Some(c), Some(d)) = (prev_fg, prev_bg) {
                 print!(
                     "{}",
-                    nu_ansi_term::Color::RGB(c.0, c.1, c.2)
+                    nu_ansi_term::Color::Rgb(c.0, c.1, c.2)
-                        .on(nu_ansi_term::Color::RGB(d.0, d.1, d.2,))
+                        .on(nu_ansi_term::Color::Rgb(d.0, d.1, d.2,))
                         .paint((0..prev_count).map(|_| "▀").collect::<String>())
                 );
             }

crates/nu_plugin_from_bson/src/from_bson.rs

@@ -6,14 +6,14 @@ use nu_source::{SpannedItem, Tag};
 use std::str::FromStr;
 
 #[derive(Default)]
-pub struct FromBSON {
+pub struct FromBson {
     pub state: Vec<u8>,
     pub name_tag: Tag,
 }
 
-impl FromBSON {
+impl FromBson {
-    pub fn new() -> FromBSON {
+    pub fn new() -> FromBson {
-        FromBSON {
+        FromBson {
             state: vec![],
             name_tag: Tag::unknown(),
         }

crates/nu_plugin_from_bson/src/lib.rs

@@ -1,4 +1,4 @@
 mod from_bson;
 mod nu;
 
-pub use from_bson::FromBSON;
+pub use from_bson::FromBson;

crates/nu_plugin_from_bson/src/main.rs

@@ -1,6 +1,6 @@
 use nu_plugin::serve_plugin;
-use nu_plugin_from_bson::FromBSON;
+use nu_plugin_from_bson::FromBson;
 
 fn main() {
-    serve_plugin(&mut FromBSON::new())
+    serve_plugin(&mut FromBson::new())
 }

crates/nu_plugin_from_bson/src/nu/mod.rs

@@ -1,13 +1,13 @@
 #[cfg(test)]
 mod tests;
 
-use crate::FromBSON;
+use crate::FromBson;
 use nu_errors::ShellError;
 use nu_plugin::Plugin;
 use nu_protocol::{CallInfo, Primitive, ReturnValue, Signature, UntaggedValue, Value};
 use nu_source::Tag;
 
-impl Plugin for FromBSON {
+impl Plugin for FromBson {
     fn config(&mut self) -> Result<Signature, ShellError> {
         Ok(Signature::build("from bson")
             .desc("Convert from .bson binary into table")

crates/nu_plugin_inc/src/lib.rs

@@ -14,24 +14,21 @@ mod tests {
         pub fn expect_action(&self, action: Action) {
             match &self.action {
                 Some(set) if set == &action => {}
-                Some(other) => panic!(format!("\nExpected {:#?}\n\ngot {:#?}", action, other)),
+                Some(_) => panic!("\nUnexpected action"),
-                None => panic!(format!("\nAction {:#?} not found.", action)),
+                None => panic!("\nAction not found."),
             }
         }
 
         pub fn expect_field(&self, field: Value) {
             let field = match field.as_column_path() {
                 Ok(column_path) => column_path,
-                Err(reason) => panic!(format!(
+                Err(_) => panic!("\nExpected a ColumnPath",),
-                    "\nExpected {:#?} to be a ColumnPath, \n\ngot {:#?}",
-                    field, reason
-                )),
             };
 
             match &self.field {
                 Some(column_path) if column_path == &field => {}
-                Some(other) => panic!(format!("\nExpected {:#?} \n\ngot {:#?}", field, other)),
+                Some(_) => panic!("\nUnexpected field."),
-                None => panic!(format!("\nField {:#?} not found.", field)),
+                None => panic!("\nField not found."),
             }
         }
     }

crates/nu_plugin_to_bson/src/lib.rs

@@ -1,4 +1,4 @@
 mod nu;
 mod to_bson;
 
-pub use to_bson::ToBSON;
+pub use to_bson::ToBson;

crates/nu_plugin_to_bson/src/main.rs

@@ -1,6 +1,6 @@
 use nu_plugin::serve_plugin;
-use nu_plugin_to_bson::ToBSON;
+use nu_plugin_to_bson::ToBson;
 
 fn main() {
-    serve_plugin(&mut ToBSON::new())
+    serve_plugin(&mut ToBson::new())
 }

crates/nu_plugin_to_bson/src/nu/mod.rs

@@ -1,13 +1,13 @@
 #[cfg(test)]
 mod tests;
 
-use crate::ToBSON;
+use crate::ToBson;
 use nu_errors::ShellError;
 use nu_plugin::Plugin;
 use nu_protocol::{ReturnValue, Signature, Value};
 use nu_source::Tag;
 
-impl Plugin for ToBSON {
+impl Plugin for ToBson {
     fn config(&mut self) -> Result<Signature, ShellError> {
         Ok(Signature::build("to bson")
             .desc("Convert table into .bson binary")

crates/nu_plugin_to_bson/src/to_bson.rs

@@ -9,13 +9,13 @@ use num_traits::ToPrimitive;
 use std::convert::TryInto;
 
 #[derive(Default)]
-pub struct ToBSON {
+pub struct ToBson {
     pub state: Vec<Value>,
 }
 
-impl ToBSON {
+impl ToBson {
-    pub fn new() -> ToBSON {
+    pub fn new() -> ToBson {
-        ToBSON { state: vec![] }
+        ToBson { state: vec![] }
     }
 }
 

src/plugins/nu_plugin_extra_from_bson.rs

@@ -1,6 +1,6 @@
 use nu_plugin::serve_plugin;
-use nu_plugin_from_bson::FromBSON;
+use nu_plugin_from_bson::FromBson;
 
 fn main() {
-    serve_plugin(&mut FromBSON::new());
+    serve_plugin(&mut FromBson::new());
 }

src/plugins/nu_plugin_extra_to_bson.rs

@@ -1,6 +1,6 @@
 use nu_plugin::serve_plugin;
-use nu_plugin_to_bson::ToBSON;
+use nu_plugin_to_bson::ToBson;
 
 fn main() {
-    serve_plugin(&mut ToBSON::new())
+    serve_plugin(&mut ToBson::new())
 }

tests/shell/pipeline/commands/external.rs

@@ -259,10 +259,7 @@ mod tilde_expansion {
         "#
         );
 
-        assert!(
+        assert!(!actual.out.contains('~'));
-            !actual.out.contains('~'),
-            format!("'{}' should not contain ~", actual.out)
-        );
     }
 
     #[test]

tests/shell/pipeline/commands/internal.rs

@@ -716,49 +716,25 @@ mod parse {
     fn errors_if_flag_passed_is_not_exact() {
         let actual = nu!(cwd: ".", "debug -ra");
 
-        assert!(
+        assert!(actual.err.contains("unexpected flag"),);
-            actual.err.contains("unexpected flag"),
-            format!(
-                "error message '{}' should contain 'unexpected flag'",
-                actual.err
-            )
-        );
 
         let actual = nu!(cwd: ".", "debug --rawx");
 
-        assert!(
+        assert!(actual.err.contains("unexpected flag"),);
-            actual.err.contains("unexpected flag"),
-            format!(
-                "error message '{}' should contain 'unexpected flag'",
-                actual.err
-            )
-        );
     }
 
     #[test]
     fn errors_if_flag_is_not_supported() {
         let actual = nu!(cwd: ".", "debug --ferris");
 
-        assert!(
+        assert!(actual.err.contains("unexpected flag"),);
-            actual.err.contains("unexpected flag"),
-            format!(
-                "error message '{}' should contain 'unexpected flag'",
-                actual.err
-            )
-        );
     }
 
     #[test]
     fn errors_if_passed_an_unexpected_argument() {
         let actual = nu!(cwd: ".", "debug ferris");
 
-        assert!(
+        assert!(actual.err.contains("unexpected argument"),);
-            actual.err.contains("unexpected argument"),
-            format!(
-                "error message '{}' should contain 'unexpected argument'",
-                actual.err
-            )
-        );
     }
 }
 
@@ -775,10 +751,7 @@ mod tilde_expansion {
         "#
         );
 
-        assert!(
+        assert!(!actual.out.contains('~'),);
-            !actual.out.contains('~'),
-            format!("'{}' should not contain ~", actual.out)
-        );
     }
 
     #[test]