Merge branch 'master' of https://github.com/o2sh/onefetch

This branch is behind on same changes.

Author: Luke-zhang-04

Diff for: Cargo.lock

@@ -29,7 +29,7 @@ strum = { version = "0.19.5", features = ["derive"] }
 image = "0.23.10"
 regex = "1"
 futures = "0.3.6"
-tokio = { version = "0.3.0", features = ["full"] }
+tokio = { version = "0.3.1", features = ["full"] }
 error-chain = "0.12"
 
 [target.'cfg(windows)'.dependencies]

Diff for: Cargo.toml

@@ -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/main.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/ascii_art.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,
@@ -17,12 +21,14 @@ pub struct Cli {
     pub no_bold: bool,
     pub image: Option<DynamicImage>,
     pub image_backend: Option<Box<dyn image_backends::ImageBackend>>,
+    pub image_colors: usize,
     pub no_merges: bool,
     pub no_color_blocks: bool,
     pub number_of_authors: usize,
     pub excluded: Vec<String>,
     pub print_languages: bool,
     pub true_color: bool,
+    pub art_off: bool,
 }
 
 impl Cli {
@@ -116,7 +122,7 @@ impl Cli {
             Arg::with_name("languages")
                 .short("l")
                 .long("languages")
-                .help("Prints out supported languages"),
+                .help("Prints out supported languages."),
         )
         .arg(
             Arg::with_name("image")
@@ -125,7 +131,7 @@ impl Cli {
                 .value_name("IMAGE")
                 .takes_value(true)
                 .max_values(1)
-                .help("Path to the IMAGE file"),
+                .help("Path to the IMAGE file."),
         )
         .arg(
             Arg::with_name("image-backend")
@@ -136,15 +142,25 @@ impl Cli {
                 .possible_values(&possible_backends)
                 .help("Which image BACKEND to use."),
         )
+        .arg(
+            Arg::with_name("color-resolution")
+                .long("color-resolution")
+                .value_name("VALUE")
+                .requires("image")
+                .takes_value(true)
+                .max_values(1)
+                .possible_values(&["16", "32", "64", "128", "256"])
+                .help("VALUE of color resolution to use with SIXEL backend."),
+        )
         .arg(
             Arg::with_name("no-merge-commits")
                 .long("no-merge-commits")
-                .help("Ignores merge commits"),
+                .help("Ignores merge commits."),
         )
         .arg(
             Arg::with_name("no-color-blocks")
                 .long("no-color-blocks")
-                .help("Hides the color blocks"),
+                .help("Hides the color blocks."),
         )
         .arg(
             Arg::with_name("authors-number")
@@ -172,13 +188,20 @@ impl Cli {
                 .multiple(true)
                 .takes_value(true)
                 .help("Ignore all files & directories matching EXCLUDE."),
+            )
+        .arg(
+            Arg::with_name("off")
+                .long("off")
+                .help("Only shows the info lines.")
+                .conflicts_with_all(&["image", "ascii-language", "ascii-input"]), 
             ).get_matches();
 
         let no_bold = matches.is_present("no-bold");
         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 art_off = matches.is_present("off");
+        let true_color = cli_utils::is_truecolor_terminal();
 
         let fields_to_hide: Vec<String> = if let Some(values) = matches.values_of("disable-fields")
         {
@@ -203,6 +226,12 @@ impl Cli {
             None
         };
 
+        let image_colors = if let Some(value) = matches.value_of("color-resolution") {
+            usize::from_str(value).unwrap()
+        } else {
+            16
+        };
+
         let path = String::from(matches.value_of("input").unwrap());
 
         let ascii_input = matches.value_of("ascii-input").map(String::from);
@@ -221,11 +250,7 @@ impl Cli {
 
         let disabled_fields = info_fields::get_disabled_fields(fields_to_hide)?;
 
-        let number_of_authors = if let Some(value) = matches.value_of("authors-number") {
-            usize::from_str(value).unwrap()
-        } else {
-            3
-        };
+        let number_of_authors: usize = matches.value_of("authors-number").unwrap().parse().unwrap();
 
         let excluded = if let Some(user_ignored) = matches.values_of("exclude") {
             user_ignored.map(String::from).collect()
@@ -242,28 +267,14 @@ impl Cli {
             no_bold,
             image,
             image_backend,
+            image_colors,
             no_merges,
             no_color_blocks,
             number_of_authors,
             excluded,
             print_languages,
             true_color,
+            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)
 }

Diff for: src/onefetch/cli.rs

@@ -0,0 +1,98 @@
+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 {
+            buf.push_str(&info_str);
+        } else 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,
+                    self.info.config.image_colors,
+                ));
+            } 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;
+                    }
+                }
+            }
+        }
+
+        write!(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)
+}

Diff for: src/onefetch/cli_utils.rs

@@ -77,7 +77,7 @@ impl KittyBackend {
 }
 
 impl super::ImageBackend for KittyBackend {
-    fn add_image(&self, lines: Vec<String>, image: &DynamicImage) -> String {
+    fn add_image(&self, lines: Vec<String>, image: &DynamicImage, _colors: usize) -> String {
         let tty_size = unsafe {
             let tty_size: winsize = std::mem::zeroed();
             ioctl(STDOUT_FILENO, TIOCGWINSZ, &tty_size);

Diff for: src/onefetch/image_backends/kitty.rs

@@ -6,7 +6,7 @@ pub mod kitty;
 pub mod sixel;
 
 pub trait ImageBackend {
-    fn add_image(&self, lines: Vec<String>, image: &DynamicImage) -> String;
+    fn add_image(&self, lines: Vec<String>, image: &DynamicImage, colors: usize) -> String;
 }
 
 #[cfg(not(windows))]

Diff for: src/onefetch/image_backends/mod.rs

@@ -71,7 +71,7 @@ impl SixelBackend {
 }
 
 impl super::ImageBackend for SixelBackend {
-    fn add_image(&self, lines: Vec<String>, image: &DynamicImage) -> String {
+    fn add_image(&self, lines: Vec<String>, image: &DynamicImage, colors: usize) -> String {
         let tty_size = unsafe {
             let tty_size: winsize = std::mem::zeroed();
             ioctl(STDOUT_FILENO, TIOCGWINSZ, &tty_size);
@@ -97,7 +97,7 @@ impl super::ImageBackend for SixelBackend {
         // reduce the amount of colors using dithering
         colorops::dither(
             &mut rgba_image,
-            &NeuQuant::new(10, 16, flat_samples.image_slice().unwrap()),
+            &NeuQuant::new(10, colors, flat_samples.image_slice().unwrap()),
         );
         let rgb_image = ImageBuffer::from_fn(rgba_image.width(), rgba_image.height(), |x, y| {
             let rgba_pixel = rgba_image.get_pixel(x, y);