@repokit/core 1.0.4 → 1.1.0

package/README.md

@@ -14,7 +14,7 @@ The Repokit CLI exists as a living source of documentation and knowledge - growi
 
 If you do not have node.js setup in your repository, you'll first want to install node.js.
 
-[NVM is a populat posix compliant installer](https://github.com/nvm-sh/nvm)
+[NVM is a popular posix compliant installer](https://github.com/nvm-sh/nvm)
 
 Once installed, you can run the following in the root of your repository
 

package/externals/types.ts

@@ -13,6 +13,7 @@ export interface IRepoKitCommand {
 export interface ICommand {
   command: string;
   description: string;
+  args?: Record<string, string>;
 }
 
 export interface ILocatedCommand extends IRepoKitCommand {

package/internals/executables/internal_executable_definition.rs

@@ -2,7 +2,39 @@ use std::collections::HashMap;
 
 #[derive(Clone)]
 pub struct InternalExecutableDefinition {
-    pub name: &'static str,
-    pub description: &'static str,
-    pub args: HashMap<&'static str, &'static str>,
+    pub name: String,
+    pub description: String,
+    pub args: Option<HashMap<String, String>>,
+}
+
+pub struct InternalExecutableDefinitionInput<'a, const N: usize> {
+    pub name: &'a str,
+    pub description: &'a str,
+    pub args: [(&'a str, &'a str); N],
+}
+
+impl InternalExecutableDefinition {
+    pub fn define<'a, const N: usize>(
+        definition: InternalExecutableDefinitionInput<N>,
+    ) -> InternalExecutableDefinition {
+        let InternalExecutableDefinitionInput {
+            name,
+            description,
+            args,
+        } = definition;
+        InternalExecutableDefinition {
+            name: String::from(name),
+            description: String::from(description),
+            args: InternalExecutableDefinition::args(args),
+        }
+    }
+
+    pub fn args<const N: usize>(tuples: [(&str, &str); N]) -> Option<HashMap<String, String>> {
+        if tuples.is_empty() {
+            return None;
+        }
+        Some(HashMap::from(tuples.map(|(key, value)| {
+            (String::from(key), String::from(value))
+        })))
+    }
 }

package/internals/external_commands/external_commands.rs

@@ -72,7 +72,7 @@ impl ExternalCommands {
         let reader: BufReader<File> = BufReader::new(file);
         for line_result in reader.lines() {
             let line: String = line_result.expect("line");
-            if line.contains("new RepoKitCommand(") {
+            if line.ends_with("\"@repokit/core\";") {
                 return true;
             }
         }

package/internals/internal_commands/help.rs

@@ -3,19 +3,19 @@ use std::collections::HashMap;
 use alphanumeric_sort::{sort_slice_by_str_key, sort_str_slice};
 
 use crate::{
-    repokit::interfaces::{Command, RepoKitCommand, ParsedCommand},
     executables::{
         intenal_executable::InternalExecutable,
         internal_executable_definition::InternalExecutableDefinition,
     },
     logger::logger::Logger,
+    repokit::interfaces::{CommandDefinition, RepoKitCommand, RootCommand},
 };
 
 pub struct Help;
 
 impl Help {
     pub fn list_all(
-        root_commands: &HashMap<String, Command>,
+        root_commands: &HashMap<String, CommandDefinition>,
         internals: &HashMap<String, Box<dyn InternalExecutable>>,
         externals: &HashMap<String, RepoKitCommand>,
     ) {
@@ -28,29 +28,31 @@ impl Help {
         println!(
             "{}{} {}",
             Logger::indent(Some(3)),
-            Logger::blue_bright(command.name),
-            Logger::gray(command.description),
+            Logger::blue(&command.name),
+            Logger::gray(&command.description),
         );
-        Help::print_args(&command.args);
+        Help::log_args(&command.args, None);
     }
 
-    pub fn log_root_command(command: &ParsedCommand) {
+    pub fn log_root_command(command: &RootCommand) {
         println!(
             "{}{} {}",
             Logger::indent(Some(3)),
             Logger::blue(&command.name),
             Logger::gray(&command.description),
         );
+        Help::log_args(&command.args, None)
     }
 
     pub fn log_external_command(command: &RepoKitCommand) {
         println!(
             "{}{} {}",
             Logger::indent(Some(3)),
-            Logger::blue_bright(&command.name),
+            Logger::blue(&command.name),
             Logger::gray(&command.description),
         );
-        Help::print_commands(&command.commands, Some(6));
+        println!();
+        Help::log_external_subcommands(&command.commands, 6);
         if !command.owner.is_empty() {
             println!(
                 "\n{}{}{}",
@@ -61,14 +63,15 @@ impl Help {
         }
     }
 
-    pub fn print_commands(map: &HashMap<String, Command>, indentation: Option<i32>) {
+    pub fn log_external_subcommands(map: &HashMap<String, CommandDefinition>, indentation: i32) {
         for (name, command) in map {
             println!(
                 "{}{}{}",
-                Logger::indent(indentation),
-                Logger::green(format!("{}: ", name).as_str()),
+                Logger::indent(Some(indentation)),
+                Logger::lime(format!("{}: ", name).as_str()),
                 Logger::gray(&command.description),
             );
+            Help::log_args(&command.args, Some(indentation + 3));
         }
     }
 
@@ -84,7 +87,7 @@ impl Help {
         }
     }
 
-    pub fn log_root_commands(root_commands: &HashMap<String, Command>) {
+    pub fn log_root_commands(root_commands: &HashMap<String, CommandDefinition>) {
         if root_commands.is_empty() {
             return;
         }
@@ -110,14 +113,16 @@ impl Help {
         }
     }
 
-    fn print_args(map: &HashMap<&'static str, &'static str>) {
-        for (name, description) in map {
-            println!(
-                "{}{}{}",
-                Logger::indent(Some(6)),
-                Logger::green(format!("{}: ", name).as_str()),
-                Logger::gray(description),
-            );
+    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()),
+                );
+            }
         }
     }
 
@@ -135,12 +140,12 @@ impl Help {
         vector
     }
 
-    fn sort_root_commands(commands: &HashMap<String, Command>) -> Vec<ParsedCommand> {
+    fn sort_root_commands(commands: &HashMap<String, CommandDefinition>) -> Vec<RootCommand> {
         let mut vector: Vec<&String> = (commands).keys().collect();
         sort_str_slice(&mut vector);
         vector
             .iter()
-            .map(|&name| ParsedCommand::from(name, commands.get(name).expect("known keys only")))
+            .map(|&name| RootCommand::from(name, commands.get(name).expect("known keys only")))
             .collect()
     }
 }

package/internals/internal_commands/list_commands.rs

@@ -1,13 +1,15 @@
 use std::collections::HashMap;
 
 use crate::{
-    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
+    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
     validations::command_validations::CommandValidations,
 };
 
@@ -24,18 +26,18 @@ impl ListCommands {
         ListCommands {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "list",
                 description: "List commands based on their scope of definition",
-                args: HashMap::from([(
+                args: [(
                     "<scope>",
                     format!(
                         "The scope of the commands you wish to list. Specify one of {}",
                         Logger::blue(SCOPES.join(" | ").as_str())
                     )
-                    .leak() as &'static str,
-                )]),
-            },
+                    .as_str(),
+                )],
+            }),
         }
     }
 

package/internals/internal_commands/list_owners.rs

@@ -5,7 +5,9 @@ use alphanumeric_sort::sort_str_slice;
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
@@ -24,11 +26,11 @@ impl ListOwners {
         ListOwners {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "owners",
                 description: "Lists all registered command owners",
-                args: HashMap::from([]),
-            },
+                args: [],
+            }),
         }
     }
 

package/internals/internal_commands/locate_command.rs

@@ -4,7 +4,9 @@ use std::{collections::HashMap, process::exit};
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     external_commands::external_commands::ExternalCommands,
     internal_commands::help::Help,
@@ -23,11 +25,11 @@ impl LocateCommand {
         LocateCommand {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "locate",
                 description: "Locates command definitions",
-                args: HashMap::from([("<name>", "The name of a registered command")]),
-            },
+                args: [("<name>", "The name of a registered command")],
+            }),
         }
     }
 

