@repokit/core 4.0.5 → 5.0.0

package/internals/internal_commands/list_themes.rs

@@ -1,114 +0,0 @@
-use std::collections::HashMap;
-
-use alphanumeric_sort::sort_str_slice;
-use colored::Colorize;
-
-use crate::{
-    argv::argv::{Argv, ArgvOption, ArgvType},
-    executables::{
-        internal_executable::InternalExecutable,
-        internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
-        },
-    },
-    logger::logger::Logger,
-    repokit::repokit_runtime::RepoKitRuntime,
-};
-
-pub struct ListThemes {
-    pub definition: InternalExecutableDefinition,
-}
-
-impl ListThemes {
-    pub fn new() -> ListThemes {
-        ListThemes {
-            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(
-            [ArgvOption {
-                name: "set",
-                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();
-        }
-        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 {}",
-                Logger::with_theme(|theme| theme.highlight(&desired_theme))
-            )
-            .as_str(),
-        );
-    }
-
-    fn get_definition(&self) -> &InternalExecutableDefinition {
-        &self.definition
-    }
-}

package/internals/internal_commands/list_version.rs

@@ -1,59 +0,0 @@
-use std::collections::HashMap;
-
-use crate::{
-    caches::version_cache::VERSION_REGEX,
-    executables::{
-        internal_executable::InternalExecutable,
-        internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
-        },
-    },
-    executor::executor::Executor,
-    logger::logger::Logger,
-    repokit::repokit_runtime::RepoKitRuntime,
-};
-
-pub struct ListVersion {
-    pub definition: InternalExecutableDefinition,
-}
-
-impl ListVersion {
-    pub fn new() -> ListVersion {
-        ListVersion {
-            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
-                name: "version",
-                description: "Lists the version of repokit running in this repository",
-                args: [],
-            }),
-        }
-    }
-
-    fn log_version(&self, version: &str) {
-        Logger::info(format!("{}", Logger::with_theme(|theme| theme.highlight(version))).as_str());
-    }
-}
-
-impl InternalExecutable for ListVersion {
-    fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
-        Logger::info("Fetching the installed version of repokit");
-        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 get_definition(&self) -> &InternalExecutableDefinition {
-        &self.definition
-    }
-}

package/internals/internal_commands/locate_command.rs

@@ -1,77 +0,0 @@
-use std::collections::HashMap;
-
-use crate::{
-    executables::{
-        internal_executable::InternalExecutable,
-        internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
-        },
-    },
-    logger::logger::Logger,
-    repokit::repokit_runtime::RepoKitRuntime,
-    validations::command_validations::CommandValidations,
-};
-
-pub struct LocateCommand {
-    pub definition: InternalExecutableDefinition,
-}
-
-impl LocateCommand {
-    pub fn new() -> LocateCommand {
-        LocateCommand {
-            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
-                name: "locate",
-                description: "Locates command definitions",
-                args: [("<name>", "The name of a registered command")],
-            }),
-        }
-    }
-
-    fn search_externals(&self, query: &str) {
-        let all = CommandValidations::collect_and_validate_externals();
-        for (_, command) in all {
-            if command.name == query {
-                Logger::log_file_path(&command.location);
-                panic!();
-            }
-        }
-    }
-
-    fn search_root(&self, command: &str) {
-        RepoKitRuntime::with_runtime(|runtime| {
-            if runtime.configuration.commands.contains_key(command) {
-                Logger::log_file_path(format!("{}/repokit.ts", &runtime.git.root).as_str());
-                panic!();
-            }
-        });
-    }
-}
-
-impl InternalExecutable for LocateCommand {
-    fn run(&self, args: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
-        if args.is_empty() {
-            Logger::exit_with_info("Please specify a command to locate");
-        }
-        let command = &args[0];
-        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::with_theme(|theme| theme.highlight(command))
-            )
-            .as_str(),
-        );
-    }
-
-    fn get_definition(&self) -> &InternalExecutableDefinition {
-        &self.definition
-    }
-}

package/internals/internal_commands/mod.rs

@@ -1,11 +0,0 @@
-pub mod help;
-pub mod internal_registry;
-pub mod list_commands;
-pub mod list_owners;
-pub mod list_themes;
-pub mod list_version;
-pub mod locate_command;
-pub mod onboarder;
-pub mod register_command;
-pub mod search_commands;
-pub mod upgrade_repokit;

package/internals/internal_commands/onboarder.rs

