@repokit/core 2.0.7 → 3.0.0

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/configuration/configuration.rs

@@ -15,7 +15,7 @@ impl Configuration {
             Logger::info(
                 format!(
                     "I found a Repokit configuration without an exported {} instance",
-                    Logger::blue("RepokitConfig")
+                    Logger::with_theme(|theme| theme.highlight("RepokitConfig"))
                 )
                 .as_str(),
             );
@@ -29,7 +29,7 @@ impl Configuration {
         Logger::info(
             format!(
                 "Please fill out this file with your desired settings. Then run {}",
-                Logger::blue_bright("repokit onboard")
+                Logger::with_theme(|theme| theme.highlight("repokit onboard"))
             )
             .as_str(),
         );

package/internals/internal_commands/help.rs

@@ -25,52 +25,62 @@ impl Help {
     }
 
     pub fn log_internal_command(command: &InternalExecutableDefinition) {
-        println!(
-            "{}{} {}",
-            Logger::indent(Some(3)),
-            Logger::blue(&command.name),
-            Logger::gray(&command.description),
-        );
+        Logger::with_theme(|theme| {
+            println!(
+                "{}{} {}",
+                Logger::indent(Some(3)),
+                theme.command(&command.name),
+                theme.description(&command.description),
+            );
+        });
         Help::log_args(&command.args, None);
     }
 
     pub fn log_root_command(command: &RootCommand) {
-        println!(
-            "{}{} {}",
-            Logger::indent(Some(3)),
-            Logger::blue(&command.name),
-            Logger::gray(&command.description),
-        );
+        Logger::with_theme(|theme| {
+            println!(
+                "{}{} {}",
+                Logger::indent(Some(3)),
+                theme.command(&command.name),
+                theme.description(&command.description),
+            );
+        });
         Help::log_args(&command.args, None)
     }
 
     pub fn log_external_command(command: &RepoKitCommand) {
-        println!(
-            "{}{} {}",
-            Logger::indent(Some(3)),
-            Logger::blue(&command.name),
-            Logger::gray(&command.description),
-        );
+        Logger::with_theme(|theme| {
+            println!(
+                "{}{} {}",
+                Logger::indent(Some(3)),
+                theme.command(&command.name),
+                theme.description(&command.description),
+            );
+        });
         println!();
         Help::log_external_subcommands(&command.commands, 6);
         if !command.owner.is_empty() {
-            println!(
-                "\n{}{}{}",
-                Logger::indent(Some(9)),
-                Logger::gray("Owned by: "),
-                Logger::cyan(&command.owner),
-            );
+            Logger::with_theme(|theme| {
+                println!(
+                    "\n{}{}{}",
+                    Logger::indent(Some(9)),
+                    theme.description("Owned by: "),
+                    Logger::cyan(&command.owner),
+                );
+            });
         }
     }
 
     pub fn log_external_subcommands(map: &HashMap<String, CommandDefinition>, indentation: i32) {
         for (name, command) in map {
-            println!(
-                "{}{}{}",
-                Logger::indent(Some(indentation)),
-                Logger::lime(format!("{}: ", name).as_str()),
-                Logger::gray(&command.description),
-            );
+            Logger::with_theme(|theme| {
+                println!(
+                    "{}{}: {}",
+                    Logger::indent(Some(indentation)),
+                    theme.sub_command(name),
+                    theme.description(&command.description),
+                );
+            });
             Help::log_args(&command.args, Some(indentation + 3));
         }
     }
@@ -91,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>) {
@@ -114,16 +124,18 @@ impl Help {
     }
 
     fn log_args(map: &Option<HashMap<String, String>>, indentation: Option<i32>) {
-        if let Some(args) = map {
-            for (name, description) in args {
-                println!(
-                    "{}{}{}",
-                    Logger::indent(Some(indentation.unwrap_or(6))),
-                    Logger::green(name.as_str()),
-                    Logger::gray(format!(" {}", description).as_str()),
-                );
+        Logger::with_theme(|theme| {
+            if let Some(args) = map {
+                for (name, description) in args {
+                    println!(
+                        "{}{} {}",
+                        Logger::indent(Some(indentation.unwrap_or(6))),
+                        theme.arg(name),
+                        theme.description(description)
+                    );
+                }
             }
-        }
+        });
     }
 
     fn sort_internal(

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_commands.rs

@@ -31,7 +31,7 @@ impl ListCommands {
                     "<scope>",
                     format!(
                         "The scope of the commands you wish to list. Specify one of {}",
-                        Logger::blue(SCOPES.join(" | ").as_str())
+                        Logger::with_theme(|theme| theme.highlight(SCOPES.join(" | ").as_str()))
                     )
                     .as_str(),
                 )],
@@ -48,7 +48,7 @@ impl ListCommands {
         Logger::exit_with_info(
             format!(
                 "Please specify a scope to list the commands of. Select one of {}",
-                Logger::blue_bright(SCOPES.join(" | ").as_str())
+                Logger::with_theme(|theme| theme.highlight(SCOPES.join(" | ").as_str()))
             )
             .as_str(),
         );
@@ -88,7 +88,7 @@ impl InternalExecutable for ListCommands {
             Logger::exit_with_info(
                 format!(
                     "I could not find any commands matching {}",
-                    Logger::blue_bright(&full_query)
+                    Logger::with_theme(|theme| theme.highlight(&full_query))
                 )
                 .as_str(),
             );

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/locate_command.rs

@@ -54,13 +54,19 @@ impl InternalExecutable for LocateCommand {
             Logger::exit_with_info("Please specify a command to locate");
         }
         let command = &args[0];
-        Logger::info(format!("Locating a command named {}", Logger::blue_bright(command)).as_str());
+        Logger::info(
+            format!(
+                "Locating a command named {}",
+                Logger::with_theme(|theme| theme.highlight(command))
+            )
+            .as_str(),
+        );
         self.search_externals(command);
         self.search_root(command);
         Logger::exit_with_error(
             format!(
                 "I could not find a command named {}",
-                Logger::blue_bright(command)
+                Logger::with_theme(|theme| theme.highlight(command))
             )
             .as_str(),
         );

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_commands/onboarder.rs

@@ -31,12 +31,18 @@ impl Onboarder {
 
 impl InternalExecutable for Onboarder {
     fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
-        Logger::info(format!("Welcome to {}", Logger::blue_bright("Repokit")).as_str());
+        Logger::info(
+            format!(
+                "Welcome to {}",
+                Logger::with_theme(|theme| theme.highlight("Repokit"))
+            )
+            .as_str(),
+        );
         Logger::info(
             "Repokit is a tool designed to self-document and publish developer facing workflows in a single CLI",
         );
         Logger::info(
-            format!("As you develop new features in your codebase, you can publish commands, API's, and tools to the {} CLI by running", Logger::blue_bright("Repokit")).as_str()
+            format!("As you develop new features in your codebase, you can publish commands, API's, and tools to the {} CLI by running", Logger::with_theme(|theme|theme.highlight("Repokit"))).as_str()
         );
         Logger::log_file_path("repokit register ./path/to/your-feature");
         Logger::info(
@@ -45,12 +51,12 @@ impl InternalExecutable for Onboarder {
         Logger::info(
             format!(
                 "The {} CLI will automatically detect these files and add them to its toolchain",
-                Logger::blue_bright("Repokit")
+                Logger::with_theme(|theme| theme.highlight("Repokit"))
             )
             .as_str(),
         );
         Logger::info(
-            format!("As your codebase grows, your {} CLI will continue to track all of the published workflows created by your team", Logger::blue_bright("Repokit")).as_str()
+            format!("As your codebase grows, your {} CLI will continue to track all of the published workflows created by your team", Logger::with_theme(|theme|theme.highlight("Repokit"))).as_str()
         );
         Logger::space_around("It's your living source of knowledge and documentation");
     }

package/internals/internal_commands/register_command.rs

@@ -50,7 +50,7 @@ impl RegisterCommand {
             Logger::info(
                 format!(
                     "Creating the path {} in your file system",
-                    Logger::blue_bright(path_arg.as_str())
+                    Logger::with_theme(|theme| theme.highlight(path_arg.as_str()))
                 )
                 .as_str(),
             );
@@ -64,13 +64,13 @@ impl RegisterCommand {
             Logger::error(
                 format!(
                     "A {} file already exists in this directory",
-                    Logger::blue_bright("Commands.ts")
+                    Logger::with_theme(|theme| theme.highlight("Commands.ts"))
                 )
                 .as_str(),
             );
             Logger::info(format!(
                 "You can append additional commands to the existing {} instance or export another one",
-                Logger::blue_bright("RepoKitCommand")
+                Logger::with_theme(|theme| theme.highlight("RepoKitCommand"))
             ).as_str());
             process::exit(0);
         }

package/internals/internal_commands/search_commands.rs

@@ -98,7 +98,7 @@ impl SearchCommands {
         Logger::info(
             format!(
                 "Matched {} command{} in your repokit config",
-                Logger::blue_bright(total.to_string().as_str()),
+                Logger::with_theme(|theme| theme.highlight(total.to_string().as_str())),
                 plural_appendage,
             )
             .as_str(),
@@ -124,7 +124,7 @@ impl SearchCommands {
         Logger::info(
             format!(
                 "Matched {} internal command{}",
-                Logger::blue_bright(total.to_string().as_str()),
+                Logger::with_theme(|theme| theme.highlight(total.to_string().as_str())),
                 plural_appendage,
             )
             .as_str(),
@@ -140,7 +140,7 @@ impl SearchCommands {
         Logger::info(
             format!(
                 "Matched {} registered command{}",
-                Logger::blue_bright(total.to_string().as_str()),
+                Logger::with_theme(|theme| theme.highlight(total.to_string().as_str())),
                 plural_appendage,
             )
             .as_str(),

package/internals/internal_commands/upgrade_repokit.rs

@@ -41,7 +41,11 @@ impl UpgradeRepoKit {
             let path = Path::new(&self.scope.root).join(lock_file).normalize();
             if path.exists() && path.is_file() {
                 Logger::info(
-                    format!("Detected {} installation", Logger::blue_bright(manager)).as_str(),
+                    format!(
+                        "Detected {} installation",
+                        Logger::with_theme(|theme| theme.highlight(manager))
+                    )
+                    .as_str(),
                 );
                 return command_prefix;
             }