Mirrors/coreutils
2
0
Fork 0
mirror of https://github.com/uutils/coreutils synced 2024-12-14 07:12:44 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #1284 from vks/clippy

Browse source 
Misc code clean up
This commit is contained in:
cnd 2018-09-05 10:43:51 +04:00 committed by GitHub
commit 1f64d83d6f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
108 changed files with 519 additions and 586 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/arch/arch.rs
View file

@ -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);

6
src/base32/base32.rs
View file

@ -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

6
src/base64/base64.rs
View file

@ -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

10
src/basename/basename.rs
View file

@ -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.",

53
src/cat/cat.rs
View file

@ -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;
}

18
src/chgrp/chgrp.rs
View file

@ -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()
}

20
src/chmod/chmod.rs
View file

@ -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(()) => {}

22
src/chown/chown.rs
View file

@ -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()
}

10
src/chroot/chroot.rs
View file

@ -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)

2
src/cksum/build.rs
View file

@ -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;

6
src/cksum/cksum.rs
View file

@ -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 {

6
src/comm/comm.rs
View file

@ -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();

4
src/cp/cp.rs
View file

@ -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());
}

9
src/cut/buffer.rs
View file

@ -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)
};

52
src/cut/cut.rs
View file

@ -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,
},
)),
}

12
src/cut/ranges.rs
View file

@ -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,

4
src/cut/searcher.rs
View file

@ -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,
}
}

64
src/date/date.rs
View file

@ -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",

2
src/dircolors/colors.rs
View file

@ -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.

22
src/dircolors/dircolors.rs
View file

@ -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));
}
}
}

8
src/dirname/dirname.rs
View file

@ -14,10 +14,10 @@ extern crate uucore;
use std::path::Path;
static NAME: &'static str = "dirname";
static SYNTAX: &'static str = "[OPTION] NAME...";
static SUMMARY: &'static str = "strip last component from file name";
static LONG_HELP: &'static str = "
static NAME: &str = "dirname";
static SYNTAX: &str = "[OPTION] NAME...";
static SUMMARY: &str = "strip last component from file name";
static LONG_HELP: &str = "
Output each NAME with its last non-slash component and trailing slashes
removed; if NAME contains no /'s, output '.' (meaning the current
directory).

42
src/du/du.rs
View file

