Merge pull request #1284 from vks/clippy

Misc code clean up

src/arch/arch.rs

@@ -15,9 +15,9 @@ extern crate uucore;
 
 use platform_info::*;
 
-static SYNTAX: &'static str = "";
-static SUMMARY: &'static str = "Determine architecture name for current machine.";
-static LONG_HELP: &'static str = "";
+static SYNTAX: &str = "";
+static SUMMARY: &str = "Determine architecture name for current machine.";
+static LONG_HELP: &str = "";
 
 pub fn uumain(args: Vec<String>) -> i32 {
     new_coreopts!(SYNTAX, SUMMARY, LONG_HELP).parse(args);

src/base32/base32.rs

@@ -16,10 +16,10 @@ use std::fs::File;
 use std::io::{stdin, BufReader, Read};
 use std::path::Path;
 
-static SYNTAX: &'static str = "[OPTION]... [FILE]";
-static SUMMARY: &'static str =
+static SYNTAX: &str = "[OPTION]... [FILE]";
+static SUMMARY: &str =
     "Base32 encode or decode FILE, or standard input, to standard output.";
-static LONG_HELP: &'static str = "
+static LONG_HELP: &str = "
  With no FILE, or when FILE is -, read standard input.
 
  The data are encoded as described for the base32 alphabet in RFC

src/base64/base64.rs

@@ -17,10 +17,10 @@ use std::fs::File;
 use std::io::{stdin, BufReader, Read};
 use std::path::Path;
 
-static SYNTAX: &'static str = "[OPTION]... [FILE]";
-static SUMMARY: &'static str =
+static SYNTAX: &str = "[OPTION]... [FILE]";
+static SUMMARY: &str =
     "Base64 encode or decode FILE, or standard input, to standard output.";
-static LONG_HELP: &'static str = "
+static LONG_HELP: &str = "
  With no FILE, or when FILE is -, read standard input.
 
  The data are encoded as described for the base64 alphabet in RFC

src/basename/basename.rs

@@ -14,11 +14,11 @@ extern crate uucore;
 
 use std::path::{is_separator, PathBuf};
 
-static NAME: &'static str = "basename";
-static SYNTAX: &'static str = "NAME [SUFFIX]";
-static SUMMARY: &'static str = "Print NAME with any leading directory components removed
+static NAME: &str = "basename";
+static SYNTAX: &str = "NAME [SUFFIX]";
+static SUMMARY: &str = "Print NAME with any leading directory components removed
  If specified, also remove a trailing SUFFIX";
-static LONG_HELP: &'static str = "";
+static LONG_HELP: &str = "";
 
 pub fn uumain(args: Vec<String>) -> i32 {
     //
@@ -44,7 +44,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
         .parse(args);
 
     // too few arguments
-    if matches.free.len() < 1 {
+    if matches.free.is_empty() {
         crash!(
             1,
             "{0}: {1}\nTry '{0} --help' for more information.",

src/cat/cat.rs

@@ -31,10 +31,10 @@ use std::os::unix::fs::FileTypeExt;
 #[cfg(unix)]
 use unix_socket::UnixStream;
 
-static SYNTAX: &'static str = "[OPTION]... [FILE]...";
-static SUMMARY: &'static str = "Concatenate FILE(s), or standard input, to standard output
+static SYNTAX: &str = "[OPTION]... [FILE]...";
+static SUMMARY: &str = "Concatenate FILE(s), or standard input, to standard output
  With no FILE, or when FILE is -, read standard input.";
-static LONG_HELP: &'static str = "";
+static LONG_HELP: &str = "";
 
 #[derive(PartialEq)]
 enum NumberingMode {
@@ -174,32 +174,23 @@ pub fn uumain(args: Vec<String>) -> i32 {
     let success = if can_write_fast {
         write_fast(files).is_ok()
     } else {
-        let tab = match show_tabs {
-            true => "^I",
-            false => "\t",
-        }.to_owned();
+        let tab = if show_tabs { "^I" } else { "\t" }.to_owned();
 
-        let end_of_line = match show_ends {
-            true => "$\n",
-            false => "\n",
-        }.to_owned();
+        let end_of_line = if show_ends { "$\n" } else { "\n" }.to_owned();
 
         let options = OutputOptions {
-            end_of_line: end_of_line,
+            end_of_line,
             number: number_mode,
-            show_nonprint: show_nonprint,
-            show_tabs: show_tabs,
-            squeeze_blank: squeeze_blank,
-            tab: tab,
+            show_nonprint,
+            show_tabs,
+            squeeze_blank,
+            tab,
         };
 
         write_lines(files, &options).is_ok()
     };
 
-    match success {
-        true => 0,
-        false => 1,
-    }
+    if success { 0 } else { 1 }
 }
 
 /// Classifies the `InputType` of file at `path` if possible
@@ -363,7 +354,7 @@ fn write_file_lines(file: &str, options: &OutputOptions, state: &mut OutputState
         let mut pos = 0;
         while pos < n {
             // skip empty line_number enumerating them if needed
-            if in_buf[pos] == '\n' as u8 {
+            if in_buf[pos] == b'\n' {
                 if !state.at_line_start || !options.squeeze_blank || !one_blank_kept {
                     one_blank_kept = true;
                     if state.at_line_start && options.number == NumberingMode::NumberAll {
@@ -415,7 +406,7 @@ fn write_file_lines(file: &str, options: &OutputOptions, state: &mut OutputState
 // Write all symbols till end of line or end of buffer is reached
 // Return the (number of written symbols + 1) or 0 if the end of buffer is reached
 fn write_to_end<W: Write>(in_buf: &[u8], writer: &mut W) -> usize {
-    match in_buf.iter().position(|c| *c == '\n' as u8) {
+    match in_buf.iter().position(|c| *c == b'\n') {
         Some(p) => {
             writer.write_all(&in_buf[..p]).unwrap();
             p + 1
@@ -431,14 +422,14 @@ fn write_tab_to_end<W: Write>(mut in_buf: &[u8], writer: &mut W) -> usize {
     loop {
         match in_buf
             .iter()
-            .position(|c| *c == '\n' as u8 || *c == '\t' as u8)
+            .position(|c| *c == b'\n' || *c == b'\t')
         {
             Some(p) => {
                 writer.write_all(&in_buf[..p]).unwrap();
-                if in_buf[p] == '\n' as u8 {
+                if in_buf[p] == b'\n' {
                     return p + 1;
                 } else {
-                    writer.write_all("^I".as_bytes()).unwrap();
+                    writer.write_all(b"^I").unwrap();
                     in_buf = &in_buf[p + 1..];
                 }
             }
@@ -454,17 +445,17 @@ fn write_nonprint_to_end<W: Write>(in_buf: &[u8], writer: &mut W, tab: &[u8]) ->
     let mut count = 0;
 
     for byte in in_buf.iter().map(|c| *c) {
-        if byte == '\n' as u8 {
+        if byte == b'\n' {
             break;
         }
         match byte {
             9 => writer.write_all(tab),
-            0...8 | 10...31 => writer.write_all(&['^' as u8, byte + 64]),
+            0...8 | 10...31 => writer.write_all(&[b'^', byte + 64]),
             32...126 => writer.write_all(&[byte]),
-            127 => writer.write_all(&['^' as u8, byte - 64]),
-            128...159 => writer.write_all(&['M' as u8, '-' as u8, '^' as u8, byte - 64]),
-            160...254 => writer.write_all(&['M' as u8, '-' as u8, byte - 128]),
-            _ => writer.write_all(&['M' as u8, '-' as u8, '^' as u8, 63]),
+            127 => writer.write_all(&[b'^', byte - 64]),
+            128...159 => writer.write_all(&[b'M', b'-', b'^', byte - 64]),
+            160...254 => writer.write_all(&[b'M', b'-', byte - 128]),
+            _ => writer.write_all(&[b'M', b'-', b'^', 63]),
         }.unwrap();
         count += 1;
     }

src/chgrp/chgrp.rs

@@ -29,9 +29,9 @@ use std::path::Path;
 use std::ffi::CString;
 use std::os::unix::ffi::OsStrExt;
 
-static SYNTAX: &'static str =
+static SYNTAX: &str =
     "chgrp [OPTION]... GROUP FILE...\n or :  chgrp [OPTION]... --reference=RFILE FILE...";
-static SUMMARY: &'static str = "Change the group of each FILE to GROUP.";
+static SUMMARY: &str = "Change the group of each FILE to GROUP.";
 
 const FTS_COMFOLLOW: u8 = 1;
 const FTS_PHYSICAL: u8 = 1 << 1;
@@ -117,7 +117,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
         Verbosity::Normal
     };
 
-    if matches.free.len() < 1 {
+    if matches.free.is_empty() {
         disp_err!("missing operand");
         return 1;
     } else if matches.free.len() < 2 && !matches.opt_present("reference") {
@@ -153,13 +153,13 @@ pub fn uumain(args: Vec<String>) -> i32 {
     }
 
     let executor = Chgrper {
-        bit_flag: bit_flag,
-        dest_gid: dest_gid,
-        verbosity: verbosity,
-        recursive: recursive,
+        bit_flag,
+        dest_gid,
+        verbosity,
+        recursive,
         dereference: derefer != 0,
-        preserve_root: preserve_root,
-        files: files,
+        preserve_root,
+        files,
     };
     executor.exec()
 }

src/chmod/chmod.rs

@@ -24,10 +24,10 @@ use walker::Walker;
 use uucore::mode;
 use uucore::fs::display_permissions_unix;
 
-const NAME: &'static str = "chmod";
-static SUMMARY: &'static str = "Change the mode of each FILE to MODE.
+const NAME: &str = "chmod";
+static SUMMARY: &str = "Change the mode of each FILE to MODE.
  With --reference, change the mode of each FILE to that of RFILE.";
-static LONG_HELP: &'static str = "
+static LONG_HELP: &str = "
  Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'.
 ";
 
@@ -81,13 +81,13 @@ pub fn uumain(mut args: Vec<String>) -> i32 {
             None
         };
         let chmoder = Chmoder {
-            changes: changes,
-            quiet: quiet,
-            verbose: verbose,
-            preserve_root: preserve_root,
-            recursive: recursive,
-            fmode: fmode,
-            cmode: cmode,
+            changes,
+            quiet,
+            verbose,
+            preserve_root,
+            recursive,
+            fmode,
+            cmode,
         };
         match chmoder.chmod(matches.free) {
             Ok(()) => {}

src/chown/chown.rs

@@ -30,9 +30,9 @@ use std::convert::AsRef;
 use std::ffi::CString;
 use std::os::unix::ffi::OsStrExt;
 
-static SYNTAX: &'static str =
+static SYNTAX: &str =
     "[OPTION]... [OWNER][:[GROUP]] FILE...\n chown [OPTION]... --reference=RFILE FILE...";
-static SUMMARY: &'static str = "change file owner and group";
+static SUMMARY: &str = "change file owner and group";
 
 const FTS_COMFOLLOW: u8 = 1;
 const FTS_PHYSICAL: u8 = 1 << 1;
@@ -136,7 +136,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
         IfFrom::All
     };
 
-    if matches.free.len() < 1 {
+    if matches.free.is_empty() {
         disp_err!("missing operand");
         return 1;
     } else if matches.free.len() < 2 && !matches.opt_present("reference") {
@@ -172,15 +172,15 @@ pub fn uumain(args: Vec<String>) -> i32 {
     let mut files = matches.free;
     files.remove(0);
     let executor = Chowner {
-        bit_flag: bit_flag,
-        dest_uid: dest_uid,
-        dest_gid: dest_gid,
-        verbosity: verbosity,
-        recursive: recursive,
+        bit_flag,
+        dest_uid,
+        dest_gid,
+        verbosity,
+        recursive,
         dereference: derefer != 0,
-        filter: filter,
-        preserve_root: preserve_root,
-        files: files,
+        filter,
+        preserve_root,
+        files,
     };
     executor.exec()
 }

src/chroot/chroot.rs

@@ -23,10 +23,10 @@ use std::iter::FromIterator;
 use std::path::Path;
 use std::process::Command;
 
-static NAME: &'static str = "chroot";
-static SYNTAX: &'static str = "[OPTION]... NEWROOT [COMMAND [ARG]...]";
-static SUMMARY: &'static str = "Run COMMAND with root directory set to NEWROOT.";
-static LONG_HELP: &'static str = "
+static NAME: &str = "chroot";
+static SYNTAX: &str = "[OPTION]... NEWROOT [COMMAND [ARG]...]";
+static SUMMARY: &str = "Run COMMAND with root directory set to NEWROOT.";
+static LONG_HELP: &str = "
  If COMMAND is not specified, it defaults to '$(SHELL) -i'.
  If $(SHELL) is not set, /bin/sh is used.
 ";
@@ -140,7 +140,7 @@ fn enter_chroot(root: &Path) {
     let root_str = root.display();
     std::env::set_current_dir(root).unwrap();
     let err = unsafe {
-        chroot(CString::new(".".as_bytes())
+        chroot(CString::new(".")
             .unwrap()
             .as_bytes_with_nul()
             .as_ptr() as *const libc::c_char)

src/cksum/build.rs

@@ -13,7 +13,7 @@ use std::fs::File;
 use std::io::Write;
 use std::path::Path;
 
-static CRC_TABLE_LEN: usize = 256;
+const CRC_TABLE_LEN: usize = 256;
 
 #[path = "../../mkmain.rs"]
 mod mkmain;

src/cksum/cksum.rs

@@ -20,9 +20,9 @@ use std::path::Path;
 
 include!(concat!(env!("OUT_DIR"), "/crc_table.rs"));
 
-static SYNTAX: &'static str = "[OPTIONS] [FILE]...";
-static SUMMARY: &'static str = "Print CRC and size for each file";
-static LONG_HELP: &'static str = "";
+static SYNTAX: &str = "[OPTIONS] [FILE]...";
+static SUMMARY: &str = "Print CRC and size for each file";
+static LONG_HELP: &str = "";
 
 #[inline]
 fn crc_update(crc: u32, input: u8) -> u32 {

src/comm/comm.rs

@@ -19,9 +19,9 @@ use std::fs::File;
 use std::io::{self, stdin, BufRead, BufReader, Stdin};
 use std::path::Path;
 
-static SYNTAX: &'static str = "[OPTIONS] FILE1 FILE2";
-static SUMMARY: &'static str = "Compare sorted files line by line";
-static LONG_HELP: &'static str = "";
+static SYNTAX: &str = "[OPTIONS] FILE1 FILE2";
+static SUMMARY: &str = "Compare sorted files line by line";
+static LONG_HELP: &str = "";
 
 fn mkdelim(col: usize, opts: &getopts::Matches) -> String {
     let mut s = String::new();

src/cp/cp.rs

@@ -676,14 +676,14 @@ impl TargetType {
 fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<Source>, Target)> {
     let mut paths = path_args.iter().map(PathBuf::from).collect::<Vec<_>>();
 
-    if paths.len() < 1 {
+    if paths.is_empty() {
         // No files specified
         return Err("missing file operand".into());
     }
 
     // Return an error if the user requested to copy more than one
     // file source to a file target
-    if options.no_target_dir && !options.target_dir.is_some() && paths.len() > 2 {
+    if options.no_target_dir && options.target_dir.is_none() && paths.len() > 2 {
         return Err(format!("extra operand {:?}", paths[2]).into());
     }
 

src/cut/buffer.rs

@@ -43,7 +43,7 @@ impl<R: Read> ByteReader<R> {
     pub fn new(read: R, newline_char: u8) -> ByteReader<R> {
         ByteReader {
             inner: BufReader::with_capacity(4096, read),
-            newline_char: newline_char,
+            newline_char,
         }
     }
 }
@@ -75,7 +75,7 @@ impl<R: Read> ByteReader<R> {
                 // need filled_buf to go out of scope
                 let filled_buf = match self.fill_buf() {
                     Ok(b) => {
-                        if b.len() == 0 {
+                        if b.is_empty() {
                             return bytes_consumed;
                         } else {
                             b
@@ -137,9 +137,8 @@ impl<R: Read> self::Bytes::Select for ByteReader<R> {
                 },
             };
 
-            match out {
-                Some(out) => crash_if_err!(1, out.write_all(&buffer[0..consume_val])),
-                None => (),
+            if let Some(out) = out {
+                crash_if_err!(1, out.write_all(&buffer[0..consume_val]));
             }
             (res, consume_val)
         };

src/cut/cut.rs

@@ -23,11 +23,11 @@ mod buffer;
 mod ranges;
 mod searcher;
 
-static SYNTAX: &'static str =
+static SYNTAX: &str =
     "[-d] [-s] [-z] [--output-delimiter] ((-f|-b|-c) {{sequence}}) {{sourcefile}}+";
-static SUMMARY: &'static str =
+static SUMMARY: &str =
     "Prints specified byte or field columns from each line of stdin or the input files";
-static LONG_HELP: &'static str = "
+static LONG_HELP: &str = "
  Each call must specify a mode (what to use for columns),
  a sequence (which columns to print), and provide a data source
 
@@ -169,14 +169,11 @@ fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> i32 {
                 }
             }
 
-            match opts.out_delim {
-                Some(ref delim) => {
-                    if print_delim {
-                        crash_if_err!(1, out.write_all(delim.as_bytes()));
-                    }
-                    print_delim = true;
+            if let Some(ref delim) = opts.out_delim {
+                if print_delim {
+                    crash_if_err!(1, out.write_all(delim.as_bytes()));
                 }
-                None => (),
+                print_delim = true;
             }
 
             // write out from low to high
@@ -293,18 +290,15 @@ fn cut_fields_delimiter<R: Read>(
 
 fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &FieldOptions) -> i32 {
     let newline_char = if opts.zero_terminated { b'\0' } else { b'\n' };
-    match opts.out_delimeter {
-        Some(ref o_delim) => {
-            return cut_fields_delimiter(
-                reader,
-                ranges,
-                &opts.delimiter,
-                opts.only_delimited,
-                newline_char,
-                o_delim,
-            )
-        }
-        None => (),
+    if let Some(ref o_delim) = opts.out_delimeter {
+        return cut_fields_delimiter(
+            reader,
+            ranges,
+            &opts.delimiter,
+            opts.only_delimited,
+            newline_char,
+            o_delim,
+        );
     }
 
     let mut buf_in = BufReader::new(reader);
@@ -348,10 +342,8 @@ fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &FieldOptions) -> i32
                 };
             }
 
-            if print_delim {
-                if low_idx >= opts.delimiter.as_bytes().len() {
-                    low_idx -= opts.delimiter.as_bytes().len();
-                }
+            if print_delim && low_idx >= opts.delimiter.as_bytes().len() {
+                low_idx -= opts.delimiter.as_bytes().len();
             }
 
             match delim_search.nth(high - low) {
@@ -509,8 +501,8 @@ pub fn uumain(args: Vec<String>) -> i32 {
                                 FieldOptions {
                                     delimiter: delim,
                                     out_delimeter: out_delim,
-                                    only_delimited: only_delimited,
-                                    zero_terminated: zero_terminated,
+                                    only_delimited,
+                                    zero_terminated,
                                 },
                             ))
                         }
@@ -520,8 +512,8 @@ pub fn uumain(args: Vec<String>) -> i32 {
                         FieldOptions {
                             delimiter: "\t".to_owned(),
                             out_delimeter: out_delim,
-                            only_delimited: only_delimited,
-                            zero_terminated: zero_terminated,
+                            only_delimited,
+                            zero_terminated,
                         },
                     )),
                 }

src/cut/ranges.rs

@@ -39,11 +39,11 @@ impl FromStr for Range {
                     Err(inval)
                 }
             }
-            (Some(n), Some(m)) if m.len() == 0 => {
+            (Some(n), Some(m)) if m.is_empty() => {
                 if let Ok(low) = n.parse::<usize>() {
                     if low > 0 {
                         Ok(Range {
-                            low: low,
+                            low,
                             high: MAX - 1,
                         })
                     } else {
@@ -56,7 +56,7 @@ impl FromStr for Range {
             (Some(n), Some(m)) if n.len() == 0 => {
                 if let Ok(high) = m.parse::<usize>() {
                     if high > 0 {
-                        Ok(Range { low: 1, high: high })
+                        Ok(Range { low: 1, high })
                     } else {
                         Err(field)
                     }
@@ -68,8 +68,8 @@ impl FromStr for Range {
                 (Ok(low), Ok(high)) => {
                     if low > 0 && low <= high {
                         Ok(Range {
-                            low: low,
-                            high: high,
+                            low,
+                            high,
                         })
                     } else if low == 0 {
                         Err(field)
@@ -118,7 +118,7 @@ pub fn complement(ranges: &[Range]) -> Vec<Range> {
 
     let mut complements = Vec::with_capacity(ranges.len() + 1);
 
-    if ranges.len() > 0 && ranges[0].low > 1 {
+    if !ranges.is_empty() && ranges[0].low > 1 {
         complements.push(Range {
             low: 1,
             high: ranges[0].low - 1,

src/cut/searcher.rs

@@ -17,8 +17,8 @@ pub struct Searcher<'a> {
 impl<'a> Searcher<'a> {
     pub fn new(haystack: &'a [u8], needle: &'a [u8]) -> Searcher<'a> {
         Searcher {
-            haystack: haystack,
-            needle: needle,
+            haystack,
+            needle,
             position: 0,
         }
     }

src/date/date.rs

@@ -21,24 +21,24 @@ use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
 
 // Options
-const DATE: &'static str = "date";
-const HOURS: &'static str = "hours";
-const MINUTES: &'static str = "minutes";
-const SECONDS: &'static str = "seconds";
-const NS: &'static str = "ns";
+const DATE: &str = "date";
+const HOURS: &str = "hours";
+const MINUTES: &str = "minutes";
+const SECONDS: &str = "seconds";
+const NS: &str = "ns";
 
 // Help strings
 
-static ISO_8601_HELP_STRING: &'static str = "output date/time in ISO 8601 format.
+static ISO_8601_HELP_STRING: &str = "output date/time in ISO 8601 format.
  FMT='date' for date only (the default),
  'hours', 'minutes', 'seconds', or 'ns'
  for date and time to the indicated precision.
  Example: 2006-08-14T02:34:56-06:00";
 
-static RFC_2822_HELP_STRING: &'static str = "output date and time in RFC 2822 format.
+static RFC_2822_HELP_STRING: &str = "output date and time in RFC 2822 format.
  Example: Mon, 14 Aug 2006 02:34:56 -0600";
 
-static RFC_3339_HELP_STRING: &'static str = "output date/time in RFC 3339 format.
+static RFC_3339_HELP_STRING: &str = "output date/time in RFC 3339 format.
  FMT='date', 'seconds', or 'ns'
  for date and time to the indicated precision.
  Example: 2006-08-14 02:34:56-06:00";
@@ -119,15 +119,12 @@ pub fn uumain(args: Vec<String>) -> i32 {
         let file: File;
 
         // Get the current time, either in the local time zone or UTC.
-        let now: DateTime<FixedOffset> = match settings.utc {
-            true => {
-                let now = Utc::now();
-                now.with_timezone(&now.offset().fix())
-            }
-            false => {
-                let now = Local::now();
-                now.with_timezone(now.offset())
-            }
+        let now: DateTime<FixedOffset> = if settings.utc {
+            let now = Utc::now();
+            now.with_timezone(&now.offset().fix())
+        } else {
+            let now = Local::now();
+            now.with_timezone(now.offset())
         };
 
         /// Parse a `String` into a `DateTime`.
@@ -198,10 +195,11 @@ fn parse_cli(args: Vec<String>) -> Settings {
               possible_value[date seconds ns]
               RFC_3339_HELP_STRING)
              (@arg custom_format: +takes_value {
-                 |s| match s.starts_with("+") {
-                     true => Ok(()),
-                     false => Err(String::from("Date formats must start with a '+' character"))
-                 }
+                 |s| if s.starts_with('+') {
+                        Ok(())
+                     } else {
+                        Err(String::from("Date formats must start with a '+' character"))
+                     }
              }))
 
             (@arg debug: --debug
@@ -245,8 +243,8 @@ fn parse_cli(args: Vec<String>) -> Settings {
 
     Settings {
         utc: matches.is_present("utc"),
-        format: format,
-        date_source: date_source,
+        format,
+        date_source,
         // TODO: Handle this option:
         set_to: None,
     }
@@ -255,18 +253,18 @@ fn parse_cli(args: Vec<String>) -> Settings {
 /// Return the appropriate format string for the given settings.
 fn make_format_string(settings: &Settings) -> &str {
     match settings.format {
-        Format::Iso8601(ref fmt) => match fmt {
-            &Iso8601Format::Date => "%F",
-            &Iso8601Format::Hours => "%FT%H%:z",
-            &Iso8601Format::Minutes => "%FT%H:%M%:z",
-            &Iso8601Format::Seconds => "%FT%T%:z",
-            &Iso8601Format::Ns => "%FT%T,%f%:z",
+        Format::Iso8601(ref fmt) => match *fmt {
+            Iso8601Format::Date => "%F",
+            Iso8601Format::Hours => "%FT%H%:z",
+            Iso8601Format::Minutes => "%FT%H:%M%:z",
+            Iso8601Format::Seconds => "%FT%T%:z",
+            Iso8601Format::Ns => "%FT%T,%f%:z",
         },
         Format::Rfc2822 => "%a, %d %h %Y %T %z",
-        Format::Rfc3339(ref fmt) => match fmt {
-            &Rfc3339Format::Date => "%F",
-            &Rfc3339Format::Seconds => "%F %T%:z",
-            &Rfc3339Format::Ns => "%F %T.%f%:z",
+        Format::Rfc3339(ref fmt) => match *fmt {
+            Rfc3339Format::Date => "%F",
+            Rfc3339Format::Seconds => "%F %T%:z",
+            Rfc3339Format::Ns => "%F %T.%f%:z",
         },
         Format::Custom(ref fmt) => fmt,
         Format::Default => "%c",

src/dircolors/colors.rs

@@ -1,4 +1,4 @@
-pub const INTERNAL_DB: &'static str =
+pub const INTERNAL_DB: &str =
     r#"# Configuration file for dircolors, a utility to help you set the
 # LS_COLORS environment variable used by GNU ls with the --color option.
 # Copyright (C) 1996-2016 Free Software Foundation, Inc.

src/dircolors/dircolors.rs

@@ -18,9 +18,9 @@ use std::io::{BufRead, BufReader};
 use std::borrow::Borrow;
 use std::env;
 
-static SYNTAX: &'static str = "[OPTION]... [FILE]";
-static SUMMARY: &'static str = "Output commands to set the LS_COLORS environment variable.";
-static LONG_HELP: &'static str = "
+static SYNTAX: &str = "[OPTION]... [FILE]";
+static SUMMARY: &str = "Output commands to set the LS_COLORS environment variable.";
+static LONG_HELP: &str = "
  If FILE is specified, read it to determine which colors to use for which
  file types and extensions.  Otherwise, a precompiled database is used.
  For details on the format of these files, run 'dircolors --print-database'
@@ -252,7 +252,7 @@ where
     table.insert("multihardlink", "mh");
     table.insert("clrtoeol", "cl");
 
-    let term = env::var("TERM").unwrap_or("none".to_owned());
+    let term = env::var("TERM").unwrap_or_else(|_| "none".to_owned());
     let term = term.as_str();
 
     let mut state = ParseState::Global;
@@ -286,18 +286,16 @@ where
                 state = ParseState::Continue;
             }
             if state != ParseState::Pass {
-                if key.starts_with(".") {
+                if key.starts_with('.') {
                     result.push_str(format!("*{}={}:", key, val).as_str());
-                } else if key.starts_with("*") {
+                } else if key.starts_with('*') {
                     result.push_str(format!("{}={}:", key, val).as_str());
                 } else if lower == "options" || lower == "color" || lower == "eightbit" {
-                    // Slackware only. Ignore
+                // Slackware only. Ignore
+                } else if let Some(s) = table.get(lower.as_str()) {
+                    result.push_str(format!("{}={}:", s, val).as_str());
                 } else {
-                    if let Some(s) = table.get(lower.as_str()) {
-                        result.push_str(format!("{}={}:", s, val).as_str());
-                    } else {
-                        return Err(format!("{}:{}: unrecognized keyword {}", fp, num, key));
-                    }
+                    return Err(format!("{}:{}: unrecognized keyword {}", fp, num, key));
                 }
             }
         }