@@ -1,60 +0,0 @@
-use std::collections::HashMap;
-
-use crate::{
-    executables::{
-        internal_executable::InternalExecutable,
-        internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
-        },
-    },
-    logger::logger::Logger,
-};
-
-pub struct Onboarder {
-    pub definition: InternalExecutableDefinition,
-}
-
-impl Onboarder {
-    pub fn new() -> Onboarder {
-        Onboarder {
-            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
-                name: "onboard",
-                description: "Onboarding instructions for first time users",
-                args: [],
-            }),
-        }
-    }
-}
-
-impl InternalExecutable for Onboarder {
-    fn run(&self, _args: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
-        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::with_theme(|theme|theme.highlight("Repokit"))).as_str()
-        );
-        Logger::log_file_path("repokit register ./path/to/your-feature");
-        Logger::info(
-            "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 - making them available to your entire team",
-                Logger::with_theme(|theme| theme.highlight("Repokit"))
-            )
-            .as_str(),
-        );
-    }
-
-    fn get_definition(&self) -> &InternalExecutableDefinition {
-        &self.definition
-    }
-}

package/internals/internal_commands/register_command.rs

@@ -1,99 +0,0 @@
-use normalize_path::NormalizePath;
-use std::{collections::HashMap, path::PathBuf};
-
-use crate::{
-    executables::{
-        internal_executable::InternalExecutable,
-        internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
-        },
-    },
-    internal_filesystem::file_builder::FileBuilder,
-    logger::logger::Logger,
-    repokit::repokit_runtime::RepoKitRuntime,
-};
-
-pub struct RegisterCommand {
-    pub definition: InternalExecutableDefinition,
-}
-
-impl RegisterCommand {
-    pub fn new() -> RegisterCommand {
-        RegisterCommand {
-            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
-                name: "register",
-                description: "Creates new Repokit commands",
-                args: [(
-                    "<path>",
-                    "A relative path to your preferred command location",
-                )],
-            }),
-        }
-    }
-
-    fn validate_path(&self, args: Vec<String>) -> PathBuf {
-        if args.is_empty() {
-            RegisterCommand::exit_on_missing_path();
-        }
-        let path_arg = args[0].clone();
-        if path_arg.is_empty() {
-            RegisterCommand::exit_on_missing_path();
-        }
-        let path = RepoKitRuntime::with_runtime(|runtime| {
-            runtime.files.git_root_path.join(&path_arg).normalize()
-        });
-        if !path.exists() {
-            Logger::info(
-                format!(
-                    "Creating the path {} in your file system",
-                    Logger::with_theme(|theme| theme.highlight(path_arg.as_str()))
-                )
-                .as_str(),
-            );
-            FileBuilder::create_dir_all(&path, |_| Logger::file_directory_error());
-        }
-        if !path.is_dir() {
-            RegisterCommand::exit_on_missing_path();
-        }
-        let command_path = &path.join("Commands.ts");
-        if command_path.exists() {
-            Logger::error(
-                format!(
-                    "A {} file already exists in this directory",
-                    Logger::with_theme(|theme| theme.highlight("Commands.ts"))
-                )
-                .as_str(),
-            );
-            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());
-        }
-        command_path.clone()
-    }
-
-    fn exit_on_missing_path() {
-        Logger::exit_with_error(
-            "Please specify a path to a directory relative to the root of your repository",
-        );
-    }
-}
-
-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 = 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");
-        Logger::info("Please fill out your command file located at:");
-        Logger::log_file_path(command_path.to_str().expect("path"));
-    }
-
-    fn get_definition(&self) -> &InternalExecutableDefinition {
-        &self.definition
-    }
-}

package/internals/internal_commands/search_commands.rs

