refacto info_fields

Author: o2sh

Diff for: src/onefetch/cli.rs

@@ -3,21 +3,21 @@ use {
         cli_utils,
         error::*,
         image_backends,
-        info_fields::{self, InfoFields},
+        info_fields::{InfoField, InfoFieldOff},
         language::Language,
     },
     clap::{crate_description, crate_name, crate_version, App, AppSettings, Arg},
     image::DynamicImage,
     std::{convert::From, env, str::FromStr},
-    strum::{EnumCount, IntoEnumIterator},
+    strum::IntoEnumIterator,
 };
 
 pub struct Cli {
     pub repo_path: String,
     pub ascii_input: Option<String>,
     pub ascii_language: Option<Language>,
     pub ascii_colors: Vec<String>,
-    pub disabled_fields: info_fields::InfoFieldOn,
+    pub disabled_fields: InfoFieldOff,
     pub no_bold: bool,
     pub image: Option<DynamicImage>,
     pub image_backend: Option<Box<dyn image_backends::ImageBackend>>,
@@ -80,8 +80,7 @@ impl Cli {
                 .case_insensitive(true)
                 .help("Allows you to disable FIELD(s) from appearing in the output.")
                 .possible_values(
-                    &InfoFields::iter()
-                        .take(InfoFields::COUNT - 1)
+                    &InfoField::iter()
                         .map(|field| field.into())
                         .collect::<Vec<&str>>()
                 ),
@@ -288,7 +287,7 @@ impl Cli {
             Vec::new()
         };
 
-        let disabled_fields = info_fields::get_disabled_fields(fields_to_hide)?;
+        let disabled_fields = InfoFieldOff::new(fields_to_hide)?;
 
         let number_of_authors: usize = matches.value_of("authors-number").unwrap().parse().unwrap();
 

Diff for: src/onefetch/error.rs

@@ -13,6 +13,7 @@ error_chain! {
         Regex(regex::Error);
         Toml(toml::de::Error);
         Git2(git2::Error);
+        Strum(strum::ParseError);
     }
 }
 

Diff for: src/onefetch/info_fields.rs

@@ -4,28 +4,9 @@ use {
     strum::{EnumCount, EnumIter, EnumString, IntoStaticStr},
 };
 
-#[derive(Default)]
-pub struct InfoFieldOn {
-    pub git_info: bool,
-    pub project: bool,
-    pub head: bool,
-    pub version: bool,
-    pub created: bool,
-    pub dependencies: bool,
-    pub languages: bool,
-    pub authors: bool,
-    pub last_change: bool,
-    pub repo: bool,
-    pub commits: bool,
-    pub pending: bool,
-    pub lines_of_code: bool,
-    pub size: bool,
-    pub license: bool,
-}
-
 #[derive(PartialEq, Eq, EnumString, EnumCount, EnumIter, IntoStaticStr)]
 #[strum(serialize_all = "snake_case")]
-pub enum InfoFields {
+pub enum InfoField {
     GitInfo,
     Project,
     HEAD,
@@ -44,32 +25,52 @@ pub enum InfoFields {
     UnrecognizedField,
 }
 
-pub fn get_disabled_fields(fields_to_hide: Vec<String>) -> Result<InfoFieldOn> {
-    let mut disabled_fields = InfoFieldOn { ..Default::default() };
+#[derive(Default)]
+pub struct InfoFieldOff {
+    pub git_info: bool,
+    pub project: bool,
+    pub head: bool,
+    pub version: bool,
+    pub created: bool,
+    pub dependencies: bool,
+    pub languages: bool,
+    pub authors: bool,
+    pub last_change: bool,
+    pub repo: bool,
+    pub commits: bool,
+    pub pending: bool,
+    pub lines_of_code: bool,
+    pub size: bool,
+    pub license: bool,
+}
+
+impl InfoFieldOff {
+    pub fn new(fields_to_hide: Vec<String>) -> Result<Self> {
+        let mut disabled_fields = InfoFieldOff { ..Default::default() };
 
-    for field in fields_to_hide.iter() {
-        let item = InfoFields::from_str(field.to_lowercase().as_str())
-            .unwrap_or(InfoFields::UnrecognizedField);
+        for field in fields_to_hide.iter() {
+            let item = InfoField::from_str(field.to_lowercase().as_str())?;
 
-        match item {
-            InfoFields::GitInfo => disabled_fields.git_info = true,
-            InfoFields::Project => disabled_fields.project = true,
-            InfoFields::HEAD => disabled_fields.head = true,
-            InfoFields::Version => disabled_fields.version = true,
-            InfoFields::Created => disabled_fields.created = true,
-            InfoFields::Dependencies => disabled_fields.dependencies = true,
-            InfoFields::Languages => disabled_fields.languages = true,
-            InfoFields::Authors => disabled_fields.authors = true,
-            InfoFields::LastChange => disabled_fields.last_change = true,
-            InfoFields::Repo => disabled_fields.repo = true,
-            InfoFields::Pending => disabled_fields.pending = true,
-            InfoFields::Commits => disabled_fields.commits = true,
-            InfoFields::LinesOfCode => disabled_fields.lines_of_code = true,
-            InfoFields::Size => disabled_fields.size = true,
-            InfoFields::License => disabled_fields.license = true,
-            _ => (),
+            match item {
+                InfoField::GitInfo => disabled_fields.git_info = true,
+                InfoField::Project => disabled_fields.project = true,
+                InfoField::HEAD => disabled_fields.head = true,
+                InfoField::Version => disabled_fields.version = true,
+                InfoField::Created => disabled_fields.created = true,
+                InfoField::Dependencies => disabled_fields.dependencies = true,
+                InfoField::Languages => disabled_fields.languages = true,
+                InfoField::Authors => disabled_fields.authors = true,
+                InfoField::LastChange => disabled_fields.last_change = true,
+                InfoField::Repo => disabled_fields.repo = true,
+                InfoField::Pending => disabled_fields.pending = true,
+                InfoField::Commits => disabled_fields.commits = true,
+                InfoField::LinesOfCode => disabled_fields.lines_of_code = true,
+                InfoField::Size => disabled_fields.size = true,
+                InfoField::License => disabled_fields.license = true,
+                _ => (),
+            }
         }
-    }
 
-    Ok(disabled_fields)
+        Ok(disabled_fields)
+    }
 }