@repokit/core 2.1.0 → 3.0.1

package/internals/argv/argv.rs

@@ -0,0 +1,133 @@
+use std::{collections::HashMap, env};
+
+use crate::logger::logger::Logger;
+
+#[derive(Clone)]
+pub enum ArgvType {
+    String,
+    Boolean,
+}
+
+#[derive(Clone)]
+pub struct ArgvOption {
+    pub value_type: ArgvType,
+    pub short: Option<String>,
+    pub name: String,
+    pub multiple: Option<bool>,
+}
+
+pub struct Argv {
+    pub values: HashMap<String, Vec<String>>,
+    lookup_table: HashMap<String, ArgvOption>,
+}
+
+impl Argv {
+    pub fn new(schema: Vec<ArgvOption>, args: Option<Vec<String>>) -> Argv {
+        let mut argv = Argv {
+            values: HashMap::new(),
+            lookup_table: Argv::build_option_table(&schema),
+        };
+        argv.parse(args);
+        argv
+    }
+
+    pub fn has(&self, key: &str) -> bool {
+        let fallback_bucket = Vec::new();
+        let values = self.values.get(key).unwrap_or(&fallback_bucket);
+        !values.is_empty()
+    }
+
+    pub fn get_first(&self, key: &str) -> String {
+        let fallback_bucket = Vec::new();
+        let values = self.values.get(key).unwrap_or(&fallback_bucket);
+        if values.is_empty() {
+            return "".to_string();
+        }
+        values[0].clone()
+    }
+
+    pub fn get_all(&mut self, key: &str) -> &mut Vec<String> {
+        self.values.entry(key.to_string()).or_default()
+    }
+
+    fn parse(&mut self, argv: Option<Vec<String>>) {
+        let args = argv.unwrap_or(env::args().collect());
+        let mut pointer = 0;
+        let length = args.len();
+        while pointer < length {
+            let arg = &args[pointer];
+            if self.lookup_table.contains_key(arg) {
+                let schema = self.lookup_table.get(arg).expect("arg exists");
+                let values = self.values.entry(schema.name.to_string()).or_default();
+                match schema.value_type {
+                    ArgvType::Boolean => {
+                        values.push("1".to_string());
+                        pointer += 1;
+                        continue;
+                    }
+                    ArgvType::String => {
+                        let mut current = pointer + 1;
+                        while current < length {
+                            let value = &args[current];
+                            if self.lookup_table.contains_key(value) {
+                                break;
+                            }
+                            if values.len() == 1
+                                && (schema.multiple.is_none()
+                                    || schema.multiple.is_some_and(|v| !v))
+                            {
+                                Logger::error(
+                                    format!(
+                                        "Recived more than one value for the option {}",
+                                        Logger::with_theme(|theme| theme.highlight(&schema.name))
+                                    )
+                                    .as_str(),
+                                );
+                            }
+                            values.push(value.to_string());
+                            current += 1;
+                        }
+                    }
+                }
+            }
+            pointer += 1;
+        }
+    }
+
+    fn build_option_table(options: &Vec<ArgvOption>) -> HashMap<String, ArgvOption> {
+        let mut table: HashMap<String, ArgvOption> = HashMap::new();
+        for option in options {
+            if option.name.len() < 2 {
+                Logger::exit_with_error("Option names must be at least 2 characters");
+            }
+            let first_char = option
+                .name
+                .chars()
+                .next()
+                .expect("already checked for emptiness")
+                .to_string();
+            let short_flag = option.short.as_ref().unwrap_or(&first_char);
+            let flags = [format!("--{}", option.name), format!("-{}", short_flag)];
+            for flag in flags {
+                if table.contains_key(&flag) {
+                    Logger::error(
+                        format!(
+                            "I encountered the flag {} more than once.",
+                            Logger::with_theme(|theme| theme.highlight(&flag)),
+                        )
+                        .as_str(),
+                    );
+                    Logger::error(
+                        format!(
+                            "Short flags will default to the first letter of the option's name. If two options begin with the same letter, please specify the {} option for one of them.",
+                            Logger::with_theme(|theme| theme.highlight("short")),
+                        )
+                        .as_str(),
+                    );
+                }
+                table.insert(flag, option.clone());
+            }
+        }
+        table
+    }
+}

package/internals/argv/mod.rs

@@ -0,0 +1 @@
+pub mod argv;

package/internals/internal_commands/help.rs

