@repokit/core 2.0.7 → 3.0.0

package/internals/internal_filesystem/internal_filesystem.rs

@@ -1,6 +1,10 @@
 use normalize_path::NormalizePath;
+
+use regex::Regex;
+use shellexpand::tilde;
 use std::{
-    fs::File,
+    fs::{self, File},
+    io::{BufRead, BufReader, Lines},
     path::{Path, PathBuf},
 };
 
@@ -49,8 +53,8 @@ impl InternalFileSystem {
             Logger::exit_with_info(
                 format!(
                     "To start using {}, please initialize your git repository by running {}",
-                    Logger::blue("Repokit"),
-                    Logger::green_bright("git init")
+                    Logger::with_theme(|theme| theme.highlight("Repokit")),
+                    Logger::with_theme(|theme| theme.highlight("git init"))
                 )
                 .as_str(),
             );
@@ -58,6 +62,58 @@ impl InternalFileSystem {
         root
     }
 
+    pub fn read_theme_preference(&self) -> String {
+        let default = Logger::with_registry(|registry| registry.default_theme.clone());
+        let theme = self.read_dot_file(&mut |mut lines, _| {
+            if let Some(theme_preference) = lines.nth(1)
+                && let Ok(preference) = theme_preference
+            {
+                return preference;
+            }
+            default.to_string()
+        });
+        theme.unwrap_or(default)
+    }
+
+    pub fn store_theme_preference(&self, theme: &str) {
+        self.read_dot_file(&mut |lines, path| {
+            let mut content: Vec<String> = lines.map(|line| line.unwrap()).collect();
+            let theme_text = theme.to_string();
+            if content.len() >= 2 {
+                content[1] = theme_text;
+            } else {
+                content.push(theme_text);
+            }
+            fs::write(path, content.join("\n"))
+        });
+    }
+
+    pub fn read_dot_file<R>(
+        &self,
+        func: &mut impl FnMut(Lines<BufReader<File>>, PathBuf) -> R,
+    ) -> Option<R> {
+        let file_path = self.create_dot_file_if_not_exists();
+        match file_path {
+            Some(path) => {
+                if let Ok(file) = File::open(&path) {
+                    let lines = BufReader::new(file).lines();
+                    return Some(func(lines, path));
+                }
+                None
+            }
+            None => None,
+        }
+    }
+
+    pub fn home() -> Option<PathBuf> {
+        let expanded_path_str = tilde("~/");
+        let path = Path::new(expanded_path_str.as_ref()).normalize();
+        if path.is_absolute() && path.exists() {
+            return Some(path);
+        }
+        None
+    }
+
     fn commands_directory(&self) -> PathBuf {
         self.absolute(format!("{}/dist/commands", self.package_directory()).as_str())
     }
@@ -80,4 +136,69 @@ impl InternalFileSystem {
             .into_string()
             .expect("Cannot construct path")
     }
+
+    fn create_dot_file_if_not_exists(&self) -> Option<PathBuf> {
+        match InternalFileSystem::home() {
+            Some(home) => {
+                let dot_file_path = home.join(".repokit");
+                if !&dot_file_path.exists() {
+                    let found_version = self.current_version();
+                    found_version.as_ref()?;
+                    let version_string = found_version.unwrap();
+                    let result = fs::write(&dot_file_path, format!("{version_string}\n"));
+                    if result.is_err() {
+                        return None;
+                    }
+                }
+                Some(dot_file_path)
+            }
+            None => {
+                Logger::error(
+                    "I encountered an issue when attempting to create a cache file on your machine",
+                );
+                Logger::error(
+                    format!(
+                        "Please create a file called {} in your home directory",
+                        Logger::with_theme(|theme| theme.highlight(".repokit"))
+                    )
+                    .as_str(),
+                );
+                Logger::error(
+                    "This file will be used to store settings and indicators that optimize how repokit runs in your repository",
+                );
+                None
+            }
+        }
+    }
+
+    pub fn current_version(&self) -> Option<String> {
+        let package_path = Path::new(&self.root)
+            .join(InternalFileSystem::package_directory(self))
+            .normalize();
+        let package_json_path = package_path.join("package.json");
+        let file = File::open(package_json_path);
+        if file.is_err() {
+            return None;
+        }
+        let lines = BufReader::new(file.unwrap()).lines();
+        let version_matcher = Regex::new(r#""([^"]*)""#).unwrap();
+        for line in lines.flatten() {
+            if line.contains("\"version\": ") {
+                let captures: Vec<String> = version_matcher
+                    .captures_iter(&line)
+                    .filter_map(|item| {
+                        item.get(1)
+                            .map(|match_text| match_text.as_str().to_string())
+                    })
+                    .collect();
+                let version = captures.get(1);
+                if version.is_some() {
+                    return Some(version.unwrap().to_string());
+                } else {
+                    return None;
+                }
+            }
+        }
+        None
+    }
 }

package/internals/logger/logger.rs

@@ -1,17 +1,27 @@
 use std::process::exit;
 use std::sync::LazyLock;
 use std::sync::Mutex;
+use std::sync::MutexGuard;
 
-use colored::{ColoredString, Colorize, CustomColor};
+use colored::{ColoredString, Colorize};
+
+use crate::repokit::interfaces::RepoKitConfig;
+use crate::themes::theme::Theme;
+use crate::themes::theme_registry::ThemeRegistry;
 
 static REGISTERED_NAME: LazyLock<Mutex<String>> =
     LazyLock::new(|| Mutex::new("Repokit".to_string()));
 
+static THEMES: LazyLock<Mutex<ThemeRegistry>> = LazyLock::new(|| Mutex::new(ThemeRegistry::new()));
+
 pub struct Logger {}
 
 impl Logger {
-    pub fn set_name(value: &str) {
-        *REGISTERED_NAME.lock().unwrap() = value.to_string();
+    pub fn configure(configuration: &RepoKitConfig) {
+        Logger::set_name(&configuration.project);
+        for theme in &configuration.themes {
+            Logger::with_registry(|mut registry| registry.register_user_theme(theme))
+        }
     }
 
     pub fn info(message: &str) {
@@ -36,8 +46,19 @@ impl Logger {
         println!("\n{}{}\n", Logger::info_prefix(), message);
     }
 
+    pub fn with_surrounding_space<F>(mut func: impl FnMut() -> F) -> F {
+        println!();
+        let result = func();
+        println!();
+        result
+    }
+
     pub fn log_file_path(path: &str) {
-        println!("\n{}{}\n", Logger::indent(None), Logger::blue_bright(path));
+        println!(
+            "\n{}{}\n",
+            Logger::indent(None),
+            Logger::with_theme(|theme| theme.highlight(path))
+        );
     }
 
     pub fn indent(times: Option<i32>) -> String {
@@ -45,54 +66,10 @@ impl Logger {
         " ".repeat(indentation.try_into().unwrap())
     }
 
-    pub fn blue(message: &str) -> ColoredString {
-        message.bright_blue()
-    }
-
-    pub fn blue_bright(message: &str) -> ColoredString {
-        message.bright_blue().bold()
-    }
-
-    pub fn magenta_bright(message: &str) -> ColoredString {
-        message.bright_magenta().bold()
-    }
-
-    pub fn magenta(message: &str) -> ColoredString {
-        message.magenta()
-    }
-
-    pub fn green(message: &str) -> ColoredString {
-        message.green()
-    }
-
-    pub fn green_bright(message: &str) -> ColoredString {
-        message.bright_green()
-    }
-
     pub fn cyan(message: &str) -> ColoredString {
         message.cyan()
     }
 
-    pub fn cyan_bright(message: &str) -> ColoredString {
-        message.bright_cyan().bold()
-    }
-
-    pub fn gray(message: &str) -> ColoredString {
-        message.custom_color(CustomColor {
-            r: 128,
-            g: 128,
-            b: 128,
-        })
-    }
-
-    pub fn lime(message: &str) -> ColoredString {
-        message.custom_color(CustomColor {
-            r: 175,
-            g: 247,
-            b: 7,
-        })
-    }
-
     pub fn file_create_error() {
         Logger::file_error("create a file");
     }
@@ -113,6 +90,15 @@ impl Logger {
         Logger::log_file_path("https://github.com/alexfigliolia/repokit/issues");
     }
 
+    pub fn with_theme<R>(func: impl Fn(&Theme) -> R) -> R {
+        Logger::with_registry(|registry| func(registry.current_theme()))
+    }
+
+    pub fn with_registry<R>(func: impl Fn(MutexGuard<'_, ThemeRegistry>) -> R) -> R {
+        let registry = THEMES.lock().unwrap();
+        func(registry)
+    }
+
     fn file_error(operation: &str) {
         Logger::info(format!("I was unable to {operation} in your repository").as_str());
         Logger::error("Please verify the permissions on your working directory or file a bug here");
@@ -120,15 +106,17 @@ impl Logger {
         exit(0);
     }
 
-    fn info_prefix() -> ColoredString {
-        format!("{}: ", *REGISTERED_NAME.lock().unwrap())
-            .bright_magenta()
-            .bold()
+    fn info_prefix() -> String {
+        Logger::with_theme(|theme| format!("{}: ", theme.prefix(&REGISTERED_NAME.lock().unwrap())))
     }
 
-    fn error_prefix() -> ColoredString {
-        format!("{}: ", *REGISTERED_NAME.lock().unwrap())
-            .red()
-            .bold()
+    fn error_prefix() -> String {
+        Logger::with_theme(|theme| {
+            format!("{}: ", theme.error_prefix(&REGISTERED_NAME.lock().unwrap()))
+        })
+    }
+
+    fn set_name(value: &str) {
+        *REGISTERED_NAME.lock().unwrap() = value.to_string();
     }
 }

package/internals/main.rs

@@ -3,6 +3,7 @@ use crate::{
     internal_filesystem::internal_filesystem::InternalFileSystem, repokit::repokit::RepoKit,
 };
 
+mod argv;
 mod configuration;
 mod executables;
 mod executor;
@@ -11,6 +12,7 @@ mod internal_commands;
 mod internal_filesystem;
 mod logger;
 mod repokit;
+mod themes;
 mod validations;
 
 fn main() {

package/internals/repokit/interfaces.rs

@@ -2,6 +2,8 @@ use std::collections::HashMap;
 
 use serde::Deserialize;
 
+use crate::themes::theme_inputs::RepoKitTheme;
+
 #[derive(Debug, Deserialize, Clone)]
 pub struct CommandDefinition {
     pub command: String,
@@ -33,6 +35,7 @@ pub struct RepoKitConfig {
     pub project: String,
     pub thirdParty: Vec<RepoKitCommand>,
     pub commands: HashMap<String, CommandDefinition>,
+    pub themes: Vec<RepoKitTheme>,
 }
 
 #[derive(Debug, Deserialize, Clone)]

package/internals/repokit/repokit.rs

@@ -11,6 +11,7 @@ use crate::{
     },
     executor::executor::Executor,
     internal_commands::help::Help,
+    internal_filesystem::internal_filesystem::InternalFileSystem,
     logger::logger::Logger,
     repokit::interfaces::{RepoKitCommand, RepoKitConfig},
     validations::command_validations::CommandValidations,
@@ -22,7 +23,9 @@ pub struct RepoKit {
 
 impl RepoKit {
     pub fn new(root: String, configuration: RepoKitConfig) -> RepoKit {
-        Logger::set_name(&configuration.project);
+        Logger::configure(&configuration);
+        let theme = InternalFileSystem::new(&root).read_theme_preference();
+        Logger::with_registry(|mut registry| registry.set_theme(&root, &theme));
         RepoKit {
             scope: RepoKitScope {
                 root,
@@ -113,7 +116,7 @@ impl RepoKit {
         Logger::info(
             format!(
                 "I'm not aware of a command named {}",
-                Logger::blue_bright(command)
+                Logger::with_theme(|theme| theme.highlight(command))
             )
             .as_str(),
         );
@@ -123,15 +126,15 @@ impl RepoKit {
         Logger::info(
             format!(
                 "The command {} was not found on {}",
-                Logger::blue_bright(sub_command),
-                Logger::blue_bright(&command.name)
+                Logger::with_theme(|theme| theme.highlight(sub_command)),
+                Logger::with_theme(|theme| theme.highlight(&command.name))
             )
             .as_str(),
         );
         Logger::info(
             format!(
                 "Here are the commands that belong to {}",
-                Logger::blue_bright(&command.name)
+                Logger::with_theme(|theme| theme.highlight(&command.name))
             )
             .as_str(),
         );
@@ -142,7 +145,7 @@ impl RepoKit {
         Logger::info(
             format!(
                 "Listing available commands for {}\n",
-                Logger::blue(&command.name)
+                Logger::with_theme(|theme| theme.command(&command.name))
             )
             .as_str(),
         );

package/internals/themes/built_in_themes/mod.rs

@@ -0,0 +1,3 @@
+pub mod money;
+pub mod seeing_red;
+pub mod the_blues;

package/internals/themes/built_in_themes/money.rs

@@ -0,0 +1,41 @@
+use colored::Color;
+
+use crate::themes::theme_colors::ThemeColors;
+
+pub const MONEY: ThemeColors = ThemeColors {
+    prefixColor: Color::TrueColor {
+        r: 26,
+        g: 227,
+        b: 133,
+    },
+    commandColor: Color::TrueColor {
+        r: 82,
+        g: 234,
+        b: 74,
+    },
+    subcommandColor: Color::TrueColor {
+        r: 51,
+        g: 241,
+        b: 162,
+    },
+    argColor: Color::TrueColor {
+        r: 124,
+        g: 244,
+        b: 102,
+    },
+    descriptionColor: Color::TrueColor {
+        r: 126,
+        g: 168,
+        b: 140,
+    },
+    errorPrefixColor: Color::TrueColor {
+        r: 220,
+        g: 36,
+        b: 100,
+    },
+    highlightColor: Color::TrueColor {
+        r: 25,
+        g: 206,
+        b: 91,
+    },
+};

package/internals/themes/built_in_themes/seeing_red.rs

@@ -0,0 +1,41 @@
+use colored::Color;
+
+use crate::themes::theme_colors::ThemeColors;
+
+pub const SEEING_RED: ThemeColors = ThemeColors {
+    prefixColor: Color::TrueColor {
+        r: 220,
+        g: 36,
+        b: 91,
+    },
+    commandColor: Color::TrueColor {
+        r: 220,
+        g: 36,
+        b: 36,
+    },
+    subcommandColor: Color::TrueColor {
+        r: 220,
+        g: 131,
+        b: 36,
+    },
+    argColor: Color::TrueColor {
+        r: 220,
+        g: 205,
+        b: 36,
+    },
+    descriptionColor: Color::TrueColor {
+        r: 179,
+        g: 100,
+        b: 151,
+    },
+    errorPrefixColor: Color::TrueColor {
+        r: 220,
+        g: 36,
+        b: 39,
+    },
+    highlightColor: Color::TrueColor {
+        r: 237,
+        g: 175,
+        b: 41,
+    },
+};

package/internals/themes/built_in_themes/the_blues.rs

@@ -0,0 +1,41 @@
+use colored::Color;
+
+use crate::themes::theme_colors::ThemeColors;
+
+pub const THE_BLUES: ThemeColors = ThemeColors {
+    prefixColor: Color::TrueColor {
+        r: 36,
+        g: 111,
+        b: 255,
+    },
+    commandColor: Color::TrueColor {
+        r: 52,
+        g: 96,
+        b: 255,
+    },
+    subcommandColor: Color::TrueColor {
+        r: 0,
+        g: 157,
+        b: 255,
+    },
+    argColor: Color::TrueColor {
+        r: 40,
+        g: 175,
+        b: 253,
+    },
+    descriptionColor: Color::TrueColor {
+        r: 100,
+        g: 165,
+        b: 179,
+    },
+    errorPrefixColor: Color::TrueColor {
+        r: 220,
+        g: 36,
+        b: 100,
+    },
+    highlightColor: Color::TrueColor {
+        r: 69,
+        g: 219,
+        b: 229,
+    },
+};

package/internals/themes/mod.rs

@@ -0,0 +1,5 @@
+pub mod built_in_themes;
+pub mod theme;
+pub mod theme_colors;
+pub mod theme_inputs;
+pub mod theme_registry;

package/internals/themes/theme.rs

@@ -0,0 +1,108 @@
+use colored::{Color, ColoredString, Colorize};
+
+use crate::themes::{
+    theme_colors::ThemeColors,
+    theme_inputs::{RepoKitTheme, ThemeInput, ThemeInputColors},
+};
+
+#[derive(Clone)]
+pub struct Theme {
+    pub name: String,
+    pub colors: ThemeColors,
+}
+
+impl Theme {
+    pub fn new(input: ThemeInput) -> Theme {
+        Theme {
+            name: input.name,
+            colors: ThemeColors {
+                prefixColor: input.colors.prefixColor.unwrap_or(Color::BrightMagenta),
+                commandColor: input.colors.commandColor.unwrap_or(Color::BrightBlue),
+                subcommandColor: input.colors.subcommandColor.unwrap_or(Color::TrueColor {
+                    r: 175,
+                    g: 247,
+                    b: 7,
+                }),
+                argColor: input.colors.argColor.unwrap_or(Color::Green),
+                descriptionColor: input.colors.descriptionColor.unwrap_or(Color::TrueColor {
+                    r: 128,
+                    g: 128,
+                    b: 128,
+                }),
+                errorPrefixColor: input.colors.errorPrefixColor.unwrap_or(Color::Red),
+                highlightColor: input.colors.highlightColor.unwrap_or(Color::BrightBlue),
+            },
+        }
+    }
+
+    pub fn prefix(&self, msg: &str) -> ColoredString {
+        msg.color(self.colors.prefixColor).bold()
+    }
+
+    pub fn command(&self, msg: &str) -> ColoredString {
+        msg.color(self.colors.commandColor)
+    }
+
+    pub fn sub_command(&self, msg: &str) -> ColoredString {
+        msg.color(self.colors.subcommandColor)
+    }
+
+    pub fn arg(&self, msg: &str) -> ColoredString {
+        msg.color(self.colors.argColor)
+    }
+
+    pub fn description(&self, msg: &str) -> ColoredString {
+        msg.color(self.colors.descriptionColor)
+    }
+
+    pub fn error_prefix(&self, msg: &str) -> ColoredString {
+        msg.color(self.colors.errorPrefixColor).bold()
+    }
+
+    pub fn highlight(&self, msg: &str) -> ColoredString {
+        msg.color(self.colors.highlightColor)
+    }
+
+    pub fn from_configuration(theme: &RepoKitTheme) -> Theme {
+        Theme::new(ThemeInput {
+            name: theme.name.clone(),
+            colors: ThemeInputColors {
+                prefixColor: Theme::parse_rgb(&theme.colors.prefixColor),
+                commandColor: Theme::parse_rgb(&theme.colors.commandColor),
+                subcommandColor: Theme::parse_rgb(&theme.colors.subcommandColor),
+                argColor: Theme::parse_rgb(&theme.colors.argColor),
+                descriptionColor: Theme::parse_rgb(&theme.colors.descriptionColor),
+                errorPrefixColor: Theme::parse_rgb(&theme.colors.errorPrefixColor),
+                highlightColor: Theme::parse_rgb(&theme.colors.highlightColor),
+            },
+        })
+    }
+
+    fn parse_rgb(rgb_str: &Option<String>) -> Option<Color> {
+        match rgb_str {
+            Some(rgb) => {
+                let trimmed = rgb
+                    .strip_prefix("rgb(")
+                    .and_then(|s| s.strip_suffix(')'))
+                    .map(|s| s.trim())?;
+
+                // 2. Split the remaining string by commas.
+                let parts: Vec<&str> = trimmed.split(',').collect();
+
+                if parts.len() == 3 {
+                    // 3. Trim whitespace from each part and parse to a u8.
+                    //    `.parse()` returns a `Result`, so we use `.ok()` to convert to an `Option`,
+                    //    and the `?` operator to return early if any parse fails.
+                    let r = parts[0].trim().parse::<u8>().ok()?;
+                    let g = parts[1].trim().parse::<u8>().ok()?;
+                    let b = parts[2].trim().parse::<u8>().ok()?;
+
+                    Some(Color::TrueColor { r, g, b })
+                } else {
+                    None
+                }
+            }
+            None => None,
+        }
+    }
+}

package/internals/themes/theme_colors.rs

@@ -0,0 +1,36 @@
+use colored::Color;
+
+use crate::themes::theme_inputs::ThemeInputColors;
+
+#[derive(Clone)]
+pub struct ThemeColors {
+    pub prefixColor: Color,
+    pub commandColor: Color,
+    pub subcommandColor: Color,
+    pub argColor: Color,
+    pub descriptionColor: Color,
+    pub errorPrefixColor: Color,
+    pub highlightColor: Color,
+}
+
+impl ThemeColors {
+    pub fn from_options(input: ThemeInputColors) -> ThemeColors {
+        ThemeColors {
+            prefixColor: input.prefixColor.unwrap_or(Color::BrightMagenta),
+            commandColor: input.commandColor.unwrap_or(Color::BrightBlue),
+            subcommandColor: input.subcommandColor.unwrap_or(Color::TrueColor {
+                r: 175,
+                g: 247,
+                b: 7,
+            }),
+            argColor: input.argColor.unwrap_or(Color::Green),
+            descriptionColor: input.descriptionColor.unwrap_or(Color::TrueColor {
+                r: 128,
+                g: 128,
+                b: 128,
+            }),
+            errorPrefixColor: input.errorPrefixColor.unwrap_or(Color::Red),
+            highlightColor: input.highlightColor.unwrap_or(Color::BrightBlue),
+        }
+    }
+}