@ -25,9 +25,9 @@ use std::os::unix::fs::MetadataExt;
use std::path::PathBuf;
use time::Timespec;
const NAME: &'static str = "du";
const SUMMARY: &'static str = "estimate file space usage";
const LONG_HELP: &'static str = "
const NAME: &str = "du";
const SUMMARY: &str = "estimate file space usage";
const LONG_HELP: &str = "
Display values are in units of the first available SIZE from
--block-size, and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environ‐
ment variables. Otherwise, units default to 1024 bytes (or 512 if
@ -65,7 +65,7 @@ impl Stat {
fn new(path: PathBuf) -> Result<Stat> {
let metadata = fs::symlink_metadata(&path)?;
Ok(Stat {
path: path,
path,
is_dir: metadata.is_dir(),
size: metadata.len(),
blocks: metadata.blocks() as u64,
@ -110,9 +110,9 @@ fn unit_string_to_number(s: &str) -> Option<u64> {
}
fn translate_to_pure_number(s: &Option<String>) -> Option<u64> {
match s {
&Some(ref s) => unit_string_to_number(s),
&None => None,
match *s {
Some(ref s) => unit_string_to_number(s),
None => None,
}
}
@ -165,7 +165,7 @@ fn du(
}
};
for f in read.into_iter() {
for f in read {
match f {
Ok(entry) => {
match Stat::new(entry.path()) {
@ -319,7 +319,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
let options = Options {
all: matches.opt_present("all"),
program_name: NAME.to_owned(),
max_depth: max_depth,
max_depth,
total: matches.opt_present("total"),
separate_dirs: matches.opt_present("S"),
};
@ -377,13 +377,13 @@ Try '{} --help' for more information.",
let line_separator = if matches.opt_present("0") { "\0" } else { "\n" };
let mut grand_total = 0;
for path_str in strs.into_iter() {
for path_str in strs {
let path = PathBuf::from(&path_str);
match Stat::new(path) {
Ok(stat) => {
let mut inodes: HashSet<u64> = HashSet::new();
let iter = du(stat, &options, 0, &mut inodes).into_iter();
let iter = du(stat, &options, 0, &mut inodes);
let (_, len) = iter.size_hint();
let len = len.unwrap();
for (index, stat) in iter.enumerate() {
@ -417,11 +417,11 @@ Try '{} --help' for more information.",
}
None => stat.modified,
};
((time / 1000) as i64, (time % 1000 * 1000000) as i32)
((time / 1000) as i64, (time % 1000 * 1_000_000) as i32)
};
time::at(Timespec::new(secs, nsecs))
};
if !summarize || (summarize && index == len - 1) {
if !summarize || index == len - 1 {
let time_str = tm.strftime(time_format_str).unwrap();
print!(
"{}\t{}\t{}{}",
@ -431,15 +431,13 @@ Try '{} --help' for more information.",
line_separator
);
}
} else {
if !summarize || (summarize && index == len - 1) {
print!(
"{}\t{}{}",
convert_size(size),
stat.path.display(),
line_separator
);
}
} else if !summarize || index == len - 1 {
print!(
"{}\t{}{}",
convert_size(size),
stat.path.display(),
line_separator
);
}
if options.total && index == (len - 1) {
// The last element will be the total size of the the path under

12
src/env/env.rs vendored
View file

@ -17,10 +17,10 @@ use std::env;
use std::io::{stdout, Write};
use std::process::Command;
static NAME: &'static str = "env";
static SYNTAX: &'static str = "[OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]";
static SUMMARY: &'static str = "Set each NAME to VALUE in the environment and run COMMAND";
static LONG_HELP: &'static str = "
static NAME: &str = "env";
static SYNTAX: &str = "[OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]";
static SUMMARY: &str = "Set each NAME to VALUE in the environment and run COMMAND";
static LONG_HELP: &str = "
A mere - implies -i. If no COMMAND, print the resulting environment
";
@ -147,7 +147,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
}
} else {
// is it a NAME=VALUE like opt ?
let mut sp = opt.splitn(2, "=");
let mut sp = opt.splitn(2, '=');
let name = sp.next();
let value = sp.next();
@ -187,7 +187,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
env::set_var(name, val);
}
if opts.program.len() >= 1 {
if !opts.program.is_empty() {
let prog = opts.program[0].clone();
let args = &opts.program[1..];
match Command::new(prog).args(args).status() {

18
src/expand/expand.rs
View file

@ -23,10 +23,10 @@ use std::iter::repeat;
use std::str::from_utf8;
use unicode_width::UnicodeWidthChar;
static SYNTAX: &'static str = "[OPTION]... [FILE]...";
static SUMMARY: &'static str = "Convert tabs in each FILE to spaces, writing to standard output.
static SYNTAX: &str = "[OPTION]... [FILE]...";
static SUMMARY: &str = "Convert tabs in each FILE to spaces, writing to standard output.
With no FILE, or when FILE is -, read standard input.";
static LONG_HELP: &'static str = "";
static LONG_HELP: &str = "";
static DEFAULT_TABSTOP: usize = 8;
@ -92,11 +92,11 @@ impl Options {
};
Options {
files: files,
tabstops: tabstops,
tspaces: tspaces,
iflag: iflag,
uflag: uflag,
files,
tabstops,
tspaces,
iflag,
uflag,
}
}
}
@ -179,7 +179,7 @@ fn expand(options: Options) {
while byte < buf.len() {
let (ctype, cwidth, nbytes) = if options.uflag {
let nbytes = uucore::utf8::utf8_char_width(buf[byte]);
let nbytes = char::from(buf[byte]).len_utf8();
if byte + nbytes > buf.len() {
// don't overrun buffer because of invalid UTF-8

12
src/expr/expr.rs
View file

@ -16,8 +16,8 @@ extern crate uucore;
mod tokens;
mod syntax_tree;
static NAME: &'static str = "expr";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "expr";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
// For expr utility we do not want getopts.
@ -35,13 +35,13 @@ pub fn uumain(args: Vec<String>) -> i32 {
}
}
fn process_expr(token_strings: &Vec<String>) -> Result<String, String> {
fn process_expr(token_strings: &[String]) -> Result<String, String> {
let maybe_tokens = tokens::strings_to_tokens(&token_strings);
let maybe_ast = syntax_tree::tokens_to_ast(maybe_tokens);
evaluate_ast(maybe_ast)
}
fn print_expr_ok(expr_result: &String) -> i32 {
fn print_expr_ok(expr_result: &str) -> i32 {
println!("{}", expr_result);
if expr_result == "0" || expr_result == "" {
1
@ -50,7 +50,7 @@ fn print_expr_ok(expr_result: &String) -> i32 {
}
}
fn print_expr_error(expr_error: &String) -> ! {
fn print_expr_error(expr_error: &str) -> ! {
crash!(2, "{}", expr_error)
}
@ -62,7 +62,7 @@ fn evaluate_ast(maybe_ast: Result<Box<syntax_tree::ASTNode>, String>) -> Result<
}
}
fn maybe_handle_help_or_version(args: &Vec<String>) -> bool {
fn maybe_handle_help_or_version(args: &[String]) -> bool {
if args.len() == 2 {
if args[1] == "--help" {
print_help();

45
src/expr/syntax_tree.rs
View file

@ -66,17 +66,17 @@ impl ASTNode {
}
}
fn new_node(token_idx: usize, op_type: &String, operands: OperandsList) -> Box<ASTNode> {
fn new_node(token_idx: usize, op_type: &str, operands: OperandsList) -> Box<ASTNode> {
Box::new(ASTNode::Node {
token_idx: token_idx,
op_type: op_type.clone(),
op_type: op_type.into(),
operands: operands,
})
}
fn new_leaf(token_idx: usize, value: &String) -> Box<ASTNode> {
fn new_leaf(token_idx: usize, value: &str) -> Box<ASTNode> {
Box::new(ASTNode::Leaf {
token_idx: token_idx,
value: value.clone(),
token_idx,
value: value.into(),
})
}
pub fn evaluate(&self) -> Result<String, String> {
@ -252,7 +252,7 @@ fn ast_from_rpn(rpn: &mut TokenStack) -> Result<Box<ASTNode>, String> {
}
fn maybe_ast_node(
token_idx: usize,
op_type: &String,
op_type: &str,
arity: usize,
rpn: &mut TokenStack,
) -> Result<Box<ASTNode>, String> {
@ -351,7 +351,10 @@ fn push_op_to_stack(
match op_stack.last() {
None => return Ok(op_stack.push((token_idx, token.clone()))),
Some(&(_, Token::ParOpen)) => return Ok(op_stack.push((token_idx, token.clone()))),
Some(&(_, Token::ParOpen)) => {
op_stack.push((token_idx, token.clone()));
return Ok(());
}
Some(&(
_,
@ -362,11 +365,13 @@ fn push_op_to_stack(
)) => if la && prev_prec >= prec || !la && prev_prec > prec {
out_stack.push(op_stack.pop().unwrap())
} else {
return Ok(op_stack.push((token_idx, token.clone())));
op_stack.push((token_idx, token.clone()));
return Ok(());
},
Some(&(_, Token::PrefixOp { .. })) => {
return Ok(op_stack.push((token_idx, token.clone())))
op_stack.push((token_idx, token.clone()));
return Ok(());
}
Some(_) => panic!("Non-operator on op_stack"),
@ -397,13 +402,13 @@ fn checked_binop<F: Fn() -> Option<T>, T>(cb: F, op: &str) -> Result<T, String>
}
}
fn infix_operator_two_ints<F>(f: F, values: &Vec<String>) -> Result<String, String>
fn infix_operator_two_ints<F>(f: F, values: &[String]) -> Result<String, String>
where
F: Fn(i64, i64) -> Result<i64, String>,
{
assert!(values.len() == 2);
if let Some(left) = values[0].parse::<i64>().ok() {
if let Some(right) = values[1].parse::<i64>().ok() {
if let Ok(left) = values[0].parse::<i64>() {
if let Ok(right) = values[1].parse::<i64>() {
return match f(left, right) {
Ok(result) => Ok(result.to_string()),
Err(reason) => Err(reason),
@ -416,7 +421,7 @@ where
fn infix_operator_two_ints_or_two_strings<FI, FS>(
fi: FI,
fs: FS,
values: &Vec<String>,
values: &[String],
) -> Result<String, String>
where
FI: Fn(i64, i64) -> Result<i64, String>,
@ -435,7 +440,7 @@ where
}
}
fn infix_operator_or(values: &Vec<String>) -> Result<String, String> {
fn infix_operator_or(values: &[String]) -> Result<String, String> {
assert!(values.len() == 2);
if value_as_bool(&values[0]) {
Ok(values[0].clone())
@ -444,7 +449,7 @@ fn infix_operator_or(values: &Vec<String>) -> Result<String, String> {
}
}
fn infix_operator_and(values: &Vec<String>) -> Result<String, String> {
fn infix_operator_and(values: &[String]) -> Result<String, String> {
if value_as_bool(&values[0]) && value_as_bool(&values[1]) {
Ok(values[0].clone())
} else {
@ -452,7 +457,7 @@ fn infix_operator_and(values: &Vec<String>) -> Result<String, String> {
}
}
fn operator_match(values: &Vec<String>) -> Result<String, String> {
fn operator_match(values: &[String]) -> Result<String, String> {
assert!(values.len() == 2);
let re = match Regex::with_options(&values[1], RegexOptions::REGEX_OPTION_NONE, Syntax::grep())
{
@ -472,12 +477,12 @@ fn operator_match(values: &Vec<String>) -> Result<String, String> {
}
}
fn prefix_operator_length(values: &Vec<String>) -> Result<String, String> {
fn prefix_operator_length(values: &[String]) -> Result<String, String> {
assert!(values.len() == 1);
Ok(values[0].len().to_string())
}
fn prefix_operator_index(values: &Vec<String>) -> Result<String, String> {
fn prefix_operator_index(values: &[String]) -> Result<String, String> {
assert!(values.len() == 2);
let haystack = &values[0];
let needles = &values[1];
@ -495,7 +500,7 @@ fn prefix_operator_index(values: &Vec<String>) -> Result<String, String> {
Ok("0".to_string())
}
fn prefix_operator_substr(values: &Vec<String>) -> Result<String, String> {
fn prefix_operator_substr(values: &[String]) -> Result<String, String> {
assert!(values.len() == 3);
let subj = &values[0];
let mut idx = match values[1].parse::<i64>() {
@ -541,7 +546,7 @@ fn bool_as_string(b: bool) -> String {
}
}
fn value_as_bool(s: &str) -> bool {
if s.len() == 0 {
if s.is_empty() {
return false;
}
match s.parse::<i64>() {

14
src/expr/tokens.rs
View file

@ -39,15 +39,15 @@ pub enum Token {
},
}
impl Token {
fn new_infix_op(v: &String, left_assoc: bool, precedence: u8) -> Self {
fn new_infix_op(v: &str, left_assoc: bool, precedence: u8) -> Self {
Token::InfixOp {
left_assoc: left_assoc,
precedence: precedence,
value: v.clone(),
left_assoc,
precedence,
value: v.into(),
}
}
fn new_value(v: &String) -> Self {
Token::Value { value: v.clone() }
fn new_value(v: &str) -> Self {
Token::Value { value: v.into() }
}
fn is_infix_plus(&self) -> bool {
@ -148,7 +148,7 @@ fn push_token_if_not_escaped(
acc: &mut Vec<(usize, Token)>,
tok_idx: usize,
token: Token,
s: &String,
s: &str,
) {
// Smells heuristics... :(
let prev_is_plus = match acc.last() {

8
src/factor/factor.rs
View file

@ -29,10 +29,10 @@ mod numeric;
include!(concat!(env!("OUT_DIR"), "/prime_table.rs"));
static SYNTAX: &'static str = "[OPTION] [NUMBER]...";
static SUMMARY: &'static str = "Print the prime factors of the given number(s).
static SYNTAX: &str = "[OPTION] [NUMBER]...";
static SUMMARY: &str = "Print the prime factors of the given number(s).
If none are specified, read from standard input.";
static LONG_HELP: &'static str = "";
static LONG_HELP: &str = "";
fn rho_pollard_pseudorandom_function(x: u64, a: u64, b: u64, num: u64) -> u64 {
if num < 1 << 63 {
@ -148,7 +148,7 @@ fn print_factors(num: u64) {
for fac in &factors {
print!(" {}", fac);
}
println!("");
println!();
}
fn print_factors_str(num_str: &str) {

89
src/fmt/fmt.rs
View file

@ -34,9 +34,9 @@ mod linebreak;
mod parasplit;
// program's NAME and VERSION are used for -V and -h
static SYNTAX: &'static str = "[OPTION]... [FILE]...";
static SUMMARY: &'static str = "Reformat paragraphs from input files (or stdin) to stdout.";
static LONG_HELP: &'static str = "";
static SYNTAX: &str = "[OPTION]... [FILE]...";
static SUMMARY: &str = "Reformat paragraphs from input files (or stdin) to stdout.";
static LONG_HELP: &str = "";
pub type FileOrStdReader = BufReader<Box<Read + 'static>>;
pub struct FmtOptions {
@ -120,62 +120,47 @@ pub fn uumain(args: Vec<String>) -> i32 {
fmt_opts.xanti_prefix = true;
}
match matches.opt_str("p") {
Some(s) => {
fmt_opts.prefix = s;
fmt_opts.use_prefix = true;
}
None => (),
if let Some(s) = matches.opt_str("p") {
fmt_opts.prefix = s;
fmt_opts.use_prefix = true;
};
match matches.opt_str("P") {
Some(s) => {
fmt_opts.anti_prefix = s;
fmt_opts.use_anti_prefix = true;
}
None => (),
if let Some(s) = matches.opt_str("P") {
fmt_opts.anti_prefix = s;
fmt_opts.use_anti_prefix = true;
};
match matches.opt_str("w") {
Some(s) => {
fmt_opts.width = match s.parse::<usize>() {
Ok(t) => t,
Err(e) => {
crash!(1, "Invalid WIDTH specification: `{}': {}", s, e);
}
};
fmt_opts.goal = cmp::min(fmt_opts.width * 94 / 100, fmt_opts.width - 3);
}
None => (),
};
match matches.opt_str("g") {
Some(s) => {
fmt_opts.goal = match s.parse::<usize>() {
Ok(t) => t,
Err(e) => {
crash!(1, "Invalid GOAL specification: `{}': {}", s, e);
}
};
if !matches.opt_present("w") {
fmt_opts.width = cmp::max(fmt_opts.goal * 100 / 94, fmt_opts.goal + 3);
} else if fmt_opts.goal > fmt_opts.width {
crash!(1, "GOAL cannot be greater than WIDTH.");
if let Some(s) = matches.opt_str("w") {
fmt_opts.width = match s.parse::<usize>() {
Ok(t) => t,
Err(e) => {
crash!(1, "Invalid WIDTH specification: `{}': {}", s, e);
}
}
None => (),
};
fmt_opts.goal = cmp::min(fmt_opts.width * 94 / 100, fmt_opts.width - 3);
};
match matches.opt_str("T") {
Some(s) => {
fmt_opts.tabwidth = match s.parse::<usize>() {
Ok(t) => t,
Err(e) => {
crash!(1, "Invalid TABWIDTH specification: `{}': {}", s, e);
}
};
if let Some(s) = matches.opt_str("g") {
fmt_opts.goal = match s.parse::<usize>() {
Ok(t) => t,
Err(e) => {
crash!(1, "Invalid GOAL specification: `{}': {}", s, e);
}
};
if !matches.opt_present("w") {
fmt_opts.width = cmp::max(fmt_opts.goal * 100 / 94, fmt_opts.goal + 3);
} else if fmt_opts.goal > fmt_opts.width {
crash!(1, "GOAL cannot be greater than WIDTH.");
}
None => (),
};
if let Some(s) = matches.opt_str("T") {
fmt_opts.tabwidth = match s.parse::<usize>() {
Ok(t) => t,
Err(e) => {
crash!(1, "Invalid TABWIDTH specification: `{}': {}", s, e);
}
};
};
if fmt_opts.tabwidth < 1 {
@ -208,7 +193,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
match para_result {
Err(s) => {
silent_unwrap!(ostream.write_all(s.as_bytes()));
silent_unwrap!(ostream.write_all("\n".as_bytes()));
silent_unwrap!(ostream.write_all(b"\n"));
}
Ok(para) => break_lines(&para, &fmt_opts, &mut ostream),
}

22
src/fmt/linebreak.rs
View file

@ -53,7 +53,7 @@ pub fn break_lines(para: &Paragraph, opts: &FmtOptions, ostream: &mut BufWriter<
let (w, w_len) = match p_words_words.next() {
Some(winfo) => (winfo.word, winfo.word_nchars),
None => {
silent_unwrap!(ostream.write_all("\n".as_bytes()));
silent_unwrap!(ostream.write_all(b"\n"));
return;
}
};
@ -77,12 +77,12 @@ pub fn break_lines(para: &Paragraph, opts: &FmtOptions, ostream: &mut BufWriter<
let uniform = para.mail_header || opts.uniform;
let mut break_args = BreakArgs {
opts: opts,
opts,
init_len: p_init_len,
indent_str: &p_indent[..],
indent_len: p_indent_len,
uniform: uniform,
ostream: ostream,
uniform,
ostream,
};
if opts.quick || para.mail_header {
@ -98,7 +98,7 @@ fn break_simple<'a, T: Iterator<Item = &'a WordInfo<'a>>>(iter: T, args: &mut Br
iter.fold((args.init_len, false), |l, winfo| {
accum_words_simple(args, l, winfo)
});
silent_unwrap!(args.ostream.write_all("\n".as_bytes()));
silent_unwrap!(args.ostream.write_all(b"\n"));
}
fn accum_words_simple<'a>(
@ -199,7 +199,7 @@ fn break_knuth_plass<'a, T: Clone + Iterator<Item = &'a WordInfo<'a>>>(
fresh = false;
write_with_spaces(word, slen, args.ostream);
}
silent_unwrap!(args.ostream.write_all("\n".as_bytes()));
silent_unwrap!(args.ostream.write_all(b"\n"));
}
struct LineBreak<'a> {
@ -381,7 +381,7 @@ fn build_best_path<'a>(paths: &[LineBreak<'a>], active: &[usize]) -> Vec<(&'a Wo
}
// "infinite" badness is more like (1+BAD_INFTY)^2 because of how demerits are computed
const BAD_INFTY: i64 = 10000000;
const BAD_INFTY: i64 = 10_000_000;
const BAD_INFTY_SQ: i64 = BAD_INFTY * BAD_INFTY;
// badness = BAD_MULT * abs(r) ^ 3
const BAD_MULT: f32 = 100.0;
@ -451,7 +451,7 @@ fn restart_active_breaks<'a>(
LineBreak {
prev: act_idx,
linebreak: Some(w),
break_before: break_before,
break_before,
demerits: 0, // this is the only active break, so we can reset the demerit count
prev_rat: if break_before { 1.0 } else { -1.0 },
length: line_length,
@ -492,16 +492,16 @@ fn slice_if_fresh(
// Write a newline and add the indent.
fn write_newline(indent: &str, ostream: &mut BufWriter<Stdout>) {
silent_unwrap!(ostream.write_all("\n".as_bytes()));
silent_unwrap!(ostream.write_all(b"\n"));
silent_unwrap!(ostream.write_all(indent.as_bytes()));
}
// Write the word, along with slen spaces.
fn write_with_spaces(word: &str, slen: usize, ostream: &mut BufWriter<Stdout>) {
if slen == 2 {
silent_unwrap!(ostream.write_all(" ".as_bytes()));
silent_unwrap!(ostream.write_all(b" "));
} else if slen == 1 {
silent_unwrap!(ostream.write_all(" ".as_bytes()));
silent_unwrap!(ostream.write_all(b" "));
}
silent_unwrap!(ostream.write_all(word.as_bytes()));
}

42
src/fmt/parasplit.rs
View file

@ -73,8 +73,8 @@ pub struct FileLines<'a> {
impl<'a> FileLines<'a> {
fn new<'b>(opts: &'b FmtOptions, lines: Lines<&'b mut FileOrStdReader>) -> FileLines<'b> {
FileLines {
opts: opts,
lines: lines,
opts,
lines,
}
}
@ -197,10 +197,10 @@ impl<'a> Iterator for FileLines<'a> {
Some(Line::FormatLine(FileLine {
line: n,
indent_end: indent_end,
indent_end,
pfxind_end: poffset,
indent_len: indent_len,
prefix_len: prefix_len,
indent_len,
prefix_len,
}))
}
}
@ -234,9 +234,9 @@ impl<'a> ParagraphStream<'a> {
let lines = FileLines::new(opts, reader.lines()).peekable();
// at the beginning of the file, we might find mail headers
ParagraphStream {
lines: lines,
lines,
next_mail: true,
opts: opts,
opts,
}
}
@ -405,12 +405,12 @@ impl<'a> Iterator for ParagraphStream<'a> {
Some(Ok(Paragraph {
lines: p_lines,
init_str: init_str,
init_len: init_len,
init_end: init_end,
indent_str: indent_str,
indent_len: indent_len,
indent_end: indent_end,
init_str,
init_len,
init_end,
indent_str,
indent_len,
indent_end,
mail_header: in_mail,
}))
}
@ -425,8 +425,8 @@ pub struct ParaWords<'a> {
impl<'a> ParaWords<'a> {
pub fn new<'b>(opts: &'b FmtOptions, para: &'b Paragraph) -> ParaWords<'b> {
let mut pw = ParaWords {
opts: opts,
para: para,
opts,
para,
words: Vec::new(),
};
pw.create_words();
@ -522,7 +522,7 @@ impl<'a> WordSplit<'a> {
// wordsplits *must* start at a non-whitespace character
let trim_string = string.trim_left();
WordSplit {
opts: opts,
opts,
string: trim_string,
length: string.len(),
position: 0,
@ -610,14 +610,14 @@ impl<'a> Iterator for WordSplit<'a> {
};
Some(WordInfo {
word: word,
word,
word_start: word_start_relative,
word_nchars: word_nchars,
before_tab: before_tab,
after_tab: after_tab,
word_nchars,
before_tab,
after_tab,
sentence_start: is_start_of_sentence,
ends_punct: self.prev_punct,
new_line: new_line,
new_line,
})
}
}

12
src/fold/fold.rs
View file

@ -16,10 +16,10 @@ use std::fs::File;
use std::io::{stdin, BufRead, BufReader, Read};
use std::path::Path;
static SYNTAX: &'static str = "[OPTION]... [FILE]...";
static SUMMARY: &'static str = "Writes each file (or standard input if no files are given)
static SYNTAX: &str = "[OPTION]... [FILE]...";
static SUMMARY: &str = "Writes each file (or standard input if no files are given)
to standard output whilst breaking long lines";
static LONG_HELP: &'static str = "";
static LONG_HELP: &str = "";
pub fn uumain(args: Vec<String>) -> i32 {
let (args, obs_width) = handle_obsolete(&args[..]);
@ -70,7 +70,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
fn handle_obsolete(args: &[String]) -> (Vec<String>, Option<String>) {
for (i, arg) in args.iter().enumerate() {
let slice = &arg;
if slice.chars().next().unwrap() == '-' && slice.len() > 1
if slice.starts_with('-') && slice.len() > 1
&& slice.chars().nth(1).unwrap().is_digit(10)
{
let mut v = args.to_vec();
@ -123,10 +123,10 @@ fn fold_file<T: Read>(mut file: BufReader<T>, bytes: bool, spaces: bool, width:
}
} else {
let mut len = line.chars().count();
let newline = line.ends_with("\n");
let newline = line.ends_with('\n');
if newline {
if len == 1 {
println!("");
println!();
continue;
}
len -= 1;

26
src/groups/groups.rs
View file

@ -14,8 +14,8 @@
extern crate uucore;
use uucore::entries::{get_groups, Locate, Passwd, gid2grp};
static SYNTAX: &'static str = "[user]";
static SUMMARY: &'static str = "display current group names";
static SYNTAX: &str = "[user]";
static SUMMARY: &str = "display current group names";
pub fn uumain(args: Vec<String>) -> i32 {
let matches = new_coreopts!(SYNTAX, SUMMARY, "").parse(args);
@ -30,19 +30,17 @@ pub fn uumain(args: Vec<String>) -> i32 {
.collect::<Vec<_>>()
.join(" ")
);
} else if let Ok(p) = Passwd::locate(matches.free[0].as_str()) {
println!(
"{}",
p.belongs_to()
.iter()
.map(|&g| gid2grp(g).unwrap())
.collect::<Vec<_>>()
.join(" ")
);
} else {
if let Ok(p) = Passwd::locate(matches.free[0].as_str()) {
println!(
"{}",
p.belongs_to()
.iter()
.map(|&g| gid2grp(g).unwrap())
.collect::<Vec<_>>()
.join(" ")
);
} else {
crash!(1, "unknown user {}", matches.free[0]);
}
crash!(1, "unknown user {}", matches.free[0]);
}
0

24
src/hashsum/hashsum.rs
View file

@ -38,8 +38,8 @@ use std::fs::File;
use std::io::{self, stdin, BufRead, BufReader, Read};
use std::path::Path;
static NAME: &'static str = "hashsum";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "hashsum";
static VERSION: &str = env!("CARGO_PKG_VERSION");
fn is_custom_binary(program: &str) -> bool {
match program {
@ -493,8 +493,8 @@ fn digest_reader<'a, T: Read>(
// Digest file, do not hold too much in memory at any given moment
let windows = cfg!(windows);
let mut buffer = Vec::with_capacity(524288);
let mut vec = Vec::with_capacity(524288);
let mut buffer = Vec::with_capacity(524_288);
let mut vec = Vec::with_capacity(524_288);
let mut looking_for_newline = false;
loop {
match reader.read_to_end(&mut buffer) {
@ -504,17 +504,17 @@ fn digest_reader<'a, T: Read>(
Ok(nread) => {
if windows && !binary {
// Windows text mode returns '\n' when reading '\r\n'
for i in 0..nread {
for &b in buffer.iter().take(nread) {
if looking_for_newline {
if buffer[i] != ('\n' as u8) {
vec.push('\r' as u8);
if b != b'\n' {
vec.push(b'\r');
}
if buffer[i] != ('\r' as u8) {
vec.push(buffer[i]);
if b != b'\r' {
vec.push(b);
looking_for_newline = false;
}
} else if buffer[i] != ('\r' as u8) {
vec.push(buffer[i]);
} else if b != b'\r' {
vec.push(b);
} else {
looking_for_newline = true;
}
@ -529,7 +529,7 @@ fn digest_reader<'a, T: Read>(
}
}
if windows && looking_for_newline {
vec.push('\r' as u8);
vec.push(b'\r');
digest.input(&vec);
}

19
src/head/head.rs
View file

@ -19,9 +19,9 @@ use std::fs::File;
use std::path::Path;
use std::str::from_utf8;
static SYNTAX: &'static str = "";
static SUMMARY: &'static str = "";
static LONG_HELP: &'static str = "";
static SYNTAX: &str = "";
static SUMMARY: &str = "";
static LONG_HELP: &str = "";
enum FilterMode {
Bytes(usize),
@ -90,16 +90,15 @@ pub fn uumain(args: Vec<String>) -> i32 {
}
}
}
None => match matches.opt_str("c") {
Some(count) => match count.parse::<usize>() {
None => if let Some(count) = matches.opt_str("c") {
match count.parse::<usize>() {
Ok(m) => settings.mode = FilterMode::Bytes(m),
Err(e) => {
show_error!("invalid byte count '{}': {}", count, e);
return 1;
}
},
None => {}
},
}
}
};
let quiet = matches.opt_present("q");
@ -129,7 +128,7 @@ pub fn uumain(args: Vec<String>) -> i32 {
for file in &files {
if settings.verbose {
if !firstime {
println!("");
println!();
}
println!("==> {} <==", file);
}
@ -160,7 +159,7 @@ fn obsolete(options: &[String]) -> (Vec<String>, Option<usize>) {
let current = options[a].clone();
let current = current.as_bytes();
if current.len() > 1 && current[0] == '-' as u8 {
if current.len() > 1 && current[0] == b'-' {
let len = current.len();
for pos in 1..len {
// Ensure that the argument is only made out of digits

8
src/hostid/hostid.rs
View file

@ -16,9 +16,9 @@ extern crate uucore;
use libc::c_long;
static SYNTAX: &'static str = "[options]";
static SUMMARY: &'static str = "";
static LONG_HELP: &'static str = "";
static SYNTAX: &str = "[options]";
static SUMMARY: &str = "";
static LONG_HELP: &str = "";
pub enum Mode {
HostId,
@ -49,6 +49,6 @@ fn hostid() {
result = gethostid();
}
result &= 0xffffffff;
result &= 0xffff_ffff;
println!("{:0>8x}", result);
}

6
src/hostname/hostname.rs
View file

@ -38,9 +38,9 @@ use libc::gethostname;
#[cfg(not(windows))]
use libc::sethostname;
const SYNTAX: &'static str = "[OPTION]... [HOSTNAME]";
const SUMMARY: &'static str = "Print or set the system's host name.";
const LONG_HELP: &'static str = "";
const SYNTAX: &str = "[OPTION]... [HOSTNAME]";
const SUMMARY: &str = "Print or set the system's host name.";
const LONG_HELP: &str = "";
pub fn uumain(args: Vec<String>) -> i32 {
#[cfg(windows)]

6
src/install/install.rs
View file

@ -21,10 +21,10 @@ use std::fs;
use std::path::{Path, PathBuf};
use std::result::Result;
static NAME: &'static str = "install";
static SUMMARY: &'static str = "Copy SOURCE to DEST or multiple SOURCE(s) to the existing
static NAME: &str = "install";
static SUMMARY: &str = "Copy SOURCE to DEST or multiple SOURCE(s) to the existing
DIRECTORY, while setting permission modes and owner/group";
static LONG_HELP: &'static str = "";
static LONG_HELP: &str = "";
const DEFAULT_MODE: u32 = 755;

4
src/join/join.rs
View file

@ -19,8 +19,8 @@ use std::io::{stdin, BufRead, BufReader, Lines, Stdin};
use std::cmp::{min, Ordering};
use clap::{App, Arg};
static NAME: &'static str = "join";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "join";
static VERSION: &str = env!("CARGO_PKG_VERSION");
#[derive(Copy, Clone, PartialEq)]
enum FileNum {

6
src/kill/kill.rs
View file

@ -18,9 +18,9 @@ use libc::{c_int, pid_t};
use std::io::Error;
use uucore::signals::ALL_SIGNALS;
static SYNTAX: &'static str = "[options] <pid> [...]";
static SUMMARY: &'static str = "";
static LONG_HELP: &'static str = "";
static SYNTAX: &str = "[options] <pid> [...]";
static SUMMARY: &str = "";
static LONG_HELP: &str = "";
static EXIT_OK: i32 = 0;
static EXIT_ERR: i32 = 1;

6
src/link/link.rs
View file

@ -16,9 +16,9 @@ use std::fs::hard_link;
use std::path::Path;
use std::io::Error;
static SYNTAX: &'static str = "[OPTIONS] FILE1 FILE2";
static SUMMARY: &'static str = "Create a link named FILE2 to FILE1";
static LONG_HELP: &'static str = "";
static SYNTAX: &str = "[OPTIONS] FILE1 FILE2";
static SUMMARY: &str = "Create a link named FILE2 to FILE1";
static LONG_HELP: &str = "";
pub fn normalize_error_message(e: Error) -> String {
match e.raw_os_error() {

6
src/ln/ln.rs
View file

@ -20,9 +20,9 @@ use std::os::unix::fs::symlink;
use std::os::windows::fs::{symlink_dir, symlink_file};
use std::path::{Path, PathBuf};
static NAME: &'static str = "ln";
static SUMMARY: &'static str = "";
static LONG_HELP: &'static str = "
static NAME: &str = "ln";
static SUMMARY: &str = "";
static LONG_HELP: &str = "
In the 1st form, create a link to TARGET with the name LINK_NAME.
In the 2nd form, create a link to TARGET in the current directory.
In the 3rd and 4th forms, create links to each TARGET in DIRECTORY.

6
src/logname/logname.rs
View file

@ -34,9 +34,9 @@ fn get_userlogin() -> Option<String> {
}
}
static SYNTAX: &'static str = "";
static SUMMARY: &'static str = "Print user's login name";
static LONG_HELP: &'static str = "";
static SYNTAX: &str = "";
static SUMMARY: &str = "Print user's login name";
static LONG_HELP: &str = "";
pub fn uumain(args: Vec<String>) -> i32 {
new_coreopts!(SYNTAX, SUMMARY, LONG_HELP).parse(args);

8
src/ls/ls.rs
View file

@ -44,16 +44,16 @@ use unicode_width::UnicodeWidthStr;
#[cfg(windows)]
use std::os::windows::fs::MetadataExt;
static NAME: &'static str = "ls";
static SUMMARY: &'static str = "";
static LONG_HELP: &'static str = "
static NAME: &str = "ls";
static SUMMARY: &str = "";
static LONG_HELP: &str = "
By default, ls will list the files and contents of any directories on
the command line, expect that it will ignore files and directories
whose names start with '.'
";
#[cfg(unix)]
static DEFAULT_COLORS: &'static str = "rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=00:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.xz=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.alz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.cab=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.m4a=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.oga=00;36:*.opus=00;36:*.spx=00;36:*.xspf=00;36:";
static DEFAULT_COLORS: &str = "rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=00:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.xz=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.alz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.cab=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.m4a=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.oga=00;36:*.opus=00;36:*.spx=00;36:*.xspf=00;36:";
#[cfg(unix)]
lazy_static! {

4
src/mkdir/mkdir.rs
View file

@ -18,8 +18,8 @@ extern crate uucore;
use std::fs;
use std::path::{Path, PathBuf};
static NAME: &'static str = "mkdir";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "mkdir";
static VERSION: &str = env!("CARGO_PKG_VERSION");
/**
* Handles option parsing

4
src/mkfifo/mkfifo.rs
View file

@ -19,8 +19,8 @@ use libc::mkfifo;
use std::ffi::CString;
use std::io::Error;
static NAME: &'static str = "mkfifo";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "mkfifo";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/mknod/mknod.rs
View file

@ -23,8 +23,8 @@ use getopts::Options;
use std::ffi::CString;
static NAME: &'static str = "mknod";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "mknod";
static VERSION: &str = env!("CARGO_PKG_VERSION");
const MODE_RW_UGO: mode_t = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;

6
src/mktemp/mktemp.rs
View file

@ -26,9 +26,9 @@ use tempfile::NamedTempFileOptions;
mod tempdir;
static NAME: &'static str = "mktemp";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static DEFAULT_TEMPLATE: &'static str = "tmp.XXXXXXXXXX";
static NAME: &str = "mktemp";
static VERSION: &str = env!("CARGO_PKG_VERSION");
static DEFAULT_TEMPLATE: &str = "tmp.XXXXXXXXXX";
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/more/more.rs
View file

@ -35,8 +35,8 @@ pub enum Mode {
Version,
}
static NAME: &'static str = "more";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "more";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = Options::new();

4
src/mv/mv.rs
View file

@ -19,8 +19,8 @@ use std::env;
use std::io::{stdin, BufRead, BufReader, Result};
use std::path::{Path, PathBuf};
static NAME: &'static str = "mv";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "mv";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub struct Behaviour {
overwrite: OverwriteMode,

4
src/nice/nice.rs
View file

@ -19,8 +19,8 @@ use libc::{c_char, c_int, execvp};
use std::ffi::CString;
use std::io::Error;
const NAME: &'static str = "nice";
const VERSION: &'static str = env!("CARGO_PKG_VERSION");
const NAME: &str = "nice";
const VERSION: &str = env!("CARGO_PKG_VERSION");
// XXX: PRIO_PROCESS is 0 on at least FreeBSD and Linux. Don't know about Mac OS X.
const PRIO_PROCESS: c_int = 0;

6
src/nl/nl.rs
View file

@ -26,9 +26,9 @@ use std::path::Path;
mod helper;
static NAME: &'static str = "nl";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static USAGE: &'static str = "nl [OPTION]... [FILE]...";
static NAME: &str = "nl";
static VERSION: &str = env!("CARGO_PKG_VERSION");
static USAGE: &str = "nl [OPTION]... [FILE]...";
// A regular expression matching everything.
// Settings store options used by nl to produce its output.

4
src/nohup/nohup.rs
View file

@ -25,8 +25,8 @@ use std::path::{Path, PathBuf};
use std::env;
use uucore::fs::{is_stderr_interactive, is_stdin_interactive, is_stdout_interactive};
static NAME: &'static str = "nohup";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "nohup";
static VERSION: &str = env!("CARGO_PKG_VERSION");
#[cfg(target_os = "macos")]
extern "C" {

4
src/nproc/nproc.rs
View file

@ -29,8 +29,8 @@ pub const _SC_NPROCESSORS_CONF: libc::c_int = 57;
#[cfg(target_os = "netbsd")]
pub const _SC_NPROCESSORS_CONF: libc::c_int = 1001;
static NAME: &'static str = "nproc";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "nproc";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/numfmt/numfmt.rs
View file

@ -15,8 +15,8 @@ use getopts::{Matches, Options};
use std::fmt;
use std::io::BufRead;
static NAME: &'static str = "numfmt";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "numfmt";
static VERSION: &str = env!("CARGO_PKG_VERSION");
const IEC_BASES: [f64; 10] = [
//premature optimization

4
src/od/od.rs
View file

@ -47,10 +47,10 @@ use inputoffset::{InputOffset, Radix};
use inputdecoder::{InputDecoder, MemoryDecoder};
use output_info::OutputInfo;
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static VERSION: &str = env!("CARGO_PKG_VERSION");
const PEEK_BUFFER_SIZE: usize = 4; // utf-8 can be 4 bytes
static USAGE: &'static str = r#"Usage:
static USAGE: &str = r#"Usage:
od [OPTION]... [--] [FILENAME]...
od [-abcdDefFhHiIlLoOsxX] [FILENAME] [[+][0x]OFFSET[.][b]]
od --traditional [OPTION]... [FILENAME] [[+][0x]OFFSET[.][b] [[+][0x]LABEL[.][b]]]

2
src/od/prn_char.rs
View file

@ -13,7 +13,7 @@ pub static FORMAT_ITEM_C: FormatterItemInfo = FormatterItemInfo {
formatter: FormatWriter::MultibyteWriter(format_item_c),
};
static A_CHRS: [&'static str; 128] = [
static A_CHRS: [&str; 128] = [
"nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel", "bs", "ht", "nl", "vt", "ff", "cr",
"so", "si", "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb", "can", "em", "sub", "esc",
"fs", "gs", "rs", "us", "sp", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-",

4
src/paste/paste.rs
View file

@ -19,8 +19,8 @@ use std::iter::repeat;
use std::fs::File;
use std::path::Path;
static NAME: &'static str = "paste";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "paste";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

8
src/pathchk/pathchk.rs
View file

@ -30,12 +30,12 @@ enum Mode {
Version, // show version information
}
static NAME: &'static str = "pathchk";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "pathchk";
static VERSION: &str = env!("CARGO_PKG_VERSION");
// a few global constants as used in the GNU implementation
static POSIX_PATH_MAX: usize = 256;
static POSIX_NAME_MAX: usize = 14;
const POSIX_PATH_MAX: usize = 256;
const POSIX_NAME_MAX: usize = 14;
pub fn uumain(args: Vec<String>) -> i32 {
// add options

4
src/pinky/pinky.rs
View file

@ -24,8 +24,8 @@ use std::os::unix::fs::MetadataExt;
use std::path::PathBuf;
static SYNTAX: &'static str = "[OPTION]... [USER]...";
static SUMMARY: &'static str = "A lightweight 'finger' program; print user information.";
static SYNTAX: &str = "[OPTION]... [USER]...";
static SUMMARY: &str = "A lightweight 'finger' program; print user information.";
const BUFSIZE: usize = 1024;

4
src/printenv/printenv.rs
View file

@ -18,8 +18,8 @@ extern crate uucore;
use std::env;
static NAME: &'static str = "printenv";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "printenv";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/printf/cli.rs
View file

@ -4,8 +4,8 @@
use std::io::{stderr, stdout, Write};
use std::env;
pub static EXIT_OK: i32 = 0;
pub static EXIT_ERR: i32 = 1;
pub const EXIT_OK: i32 = 0;
pub const EXIT_ERR: i32 = 1;
pub fn err_msg(msg: &str) {
let exe_path = match env::current_exe() {

10
src/printf/printf.rs
View file

@ -8,10 +8,10 @@ mod cli;
mod memo;
mod tokenize;
static NAME: &'static str = "printf";
static VERSION: &'static str = "0.0.1";
static SHORT_USAGE: &'static str = "printf: usage: printf [-v var] format [arguments]";
static LONGHELP_LEAD: &'static str = "printf
static NAME: &str = "printf";
static VERSION: &str = "0.0.1";
static SHORT_USAGE: &str = "printf: usage: printf [-v var] format [arguments]";
static LONGHELP_LEAD: &str = "printf
USAGE: printf FORMATSTRING [ARGUMENT]...
@ -26,7 +26,7 @@ Options:
--version output version information and exit
";
static LONGHELP_BODY: &'static str = "
static LONGHELP_BODY: &str = "
Prints the , replacing escaped character sequences with character literals
and substitution field sequences with passed arguments

4
src/ptx/ptx.rs
View file

@ -26,8 +26,8 @@ use std::default::Default;
use std::fs::File;
use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
static NAME: &'static str = "ptx";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "ptx";
static VERSION: &str = env!("CARGO_PKG_VERSION");
#[derive(Debug)]
enum OutFormat {

4
src/pwd/pwd.rs
View file

@ -18,8 +18,8 @@ use std::env;
use std::path::{Path, PathBuf};
use std::io;
static NAME: &'static str = "pwd";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "pwd";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn absolute_path(path: &Path) -> io::Result<PathBuf> {
let path_buf = path.canonicalize()?;

4
src/readlink/readlink.rs
View file

@ -19,8 +19,8 @@ use std::io::{stdout, Write};
use std::path::PathBuf;
use uucore::fs::{canonicalize, CanonicalizeMode};
const NAME: &'static str = "readlink";
const VERSION: &'static str = env!("CARGO_PKG_VERSION");
const NAME: &str = "readlink";
const VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/realpath/realpath.rs
View file

@ -18,8 +18,8 @@ use std::fs;
use std::path::{Path, PathBuf};
use uucore::fs::{canonicalize, CanonicalizeMode};
static NAME: &'static str = "realpath";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "realpath";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/relpath/relpath.rs
View file

@ -18,8 +18,8 @@ use std::env;
use std::path::{Path, PathBuf};
use uucore::fs::{canonicalize, CanonicalizeMode};
static NAME: &'static str = "relpath";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "relpath";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/rm/rm.rs
View file

@ -42,8 +42,8 @@ struct Options {
verbose: bool,
}
static NAME: &'static str = "rm";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "rm";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
// TODO: make getopts support -R in addition to -r

4
src/rmdir/rmdir.rs
View file

@ -17,8 +17,8 @@ extern crate uucore;
use std::fs;
use std::path::Path;
static NAME: &'static str = "rmdir";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "rmdir";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/seq/seq.rs
View file

@ -11,8 +11,8 @@ extern crate uucore;
use std::cmp;
use std::io::{stdout, Write};
static NAME: &'static str = "seq";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "seq";
static VERSION: &str = env!("CARGO_PKG_VERSION");
#[derive(Clone)]
struct SeqOptions {

6
src/shred/shred.rs
View file

@ -25,10 +25,10 @@ use std::path::{Path, PathBuf};
#[macro_use]
extern crate uucore;
static NAME: &'static str = "shred";
static VERSION_STR: &'static str = "1.0.0";
static NAME: &str = "shred";
static VERSION_STR: &str = "1.0.0";
const BLOCK_SIZE: usize = 512;
const NAMESET: &'static str = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_.";
const NAMESET: &str = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_.";
// Patterns as shown in the GNU coreutils shred implementation
const PATTERNS: [&'static [u8]; 22] = [

4
src/shuf/shuf.rs
View file

@ -26,8 +26,8 @@ enum Mode {
InputRange((usize, usize)),
}
static NAME: &'static str = "shuf";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "shuf";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/sleep/sleep.rs
View file

@ -17,8 +17,8 @@ extern crate uucore;
use std::thread;
use std::time::Duration;
static NAME: &'static str = "sleep";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "sleep";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

8
src/sort/sort.rs
View file

@ -26,11 +26,11 @@ use uucore::fs::is_stdin_interactive;
use semver::Version;
use itertools::Itertools; // for Iterator::dedup()
static NAME: &'static str = "sort";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "sort";
static VERSION: &str = env!("CARGO_PKG_VERSION");
static DECIMAL_PT: char = '.';
static THOUSANDS_SEP: char = ',';
const DECIMAL_PT: char = '.';
const THOUSANDS_SEP: char = ',';
enum SortMode {
Numeric,

4
src/split/split.rs
View file

@ -19,8 +19,8 @@ use std::fs::{File, OpenOptions};
use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
use std::path::Path;
static NAME: &'static str = "split";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "split";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/stdbuf/build.rs
View file

@ -7,12 +7,12 @@ mod mkmain;
#[cfg(target_os = "linux")]
mod platform {
pub const DYLIB_EXT: &'static str = ".so";
pub const DYLIB_EXT: &str = ".so";
}
#[cfg(target_os = "macos")]
mod platform {
pub const DYLIB_EXT: &'static str = ".dylib";
pub const DYLIB_EXT: &str = ".dylib";
}
fn main() {

6
src/stdbuf/stdbuf.rs
View file

@ -23,10 +23,10 @@ use std::os::unix::process::ExitStatusExt;
use std::path::PathBuf;
use std::process::Command;
static NAME: &'static str = "stdbuf";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "stdbuf";
static VERSION: &str = env!("CARGO_PKG_VERSION");
const STDBUF_INJECT: &'static [u8] = include_bytes!(concat!(env!("OUT_DIR"), "/libstdbuf.so"));
const STDBUF_INJECT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/libstdbuf.so"));
enum BufferType {
Default,

4
src/sum/sum.rs
View file

@ -18,8 +18,8 @@ use std::fs::File;
use std::io::{stdin, Read, Result};
use std::path::Path;
static NAME: &'static str = "sum";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "sum";
static VERSION: &str = env!("CARGO_PKG_VERSION");
fn bsd_sum(mut reader: Box<Read>) -> (usize, u16) {
let mut buf = [0; 1024];

4
src/sync/sync.rs
View file

@ -21,8 +21,8 @@ extern crate uucore;
#[cfg(not(windows))]
extern crate uucore;
static NAME: &'static str = "sync";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "sync";
static VERSION: &str = env!("CARGO_PKG_VERSION");
#[cfg(unix)]
mod platform {

4
src/tac/tac.rs
View file

@ -17,8 +17,8 @@ extern crate uucore;
use std::fs::File;
use std::io::{stdin, stdout, BufReader, Read, Stdout, Write};
static NAME: &'static str = "tac";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "tac";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/tail/tail.rs
View file

@ -29,8 +29,8 @@ use std::str::from_utf8;
use std::thread::sleep;
use std::time::Duration;
static NAME: &'static str = "tail";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "tail";
static VERSION: &str = env!("CARGO_PKG_VERSION");
enum FilterMode {
Bytes(u64),

4
src/tee/tee.rs
View file

@ -17,8 +17,8 @@ use std::fs::OpenOptions;
use std::io::{copy, sink, stdin, stdout, Error, ErrorKind, Read, Result, Write};
use std::path::{Path, PathBuf};
static NAME: &'static str = "tee";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "tee";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
match options(&args).and_then(exec) {

2
src/test/test.rs
View file

@ -18,7 +18,7 @@ use std::ffi::OsString;
use std::env::args_os;
use std::str::from_utf8;
static NAME: &'static str = "test";
static NAME: &str = "test";
// TODO: decide how to handle non-UTF8 input for all the utils
// Definitely don't use [u8], try keeping it as OsStr or OsString instead

6
src/timeout/timeout.rs
View file

@ -21,10 +21,10 @@ use std::process::{Command, Stdio};
use std::time::Duration;
use uucore::process::ChildExt;
static NAME: &'static str = "timeout";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "timeout";
static VERSION: &str = env!("CARGO_PKG_VERSION");
static ERR_EXIT_STATUS: i32 = 125;
const ERR_EXIT_STATUS: i32 = 125;
pub fn uumain(args: Vec<String>) -> i32 {
let program = args[0].clone();

4
src/touch/touch.rs
View file

@ -21,8 +21,8 @@ use std::fs::{self, File};
use std::io::{self, Error};
use std::path::Path;
static NAME: &'static str = "touch";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "touch";
static VERSION: &str = env!("CARGO_PKG_VERSION");
// Since touch's date/timestamp parsing doesn't account for timezone, the
// returned value from time::strptime() is UTC. We get system's timezone to

4
src/tr/tr.rs
View file

@ -28,8 +28,8 @@ use expand::ExpandSet;
mod expand;
static NAME: &'static str = "tr";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "tr";
static VERSION: &str = env!("CARGO_PKG_VERSION");
const BUFFER_LEN: usize = 1024;
trait SymbolTranslator {

4
src/truncate/truncate.rs
View file

@ -31,8 +31,8 @@ enum TruncateMode {
RoundUp,
}
static NAME: &'static str = "truncate";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "truncate";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/tsort/tsort.rs
View file

@ -20,8 +20,8 @@ use std::fs::File;
use std::io::{stdin, BufRead, BufReader, Read};
use std::path::Path;
static NAME: &'static str = "tsort";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "tsort";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

4
src/tty/tty.rs
View file

@ -24,8 +24,8 @@ extern "C" {
fn ttyname(filedesc: libc::c_int) -> *const libc::c_char;
}
static NAME: &'static str = "tty";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "tty";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = getopts::Options::new();

32
src/uname/uname.rs
View file

@ -19,35 +19,35 @@ extern crate uucore;
use clap::{App, Arg};
use platform_info::*;
const VERSION: &'static str = env!("CARGO_PKG_VERSION");
const ABOUT: &'static str = "Print certain system information. With no OPTION, same as -s.";
const VERSION: &str = env!("CARGO_PKG_VERSION");
const ABOUT: &str = "Print certain system information. With no OPTION, same as -s.";
const OPT_ALL: &'static str = "all";
const OPT_KERNELNAME: &'static str = "kernel-name";
const OPT_NODENAME: &'static str = "nodename";
const OPT_KERNELVERSION: &'static str = "kernel-version";
const OPT_KERNELRELEASE: &'static str = "kernel-release";
const OPT_MACHINE: &'static str = "machine";
const OPT_ALL: &str = "all";
const OPT_KERNELNAME: &str = "kernel-name";
const OPT_NODENAME: &str = "nodename";
const OPT_KERNELVERSION: &str = "kernel-version";
const OPT_KERNELRELEASE: &str = "kernel-release";
const OPT_MACHINE: &str = "machine";
//FIXME: unimplemented options
//const OPT_PROCESSOR: &'static str = "processor";
//const OPT_HWPLATFORM: &'static str = "hardware-platform";
const OPT_OS: &'static str = "operating-system";
const OPT_OS: &str = "operating-system";
#[cfg(target_os = "linux")]
const HOST_OS: &'static str = "GNU/Linux";
const HOST_OS: &str = "GNU/Linux";
#[cfg(target_os = "windows")]
const HOST_OS: &'static str = "Windows NT";
const HOST_OS: &str = "Windows NT";
#[cfg(target_os = "freebsd")]
const HOST_OS: &'static str = "FreeBSD";
const HOST_OS: &str = "FreeBSD";
#[cfg(target_os = "openbsd")]
const HOST_OS: &'static str = "OpenBSD";
const HOST_OS: &str = "OpenBSD";
#[cfg(target_os = "macos")]
const HOST_OS: &'static str = "Darwin";
const HOST_OS: &str = "Darwin";
#[cfg(target_os = "fuchsia")]
const HOST_OS: &'static str = "Fuchsia";
const HOST_OS: &str = "Fuchsia";
#[cfg(target_os = "redox")]
const HOST_OS: &'static str = "Redox";
const HOST_OS: &str = "Redox";
pub fn uumain(args: Vec<String>) -> i32 {
let usage = format!("{} [OPTION]...", executable!());

1
src/unexpand/Cargo.toml
View file

@ -14,7 +14,6 @@ unicode-width = "0.1.5"
[dependencies.uucore]
path = "../uucore"
features = ["utf8"]
[[bin]]
name = "unexpand"

8
src/unexpand/unexpand.rs
View file

@ -22,10 +22,10 @@ use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Stdout, Write}
use std::str::from_utf8;
use unicode_width::UnicodeWidthChar;
static NAME: &'static str = "unexpand";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "unexpand";
static VERSION: &str = env!("CARGO_PKG_VERSION");
static DEFAULT_TABSTOP: usize = 8;
const DEFAULT_TABSTOP: usize = 8;
fn tabstops_parse(s: String) -> Vec<usize> {
let words = s.split(',').collect::<Vec<&str>>();
@ -239,7 +239,7 @@ fn unexpand(options: Options) {
}
let (ctype, cwidth, nbytes) = if options.uflag {
let nbytes = uucore::utf8::utf8_char_width(buf[byte]);
let nbytes = char::from(buf[byte]).len_utf8();
// figure out how big the next char is, if it's UTF-8
if byte + nbytes > buf.len() {

4
src/uniq/uniq.rs
View file

@ -21,8 +21,8 @@ use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
use std::path::Path;
use std::str::FromStr;
static NAME: &'static str = "uniq";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "uniq";
static VERSION: &str = env!("CARGO_PKG_VERSION");
#[derive(PartialEq)]
enum Delimiters {

4
src/unlink/unlink.rs
View file

@ -24,8 +24,8 @@ use std::io::{Error, ErrorKind};
use std::mem::uninitialized;
use std::ffi::CString;
static NAME: &'static str = "unlink";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "unlink";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = Options::new();

4
src/uptime/uptime.rs
View file

@ -23,8 +23,8 @@ pub use uucore::libc;
use getopts::Options;
static NAME: &'static str = "uptime";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "uptime";
static VERSION: &str = env!("CARGO_PKG_VERSION");
#[cfg(unix)]
use libc::getloadavg;

4
src/users/users.rs
View file

@ -21,8 +21,8 @@ use uucore::utmpx::*;
use getopts::Options;
static NAME: &'static str = "users";
static VERSION: &'static str = env!("CARGO_PKG_VERSION");
static NAME: &str = "users";
static VERSION: &str = env!("CARGO_PKG_VERSION");
pub fn uumain(args: Vec<String>) -> i32 {
let mut opts = Options::new();

2
src/uucore/coreopts.rs
View file

@ -18,7 +18,7 @@ impl<'a> CoreOptions<'a> {
pub fn new(help_text: HelpText<'a>) -> Self {
let mut ret = CoreOptions {
options: getopts::Options::new(),
help_text: help_text,
help_text,
};
ret.options
.optflag("", "help", "print usage information")

4
src/uucore/encoding.rs
View file

@ -66,8 +66,8 @@ impl<R: Read> Data<R> {
Data {
line_wrap: 76,
ignore_garbage: false,
input: input,
format: format,
input,
format,
alphabet: match format {
Base32 => b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
Base64 => b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789=+/",

2
src/uucore/fs.rs
View file

@ -31,7 +31,7 @@ macro_rules! has {
)
}
pub fn resolve_relative_path<'a>(path: &'a Path) -> Cow<'a, Path> {
pub fn resolve_relative_path(path: &Path) -> Cow<Path> {
if path.components().all(|e| e != Component::ParentDir) {
return path.into();
}

Some files were not shown because too many files have changed in this diff Show more