@@ -101,13 +101,13 @@ impl Help {
         if root_commands.is_empty() {
             return;
         }
-        let sorted_commands = Help::sort_root_commands(root_commands);
         Logger::info("Project Level Commands:");
-        println!();
-        for command in sorted_commands {
-            Help::log_root_command(&command);
-        }
-        println!();
+        Logger::with_surrounding_space(|| {
+            let sorted_commands = Help::sort_root_commands(root_commands);
+            for command in sorted_commands {
+                Help::log_root_command(&command);
+            }
+        });
     }
 
     pub fn log_external_commands(externals: &HashMap<String, RepoKitCommand>) {

package/internals/internal_commands/internal_registry.rs

@@ -5,9 +5,9 @@ use crate::{
         intenal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
     },
     internal_commands::{
-        list_commands::ListCommands, list_owners::ListOwners, locate_command::LocateCommand,
-        onboarder::Onboarder, register_command::RegisterCommand, search_commands::SearchCommands,
-        upgrade_repokit::UpgradeRepoKit,
+        list_commands::ListCommands, list_owners::ListOwners, list_themes::ListThemes,
+        locate_command::LocateCommand, onboarder::Onboarder, register_command::RegisterCommand,
+        search_commands::SearchCommands, upgrade_repokit::UpgradeRepoKit,
     },
 };
 
@@ -23,7 +23,7 @@ impl InternalRegistry {
     }
 
     pub fn get_all(&self) -> HashMap<String, Box<dyn InternalExecutable>> {
-        let internals: [Box<dyn InternalExecutable>; 7] = [
+        let internals: [Box<dyn InternalExecutable>; 8] = [
             Box::new(Onboarder::new(&self.scope)),
             Box::new(ListCommands::new(&self.scope)),
             Box::new(SearchCommands::new(&self.scope)),
@@ -31,6 +31,7 @@ impl InternalRegistry {
             Box::new(LocateCommand::new(&self.scope)),
             Box::new(RegisterCommand::new(&self.scope)),
             Box::new(UpgradeRepoKit::new(&self.scope)),
+            Box::new(ListThemes::new(&self.scope)),
         ];
         HashMap::from(internals.map(|x| (x.get_definition().name.to_string(), x)))
     }

package/internals/internal_commands/list_owners.rs

@@ -51,17 +51,17 @@ impl InternalExecutable for ListOwners {
         if owners.is_empty() {
             return Logger::exit_with_info("No owners found");
         }
-        println!();
         let mut list: Vec<String> = owners.into_iter().collect();
-        sort_str_slice(&mut list);
-        for (index, owner) in list.iter().enumerate() {
-            println!(
-                "{}{}",
-                Logger::indent(None),
-                Logger::cyan(format!("{}. {}", index + 1, &owner).as_str()),
-            );
-        }
-        println!();
+        Logger::with_surrounding_space(|| {
+            sort_str_slice(&mut list);
+            for (index, owner) in list.iter().enumerate() {
+                println!(
+                    "{}{}",
+                    Logger::indent(None),
+                    Logger::cyan(format!("{}. {}", index + 1, &owner).as_str()),
+                );
+            }
+        });
     }
 
     fn help(&self) {

package/internals/internal_commands/list_themes.rs

@@ -0,0 +1,113 @@
+use std::collections::HashMap;
+
+use alphanumeric_sort::sort_str_slice;
+use colored::Colorize;
+
+use crate::{
+    argv::argv::{Argv, ArgvOption, ArgvType},
+    executables::{
+        intenal_executable::InternalExecutable,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
+        },
+    },
+    internal_commands::help::Help,
+    logger::logger::Logger,
+};
+
+pub struct ListThemes {
+    pub scope: RepoKitScope,
+    pub definition: InternalExecutableDefinition,
+}
+
+impl ListThemes {
+    pub fn new(scope: &RepoKitScope) -> ListThemes {
+        ListThemes {
+            scope: scope.clone(),
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
+                name: "themes",
+                description: "Lists your repositories available themes",
+                args: [(
+                    "(--set | -s)",
+                    "An optional flag allowing you to set your theme",
+                )],
+            }),
+        }
+    }
+
+    fn list_themes(&self) {
+        Logger::info("Listing available themes");
+        let themes = Logger::with_registry(|registry| registry.themes.clone());
+        let current_theme = Logger::with_theme(|theme| theme.name.clone());
+        let mut keys: Vec<&String> = themes.keys().collect();
+        sort_str_slice(&mut keys);
+        Logger::with_surrounding_space(|| {
+            let mut pointer = 1;
+            for name in &keys {
+                let mut post_fix = "";
+                let is_active_theme = name.as_str() == current_theme;
+                if is_active_theme {
+                    post_fix = " <--- selected";
+                }
+                println!(
+                    "{}{}{}",
+                    Logger::indent(None),
+                    Logger::with_theme(|theme| {
+                        let name_text = if is_active_theme {
+                            theme.highlight(name).bold()
+                        } else {
+                            theme.highlight(name)
+                        };
+                        format!("{}. {}", pointer.to_string().as_str(), name_text)
+                    }),
+                    post_fix
+                );
+                pointer += 1;
+            }
+        });
+    }
+}
+
+impl InternalExecutable for ListThemes {
+    fn run(&self, args: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
+        let argv = Argv::new(
+            vec![ArgvOption {
+                name: "set".to_string(),
+                value_type: ArgvType::String,
+                short: None,
+                multiple: None,
+            }],
+            Some(args),
+        );
+        if !argv.has("set") {
+            return self.list_themes();
+        }
+        let desired_theme = argv.get_first("set");
+        if Logger::with_registry(|registry| !registry.has(&desired_theme)) {
+            Logger::error(
+                format!(
+                    "I'm not aware of a theme named {}",
+                    Logger::with_theme(|theme| theme.highlight(&desired_theme))
+                )
+                .as_str(),
+            );
+            return self.list_themes();
+        }
+        Logger::with_registry(|mut registry| registry.set_theme(&self.scope.root, &desired_theme));
+        Logger::info(
+            format!(
+                "Your theme has been set to {}",
+                Logger::with_theme(|theme| theme.highlight(&desired_theme))
+            )
+            .as_str(),
+        );
+    }
+
+    fn help(&self) {
+        Help::log_internal_command(&self.definition);
+    }
+
+    fn get_definition(&self) -> &InternalExecutableDefinition {
+        &self.definition
+    }
+}