@@ -1,201 +0,0 @@
-use alphanumeric_sort::sort_slice_by_str_key;
-use std::collections::HashMap;
-
-use crate::{
-    executables::{
-        internal_executable::InternalExecutable,
-        internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
-        },
-    },
-    internal_commands::help::Help,
-    logger::logger::Logger,
-    repokit::{
-        command_definition::CommandDefinition, repokit_command::RepoKitCommand,
-        repokit_runtime::RepoKitRuntime,
-    },
-    validations::command_validations::CommandValidations,
-};
-
-pub struct SearchCommands {
-    pub definition: InternalExecutableDefinition,
-}
-
-impl SearchCommands {
-    pub fn new() -> SearchCommands {
-        SearchCommands {
-            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
-                name: "search",
-                description: "Retrieve commands that match any search query",
-                args: [(
-                    "<query>",
-                    "A search string to match against command names, descriptions, arguments, or owner",
-                )],
-            }),
-        }
-    }
-
-    fn search_internal(&self, query: &str, command: &Box<dyn InternalExecutable>) -> bool {
-        let config = command.get_definition();
-        if config.name.to_lowercase().contains(query) {
-            return true;
-        }
-        if config.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
-    }
-
-    fn search_external(&self, query: &str, command: &RepoKitCommand) -> bool {
-        if command.name.to_lowercase().contains(query) {
-            return true;
-        }
-        if command.owner.to_lowercase().contains(query) {
-            return true;
-        }
-        let git_root = RepoKitRuntime::with_runtime(|runtime| runtime.git.root.clone());
-        if command
-            .location
-            .replace(&git_root, "")
-            .to_lowercase()
-            .contains(query)
-        {
-            return true;
-        }
-        if command.description.to_lowercase().contains(query) {
-            return true;
-        }
-        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, 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
-    }
-
-    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() {
-            Help::log_root_commands(root_results);
-        }
-        Logger::info(
-            format!(
-                "Matched {} command{} in your repokit config",
-                Logger::with_theme(|theme| theme.highlight(total.to_string().as_str())),
-                plural_appendage,
-            )
-            .as_str(),
-        );
-    }
-
-    fn log_internal_results(
-        &self,
-        internal_results: &HashMap<String, &Box<dyn InternalExecutable>>,
-    ) {
-        let total = internal_results.len();
-        let plural_appendage = if total == 1 { "" } else { "s" };
-        if !internal_results.is_empty() {
-            let mut sorted_internals: Vec<&&Box<dyn InternalExecutable>> =
-                internal_results.values().collect();
-            sort_slice_by_str_key(&mut sorted_internals, |x| &x.get_definition().name);
-            Logger::space_around("Internal Commands:");
-            for internal in sorted_internals {
-                internal.help();
-                println!();
-            }
-        }
-        Logger::info(
-            format!(
-                "Matched {} internal command{}",
-                Logger::with_theme(|theme| theme.highlight(total.to_string().as_str())),
-                plural_appendage,
-            )
-            .as_str(),
-        );
-    }
-
-    fn log_external_results(&self, external_commands: &HashMap<String, RepoKitCommand>) {
-        let total = external_commands.len();
-        let plural_appendage = if total == 1 { "" } else { "s" };
-        if !external_commands.is_empty() {
-            Help::log_external_commands(external_commands);
-        }
-        Logger::info(
-            format!(
-                "Matched {} registered command{}",
-                Logger::with_theme(|theme| theme.highlight(total.to_string().as_str())),
-                plural_appendage,
-            )
-            .as_str(),
-        );
-    }
-}
-
-impl InternalExecutable for SearchCommands {
-    fn run(&self, args: Vec<String>, internals: &HashMap<String, Box<dyn InternalExecutable>>) {
-        Logger::info("Searching commands");
-        if args.is_empty() {
-            Logger::exit_with_error("Please specify a search string to query with");
-        }
-        let query = args.join(" ").to_lowercase();
-        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();
-        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);
-            }
-        }
-        for (name, command) in externals {
-            if self.search_external(&query, &command) {
-                external_results.insert(name, command);
-            }
-        }
-        if root_results.is_empty() && internal_results.is_empty() && external_results.is_empty() {
-            Logger::exit_with_info("No matched commands");
-        }
-        self.log_root_results(&root_results);
-        self.log_internal_results(&internal_results);
-        self.log_external_results(&external_results);
-    }
-
-    fn get_definition(&self) -> &InternalExecutableDefinition {
-        &self.definition
-    }
-}

package/internals/internal_commands/upgrade_repokit.rs

@@ -1,71 +0,0 @@
-use std::collections::HashMap;
-
-use terminal_spinners::{BOUNCING_BALL, SpinnerBuilder};
-
-use crate::{
-    executables::{
-        internal_executable::InternalExecutable,
-        internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
-        },
-    },
-    executor::executor::Executor,
-    logger::logger::Logger,
-    repokit::repokit_runtime::RepoKitRuntime,
-};
-
-pub struct UpgradeRepoKit {
-    pub definition: InternalExecutableDefinition,
-}
-
-impl UpgradeRepoKit {
-    pub fn new() -> UpgradeRepoKit {
-        UpgradeRepoKit {
-            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
-                name: "upgrade",
-                description: "Upgrades your installation of repokit to the latest stable version",
-                args: [],
-            }),
-        }
-    }
-
-    pub fn static_execute(&self) {
-        Logger::info("Upgrading installation");
-        let handle = SpinnerBuilder::new()
-            .spinner(&BOUNCING_BALL)
-            .text(" Installing")
-            .start();
-        RepoKitRuntime::with_runtime(|runtime| {
-            Executor::exec(
-                format!("{} @repokit/core@latest", runtime.node.install_command).as_str(),
-                |cmd| cmd.current_dir(&runtime.git.root),
-            )
-        });
-        handle.done();
-        Logger::info("Upgrade Complete!");
-    }
-}
-
-impl InternalExecutable for UpgradeRepoKit {
-    fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
-        self.static_execute();
-        if let Some(new_version) = RepoKitRuntime::with_runtime(|runtime| {
-            runtime
-                .caches
-                .version_cache
-                .refresh_installed_version(&runtime.files)
-        }) {
-            Logger::info(
-                format!(
-                    "The currently installed version is {}",
-                    Logger::with_theme(|theme| theme.highlight(&new_version))
-                )
-                .as_str(),
-            );
-        }
-    }
-
-    fn get_definition(&self) -> &InternalExecutableDefinition {
-        &self.definition
-    }
-}