Merge branch 'master' into disable-ascii-art

Author: o2sh

src/main.rs

@@ -1,11 +1,11 @@
 // `error_chain!` can recurse deeply
 #![recursion_limit = "1024"]
 
-use onefetch::{cli::Cli, error::*, info};
+use onefetch::{cli::Cli, cli_utils, error::*, info};
 
 use {
     process::{Command, Stdio},
-    std::process,
+    std::{io, process},
 };
 
 mod onefetch;
@@ -22,12 +22,15 @@ fn run() -> Result<()> {
     let options = Cli::new()?;
 
     if options.print_languages {
-        return Cli::print_supported_languages();
+        return cli_utils::print_supported_languages();
     }
 
     let info = info::Info::new(options)?;
 
-    print!("{}", info);
+    let mut printer = cli_utils::Printer::new(io::BufWriter::new(io::stdout()), info);
+
+    printer.print()?;
+
     Ok(())
 }
 
@@ -38,7 +41,7 @@ fn main() {
             process::exit(0);
         }
         Err(error) => {
-            let stderr = std::io::stderr();
+            let stderr = io::stderr();
             default_error_handler(&error, &mut stderr.lock());
             process::exit(1);
         }

src/onefetch/ascii_art.rs

@@ -2,13 +2,13 @@ use colored::{Color, Colorize};
 
 pub struct AsciiArt<'a> {
     content: Box<dyn 'a + Iterator<Item = &'a str>>,
