refacto info.rs by adding printer

Author: o2sh

Diff for: 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);
         }

Diff for: 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() {

Diff for: 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,
@@ -178,7 +182,7 @@ impl Cli {
         let no_merges = matches.is_present("no-merge-commits");
         let no_color_blocks = matches.is_present("no-color-blocks");
         let print_languages = matches.is_present("languages");
-        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")
         {
@@ -250,20 +254,4 @@ impl Cli {
             true_color,
         })
     }
-
-    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)
 }

Diff for: src/onefetch/cli_utils.rs

@@ -0,0 +1,94 @@
+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 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_str("\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)
+}