@repokit/core 3.0.6 → 4.0.0

package/internals/internal_commands/internal_registry.rs

@@ -1,9 +1,7 @@
 use std::collections::HashMap;
 
 use crate::{
-    executables::{
-        internal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
-    },
+    executables::internal_executable::InternalExecutable,
     internal_commands::{
         list_commands::ListCommands, list_owners::ListOwners, list_themes::ListThemes,
         list_version::ListVersion, locate_command::LocateCommand, onboarder::Onboarder,
@@ -12,28 +10,24 @@ use crate::{
     },
 };
 
-pub struct InternalRegistry {
-    scope: RepoKitScope,
-}
+pub struct InternalCommandRegistry;
 
-impl InternalRegistry {
-    pub fn new(scope: &RepoKitScope) -> InternalRegistry {
-        InternalRegistry {
-            scope: scope.clone(),
-        }
+impl InternalCommandRegistry {
+    pub fn new() -> InternalCommandRegistry {
+        InternalCommandRegistry {}
     }
 
     pub fn get_all(&self) -> HashMap<String, Box<dyn InternalExecutable>> {
         let internals: [Box<dyn InternalExecutable>; 9] = [
-            Box::new(Onboarder::new(&self.scope)),
-            Box::new(ListCommands::new(&self.scope)),
-            Box::new(SearchCommands::new(&self.scope)),
-            Box::new(ListOwners::new(&self.scope)),
-            Box::new(LocateCommand::new(&self.scope)),
-            Box::new(RegisterCommand::new(&self.scope)),
-            Box::new(UpgradeRepoKit::new(&self.scope)),
-            Box::new(ListThemes::new(&self.scope)),
-            Box::new(ListVersion::new(&self.scope)),
+            Box::new(Onboarder::new()),
+            Box::new(ListCommands::new()),
+            Box::new(SearchCommands::new()),
+            Box::new(ListOwners::new()),
+            Box::new(LocateCommand::new()),
+            Box::new(RegisterCommand::new()),
+            Box::new(UpgradeRepoKit::new()),
+            Box::new(ListThemes::new()),
+            Box::new(ListVersion::new()),
         ];
         HashMap::from(internals.map(|x| (x.get_definition().name.to_string(), x)))
     }

package/internals/internal_commands/list_commands.rs

@@ -4,26 +4,24 @@ use crate::{
     executables::{
         internal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
         },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::repokit_command::RepoKitCommand,
+    repokit::{repokit_command::RepoKitCommand, repokit_runtime::RepoKitRuntime},
     validations::command_validations::CommandValidations,
 };
 
 pub struct ListCommands {
-    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 static SCOPES: [&str; 4] = ["internal", "registered", "root", "<owner>"];
 
 impl ListCommands {
-    pub fn new(scope: &RepoKitScope) -> ListCommands {
+    pub fn new() -> ListCommands {
         ListCommands {
-            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "list",
                 description: "List commands based on their scope of definition",
@@ -39,11 +37,6 @@ impl ListCommands {
         }
     }
 
-    fn collect_registered_commands(&self) -> HashMap<String, RepoKitCommand> {
-        let validators = CommandValidations::new(&self.scope);
-        validators.collect_and_validate_externals()
-    }
-
     fn exit_on_invalid_scope(&self) {
         Logger::exit_with_info(
             format!(
@@ -66,9 +59,11 @@ impl InternalExecutable for ListCommands {
             return Help::log_internal_commands(internals);
         }
         if scope == SCOPES[2] {
-            return Help::log_root_commands(&self.scope.configuration.commands);
+            return RepoKitRuntime::with_runtime(|runtime| {
+                Help::log_root_commands(&runtime.configuration.commands)
+            });
         }
-        let registered_commands = self.collect_registered_commands();
+        let registered_commands = CommandValidations::collect_and_validate_externals();
         if scope == SCOPES[1] {
             return Help::log_external_commands(&registered_commands);
         }
@@ -96,10 +91,6 @@ impl InternalExecutable for ListCommands {
         Help::log_external_commands(&matches);
     }
 
-    fn help(&self) {
-        Help::log_internal_command(&self.definition);
-    }
-
     fn get_definition(&self) -> &InternalExecutableDefinition {
         &self.definition
     }

package/internals/internal_commands/list_owners.rs

@@ -6,24 +6,20 @@ use crate::{
     executables::{
         internal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
         },
     },
-    internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::repokit_command::RepoKitCommand,
     validations::command_validations::CommandValidations,
 };
 
 pub struct ListOwners {
-    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl ListOwners {
-    pub fn new(scope: &RepoKitScope) -> ListOwners {
+    pub fn new() -> ListOwners {
         ListOwners {
-            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "owners",
                 description: "Lists all registered command owners",
@@ -31,16 +27,11 @@ impl ListOwners {
             }),
         }
     }
-
-    fn collect_registered_commands(&self) -> HashMap<String, RepoKitCommand> {
-        let validators = CommandValidations::new(&self.scope);
-        validators.collect_and_validate_externals()
-    }
 }
 
 impl InternalExecutable for ListOwners {
     fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
-        let registered_commands = self.collect_registered_commands();
+        let registered_commands = CommandValidations::collect_and_validate_externals();
         Logger::info("Listing all command owners");
         let mut owners: HashSet<String> = HashSet::new();
         for (_, command) in registered_commands {
@@ -64,10 +55,6 @@ impl InternalExecutable for ListOwners {
         });
     }
 
-    fn help(&self) {
-        Help::log_internal_command(&self.definition);
-    }
-
     fn get_definition(&self) -> &InternalExecutableDefinition {
         &self.definition
     }

package/internals/internal_commands/list_themes.rs

@@ -8,22 +8,20 @@ use crate::{
     executables::{
         internal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
         },
     },
-    internal_commands::help::Help,
     logger::logger::Logger,
+    repokit::repokit_runtime::RepoKitRuntime,
 };
 
 pub struct ListThemes {
-    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl ListThemes {
-    pub fn new(scope: &RepoKitScope) -> ListThemes {
+    pub fn new() -> ListThemes {
         ListThemes {
-            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "themes",
                 description: "Lists your repositories available themes",
@@ -93,7 +91,14 @@ impl InternalExecutable for ListThemes {
             );
             return self.list_themes();
         }
-        Logger::with_registry(|mut registry| registry.set_theme(&self.scope.root, &desired_theme));
+        if Logger::with_registry(|mut registry| registry.set_theme(&desired_theme)) {
+            RepoKitRuntime::with_runtime(|runtime| {
+                runtime
+                    .caches
+                    .settings_cache
+                    .store_theme_preference(&desired_theme);
+            });
+        }
         Logger::info(
             format!(
                 "Your theme has been set to {}",
@@ -103,10 +108,6 @@ impl InternalExecutable for ListThemes {
         );
     }
 
-    fn help(&self) {
-        Help::log_internal_command(&self.definition);
-    }
-
     fn get_definition(&self) -> &InternalExecutableDefinition {
         &self.definition
     }

package/internals/internal_commands/list_version.rs

@@ -1,27 +1,25 @@
 use std::collections::HashMap;
 
 use crate::{
+    caches::version_cache::VERSION_REGEX,
     executables::{
         internal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
         },
     },
     executor::executor::Executor,
-    internal_commands::help::Help,
-    internal_filesystem::internal_filesystem::InternalFileSystem,
     logger::logger::Logger,
+    repokit::repokit_runtime::RepoKitRuntime,
 };
 
 pub struct ListVersion {
-    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl ListVersion {
-    pub fn new(scope: &RepoKitScope) -> ListVersion {
+    pub fn new() -> ListVersion {
         ListVersion {
-            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "version",
                 description: "Lists the version of repokit running in this repository",
@@ -38,22 +36,23 @@ impl ListVersion {
 impl InternalExecutable for ListVersion {
     fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
         Logger::info("Fetching the installed version of repokit");
-        if let Some(local_version) =
-            InternalFileSystem::new(&self.scope.root).installed_repokit_version()
-        {
-            return self.log_version(&local_version);
-        }
-        Logger::info("Falling back to the runtime version");
-        if let Some(runtime_version) = InternalFileSystem::runtime_repokit_version() {
-            return self.log_version(&runtime_version);
+        if RepoKitRuntime::with_runtime(|runtime| {
+            if VERSION_REGEX.is_match(&runtime.caches.version_cache.installed_version) {
+                self.log_version(&runtime.caches.version_cache.installed_version);
+                return true;
+            }
+            if VERSION_REGEX.is_match(&runtime.caches.version_cache.runtime_version) {
+                Logger::info("Falling back to the runtime version");
+                self.log_version(&runtime.caches.version_cache.runtime_version);
+                return true;
+            }
+            false
+        }) {
+            return;
         }
         Executor::with_stdio("npm list @repokit/core", |cmd| cmd);
     }
 
-    fn help(&self) {
-        Help::log_internal_command(&self.definition);
-    }
-
     fn get_definition(&self) -> &InternalExecutableDefinition {
         &self.definition
     }

package/internals/internal_commands/locate_command.rs

@@ -4,24 +4,21 @@ use crate::{
     executables::{
         internal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
         },
     },
-    internal_commands::help::Help,
     logger::logger::Logger,
-    post_processing::post_processor::PostProcessor,
+    repokit::repokit_runtime::RepoKitRuntime,
     validations::command_validations::CommandValidations,
 };
 
 pub struct LocateCommand {
-    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl LocateCommand {
-    pub fn new(scope: &RepoKitScope) -> LocateCommand {
+    pub fn new() -> LocateCommand {
         LocateCommand {
-            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "locate",
                 description: "Locates command definitions",
@@ -31,21 +28,22 @@ impl LocateCommand {
     }
 
     fn search_externals(&self, query: &str) {
-        let finder = CommandValidations::new(&self.scope);
-        let all = finder.collect_and_validate_externals();
+        let all = CommandValidations::collect_and_validate_externals();
         for (_, command) in all {
             if command.name == query {
                 Logger::log_file_path(&command.location);
-                PostProcessor::get().flush();
+                panic!();
             }
         }
     }
 
     fn search_root(&self, command: &str) {
-        if self.scope.configuration.commands.contains_key(command) {
-            Logger::log_file_path(format!("{}/repokit.ts", &self.scope.root).as_str());
-            PostProcessor::get().flush();
-        }
+        RepoKitRuntime::with_runtime(|runtime| {
+            if runtime.configuration.commands.contains_key(command) {
+                Logger::log_file_path(format!("{}/repokit.ts", &runtime.git.root).as_str());
+                panic!();
+            }
+        });
     }
 }
 
@@ -73,10 +71,6 @@ impl InternalExecutable for LocateCommand {
         );
     }
 
-    fn help(&self) {
-        Help::log_internal_command(&self.definition);
-    }
-
     fn get_definition(&self) -> &InternalExecutableDefinition {
         &self.definition
     }

package/internals/internal_commands/onboarder.rs

@@ -4,22 +4,19 @@ use crate::{
     executables::{
         internal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
         },
     },
-    internal_commands::help::Help,
     logger::logger::Logger,
 };
 
 pub struct Onboarder {
-    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl Onboarder {
-    pub fn new(scope: &RepoKitScope) -> Onboarder {
+    pub fn new() -> Onboarder {
         Onboarder {
-            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "onboard",
                 description: "Onboarding instructions for first time users",
@@ -30,7 +27,7 @@ impl Onboarder {
 }
 
 impl InternalExecutable for Onboarder {
-    fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
+    fn run(&self, _args: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
         Logger::info(
             format!(
                 "Welcome to {}",
@@ -46,23 +43,15 @@ impl InternalExecutable for Onboarder {
         );
         Logger::log_file_path("repokit register ./path/to/your-feature");
         Logger::info(
-            "This command creates a tooling definition for your feature in a file collocated to your code",
+            "This command creates a tooling definition for your feature designed to live along side the feature's implementation",
         );
         Logger::info(
             format!(
-                "The {} CLI will automatically detect these files and add them to its toolchain",
+                "The {} CLI will automatically detect these files and add them to its toolchain - making them available to your entire team",
                 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::with_theme(|theme|theme.highlight("Repokit"))).as_str()
-        );
-        Logger::space_around("It's your living source of knowledge and documentation");
-    }
-
-    fn help(&self) {
-        Help::log_internal_command(&self.definition);
     }
 
     fn get_definition(&self) -> &InternalExecutableDefinition {

package/internals/internal_commands/register_command.rs

@@ -1,31 +1,25 @@
 use normalize_path::NormalizePath;
-use std::{
-    collections::HashMap,
-    path::{Path, PathBuf},
-};
+use std::{collections::HashMap, path::PathBuf};
 
 use crate::{
     executables::{
         internal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
         },
     },
-    internal_commands::help::Help,
-    internal_filesystem::{file_builder::FileBuilder, internal_filesystem::InternalFileSystem},
+    internal_filesystem::file_builder::FileBuilder,
     logger::logger::Logger,
-    post_processing::post_processor::PostProcessor,
+    repokit::repokit_runtime::RepoKitRuntime,
 };
 
 pub struct RegisterCommand {
-    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl RegisterCommand {
-    pub fn new(scope: &RepoKitScope) -> RegisterCommand {
+    pub fn new() -> RegisterCommand {
         RegisterCommand {
-            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "register",
                 description: "Creates new Repokit commands",
@@ -45,7 +39,9 @@ impl RegisterCommand {
         if path_arg.is_empty() {
             RegisterCommand::exit_on_missing_path();
         }
-        let path = Path::new(&self.scope.root).join(&path_arg).normalize();
+        let path = RepoKitRuntime::with_runtime(|runtime| {
+            runtime.files.git_root_path.join(&path_arg).normalize()
+        });
         if !path.exists() {
             Logger::info(
                 format!(
@@ -68,11 +64,10 @@ impl RegisterCommand {
                 )
                 .as_str(),
             );
-            Logger::info(format!(
+            Logger::exit_with_info(format!(
                 "You can append additional commands to the existing {} instance or export another one",
                 Logger::with_theme(|theme| theme.highlight("RepoKitCommand"))
             ).as_str());
-            PostProcessor::get().flush();
         }
         command_path.clone()
     }
@@ -88,8 +83,9 @@ impl InternalExecutable for RegisterCommand {
     fn run(&self, args: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
         Logger::info("Registering a new command");
         let command_path = self.validate_path(args);
-        let mut source =
-            InternalFileSystem::new(&self.scope.root).resolve_template("command_template.txt");
+        let mut source = RepoKitRuntime::with_runtime(|runtime| {
+            runtime.files.resolve_template("command_template.txt")
+        });
         let mut target = FileBuilder::create(&command_path, |_| Logger::file_create_error());
         FileBuilder::copy_to(&mut source, &mut target, |_| Logger::file_write_error());
         Logger::info("Creating command file");
@@ -97,10 +93,6 @@ impl InternalExecutable for RegisterCommand {
         Logger::log_file_path(command_path.to_str().expect("path"));
     }
 
-    fn help(&self) {
-        Help::log_internal_command(&self.definition);
-    }
-
     fn get_definition(&self) -> &InternalExecutableDefinition {
         &self.definition
     }

package/internals/internal_commands/search_commands.rs

@@ -5,24 +5,25 @@ use crate::{
     executables::{
         internal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
         },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::{command_definition::CommandDefinition, repokit_command::RepoKitCommand},
+    repokit::{
+        command_definition::CommandDefinition, repokit_command::RepoKitCommand,
+        repokit_runtime::RepoKitRuntime,
+    },
     validations::command_validations::CommandValidations,
 };
 
 pub struct SearchCommands {
-    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl SearchCommands {
-    pub fn new(scope: &RepoKitScope) -> SearchCommands {
+    pub fn new() -> SearchCommands {
         SearchCommands {
-            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "search",
                 description: "Retrieve commands that match any search query",
@@ -61,9 +62,10 @@ impl SearchCommands {
         if command.owner.to_lowercase().contains(query) {
             return true;
         }
+        let git_root = RepoKitRuntime::with_runtime(|runtime| runtime.git.root.clone());
         if command
             .location
-            .replace(self.scope.root.as_str(), "")
+            .replace(&git_root, "")
             .to_lowercase()
             .contains(query)
         {
@@ -72,20 +74,29 @@ impl SearchCommands {
         if command.description.to_lowercase().contains(query) {
             return true;
         }
-        for (arg, sub_command) in &command.commands {
-            if arg.to_lowercase().contains(query) || self.search_command(query, sub_command) {
+        for (command_name, definition) in &command.commands {
+            if command_name.to_lowercase().contains(query) || self.search_command(query, definition)
+            {
                 return true;
             }
         }
         false
     }
 
-    fn search_command(&self, query: &str, command: &CommandDefinition) -> bool {
-        if command.command.to_lowercase().contains(query)
-            || command.description.to_lowercase().contains(query)
+    fn search_command(&self, query: &str, definition: &CommandDefinition) -> bool {
+        if definition.command.to_lowercase().contains(query)
+            || definition.description.to_lowercase().contains(query)
         {
             return true;
         }
+        if let Some(args) = &definition.args {
+            for (flag, description) in args {
+                if flag.to_lowercase().contains(query) || description.to_lowercase().contains(query)
+                {
+                    return true;
+                }
+            }
+        }
         false
     }
 
@@ -155,15 +166,17 @@ impl InternalExecutable for SearchCommands {
             Logger::exit_with_error("Please specify a search string to query with");
         }
         let query = args.join(" ").to_lowercase();
-        let externals = CommandValidations::new(&self.scope).collect_and_validate_externals();
+        let externals = CommandValidations::collect_and_validate_externals();
         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.scope.configuration.commands {
-            if self.search_command(&query, script) {
-                root_results.insert(command.clone(), script.clone());
+        RepoKitRuntime::with_runtime(|runtime| {
+            for (command, script) in &runtime.configuration.commands {
+                if self.search_command(&query, script) {
+                    root_results.insert(command.clone(), script.clone());
+                }
             }
-        }
+        });
         for (name, command) in internals {
             if self.search_internal(&query, command) {
                 internal_results.insert(name.clone(), command);
@@ -182,10 +195,6 @@ impl InternalExecutable for SearchCommands {
         self.log_external_results(&external_results);
     }
 
-    fn help(&self) {
-        Help::log_internal_command(&self.definition);
-    }
-
     fn get_definition(&self) -> &InternalExecutableDefinition {
         &self.definition
     }