Llewellyn/exa
1
0
Fork 0
mirror of https://github.com/Llewellynvdm/exa.git synced 2025-01-27 23:58:25 +00:00
Code Issues Projects Releases Wiki Activity

The Selfening

Browse Source 
This commit uses Clippy to fix all the 'use_self' warnings. Using Self instead of the type name has been good Rust style for a while now, and it's become the style I'm used to seeing.
This commit is contained in:
Benjamin Sago 2020-10-10 13:55:26 +01:00
parent 74d9f1402b
commit 70a30ed683
26 changed files with 251 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/fs/dir.rs
View File

@ -35,14 +35,14 @@ impl Dir {
/// The `read_dir` iterator doesn’t actually yield the `.` and `..`
/// entries, so if the user wants to see them, we’ll have to add them
/// ourselves after the files have been read.
pub fn read_dir(path: PathBuf) -> IOResult<Dir> {
pub fn read_dir(path: PathBuf) -> IOResult<Self> {
info!("Reading directory {:?}", &path);
let contents = fs::read_dir(&path)?
.map(|result| result.map(|entry| entry.path()))
.collect::<Result<_,_>>()?;
Ok(Dir { contents, path })
Ok(Self { contents, path })
}
/// Produce an iterator of IO results of trying to read all the files in
@ -180,8 +180,8 @@ pub enum DotFilter {
}
impl Default for DotFilter {
fn default() -> DotFilter {
DotFilter::JustFiles
fn default() -> Self {
Self::JustFiles
}
}
@ -190,18 +190,18 @@ impl DotFilter {
/// Whether this filter should show dotfiles in a listing.
fn shows_dotfiles(self) -> bool {
match self {
DotFilter::JustFiles => false,
DotFilter::Dotfiles => true,
DotFilter::DotfilesAndDots => true,
Self::JustFiles => false,
Self::Dotfiles => true,
Self::DotfilesAndDots => true,
}
}
/// Whether this filter should add dot directories to a listing.
fn dots(self) -> DotsNext {
match self {
DotFilter::JustFiles => DotsNext::Files,
DotFilter::Dotfiles => DotsNext::Files,
DotFilter::DotfilesAndDots => DotsNext::Dot,
Self::JustFiles => DotsNext::Files,
Self::Dotfiles => DotsNext::Files,
Self::DotfilesAndDots => DotsNext::Dot,
}
}
}

6
src/fs/dir_action.rs
View File

@ -41,7 +41,7 @@ impl DirAction {
/// Gets the recurse options, if this dir action has any.
pub fn recurse_options(&self) -> Option<RecurseOptions> {
match *self {
DirAction::Recurse(o) => Some(o),
Self::Recurse(o) => Some(o),
_ => None,
}
}
@ -49,8 +49,8 @@ impl DirAction {
/// Whether to treat directories as regular files or not.
pub fn treat_dirs_as_files(&self) -> bool {
match *self {
DirAction::AsFile => true,
DirAction::Recurse(o) => o.tree,
Self::AsFile => true,
Self::Recurse(o) => o.tree,
_ => false,
}
}

8
src/fs/feature/git.rs
View File

@ -38,7 +38,7 @@ use std::iter::FromIterator;
impl FromIterator<PathBuf> for GitCache {
fn from_iter<I: IntoIterator<Item=PathBuf>>(iter: I) -> Self {
let iter = iter.into_iter();
let mut git = GitCache {
let mut git = Self {
repos: Vec::with_capacity(iter.size_hint().0),
misses: Vec::new(),
};
@ -152,7 +152,7 @@ impl GitRepo {
/// Searches for a Git repository at any point above the given path.
/// Returns the original buffer if none is found.
fn discover(path: PathBuf) -> Result<GitRepo, PathBuf> {
fn discover(path: PathBuf) -> Result<Self, PathBuf> {
info!("Searching for Git repository above {:?}", path);
let repo = match git2::Repository::discover(&path) {
Ok(r) => r,
@ -165,7 +165,7 @@ impl GitRepo {
match repo.workdir().map(|wd| wd.to_path_buf()) {
Some(workdir) => {
let contents = Mutex::new(GitContents::Before { repo });
Ok(GitRepo { contents, workdir, original_path: path, extra_paths: Vec::new() })
Ok(Self { contents, workdir, original_path: path, extra_paths: Vec::new() })
},
None => {
warn!("Repository has no workdir?");
@ -181,7 +181,7 @@ impl GitContents {
/// (consuming the value) if it has. This is needed because the entire
/// enum variant gets replaced when a repo is queried (see above).
fn inner_repo(self) -> git2::Repository {
if let GitContents::Before { repo } = self {
if let Self::Before { repo } = self {
repo
}
else {

4
src/fs/feature/xattr.rs
View File

@ -126,13 +126,13 @@ mod lister {
}
impl Lister {
pub fn new(do_follow: FollowSymlinks) -> Lister {
pub fn new(do_follow: FollowSymlinks) -> Self {
let c_flags: c_int = match do_follow {
FollowSymlinks::Yes => 0x0001,
FollowSymlinks::No => 0x0000,
};
Lister { c_flags }
Self { c_flags }
}
pub fn translate_attribute_name(&self, input: &[u8]) -> String {

6
src/fs/fields.rs
View File

@ -50,7 +50,7 @@ pub enum Type {
impl Type {
pub fn is_regular_file(&self) -> bool {
matches!(*self, Type::File)
matches!(*self, Self::File)
}
}
@ -220,7 +220,7 @@ use std::default::Default;
impl Default for Git {
/// Create a Git status for a file with nothing done to it.
fn default() -> Git {
Git { staged: GitStatus::NotModified, unstaged: GitStatus::NotModified }
fn default() -> Self {
Self { staged: GitStatus::NotModified, unstaged: GitStatus::NotModified }
}
}

46
src/fs/filter.rs
View File

@ -240,41 +240,41 @@ impl SortField {
use self::SortCase::{ABCabc, AaBbCc};
match self {
SortField::Unsorted => Ordering::Equal,
Self::Unsorted => Ordering::Equal,
SortField::Name(ABCabc) => natord::compare(&a.name, &b.name),
SortField::Name(AaBbCc) => natord::compare_ignore_case(&a.name, &b.name),
Self::Name(ABCabc) => natord::compare(&a.name, &b.name),
Self::Name(AaBbCc) => natord::compare_ignore_case(&a.name, &b.name),
SortField::Size => a.metadata.len().cmp(&b.metadata.len()),
SortField::FileInode => a.metadata.ino().cmp(&b.metadata.ino()),
SortField::ModifiedDate => a.modified_time().cmp(&b.modified_time()),
SortField::AccessedDate => a.accessed_time().cmp(&b.accessed_time()),
SortField::ChangedDate => a.changed_time().cmp(&b.changed_time()),
SortField::CreatedDate => a.created_time().cmp(&b.created_time()),
SortField::ModifiedAge => b.modified_time().cmp(&a.modified_time()), // flip b and a
Self::Size => a.metadata.len().cmp(&b.metadata.len()),
Self::FileInode => a.metadata.ino().cmp(&b.metadata.ino()),
Self::ModifiedDate => a.modified_time().cmp(&b.modified_time()),
Self::AccessedDate => a.accessed_time().cmp(&b.accessed_time()),
Self::ChangedDate => a.changed_time().cmp(&b.changed_time()),
Self::CreatedDate => a.created_time().cmp(&b.created_time()),
Self::ModifiedAge => b.modified_time().cmp(&a.modified_time()), // flip b and a
SortField::FileType => match a.type_char().cmp(&b.type_char()) { // todo: this recomputes
Self::FileType => match a.type_char().cmp(&b.type_char()) { // todo: this recomputes
Ordering::Equal => natord::compare(&*a.name, &*b.name),
order => order,
},
SortField::Extension(ABCabc) => match a.ext.cmp(&b.ext) {
Self::Extension(ABCabc) => match a.ext.cmp(&b.ext) {
Ordering::Equal => natord::compare(&*a.name, &*b.name),
order => order,
},
SortField::Extension(AaBbCc) => match a.ext.cmp(&b.ext) {
Self::Extension(AaBbCc) => match a.ext.cmp(&b.ext) {
Ordering::Equal => natord::compare_ignore_case(&*a.name, &*b.name),
order => order,
},
SortField::NameMixHidden(ABCabc) => natord::compare(
SortField::strip_dot(&a.name),
SortField::strip_dot(&b.name)
Self::NameMixHidden(ABCabc) => natord::compare(
Self::strip_dot(&a.name),
Self::strip_dot(&b.name)
),
SortField::NameMixHidden(AaBbCc) => natord::compare_ignore_case(
SortField::strip_dot(&a.name),
SortField::strip_dot(&b.name)
Self::NameMixHidden(AaBbCc) => natord::compare_ignore_case(
Self::strip_dot(&a.name),
Self::strip_dot(&b.name)
)
}
}
@ -299,7 +299,7 @@ pub struct IgnorePatterns {
impl FromIterator<glob::Pattern> for IgnorePatterns {
fn from_iter<I: IntoIterator<Item = glob::Pattern>>(iter: I) -> Self {
IgnorePatterns { patterns: iter.into_iter().collect() }
Self { patterns: iter.into_iter().collect() }
}
}
@ -328,12 +328,12 @@ impl IgnorePatterns {
}
}
(IgnorePatterns { patterns }, errors)
(Self { patterns }, errors)
}
/// Create a new empty set of patterns that matches nothing.
pub fn empty() -> IgnorePatterns {
IgnorePatterns { patterns: Vec::new() }
pub fn empty() -> Self {
Self { patterns: Vec::new() }
}
/// Test whether the given file should be hidden from the results.

14
src/options/dir_action.rs
View File

@ -12,7 +12,7 @@ impl DirAction {
/// There are three possible actions, and they overlap somewhat: the
/// `--tree` flag is another form of recursion, so those two are allowed
/// to both be present, but the `--list-dirs` flag is used separately.
pub fn deduce(matches: &MatchedFlags) -> Result<DirAction, Misfire> {
pub fn deduce(matches: &MatchedFlags) -> Result<Self, Misfire> {
let recurse = matches.has(&flags::RECURSE)?;
let as_file = matches.has(&flags::LIST_DIRS)?;
let tree = matches.has(&flags::TREE)?;
@ -31,16 +31,16 @@ impl DirAction {
}
if tree {
Ok(DirAction::Recurse(RecurseOptions::deduce(matches, true)?))
Ok(Self::Recurse(RecurseOptions::deduce(matches, true)?))
}
else if recurse {
Ok(DirAction::Recurse(RecurseOptions::deduce(matches, false)?))
Ok(Self::Recurse(RecurseOptions::deduce(matches, false)?))
}
else if as_file {
Ok(DirAction::AsFile)
Ok(Self::AsFile)
}
else {
Ok(DirAction::List)
Ok(Self::List)
}
}
}
@ -52,7 +52,7 @@ impl RecurseOptions {
/// flag’s value, and whether the `--tree` flag was passed, which was
/// determined earlier. The maximum level should be a number, and this
/// will fail with an `Err` if it isn’t.
pub fn deduce(matches: &MatchedFlags, tree: bool) -> Result<RecurseOptions, Misfire> {
pub fn deduce(matches: &MatchedFlags, tree: bool) -> Result<Self, Misfire> {
let max_depth = if let Some(level) = matches.get(&flags::LEVEL)? {
match level.to_string_lossy().parse() {
Ok(l) => Some(l),
@ -63,7 +63,7 @@ impl RecurseOptions {
None
};
Ok(RecurseOptions { tree, max_depth })
Ok(Self { tree, max_depth })
}
}

60
src/options/filter.rs
View File

@ -10,8 +10,8 @@ use crate::options::parser::MatchedFlags;
impl FileFilter {
/// Determines which of all the file filter options to use.
pub fn deduce(matches: &MatchedFlags) -> Result<FileFilter, Misfire> {
Ok(FileFilter {
pub fn deduce(matches: &MatchedFlags) -> Result<Self, Misfire> {
Ok(Self {
list_dirs_first: matches.has(&flags::DIRS_FIRST)?,
reverse: matches.has(&flags::REVERSE)?,
only_dirs: matches.has(&flags::ONLY_DIRS)?,
@ -29,10 +29,10 @@ impl SortField {
/// This argument’s value can be one of several flags, listed above.
/// Returns the default sort field if none is given, or `Err` if the
/// value doesn’t correspond to a sort field we know about.
fn deduce(matches: &MatchedFlags) -> Result<SortField, Misfire> {
fn deduce(matches: &MatchedFlags) -> Result<Self, Misfire> {
let word = match matches.get(&flags::SORT)? {
Some(w) => w,
None => return Ok(SortField::default()),
None => return Ok(Self::default()),
};
// Get String because we can’t match an OsStr
@ -42,28 +42,28 @@ impl SortField {
};
let field = match word {
"name" | "filename" => SortField::Name(SortCase::AaBbCc),
"Name" | "Filename" => SortField::Name(SortCase::ABCabc),
".name" | ".filename" => SortField::NameMixHidden(SortCase::AaBbCc),
".Name" | ".Filename" => SortField::NameMixHidden(SortCase::ABCabc),
"size" | "filesize" => SortField::Size,
"ext" | "extension" => SortField::Extension(SortCase::AaBbCc),
"Ext" | "Extension" => SortField::Extension(SortCase::ABCabc),
"name" | "filename" => Self::Name(SortCase::AaBbCc),
"Name" | "Filename" => Self::Name(SortCase::ABCabc),
".name" | ".filename" => Self::NameMixHidden(SortCase::AaBbCc),
".Name" | ".Filename" => Self::NameMixHidden(SortCase::ABCabc),
"size" | "filesize" => Self::Size,
"ext" | "extension" => Self::Extension(SortCase::AaBbCc),
"Ext" | "Extension" => Self::Extension(SortCase::ABCabc),
// “new” sorts oldest at the top and newest at the bottom; “old”
// sorts newest at the top and oldest at the bottom. I think this
// is the right way round to do this: “size” puts the smallest at
// the top and the largest at the bottom, doesn’t it?
"date" | "time" | "mod" | "modified" | "new" | "newest" => SortField::ModifiedDate,
"date" | "time" | "mod" | "modified" | "new" | "newest" => Self::ModifiedDate,
// Similarly, “age” means that files with the least age (the
// newest files) get sorted at the top, and files with the most
// age (the oldest) at the bottom.
"age" | "old" | "oldest" => SortField::ModifiedAge,
"ch" | "changed" => SortField::ChangedDate,
"acc" | "accessed" => SortField::AccessedDate,
"cr" | "created" => SortField::CreatedDate,
"inode" => SortField::FileInode,
"type" => SortField::FileType,
"none" => SortField::Unsorted,
"age" | "old" | "oldest" => Self::ModifiedAge,
"ch" | "changed" => Self::ChangedDate,
"acc" | "accessed" => Self::AccessedDate,
"cr" | "created" => Self::CreatedDate,
"inode" => Self::FileInode,
"type" => Self::FileType,
"none" => Self::Unsorted,
_ => return Err(Misfire::BadArgument(&flags::SORT, word.into()))
};
@ -105,8 +105,8 @@ impl SortField {
// You can get the old behaviour back by sorting with `--sort=Name`.
impl Default for SortField {
fn default() -> SortField {
SortField::Name(SortCase::AaBbCc)
fn default() -> Self {
Self::Name(SortCase::AaBbCc)
}
}
@ -119,14 +119,14 @@ impl DotFilter {
/// It also checks for the `--tree` option in strict mode, because of a
/// special case where `--tree --all --all` won’t work: listing the
/// parent directory in tree mode would loop onto itself!
pub fn deduce(matches: &MatchedFlags) -> Result<DotFilter, Misfire> {
pub fn deduce(matches: &MatchedFlags) -> Result<Self, Misfire> {
let count = matches.count(&flags::ALL);
if count == 0 {
Ok(DotFilter::JustFiles)
Ok(Self::JustFiles)
}
else if count == 1 {
Ok(DotFilter::Dotfiles)
Ok(Self::Dotfiles)
}
else if matches.count(&flags::TREE) > 0 {
Err(Misfire::TreeAllAll)
@ -135,7 +135,7 @@ impl DotFilter {
Err(Misfire::Conflict(&flags::ALL, &flags::ALL))
}
else {
Ok(DotFilter::DotfilesAndDots)
Ok(Self::DotfilesAndDots)
}
}
}
@ -146,18 +146,18 @@ impl IgnorePatterns {
/// Determines the set of glob patterns to use based on the
/// `--ignore-glob` argument’s value. This is a list of strings
/// separated by pipe (`|`) characters, given in any order.
pub fn deduce(matches: &MatchedFlags) -> Result<IgnorePatterns, Misfire> {
pub fn deduce(matches: &MatchedFlags) -> Result<Self, Misfire> {
// If there are no inputs, we return a set of patterns that doesn’t
// match anything, rather than, say, `None`.
let inputs = match matches.get(&flags::IGNORE_GLOB)? {
None => return Ok(IgnorePatterns::empty()),
None => return Ok(Self::empty()),
Some(is) => is,
};
// Awkwardly, though, a glob pattern can be invalid, and we need to
// deal with invalid patterns somehow.
let (patterns, mut errors) = IgnorePatterns::parse_from_iter(inputs.to_string_lossy().split('|'));
let (patterns, mut errors) = Self::parse_from_iter(inputs.to_string_lossy().split('|'));
// It can actually return more than one glob error,
// but we only use one. (TODO)
@ -171,8 +171,8 @@ impl IgnorePatterns {
impl GitIgnore {
pub fn deduce(matches: &MatchedFlags) -> Result<Self, Misfire> {
Ok(if matches.has(&flags::GIT_IGNORE)? { GitIgnore::CheckAndIgnore }
else { GitIgnore::Off })
Ok(if matches.has(&flags::GIT_IGNORE)? { Self::CheckAndIgnore }
else { Self::Off })
}
}

4
src/options/help.rs
View File

@ -86,12 +86,12 @@ impl HelpString {
/// We don’t do any strict-mode error checking here: it’s OK to give
/// the --help or --long flags more than once. Actually checking for
/// errors when the user wants help is kind of petty!
pub fn deduce(matches: &MatchedFlags) -> Result<(), HelpString> {
pub fn deduce(matches: &MatchedFlags) -> Result<(), Self> {
if matches.count(&flags::HELP) > 0 {
let only_long = matches.count(&flags::LONG) > 0;
let git = cfg!(feature="git");
let xattrs = xattr::ENABLED;
Err(HelpString { only_long, git, xattrs })
Err(Self { only_long, git, xattrs })
}
else {
Ok(()) // no help needs to be shown

12
src/options/misfire.rs
View File

@ -56,16 +56,16 @@ impl Misfire {
/// The OS return code this misfire should signify.
pub fn is_error(&self) -> bool {
match *self {
Misfire::Help(_) => false,
Misfire::Version(_) => false,
Self::Help(_) => false,
Self::Version(_) => false,
_ => true,
}
}
}
impl From<glob::PatternError> for Misfire {
fn from(error: glob::PatternError) -> Misfire {
Misfire::FailedGlobPattern(error.to_string())
fn from(error: glob::PatternError) -> Self {
Self::FailedGlobPattern(error.to_string())
}
}
@ -120,9 +120,9 @@ impl Misfire {
pub fn suggestion(&self) -> Option<&'static str> {
// ‘ls -lt’ and ‘ls -ltr’ are common combinations
match *self {
Misfire::BadArgument(ref time, ref r) if *time == &flags::TIME && r == "r" =>
Self::BadArgument(ref time, ref r) if *time == &flags::TIME && r == "r" =>
Some("To sort oldest files last, try \"--sort oldest\", or just \"-sold\""),
Misfire::InvalidOptions(ParseError::NeedsValue { ref flag, .. }) if *flag == Flag::Short(b't') =>
Self::InvalidOptions(ParseError::NeedsValue { ref flag, .. }) if *flag == Flag::Short(b't') =>
Some("To sort newest files last, try \"--sort newest\", or just \"-snew\""),
_ => None
}

8
src/options/mod.rs
View File

@ -119,7 +119,7 @@ impl Options {
/// struct and a list of free filenames, using the environment variables
/// for extra options.
#[allow(unused_results)]
pub fn parse<'args, I, V>(args: I, vars: &V) -> Result<(Options, Vec<&'args OsStr>), Misfire>
pub fn parse<'args, I, V>(args: I, vars: &V) -> Result<(Self, Vec<&'args OsStr>), Misfire>
where I: IntoIterator<Item=&'args OsString>,
V: Vars {
use crate::options::parser::{Matches, Strictness};
@ -138,7 +138,7 @@ impl Options {
HelpString::deduce(&flags).map_err(Misfire::Help)?;
VersionString::deduce(&flags).map_err(Misfire::Version)?;
let options = Options::deduce(&flags, vars)?;
let options = Self::deduce(&flags, vars)?;
Ok((options, frees))
}
@ -159,12 +159,12 @@ impl Options {
/// Determines the complete set of options based on the given command-line
/// arguments, after they’ve been parsed.
fn deduce<V: Vars>(matches: &MatchedFlags, vars: &V) -> Result<Options, Misfire> {
fn deduce<V: Vars>(matches: &MatchedFlags, vars: &V) -> Result<Self, Misfire> {
let dir_action = DirAction::deduce(matches)?;
let filter = FileFilter::deduce(matches)?;
let view = View::deduce(matches, vars)?;
Ok(Options { dir_action, view, filter })
Ok(Self { dir_action, view, filter })
}
}

8
src/options/parser.rs
View File

@ -61,8 +61,8 @@ pub enum Flag {
impl Flag {
pub fn matches(&self, arg: &Arg) -> bool {
match *self {
Flag::Short(short) => arg.short == Some(short),
Flag::Long(long) => arg.long == long,
Self::Short(short) => arg.short == Some(short),
Self::Long(long) => arg.long == long,
}
}
}
@ -70,8 +70,8 @@ impl Flag {
impl fmt::Display for Flag {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match *self {
Flag::Short(short) => write!(f, "-{}", short as char),
Flag::Long(long) => write!(f, "--{}", long),
Self::Short(short) => write!(f, "-{}", short as char),
Self::Long(long) => write!(f, "--{}", long),
}
}
}

24
src/options/style.rs
View File

@ -28,8 +28,8 @@ enum TerminalColours {
}
impl Default for TerminalColours {
fn default() -> TerminalColours {
TerminalColours::Automatic
fn default() -> Self {
Self::Automatic
}
}
@ -37,21 +37,21 @@ impl Default for TerminalColours {
impl TerminalColours {
/// Determine which terminal colour conditions to use.
fn deduce(matches: &MatchedFlags) -> Result<TerminalColours, Misfire> {
fn deduce(matches: &MatchedFlags) -> Result<Self, Misfire> {
let word = match matches.get_where(|f| f.matches(&flags::COLOR) || f.matches(&flags::COLOUR))? {
Some(w) => w,
None => return Ok(TerminalColours::default()),
None => return Ok(Self::default()),
};
if word == "always" {
Ok(TerminalColours::Always)
Ok(Self::Always)
}
else if word == "auto" || word == "automatic" {
Ok(TerminalColours::Automatic)
Ok(Self::Automatic)
}
else if word == "never" {
Ok(TerminalColours::Never)
Ok(Self::Never)
}
else {
Err(Misfire::BadArgument(&flags::COLOR, word.into()))
@ -90,7 +90,7 @@ impl Styles {
// custom colours at all
let tc = TerminalColours::deduce(matches)?;
if tc == Never || (tc == Automatic && widther().is_none()) {
return Ok(Styles {
return Ok(Self {
colours: Colours::plain(),
style: FileStyle { classify, exts: Box::new(NoFileColours) },
});
@ -111,7 +111,7 @@ impl Styles {
};
let style = FileStyle { classify, exts };
Ok(Styles { colours, style })
Ok(Self { colours, style })
}
}
@ -197,11 +197,11 @@ impl ExtensionMappings {
impl Classify {
fn deduce(matches: &MatchedFlags) -> Result<Classify, Misfire> {
fn deduce(matches: &MatchedFlags) -> Result<Self, Misfire> {
let flagged = matches.has(&flags::CLASSIFY)?;
Ok(if flagged { Classify::AddFileIndicators }
else { Classify::JustFilenames })
Ok(if flagged { Self::AddFileIndicators }
else { Self::JustFilenames })
}
}

4
src/options/version.rs
View File

@ -19,9 +19,9 @@ impl VersionString {
/// ‘deduce’ functions, returning Err if help needs to be shown.
///
/// Like --help, this doesn’t bother checking for errors.
pub fn deduce(matches: &MatchedFlags) -> Result<(), VersionString> {
pub fn deduce(matches: &MatchedFlags) -> Result<(), Self> {
if matches.count(&flags::VERSION) > 0 {
Err(VersionString)
Err(Self)
}
else {
Ok(()) // no version needs to be shown

84
src/options/view.rs
View File

@ -13,12 +13,12 @@ use crate::fs::feature::xattr;
impl View {
/// Determine which view to use and all of that view’s arguments.
pub fn deduce<V: Vars>(matches: &MatchedFlags, vars: &V) -> Result<View, Misfire> {
pub fn deduce<V: Vars>(matches: &MatchedFlags, vars: &V) -> Result<Self, Misfire> {
use crate::options::style::Styles;
let mode = Mode::deduce(matches, vars)?;
let Styles { colours, style } = Styles::deduce(matches, vars, || *TERM_WIDTH)?;
Ok(View { mode, colours, style })
Ok(Self { mode, colours, style })
}
}
@ -26,7 +26,7 @@ impl View {
impl Mode {
/// Determine the mode from the command-line arguments.
pub fn deduce<V: Vars>(matches: &MatchedFlags, vars: &V) -> Result<Mode, Misfire> {
pub fn deduce<V: Vars>(matches: &MatchedFlags, vars: &V) -> Result<Self, Misfire> {
use crate::options::misfire::Misfire::*;
let long = || {
@ -54,7 +54,7 @@ impl Mode {
}
else {
let lines = lines::Options { icons: matches.has(&flags::ICONS)? };
Ok(Mode::Lines(lines))
Ok(Self::Lines(lines))
}
}
else if matches.has(&flags::TREE)? {
@ -65,7 +65,7 @@ impl Mode {
icons: matches.has(&flags::ICONS)?,
};
Ok(Mode::Details(details))
Ok(Self::Details(details))
}
else {
let grid = grid::Options {
@ -74,7 +74,7 @@ impl Mode {
icons: matches.has(&flags::ICONS)?,
};
Ok(Mode::Grid(grid))
Ok(Self::Grid(grid))
}
}
@ -89,14 +89,14 @@ impl Mode {
icons: matches.has(&flags::ICONS)?,
};
Ok(Mode::Details(details))
Ok(Self::Details(details))
}
else if matches.has(&flags::LONG)? {
let details = long()?;
Ok(Mode::Details(details))
Ok(Self::Details(details))
} else {
let lines = lines::Options { icons: matches.has(&flags::ICONS)?, };
Ok(Mode::Lines(lines))
Ok(Self::Lines(lines))
}
};
@ -104,16 +104,16 @@ impl Mode {
let details = long()?;
if matches.has(&flags::GRID)? {
let other_options_mode = other_options_scan()?;
if let Mode::Grid(grid) = other_options_mode {
if let Self::Grid(grid) = other_options_mode {
let row_threshold = RowThreshold::deduce(vars)?;
return Ok(Mode::GridDetails(grid_details::Options { grid, details, row_threshold }));
return Ok(Self::GridDetails(grid_details::Options { grid, details, row_threshold }));
}
else {
return Ok(other_options_mode);
}
}
else {
return Ok(Mode::Details(details));
return Ok(Self::Details(details));
}
}
@ -161,28 +161,28 @@ impl TerminalWidth {
/// Determine a requested terminal width from the command-line arguments.
///
/// Returns an error if a requested width doesn’t parse to an integer.
fn deduce<V: Vars>(vars: &V) -> Result<TerminalWidth, Misfire> {
fn deduce<V: Vars>(vars: &V) -> Result<Self, Misfire> {
use crate::options::vars;
if let Some(columns) = vars.get(vars::COLUMNS).and_then(|s| s.into_string().ok()) {
match columns.parse() {
Ok(width) => Ok(TerminalWidth::Set(width)),
Ok(width) => Ok(Self::Set(width)),
Err(e) => Err(Misfire::FailedParse(e)),
}
}
else if let Some(width) = *TERM_WIDTH {
Ok(TerminalWidth::Terminal(width))
Ok(Self::Terminal(width))
}
else {
Ok(TerminalWidth::Unset)
Ok(Self::Unset)
}
}
fn width(&self) -> Option<usize> {
match *self {
TerminalWidth::Set(width) |
TerminalWidth::Terminal(width) => Some(width),
TerminalWidth::Unset => None,
Self::Set(width) |
Self::Terminal(width) => Some(width),
Self::Unset => None,
}
}
}
@ -192,17 +192,17 @@ impl RowThreshold {
/// Determine whether to use a row threshold based on the given
/// environment variables.
fn deduce<V: Vars>(vars: &V) -> Result<RowThreshold, Misfire> {
fn deduce<V: Vars>(vars: &V) -> Result<Self, Misfire> {
use crate::options::vars;
if let Some(columns) = vars.get(vars::EXA_GRID_ROWS).and_then(|s| s.into_string().ok()) {
match columns.parse() {
Ok(rows) => Ok(RowThreshold::MinimumRows(rows)),
Ok(rows) => Ok(Self::MinimumRows(rows)),
Err(e) => Err(Misfire::FailedParse(e)),
}
}
else {
Ok(RowThreshold::AlwaysGrid)
Ok(Self::AlwaysGrid)
}
}
}
@ -214,7 +214,7 @@ impl TableOptions {
let time_format = TimeFormat::deduce(matches, vars)?;
let size_format = SizeFormat::deduce(matches)?;
let columns = Columns::deduce(matches)?;
Ok(TableOptions { env, time_format, size_format, columns })
Ok(Self { env, time_format, size_format, columns })
}
}
@ -234,7 +234,7 @@ impl Columns {
let filesize = !matches.has(&flags::NO_FILESIZE)?;
let user = !matches.has(&flags::NO_USER)?;
Ok(Columns { time_types, git, octal, blocks, group, inode, links, permissions, filesize, user })
Ok(Self { time_types, git, octal, blocks, group, inode, links, permissions, filesize, user })
}
}
@ -249,13 +249,13 @@ impl SizeFormat {
/// strings of digits in your head. Changing the format to anything else
/// involves the `--binary` or `--bytes` flags, and these conflict with
/// each other.
fn deduce(matches: &MatchedFlags) -> Result<SizeFormat, Misfire> {
fn deduce(matches: &MatchedFlags) -> Result<Self, Misfire> {
let flag = matches.has_where(|f| f.matches(&flags::BINARY) || f.matches(&flags::BYTES))?;
Ok(match flag {
Some(f) if f.matches(&flags::BINARY) => SizeFormat::BinaryBytes,
Some(f) if f.matches(&flags::BYTES) => SizeFormat::JustBytes,
_ => SizeFormat::DecimalBytes,
Some(f) if f.matches(&flags::BINARY) => Self::BinaryBytes,
Some(f) if f.matches(&flags::BYTES) => Self::JustBytes,
_ => Self::DecimalBytes,
})
}
}
@ -264,7 +264,7 @@ impl SizeFormat {
impl TimeFormat {
/// Determine how time should be formatted in timestamp columns.
fn deduce<V: Vars>(matches: &MatchedFlags, vars: &V) -> Result<TimeFormat, Misfire> {
fn deduce<V: Vars>(matches: &MatchedFlags, vars: &V) -> Result<Self, Misfire> {
pub use crate::output::time::{DefaultFormat, ISOFormat};
let word = match matches.get(&flags::TIME_STYLE)? {
@ -273,22 +273,22 @@ impl TimeFormat {
use crate::options::vars;
match vars.get(vars::TIME_STYLE) {
Some(ref t) if !t.is_empty() => t.clone(),
_ => return Ok(TimeFormat::DefaultFormat(DefaultFormat::load()))
_ => return Ok(Self::DefaultFormat(DefaultFormat::load()))
}
},
};
if &word == "default" {
Ok(TimeFormat::DefaultFormat(DefaultFormat::load()))
Ok(Self::DefaultFormat(DefaultFormat::load()))
}
else if &word == "iso" {
Ok(TimeFormat::ISOFormat(ISOFormat::load()))
Ok(Self::ISOFormat(ISOFormat::load()))
}
else if &word == "long-iso" {
Ok(TimeFormat::LongISO)
Ok(Self::LongISO)
}
else if &word == "full-iso" {
Ok(TimeFormat::FullISO)
Ok(Self::FullISO)
}
else {
Err(Misfire::BadArgument(&flags::TIME_STYLE, word))
@ -309,7 +309,7 @@ impl TimeTypes {
/// It’s valid to show more than one column by passing in more than one
/// option, but passing *no* options means that the user just wants to
/// see the default set.
fn deduce(matches: &MatchedFlags) -> Result<TimeTypes, Misfire> {
fn deduce(matches: &MatchedFlags) -> Result<Self, Misfire> {
let possible_word = matches.get(&flags::TIME)?;
let modified = matches.has(&flags::MODIFIED)?;
let changed = matches.has(&flags::CHANGED)?;
@ -319,7 +319,7 @@ impl TimeTypes {
let no_time = matches.has(&flags::NO_TIME)?;
let time_types = if no_time {
TimeTypes { modified: false, changed: false, accessed: false, created: false }
Self { modified: false, changed: false, accessed: false, created: false }
} else if let Some(word) = possible_word {
if modified {
return Err(Misfire::Useless(&flags::MODIFIED, true, &flags::TIME));
@ -334,26 +334,26 @@ impl TimeTypes {
return Err(Misfire::Useless(&flags::CREATED, true, &flags::TIME));
}
else if word == "mod" || word == "modified" {
TimeTypes { modified: true, changed: false, accessed: false, created: false }
Self { modified: true, changed: false, accessed: false, created: false }
}
else if word == "ch" || word == "changed" {
TimeTypes { modified: false, changed: true, accessed: false, created: false }
Self { modified: false, changed: true, accessed: false, created: false }
}
else if word == "acc" || word == "accessed" {
TimeTypes { modified: false, changed: false, accessed: true, created: false }
Self { modified: false, changed: false, accessed: true, created: false }
}
else if word == "cr" || word == "created" {
TimeTypes { modified: false, changed: false, accessed: false, created: true }
Self { modified: false, changed: false, accessed: false, created: true }
}
else {
return Err(Misfire::BadArgument(&flags::TIME, word.into()));
}
}
else if modified || changed || accessed || created {
TimeTypes { modified, changed, accessed, created }
Self { modified, changed, accessed, created }
}
else {
TimeTypes::default()
Self::default()
};
Ok(time_types)

32
src/output/cell.rs
View File

@ -42,7 +42,7 @@ impl TextCell {
pub fn paint(style: Style, text: String) -> Self {
let width = DisplayWidth::from(&*text);
TextCell {
Self {
contents: vec![ style.paint(text) ].into(),
width,
}
@ -54,7 +54,7 @@ impl TextCell {
pub fn paint_str(style: Style, text: &'static str) -> Self {
let width = DisplayWidth::from(text);
TextCell {
Self {
contents: vec![ style.paint(text) ].into(),
width,
}
@ -67,7 +67,7 @@ impl TextCell {
/// This is used in place of empty table cells, as it is easier to read
/// tabular data when there is *something* in each cell.
pub fn blank(style: Style) -> Self {
TextCell {
Self {
contents: vec![ style.paint("-") ].into(),
width: DisplayWidth::from(1),
}
@ -92,7 +92,7 @@ impl TextCell {
}
/// Adds all the contents of another `TextCell` to the end of this cell.
pub fn append(&mut self, other: TextCell) {
pub fn append(&mut self, other: Self) {
(*self.width) += *other.width;
self.contents.0.extend(other.contents.0);
}
@ -136,8 +136,8 @@ impl TextCell {
pub struct TextCellContents(Vec<ANSIString<'static>>);
impl From<Vec<ANSIString<'static>>> for TextCellContents {
fn from(strings: Vec<ANSIString<'static>>) -> TextCellContents {
TextCellContents(strings)
fn from(strings: Vec<ANSIString<'static>>) -> Self {
Self(strings)
}
}
@ -197,14 +197,14 @@ impl TextCellContents {
pub struct DisplayWidth(usize);
impl<'a> From<&'a str> for DisplayWidth {
fn from(input: &'a str) -> DisplayWidth {
DisplayWidth(UnicodeWidthStr::width(input))
fn from(input: &'a str) -> Self {
Self(UnicodeWidthStr::width(input))
}
}
impl From<usize> for DisplayWidth {
fn from(width: usize) -> DisplayWidth {
DisplayWidth(width)
fn from(width: usize) -> Self {
Self(width)
}
}
@ -223,24 +223,24 @@ impl DerefMut for DisplayWidth {
}
impl Add for DisplayWidth {
type Output = DisplayWidth;
type Output = Self;
fn add(self, rhs: DisplayWidth) -> Self::Output {
DisplayWidth(self.0 + rhs.0)
fn add(self, rhs: Self) -> Self::Output {
Self(self.0 + rhs.0)
}
}
impl Add<usize> for DisplayWidth {
type Output = DisplayWidth;
type Output = Self;
fn add(self, rhs: usize) -> Self::Output {
DisplayWidth(self.0 + rhs)
Self(self.0 + rhs)
}
}
impl Sum for DisplayWidth {
fn sum<I>(iter: I) -> Self where I: Iterator<Item=Self> {
iter.fold(DisplayWidth(0), Add::add)
iter.fold(Self(0), Add::add)
}
}

4
src/output/file_name.rs
View File

@ -65,8 +65,8 @@ pub enum Classify {
}
impl Default for Classify {
fn default() -> Classify {
Classify::JustFilenames
fn default() -> Self {
Self::JustFilenames
}
}

6
src/output/icons.rs
View File

@ -17,9 +17,9 @@ pub enum Icons {
impl Icons {
pub fn value(&self) -> char {
match *self {
Icons::Audio => '\u{f001}',
Icons::Image => '\u{f1c5}',
Icons::Video => '\u{f03d}',
Self::Audio => '\u{f001}',
Self::Image => '\u{f1c5}',
Self::Video => '\u{f03d}',
}
}
}

4
src/output/render/blocks.rs
View File

@ -7,8 +7,8 @@ use crate::fs::fields as f;
impl f::Blocks {
pub fn render<C: Colours>(&self, colours: &C) -> TextCell {
match *self {
f::Blocks::Some(ref blk) => TextCell::paint(colours.block_count(), blk.to_string()),
f::Blocks::None => TextCell::blank(colours.no_blocks()),
Self::Some(ref blk) => TextCell::paint(colours.block_count(), blk.to_string()),
Self::None => TextCell::blank(colours.no_blocks()),
}
}
}

16
src/output/render/filetype.rs
View File

@ -6,14 +6,14 @@ use crate::fs::fields as f;
impl f::Type {
pub fn render<C: Colours>(&self, colours: &C) -> ANSIString<'static> {
match *self {
f::Type::File => colours.normal().paint("."),
f::Type::Directory => colours.directory().paint("d"),
f::Type::Pipe => colours.pipe().paint("|"),
f::Type::Link => colours.symlink().paint("l"),
f::Type::BlockDevice => colours.block_device().paint("b"),
f::Type::CharDevice => colours.char_device().paint("c"),
f::Type::Socket => colours.socket().paint("s"),
f::Type::Special => colours.special().paint("?"),
Self::File => colours.normal().paint("."),
Self::Directory => colours.directory().paint("d"),
Self::Pipe => colours.pipe().paint("|"),
Self::Link => colours.symlink().paint("l"),
Self::BlockDevice => colours.block_device().paint("b"),
Self::CharDevice => colours.char_device().paint("c"),
Self::Socket => colours.socket().paint("s"),
Self::Special => colours.special().paint("?"),
}
}
}

16
src/output/render/git.rs
View File

@ -20,14 +20,14 @@ impl f::Git {
impl f::GitStatus {
fn render(&self, colours: &dyn Colours) -> ANSIString<'static> {
match *self {
f::GitStatus::NotModified => colours.not_modified().paint("-"),
f::GitStatus::New => colours.new().paint("N"),
f::GitStatus::Modified => colours.modified().paint("M"),
f::GitStatus::Deleted => colours.deleted().paint("D"),
f::GitStatus::Renamed => colours.renamed().paint("R"),
f::GitStatus::TypeChange => colours.type_change().paint("T"),
f::GitStatus::Ignored => colours.ignored().paint("I"),
f::GitStatus::Conflicted => colours.conflicted().paint("U"),
Self::NotModified => colours.not_modified().paint("-"),
Self::New => colours.new().paint("N"),
Self::Modified => colours.modified().paint("M"),
Self::Deleted => colours.deleted().paint("D"),
Self::Renamed => colours.renamed().paint("R"),
Self::TypeChange => colours.type_change().paint("T"),
Self::Ignored => colours.ignored().paint("I"),
Self::Conflicted => colours.conflicted().paint("U"),
}
}
}

6
src/output/render/size.rs
View File

@ -12,9 +12,9 @@ impl f::Size {
use number_prefix::NumberPrefix;
let size = match *self {
f::Size::Some(s) => s,
f::Size::None => return TextCell::blank(colours.no_size()),
f::Size::DeviceIDs(ref ids) => return ids.render(colours),
Self::Some(s) => s,
Self::None => return TextCell::blank(colours.no_size()),
Self::DeviceIDs(ref ids) => return ids.render(colours),
};
let result = match size_format {

54
src/output/table.rs
View File

@ -144,12 +144,12 @@ impl Column {
/// Get the alignment this column should use.
pub fn alignment(&self) -> Alignment {
match *self {
Column::FileSize
| Column::HardLinks
| Column::Inode
| Column::Blocks
| Column::GitStatus => Alignment::Right,
_ => Alignment::Left,
Self::FileSize |
Self::HardLinks |
Self::Inode |
Self::Blocks |
Self::GitStatus => Alignment::Right,
_ => Alignment::Left,
}
}
@ -157,16 +157,16 @@ impl Column {
/// to have a header row printed.
pub fn header(&self) -> &'static str {
match *self {
Column::Permissions => "Permissions",
Column::FileSize => "Size",
Column::Timestamp(t) => t.header(),
Column::Blocks => "Blocks",
Column::User => "User",
Column::Group => "Group",
Column::HardLinks => "Links",
Column::Inode => "inode",
Column::GitStatus => "Git",
Column::Octal => "Octal",
Self::Permissions => "Permissions",
Self::FileSize => "Size",
Self::Timestamp(t) => t.header(),
Self::Blocks => "Blocks",
Self::User => "User",
Self::Group => "Group",
Self::HardLinks => "Links",
Self::Inode => "inode",
Self::GitStatus => "Git",
Self::Octal => "Octal",
}
}
}
@ -189,8 +189,8 @@ pub enum SizeFormat {
}
impl Default for SizeFormat {
fn default() -> SizeFormat {
SizeFormat::DecimalBytes
fn default() -> Self {
Self::DecimalBytes
}
}
@ -217,10 +217,10 @@ impl TimeType {
/// Returns the text to use for a column’s heading in the columns output.
pub fn header(self) -> &'static str {
match self {
TimeType::Modified => "Date Modified",
TimeType::Changed => "Date Changed",
TimeType::Accessed => "Date Accessed",
TimeType::Created => "Date Created",
Self::Modified => "Date Modified",
Self::Changed => "Date Changed",
Self::Accessed => "Date Accessed",
Self::Created => "Date Created",
}
}
}
@ -243,8 +243,8 @@ impl Default for TimeTypes {
/// By default, display just the ‘modified’ time. This is the most
/// common option, which is why it has this shorthand.
fn default() -> TimeTypes {
TimeTypes { modified: true, changed: false, accessed: false, created: false }
fn default() -> Self {
Self { modified: true, changed: false, accessed: false, created: false }
}
}
@ -287,7 +287,7 @@ impl Environment {
let users = Mutex::new(UsersCache::new());
Environment { tz, numeric, users }
Self { tz, numeric, users }
}
}
@ -425,8 +425,8 @@ impl Deref for TableWidths {
}
impl TableWidths {
pub fn zero(count: usize) -> TableWidths {
TableWidths(vec![ 0; count ])
pub fn zero(count: usize) -> Self {
Self(vec![ 0; count ])
}
pub fn add_widths(&mut self, row: &Row) {

28
src/output/time.rs
View File

@ -52,19 +52,19 @@ pub enum TimeFormat {
impl TimeFormat {
pub fn format_local(&self, time: SystemTime) -> String {
match *self {
TimeFormat::DefaultFormat(ref fmt) => fmt.format_local(time),
TimeFormat::ISOFormat(ref iso) => iso.format_local(time),
TimeFormat::LongISO => long_local(time),
TimeFormat::FullISO => full_local(time),
Self::DefaultFormat(ref fmt) => fmt.format_local(time),
Self::ISOFormat(ref iso) => iso.format_local(time),
Self::LongISO => long_local(time),
Self::FullISO => full_local(time),
}
}
pub fn format_zoned(&self, time: SystemTime, zone: &TimeZone) -> String {
match *self {
TimeFormat::DefaultFormat(ref fmt) => fmt.format_zoned(time, zone),
TimeFormat::ISOFormat(ref iso) => iso.format_zoned(time, zone),
TimeFormat::LongISO => long_zoned(time, zone),
TimeFormat::FullISO => full_zoned(time, zone),
Self::DefaultFormat(ref fmt) => fmt.format_zoned(time, zone),
Self::ISOFormat(ref iso) => iso.format_zoned(time, zone),
Self::LongISO => long_zoned(time, zone),
Self::FullISO => full_zoned(time, zone),
}
}
}
@ -88,7 +88,7 @@ pub struct DefaultFormat {
}
impl DefaultFormat {
pub fn load() -> DefaultFormat {
pub fn load() -> Self {
use unicode_width::UnicodeWidthStr;
let locale = locale::Time::load_user_locale()
@ -117,7 +117,7 @@ impl DefaultFormat {
_ => DateFormat::parse("{2>:D} {:M} {5>:Y}").unwrap()
};
DefaultFormat { current_year, locale, date_and_time, date_and_year }
Self { current_year, locale, date_and_time, date_and_year }
}
}
@ -150,7 +150,7 @@ impl DefaultFormat {
if self.is_recent(date) {
format!("{:2} {} {:02}:{:02}",
date.day(), DefaultFormat::month_to_abbrev(date.month()),
date.day(), Self::month_to_abbrev(date.month()),
date.hour(), date.minute())
}
else {
@ -164,7 +164,7 @@ impl DefaultFormat {
if self.is_recent(date) {
format!("{:2} {} {:02}:{:02}",
date.day(), DefaultFormat::month_to_abbrev(date.month()),
date.day(), Self::month_to_abbrev(date.month()),
date.hour(), date.minute())
}
else {
@ -250,9 +250,9 @@ pub struct ISOFormat {
}
impl ISOFormat {
pub fn load() -> ISOFormat {
pub fn load() -> Self {
let current_year = LocalDateTime::now().year();
ISOFormat { current_year }
Self { current_year }
}
}

20
src/output/tree.rs
View File

@ -61,10 +61,10 @@ impl TreePart {
/// (Warning: not actually ASCII)
pub fn ascii_art(&self) -> &'static str {
match *self {
TreePart::Edge => "├──",
TreePart::Line => "│ ",
TreePart::Corner => "└──",
TreePart::Blank => " ",
Self::Edge => "├──",
Self::Line => "│ ",
Self::Corner => "└──",
Self::Blank => " ",
}
}
}
@ -138,8 +138,8 @@ impl TreeTrunk {
}
impl TreeParams {
pub fn new(depth: TreeDepth, last: bool) -> TreeParams {
TreeParams { depth, last }
pub fn new(depth: TreeDepth, last: bool) -> Self {
Self { depth, last }
}
pub fn is_at_root(&self) -> bool {
@ -148,12 +148,12 @@ impl TreeParams {
}
impl TreeDepth {
pub fn root() -> TreeDepth {
TreeDepth(0)
pub fn root() -> Self {
Self(0)
}
pub fn deeper(self) -> TreeDepth {
TreeDepth(self.0 + 1)
pub fn deeper(self) -> Self {
Self(self.0 + 1)
}
/// Creates an iterator that, as well as yielding each value, yields a

8
src/style/colours.rs
View File

@ -109,12 +109,12 @@ pub struct Git {
}
impl Colours {
pub fn plain() -> Colours {
Colours::default()
pub fn plain() -> Self {
Self::default()
}
pub fn colourful(scale: bool) -> Colours {
Colours {
pub fn colourful(scale: bool) -> Self {
Self {
colourful: true,
filekinds: FileKinds {