package/internals/internal_commands/onboarder.rs

@@ -3,7 +3,9 @@ use std::collections::HashMap;
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
@@ -21,11 +23,11 @@ impl Onboarder {
         Onboarder {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "onboard",
                 description: "Onboarding instructions for first time users",
-                args: HashMap::from([]),
-            },
+                args: [],
+            }),
         }
     }
 }

package/internals/internal_commands/register_command.rs

@@ -10,7 +10,9 @@ use std::{
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     internal_commands::help::Help,
     internal_filesystem::internal_filesystem::InternalFileSystem,
@@ -29,14 +31,14 @@ impl RegisterCommand {
         RegisterCommand {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "register",
                 description: "Creates new Repokit commands",
-                args: HashMap::from([(
+                args: [(
                     "<path>",
                     "A relative path to your preferred command location",
-                )]),
-            },
+                )],
+            }),
         }
     }
 

package/internals/internal_commands/search_commands.rs

@@ -2,13 +2,15 @@ use alphanumeric_sort::sort_slice_by_str_key;
 use std::collections::HashMap;
 
 use crate::{
-    repokit::interfaces::{Command, RepoKitCommand, RepoKitConfig},
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
+    repokit::interfaces::{CommandDefinition, RepoKitCommand, RepoKitConfig},
     validations::command_validations::CommandValidations,
 };
 