package/internals/internal_commands/mod.rs

@@ -2,6 +2,7 @@ pub mod help;
 pub mod internal_registry;
 pub mod list_commands;
 pub mod list_owners;
+pub mod list_themes;
 pub mod locate_command;
 pub mod onboarder;
 pub mod register_command;

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},
 };
 
@@ -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

@@ -38,10 +38,27 @@ impl Logger {
         exit(0);
     }
 
+    pub fn list(items: &[&str], indentation: Option<i32>) {
+        Logger::with_surrounding_space(|| {
+            let mut pointer = 0;
+            for item in items {
+                println!("{}{}. {}", Logger::indent(indentation), pointer + 1, item);
+                pointer += 1
+            }
+        })
+    }
+
     pub fn space_around(message: &str) {
         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",
@@ -80,7 +97,7 @@ impl Logger {
     }
 
     pub fn with_theme<R>(func: impl Fn(&Theme) -> R) -> R {
-        Logger::with_registry(|registry| func(&registry.theme))
+        Logger::with_registry(|registry| func(registry.current_theme()))
     }
 
     pub fn with_registry<R>(func: impl Fn(MutexGuard<'_, ThemeRegistry>) -> R) -> R {

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;

package/internals/repokit/interfaces.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use serde::Deserialize;
 
-use crate::themes::theme::RepoKitTheme;
+use crate::themes::theme_inputs::RepoKitTheme;
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct CommandDefinition {
@@ -35,7 +35,7 @@ pub struct RepoKitConfig {
     pub project: String,
     pub thirdParty: Vec<RepoKitCommand>,
     pub commands: HashMap<String, CommandDefinition>,
-    pub theme: Option<RepoKitTheme>,
+    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,
@@ -23,9 +24,11 @@ pub struct RepoKit {
 impl RepoKit {
     pub fn new(root: String, configuration: RepoKitConfig) -> RepoKit {
         Logger::set_name(&configuration.project);
-        if let Some(theme) = &configuration.theme {
-            Logger::with_registry(|mut registry| registry.register(theme))
+        for theme in &configuration.themes {
+            Logger::with_registry(|mut registry| registry.register_user_theme(theme))
         }
+        let theme = InternalFileSystem::new(&root).read_theme_preference();
+        Logger::with_registry(|mut registry| registry.set_theme(&root, &theme));
         RepoKit {
             scope: RepoKitScope {
                 root,

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,
+    },
+};