Support repos "without source code" (#1580)

Author: o2sh

src/info/langs/mod.rs

@@ -1,13 +1,12 @@
-use anyhow::{Context, Result};
 use language::{Language, LanguageType};
 use std::collections::HashMap;
 use std::path::Path;
 use strum::IntoEnumIterator;
 
 pub mod language;
 
-pub fn get_main_language(loc_by_language: &[(Language, usize)]) -> Language {
- loc_by_language[0].0
+pub fn get_main_language(loc_by_language_opt: Option<&Vec<(Language, usize)>>) -> Option<Language> {
+ loc_by_language_opt.map(|loc_by_language| loc_by_language[0].0)
 }
 
 /// Returns a vector of tuples containing all the languages detected inside the repository.
@@ -18,21 +17,10 @@ pub fn get_loc_by_language_sorted(
  globs_to_exclude: &[String],
  language_types: &[LanguageType],
  include_hidden: bool,
-) -> Result<Vec<(Language, usize)>> {
+) -> Option<Vec<(Language, usize)>> {
  let locs = get_locs(dir, globs_to_exclude, language_types, include_hidden);
-
- let loc_by_language = get_loc_by_language(&locs).with_context(|| {
- format!(
- "No source code found in the repository at '{}'.\n\
- Note: Some language types (prose, data) are excluded by default. \
- Consider using the '--type' option to include them.",
- dir.display()
- )
- })?;
-
- let loc_by_language_sorted = sort_by_loc(loc_by_language);
-
- Ok(loc_by_language_sorted)
+ let loc_by_language_opt = get_loc_by_language(&locs);
+ loc_by_language_opt.map(sort_by_loc)
 }
 
 fn sort_by_loc(map: HashMap<Language, usize>) -> Vec<(Language, usize)> {
@@ -44,7 +32,7 @@ fn sort_by_loc(map: HashMap<Language, usize>) -> Vec<(Language, usize)> {
 fn get_loc_by_language(languages: &tokei::Languages) -> Option<HashMap<Language, usize>> {
  let mut loc_by_language = HashMap::new();
 
- for (language_name, language) in languages.iter() {
+ for (language_name, language) in languages {
  let loc = language::loc(language_name, language);
 
  if loc == 0 {

src/info/mod.rs

@@ -53,7 +53,7 @@ mod url;
 pub mod utils;
 mod version;
 
-#[derive(Serialize)]
+#[derive(Serialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct Info {
  title: Option<Title>,
@@ -65,7 +65,7 @@ pub struct Info {
  #[serde(skip_serializing)]
  no_bold: bool,
  #[serde(skip_serializing)]
- pub dominant_language: Language,
+ pub dominant_language: Option<Language>,
  #[serde(skip_serializing)]
  pub ascii_colors: Vec<DynColors>,
 }
@@ -158,11 +158,11 @@ pub fn build_info(cli_options: &CliOptions) -> Result<Info> {
  let loc_by_language = loc_by_language_sorted_handle
  .join()
  .ok()
- .context("BUG: panic in language statistics thread")??;
- let dominant_language = langs::get_main_language(&loc_by_language);
+ .context("BUG: panic in language statistics thread")?;
+ let dominant_language = langs::get_main_language(loc_by_language.as_ref());
  let ascii_colors = get_ascii_colors(
+ dominant_language.as_ref(),
  cli_options.ascii.ascii_language.as_ref(),
- &dominant_language,
  &cli_options.ascii.ascii_colors,
  true_color,
  );
@@ -185,7 +185,7 @@ pub fn build_info(cli_options: &CliOptions) -> Result<Info> {
  .version(&repo, manifest.as_ref())?
  .created(&git_metrics, iso_time)
  .languages(
- &loc_by_language,
+ loc_by_language.as_ref(),
  true_color,
  number_of_languages_to_display,
  &text_colors,
@@ -208,7 +208,7 @@ pub fn build_info(cli_options: &CliOptions) -> Result<Info> {
  globs_to_exclude,
  number_separator,
  )?
- .loc(&loc_by_language, number_separator)
+ .loc(loc_by_language.as_ref(), number_separator)
  .size(&repo, number_separator)
  .license(&repo_path, manifest.as_ref())?
  .build(cli_options, text_colors, dominant_language, ascii_colors))
@@ -318,21 +318,23 @@ impl InfoBuilder {
 
  fn languages(
  mut self,
- loc_by_language: &[(Language, usize)],
+ loc_by_language_opt: Option<&Vec<(Language, usize)>>,
  true_color: bool,
  number_of_languages: usize,
  text_colors: &TextColors,
  cli_options: &CliOptions,
  ) -> Self {
  if !self.disabled_fields.contains(&InfoType::Languages) {
- let languages = LanguagesInfo::new(
- loc_by_language,
- true_color,
- number_of_languages,
- text_colors.info,
- cli_options.visuals.nerd_fonts,
- );
- self.info_fields.push(Box::new(languages));
+ if let Some(loc_by_language) = loc_by_language_opt {
+ let languages = LanguagesInfo::new(
+ loc_by_language,
+ true_color,
+ number_of_languages,
+ text_colors.info,
+ cli_options.visuals.nerd_fonts,
+ );
+ self.info_fields.push(Box::new(languages));
+ }
  }
  self
  }
@@ -429,12 +431,14 @@ impl InfoBuilder {
 
  fn loc(
  mut self,
- loc_by_language: &[(Language, usize)],
+ loc_by_language_opt: Option<&Vec<(Language, usize)>>,
  number_separator: NumberSeparator,
  ) -> Self {
  if !self.disabled_fields.contains(&InfoType::LinesOfCode) {
- let lines_of_code = LocInfo::new(loc_by_language, number_separator);
- self.info_fields.push(Box::new(lines_of_code));
+ if let Some(loc_by_language) = loc_by_language_opt {
+ let lines_of_code = LocInfo::new(loc_by_language, number_separator);
+ self.info_fields.push(Box::new(lines_of_code));
+ }
  }
  self
  }
@@ -443,7 +447,7 @@ impl InfoBuilder {
  self,
  cli_options: &CliOptions,
  text_colors: TextColors,
- dominant_language: Language,
+ dominant_language: Option<Language>,
  ascii_colors: Vec<DynColors>,
  ) -> Info {
  Info {

src/main.rs

@@ -5,7 +5,7 @@ use clap::{CommandFactory, Parser};
 use human_panic::setup_panic;
 use onefetch::cli::{self, CliOptions};
 use onefetch::info::build_info;
-use onefetch::ui::printer::Printer;
+use onefetch::ui::printer::factory::PrinterFactory;
 use std::io;
 
 fn main() -> Result<()> {
@@ -32,9 +32,11 @@ fn main() -> Result<()> {
 
  let info = build_info(&cli_options)?;
 
- let mut printer = Printer::new(io::BufWriter::new(io::stdout()), info, cli_options)?;
+ let printer = PrinterFactory::new(info, cli_options)?.create()?;
 
- printer.print()?;
+ let mut writer = io::BufWriter::new(io::stdout());
+
+ printer.print(&mut writer)?;
 
  Ok(())
 }

src/ui/mod.rs

@@ -5,30 +5,26 @@ pub mod printer;
 pub mod text_colors;
 
 pub fn get_ascii_colors(
- ascii_language: Option<&Language>,
- dominant_language: &Language,
+ language_opt: Option<&Language>,
+ override_language_opt: Option<&Language>,
  ascii_colors: &[u8],
  true_color: bool,
 ) -> Vec<DynColors> {
- let language = if let Some(ascii_language) = ascii_language {
- ascii_language
- } else {
- dominant_language
+ let language_colors = match language_opt {
+ Some(lang) => override_language_opt.unwrap_or(lang).get_colors(true_color),
+ None => vec![DynColors::Ansi(AnsiColors::White)],
  };
+ if ascii_colors.is_empty() {
+ return language_colors;
+ }
 
- let mut language_colors: Vec<DynColors> = language.get_colors(true_color);
+ let mut colors: Vec<DynColors> = ascii_colors.iter().map(num_to_color).collect();
 
- if ascii_colors.is_empty() {
- language_colors
- } else {
- let mut colors: Vec<DynColors> = ascii_colors.iter().map(num_to_color).collect();
-
- if language_colors.len() > colors.len() {
- let mut missing = language_colors.drain(colors.len()..).collect();
- colors.append(&mut missing);
- }
- colors
+ if language_colors.len() > colors.len() {
+ colors.extend(language_colors.into_iter().skip(colors.len()));
  }
+
+ colors
 }
 
 pub fn num_to_color(num: &u8) -> DynColors {
@@ -63,9 +59,33 @@ mod test {
  assert_eq!(num_to_color(&u8::MAX), DynColors::Ansi(AnsiColors::Default));
  }
 
+ #[test]
+ fn get_ascii_colors_no_language_no_custom_language_custom_colors() {
+ let colors = get_ascii_colors(None, None, &[3, 5, 8], false);
+ assert_eq!(colors.len(), 3);
+ assert_eq!(
+ colors,
+ vec![num_to_color(&3), num_to_color(&5), num_to_color(&8)]
+ );
+ }
+
+ #[test]
+ fn get_ascii_colors_no_language_no_custom_language() {
+ let colors = get_ascii_colors(None, None, &[], false);
+ assert_eq!(colors.len(), 1);
+ assert_eq!(colors, vec![DynColors::Ansi(AnsiColors::White)]);
+ }
+
+ #[test]
+ fn get_ascii_colors_no_language_with_custom_language() {
+ let colors = get_ascii_colors(None, Some(&Language::Python), &[], false);
+ assert_eq!(colors.len(), 1);
+ assert_eq!(colors, vec![DynColors::Ansi(AnsiColors::White)]);
+ }
+
  #[test]
  fn get_ascii_colors_no_custom_language_no_custom_colors_no_true_color() {
- let colors = get_ascii_colors(None.as_ref(), &Language::Rust, &[], false);
+ let colors = get_ascii_colors(Some(&Language::Rust), None, &[], false);
  assert_eq!(colors.len(), 2);
  assert_eq!(
  colors,
@@ -78,7 +98,7 @@ mod test {
 
  #[test]
  fn get_ascii_colors_no_custom_language_no_custom_colors_true_color() {
- let colors = get_ascii_colors(None, &Language::Rust, &[], true);
+ let colors = get_ascii_colors(Some(&Language::Rust), None, &[], true);
  assert_eq!(colors.len(), 2);
  assert_eq!(
  colors,
@@ -88,14 +108,14 @@ mod test {
 
  #[test]
  fn get_ascii_colors_custom_language_no_custom_colors_no_true_color() {
- let colors = get_ascii_colors(Some(&Language::Sh), &Language::Rust, &[], false);
+ let colors = get_ascii_colors(Some(&Language::Rust), Some(&Language::Sh), &[], false);
  assert_eq!(colors.len(), 1);
  assert_eq!(colors, vec![DynColors::Ansi(AnsiColors::Green)]);
  }
 
  #[test]
  fn get_ascii_colors_no_custom_language_custom_colors_no_true_color() {
- let colors = get_ascii_colors(None.as_ref(), &Language::Rust, &[2, 3], false);
+ let colors = get_ascii_colors(Some(&Language::Rust), None, &[2, 3], false);
  assert_eq!(colors.len(), 2);
  assert_eq!(colors, vec![num_to_color(&2), num_to_color(&3)]);
  }
@@ -104,7 +124,7 @@ mod test {
  fn get_ascii_colors_fill_custom_colors_with_language_colors() {
  // When custom ascii colors are not enough for the given language,
  // language colors should be used as default
- let colors = get_ascii_colors(None, &Language::Go, &[0], false);
+ let colors = get_ascii_colors(Some(&Language::Go), None, &[0], false);
  assert_eq!(colors.len(), 3);
  assert_eq!(
  colors,