@@ -23,14 +25,14 @@ impl SearchCommands {
         SearchCommands {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "search",
                 description: "Retrieve commands that match any search query",
-                args: HashMap::from([(
+                args: [(
                     "<query>",
                     "A search string to match against command names, descriptions, arguments, or owner",
-                )]),
-            },
+                )],
+            }),
         }
     }
 
@@ -42,11 +44,16 @@ impl SearchCommands {
         if config.description.to_lowercase().contains(query) {
             return true;
         }
-        for (arg, description) in &config.args {
-            if arg.to_lowercase().contains(query) || description.to_lowercase().contains(query) {
-                return true;
+        if let Some(args) = &config.args {
+            for (arg, description) in args {
+                if arg.to_lowercase().contains(query)
+                    || description.to_lowercase().contains(query)
+                {
+                    return true;
+                }
             }
         }
+
         false
     }
 
@@ -76,7 +83,7 @@ impl SearchCommands {
         false
     }
 
-    fn search_command(&self, query: &str, command: &Command) -> bool {
+    fn search_command(&self, query: &str, command: &CommandDefinition) -> bool {
         if command.command.to_lowercase().contains(query)
             || command.description.to_lowercase().contains(query)
         {
@@ -85,7 +92,7 @@ impl SearchCommands {
         false
     }
 
-    fn log_root_results(&self, root_results: &HashMap<String, Command>) {
+    fn log_root_results(&self, root_results: &HashMap<String, CommandDefinition>) {
         let total = root_results.len();
         let plural_appendage = if total == 1 { "" } else { "s" };
         if !root_results.is_empty() {
@@ -153,7 +160,7 @@ impl InternalExecutable for SearchCommands {
         let query = args.join(" ").to_lowercase();
         let externals = CommandValidations::new(self.root.clone(), self.configuration.clone())
             .collect_and_validate_externals();
-        let mut root_results: HashMap<String, Command> = HashMap::new();
+        let mut root_results: HashMap<String, CommandDefinition> = HashMap::new();
         let mut internal_results: HashMap<String, &Box<dyn InternalExecutable>> = HashMap::new();
         let mut external_results: HashMap<String, RepoKitCommand> = HashMap::new();
         for (command, script) in &self.configuration.commands {

package/internals/internal_commands/upgrade_repokit.rs

@@ -4,7 +4,9 @@ use std::{collections::HashMap, path::Path, process::exit};
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     executor::executor::Executor,
     internal_commands::help::Help,
@@ -23,11 +25,11 @@ impl UpgradeRepoKit {
         UpgradeRepoKit {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "upgrade",
                 description: "Upgrades your installation of repokit to the latest stable version",
-                args: HashMap::from([]),
-            },
+                args: [],
+            }),
         }
     }
 

package/internals/logger/logger.rs

@@ -84,6 +84,14 @@ impl Logger {
         })
     }
 
+    pub fn lime(message: &str) -> ColoredString {
+        message.custom_color(CustomColor {
+            r: 175,
+            g: 247,
+            b: 7,
+        })
+    }
+
     fn info_prefix() -> ColoredString {
         format!("{}: ", *REGISTERED_NAME.lock().unwrap())
             .bright_magenta()

package/internals/repokit/interfaces.rs

@@ -3,22 +3,25 @@ use std::collections::HashMap;
 use serde::Deserialize;
 
 #[derive(Debug, Deserialize, Clone)]
-pub struct Command {
+pub struct CommandDefinition {
     pub command: String,
     pub description: String,
+    pub args: Option<HashMap<String, String>>,
 }
 
 #[derive(Debug, Deserialize, Clone)]
-pub struct ParsedCommand {
+pub struct RootCommand {
     pub name: String,
     pub command: String,
     pub description: String,
+    pub args: Option<HashMap<String, String>>,
 }
 
-impl ParsedCommand {
-    pub fn from(name: &str, command: &Command) -> ParsedCommand {
-        ParsedCommand {
+impl RootCommand {
+    pub fn from(name: &str, command: &CommandDefinition) -> RootCommand {
+        RootCommand {
             name: name.to_string(),
+            args: command.args.clone(),
             command: command.command.to_string(),
             description: command.description.to_string(),
         }
@@ -28,7 +31,7 @@ impl ParsedCommand {
 #[derive(Debug, Deserialize, Clone)]
 pub struct RepoKitConfig {
     pub project: String,
-    pub commands: HashMap<String, Command>,
+    pub commands: HashMap<String, CommandDefinition>,
 }
 
 #[derive(Debug, Deserialize, Clone)]
@@ -37,5 +40,5 @@ pub struct RepoKitCommand {
     pub owner: String,
     pub location: String,
     pub description: String,
-    pub commands: HashMap<String, Command>,
+    pub commands: HashMap<String, CommandDefinition>,
 }

package/internals/repokit/repokit.rs

@@ -125,17 +125,18 @@ impl RepoKit {
             )
             .as_str(),
         );
-        Help::print_commands(&command.commands, Some(3));
+        Help::log_external_subcommands(&command.commands, 3);
     }
 
     fn log_external_command(&self, command: &RepoKitCommand) {
         Logger::info(
             format!(
-                "Listing available commands for {}",
-                Logger::blue_bright(&command.name)
+                "Listing available commands for {}\n",
+                Logger::blue(&command.name)
             )
             .as_str(),
         );
-        Help::print_commands(&command.commands, Some(3))
+        Help::log_external_subcommands(&command.commands, 3);
+        println!();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "keywords": [
     "cli",
@@ -20,7 +20,7 @@
     "access": "public"
   },
   "scripts": {
-    "build:all": "yarn lint:ts && yarn lint:rust && yarn install:repokit",
+    "build:all": "yarn lint:ts && yarn lint:rust && yarn install:rust",
     "build:rust": "cargo build --release",
     "install:rust": "yarn build:rust && cargo install --path .",
     "lint:rust": "cargo clippy --fix --allow-dirty",