-    colors: Vec<Color>,
+    colors: &'a [Color],
     bold: bool,
     start: usize,
     end: usize,
 }
 impl<'a> AsciiArt<'a> {
-    pub fn new(input: &'a str, colors: Vec<Color>, bold: bool) -> AsciiArt<'a> {
+    pub fn new(input: &'a str, colors: &'a [Color], bold: bool) -> AsciiArt<'a> {
         let mut lines: Vec<_> = input.lines().skip_while(|line| line.is_empty()).collect();
         while let Some(line) = lines.last() {
             if Tokens(line).is_empty() {

src/onefetch/cli.rs

@@ -1,6 +1,10 @@
 use {
     crate::onefetch::{
-        error::*, image_backends, info_fields, info_fields::InfoFields, language::Language,
+        cli_utils,
+        error::*,
+        image_backends,
+        info_fields::{self, InfoFields},
+        language::Language,
     },
     clap::{crate_description, crate_name, crate_version, App, AppSettings, Arg},
     image::DynamicImage,
@@ -186,7 +190,7 @@ impl Cli {
         let no_color_blocks = matches.is_present("no-color-blocks");
         let print_languages = matches.is_present("languages");
         let art_off = matches.is_present("off");
-        let true_color = is_truecolor_terminal();
+        let true_color = cli_utils::is_truecolor_terminal();
 
         let fields_to_hide: Vec<String> = if let Some(values) = matches.values_of("disable-fields")
         {
@@ -259,20 +263,4 @@ impl Cli {
             art_off,
         })
     }
-
-    pub fn print_supported_languages() -> Result<()> {
-        let iterator = Language::iter().filter(|x| *x != Language::Unknown);
-
-        for l in iterator {
-            println!("{}", l);
-        }
-
-        Ok(())
-    }
-}
-
-fn is_truecolor_terminal() -> bool {
-    env::var("COLORTERM")
-        .map(|colorterm| colorterm == "truecolor" || colorterm == "24bit")
-        .unwrap_or(false)
 }

src/onefetch/cli_utils.rs

@@ -0,0 +1,96 @@
+use crate::onefetch::{ascii_art::AsciiArt, error::*, info::Info, language::Language};
+use colored::Color;
+use std::env;
+use std::io::Write;
+use strum::IntoEnumIterator;
+
+pub struct Printer<W> {
+    writer: W,
+    info: Info,
+}
+
+impl<W: Write> Printer<W> {
+    pub fn new(writer: W, info: Info) -> Self {
+        Self { writer, info }
+    }
+
+    pub fn print(&mut self) -> Result<()> {
+        let center_pad = "   ";
+        let info_str = format!("{}", &self.info);
+        let mut info_lines = info_str.lines();
+        let colors: Vec<Color> = Vec::new();
+        let mut buf = String::new();
+
+        if !self.info.config.art_off {
+            if let Some(custom_image) = &self.info.config.image {
+                if let Some(image_backend) = &self.info.config.image_backend {
+                    buf.push_str(&image_backend.add_image(
+                        info_lines.map(|s| format!("{}{}", center_pad, s)).collect(),
+                        custom_image,
+                    ));
+                } else {
+                    panic!("No image backend found")
+                }
+            } else {
+                let mut logo_lines = if let Some(custom_ascii) = &self.info.config.ascii_input {
+                    AsciiArt::new(custom_ascii, &colors, !self.info.config.no_bold)
+                } else {
+                    AsciiArt::new(
+                        self.get_ascii(),
+                        &self.info.colors,
+                        !self.info.config.no_bold,
+                    )
+                };
+
+                loop {
+                    match (logo_lines.next(), info_lines.next()) {
+                        (Some(logo_line), Some(info_line)) => {
+                            buf.push_str(&format!("{}{}{:^}\n", logo_line, center_pad, info_line))
+                        }
+                        (Some(logo_line), None) => buf.push_str(&format!("{}\n", logo_line)),
+                        (None, Some(info_line)) => buf.push_str(&format!(
+                            "{:<width$}{}{:^}\n",
+                            "",
+                            center_pad,
+                            info_line,
+                            width = logo_lines.width()
+                        )),
+                        (None, None) => {
+                            buf.push('\n');
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        writeln!(self.writer, "{}", buf)?;
+
+        Ok(())
+    }
+
+    fn get_ascii(&self) -> &str {
+        let language = if let Language::Unknown = self.info.config.ascii_language {
+            &self.info.dominant_language
+        } else {
+            &self.info.config.ascii_language
+        };
+
+        language.get_ascii_art()
+    }
+}
+
+pub fn print_supported_languages() -> Result<()> {
+    let iterator = Language::iter().filter(|x| *x != Language::Unknown);
+
+    for l in iterator {
+        println!("{}", l);
+    }
+
+    Ok(())
+}
+
+pub fn is_truecolor_terminal() -> bool {
+    env::var("COLORTERM")
+        .map(|colorterm| colorterm == "truecolor" || colorterm == "24bit")
+        .unwrap_or(false)
+}

src/onefetch/info.rs

@@ -1,12 +1,10 @@
 use {
     crate::onefetch::{
-        ascii_art::AsciiArt, cli::Cli, commit_info::CommitInfo, error::*, language::Language,
-        license::Detector,
+        cli::Cli, commit_info::CommitInfo, error::*, language::Language, license::Detector,
     },
     colored::{Color, ColoredString, Colorize},
     git2::Repository,
     regex::Regex,
-    std::fmt::Write,
     tokio::process::Command,
 };
 
@@ -17,7 +15,7 @@ pub struct Info {
     current_commit: CommitInfo,
     version: String,
     creation_date: String,
-    dominant_language: Language,
+    pub dominant_language: Language,
     languages: Vec<(Language, f64)>,
     authors: Vec<(String, usize, usize)>,
     last_change: String,
@@ -29,13 +27,13 @@ pub struct Info {
     number_of_tags: usize,
     number_of_branches: usize,
     license: String,
-    config: Cli,
+    pub colors: Vec<Color>,
+    pub config: Cli,
 }
 
 impl std::fmt::Display for Info {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        let mut buf = String::new();
-        let color = match self.colors().get(0) {
+        let color = match self.colors.get(0) {
             Some(&c) => c,
             None => Color::White,
         };
@@ -44,24 +42,20 @@ impl std::fmt::Display for Info {
             if self.git_username != "" {
                 git_info_length = self.git_username.len() + self.git_version.len() + 3;
                 write!(
-                    &mut buf,
+                    f,
                     "{} ~ ",
                     &self.get_formatted_info_label(&self.git_username, color)
                 )?;
             } else {
                 git_info_length = self.git_version.len();
             }
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label(&self.git_version, color),
                 "",
             )?;
             let separator = "-".repeat(git_info_length);
-            write_buf(
-                &mut buf,
-                &self.get_formatted_info_label("", color),
-                &separator,
-            )?;
+            write_buf(f, &self.get_formatted_info_label("", color), &separator)?;
         }
         if !self.config.disabled_fields.project {
             let branches_str = match self.number_of_branches {
@@ -87,39 +81,39 @@ impl std::fmt::Display for Info {
             let project_str = &self.get_formatted_info_label("Project: ", color);
 
             writeln!(
-                buf,
+                f,
                 "{}{} {}",
                 project_str, self.project_name, branches_tags_str
             )?;
         }
 
         if !self.config.disabled_fields.head {
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label("HEAD: ", color),
                 &self.current_commit,
             )?;
         }
 
         if !self.config.disabled_fields.pending && self.pending != "" {
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label("Pending: ", color),
                 &self.pending,
             )?;
         }
 
         if !self.config.disabled_fields.version {
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label("Version: ", color),
                 &self.version,
             )?;
         }
 
         if !self.config.disabled_fields.created {
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label("Created: ", color),
                 &self.creation_date,
             )?;
@@ -150,10 +144,10 @@ impl std::fmt::Display for Info {
                         s = s + &format!("{} ({} %) ", language.0, formatted_number);
                     }
                 }
-                writeln!(buf, "{}{}", &self.get_formatted_info_label(title, color), s)?;
+                writeln!(f, "{}{}", &self.get_formatted_info_label(title, color), s)?;
             } else {
                 write_buf(
-                    &mut buf,
+                    f,
                     &self.get_formatted_info_label("Language: ", color),
                     &self.dominant_language,
                 )?;
@@ -168,7 +162,7 @@ impl std::fmt::Display for Info {
             };
 
             writeln!(
-                buf,
+                f,
                 "{}{}% {} {}",
                 &self.get_formatted_info_label(title, color),
                 self.authors[0].2,
@@ -180,7 +174,7 @@ impl std::fmt::Display for Info {
 
             for author in self.authors.iter().skip(1) {
                 writeln!(
-                    buf,
+                    f,
                     "{}{}% {} {}",
                     &self.get_formatted_info_label(&title, color),
                     author.2,
@@ -192,55 +186,55 @@ impl std::fmt::Display for Info {
 
         if !self.config.disabled_fields.last_change {
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label("Last change: ", color),
                 &self.last_change,
             )?;
         }
 
         if !self.config.disabled_fields.repo {
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label("Repo: ", color),
                 &self.repo_url,
             )?;
         }
 
         if !self.config.disabled_fields.commits {
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label("Commits: ", color),
                 &self.commits,
             )?;
         }
 
         if !self.config.disabled_fields.lines_of_code {
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label("Lines of code: ", color),
                 &self.number_of_lines,
             )?;
         }
 
         if !self.config.disabled_fields.size {
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label("Size: ", color),
                 &self.repo_size,
             )?;
         }
 
         if !self.config.disabled_fields.license {
             write_buf(
-                &mut buf,
+                f,
                 &self.get_formatted_info_label("License: ", color),
                 &self.license,
             )?;
         }
 
         if !self.config.no_color_blocks {
             writeln!(
-                buf,
+                f,
                 "\n{0}{1}{2}{3}{4}{5}{6}{7}",
                 "   ".on_black(),
                 "   ".on_red(),
@@ -253,53 +247,6 @@ impl std::fmt::Display for Info {
             )?;
         }
 
-        let center_pad = "   ";
-        let mut info_lines = buf.lines();
-
-        if self.config.art_off {
-            writeln!(f, "{}", buf)?;
-        } else if let Some(custom_image) = &self.config.image {
-            if let Some(image_backend) = &self.config.image_backend {
-                writeln!(
-                    f,
-                    "{}",
-                    image_backend.add_image(
-                        info_lines.map(|s| format!("{}{}", center_pad, s)).collect(),
-                        custom_image
-                    )
-                )?;
-            } else {
-                panic!("No image backend found")
-            }
-        } else {
-            let mut logo_lines = if let Some(custom_ascii) = &self.config.ascii_input {
-                AsciiArt::new(custom_ascii, Vec::new(), !self.config.no_bold)
-            } else {
-                AsciiArt::new(self.get_ascii(), self.colors(), !self.config.no_bold)
-            };
-
-            loop {
-                match (logo_lines.next(), info_lines.next()) {
-                    (Some(logo_line), Some(info_line)) => {
-                        writeln!(f, "{}{}{:^}", logo_line, center_pad, info_line)?
-                    }
-                    (Some(logo_line), None) => writeln!(f, "{}", logo_line)?,
-                    (None, Some(info_line)) => writeln!(
-                        f,
-                        "{:<width$}{}{:^}",
-                        "",
-                        center_pad,
-                        info_line,
-                        width = logo_lines.width()
-                    )?,
-                    (None, None) => {
-                        writeln!(f, "\n")?;
-                        break;
-                    }
-                }
-            }
-        }
-
         Ok(())
     }
 }
@@ -340,6 +287,12 @@ impl Info {
         let last_change = Info::get_date_of_last_commit(&git_history);
         let project_license = Detector::new()?.get_project_license(workdir_str);
         let dominant_language = Language::get_dominant_language(&languages_stats);
+        let colors = Info::get_colors(
+            &config.ascii_language,
+            &dominant_language,
+            &config.ascii_colors,
+            config.true_color,
+        );
 
         Ok(Info {
             git_version: git_v,
@@ -360,6 +313,7 @@ impl Info {
             number_of_tags,
             number_of_branches,
             license: project_license?,
+            colors,
             config,
         })
     }
@@ -690,30 +644,25 @@ impl Info {
         }
     }
 
-    fn get_ascii(&self) -> &str {
-        let language = if let Language::Unknown = self.config.ascii_language {
-            &self.dominant_language
-        } else {
-            &self.config.ascii_language
-        };
-
-        language.get_ascii_art()
-    }
-
-    fn colors(&self) -> Vec<Color> {
-        let language = if let Language::Unknown = self.config.ascii_language {
-            &self.dominant_language
+    fn get_colors(
+        ascii_language: &Language,
+        dominant_language: &Language,
+        ascii_colors: &[String],
+        true_color: bool,
+    ) -> Vec<Color> {
+        let language = if let Language::Unknown = ascii_language {
+            &dominant_language
         } else {
-            &self.config.ascii_language
+            &ascii_language
         };
 
-        let colors = language.get_colors(self.config.true_color);
+        let colors = language.get_colors(true_color);
 
         let colors: Vec<Color> = colors
             .iter()
             .enumerate()
             .map(|(index, default_color)| {
-                if let Some(color_num) = self.config.ascii_colors.get(index) {
+                if let Some(color_num) = ascii_colors.get(index) {
                     if let Some(color) = Info::num_to_color(color_num) {
                         return color;
                     }
@@ -749,7 +698,7 @@ impl Info {
 }
 
 fn write_buf<T: std::fmt::Display>(
-    buffer: &mut String,
+    buffer: &mut std::fmt::Formatter,
     title: &ColoredString,
     content: T,
 ) -> std::fmt::Result {

src/onefetch/language.rs

@@ -231,16 +231,16 @@ define_languages! {
             Color::Red,
             Color::Red
         ] : [
-            Color::TrueColor{ r:248, g:129, b:052 },
-            Color::TrueColor{ r:249, g:119, b:050 },
-            Color::TrueColor{ r:249, g:109, b:048 },
-            Color::TrueColor{ r:250, g:099, b:046 },
-            Color::TrueColor{ r:250, g:089, b:044 },
-            Color::TrueColor{ r:251, g:080, b:042 },
-            Color::TrueColor{ r:251, g:070, b:040 },
-            Color::TrueColor{ r:252, g:060, b:038 },
-            Color::TrueColor{ r:252, g:050, b:036 },
-            Color::TrueColor{ r:253, g:040, b:034 }
+            Color::TrueColor{ r:248, g:129, b:52 },
+            Color::TrueColor{ r:249, g:119, b:50 },
+            Color::TrueColor{ r:249, g:109, b:48 },
+            Color::TrueColor{ r:250, g:99, b:46 },
+            Color::TrueColor{ r:250, g:89, b:44 },
+            Color::TrueColor{ r:251, g:80, b:42 },
+            Color::TrueColor{ r:251, g:70, b:40 },
+            Color::TrueColor{ r:252, g:60, b:38 },
+            Color::TrueColor{ r:252, g:50, b:36 },
+            Color::TrueColor{ r:253, g:40, b:34 }
         ] )
     },
     { Tcl, "tcl.ascii", "Tcl", define_colors!( [Color::Blue, Color::White, Color::Cyan] ) },
@@ -249,7 +249,7 @@ define_languages! {
     { Vue, "vue.ascii", "Vue", define_colors!( [Color::Green, Color::Blue] ) },
     { Xml, "xml.ascii", "XML", define_colors!( [Color::Yellow, Color::White, Color::Green] ) },
     { Zig, "zig.ascii", "Zig", define_colors!( [Color::Yellow] ) },
-    { Zsh, "zsh.ascii", "Z-shell", define_colors!( [Color::White] ) },
+    { Zsh, "zsh.ascii", "Zsh", define_colors!( [Color::White] ) },
 }
 
 impl Language {

src/onefetch/mod.rs

@@ -1,5 +1,6 @@
 pub mod ascii_art;
 pub mod cli;
+pub mod cli_utils;
 pub mod commit_info;
 pub mod error;
 pub mod image_backends;