@repokit/core 0.0.1

package/workspaces/repokit/repokit.rs

@@ -0,0 +1,141 @@
+use std::{
+    collections::HashMap,
+    env::args,
+    path::Path,
+    process::{self},
+};
+
+use crate::{
+    executables::intenal_executable::InternalExecutable,
+    executor::executor::Executor,
+    internal_commands::help::Help,
+    logger::logger::Logger,
+    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
+    validations::command_validations::CommandValidations,
+};
+
+pub struct RepoKit {
+    pub root: String,
+    pub configuration: RepoKitConfig,
+}
+
+impl RepoKit {
+    pub fn new(root: String, configuration: RepoKitConfig) -> RepoKit {
+        Logger::set_name(&configuration.project);
+        RepoKit {
+            root,
+            configuration,
+        }
+    }
+
+    pub fn invoke(&self) {
+        let (command, args) = self.parse();
+        let validator = CommandValidations::from(self);
+        let internals = validator.collect_and_validate_internals();
+        if internals.contains_key(&command) {
+            let interface = internals.get(&command).expect("exists");
+            return interface.run(args, &internals);
+        }
+        if self.configuration.commands.contains_key(&command) {
+            let root_script = self.configuration.commands.get(&command).expect("exists");
+            return Executor::with_stdio(
+                format!("{} {}", root_script.command, &args.join(" ")),
+                |cmd| cmd.current_dir(Path::new(&self.root)),
+            );
+        }
+        let externals = validator.collect_and_validate_externals();
+        CommandValidations::detect_collisions_between_internals_and_externals(
+            &internals, &externals,
+        );
+        if externals.contains_key(&command) {
+            let interface = externals.get(&command).expect("exists");
+            if args.is_empty() {
+                return self.log_external_command(interface);
+            }
+            let sub_command = &args[0];
+            if interface.commands.contains_key(sub_command) {
+                let script = interface.commands.get(sub_command).expect("exists");
+                let working_dir = Path::new(&interface.location).parent().expect("exists");
+                return Executor::with_stdio(
+                    format!("{}{}", &script.command, &args[1..].join(" ")),
+                    |cmd| cmd.current_dir(working_dir),
+                );
+            }
+            return self.subcommand_not_found(interface, sub_command);
+        }
+        self.command_not_found(&command, &internals, &externals)
+    }
+
+    fn parse(&self) -> (String, Vec<String>) {
+        let argv: Vec<String> = args().collect();
+        if argv.len() < 2 {
+            let (internals, externals) = self.collect_and_validate();
+            Help::list_all(&self.configuration.commands, &internals, &externals);
+            process::exit(0);
+        }
+        let command = &argv[1];
+        let args = &(&argv)[2..];
+        (command.clone(), args.to_vec())
+    }
+
+    fn collect_and_validate(
+        &self,
+    ) -> (
+        HashMap<String, Box<dyn InternalExecutable>>,
+        HashMap<String, RepoKitCommand>,
+    ) {
+        let validator = CommandValidations::from(self);
+        let internals = validator.collect_and_validate_internals();
+        let externals = validator.collect_and_validate_externals();
+        CommandValidations::detect_collisions_between_internals_and_externals(
+            &internals, &externals,
+        );
+        (internals, externals)
+    }
+
+    fn command_not_found(
+        &self,
+        command: &str,
+        internals: &HashMap<String, Box<dyn InternalExecutable>>,
+        externals: &HashMap<String, RepoKitCommand>,
+    ) {
+        Help::list_all(&self.configuration.commands, internals, externals);
+        Logger::info(
+            format!(
+                "I'm not aware of a command named {}",
+                Logger::blue_bright(command)
+            )
+            .as_str(),
+        );
+    }
+
+    fn subcommand_not_found(&self, command: &RepoKitCommand, sub_command: &str) {
+        Logger::info(
+            format!(
+                "The command {} was not found on {}",
+                Logger::blue_bright(sub_command),
+                Logger::blue_bright(&command.name)
+            )
+            .as_str(),
+        );
+        Logger::info(
+            format!(
+                "Here are the commands that belong to {}",
+                Logger::blue_bright(&command.name)
+            )
+            .as_str(),
+        );
+        Help::print_commands(&command.commands, Some(3));
+    }
+
+    fn log_external_command(&self, command: &RepoKitCommand) {
+        Logger::info(
+            format!(
+                "Listing available commands for {}",
+                Logger::blue_bright(&command.name)
+            )
+            .as_str(),
+        );
+        Help::print_commands(&command.commands, Some(3))
+    }
+}

package/workspaces/validations/command_validations.rs

@@ -0,0 +1,140 @@
+use std::collections::HashMap;
+
+use futures::executor;
+
+use crate::{
+    repokit::{
+        repokit::RepoKit,
+        interfaces::{RepoKitCommand, RepoKitConfig},
+    },
+    executables::intenal_executable::InternalExecutable,
+    external_commands::external_commands::ExternalCommands,
+    internal_commands::internal_registry::InternalRegistry,
+    logger::logger::Logger,
+};
+
+pub struct CommandValidations {
+    root: String,
+    configuration: RepoKitConfig,
+}
+
+impl CommandValidations {
+    pub fn new(root: String, configuration: RepoKitConfig) -> CommandValidations {
+        CommandValidations {
+            root,
+            configuration,
+        }
+    }
+
+    pub fn from(kit: &RepoKit) -> CommandValidations {
+        CommandValidations {
+            root: kit.root.clone(),
+            configuration: kit.configuration.clone(),
+        }
+    }
+
+    pub fn collect_and_validate_internals(&self) -> HashMap<String, Box<dyn InternalExecutable>> {
+        let internals =
+            InternalRegistry::new(self.root.clone(), self.configuration.clone()).get_all();
+        self.detect_collisions_between_internals_and_root_commands(&internals);
+        internals
+    }
+
+    pub fn collect_and_validate_externals(&self) -> HashMap<String, RepoKitCommand> {
+        let finder = ExternalCommands::new(self.root.clone());
+        let externals = executor::block_on(finder.find_all());
+        self.detect_collisions_between_root_commands_and_externals(&externals)
+    }
+
+    pub fn detect_collisions_between_internals_and_externals(
+        internals: &HashMap<String, Box<dyn InternalExecutable>>,
+        externals: &HashMap<String, RepoKitCommand>,
+    ) {
+        for (name, command) in externals {
+            if internals.contains_key(name) {
+                Logger::info(
+                    format!(
+                        "I encountered a command named {} that conflicts with one of my internals",
+                        Logger::blue_bright(name),
+                    )
+                    .as_str(),
+                );
+                Logger::info("Here's where it's located:");
+                Logger::log_file_path(&command.location);
+                Logger::exit_with_info("Please rename it");
+            }
+        }
+    }
+
+    fn detect_collisions_between_internals_and_root_commands(
+        &self,
+        internals: &HashMap<String, Box<dyn InternalExecutable>>,
+    ) {
+        for name in internals.keys() {
+            if self.configuration.commands.contains_key(name) {
+                Logger::info(
+                    format!(
+                        "I encountered a command named {} in your {} file that conflicts with one of my internals",
+                        Logger::blue_bright(name),
+                        Logger::blue_bright("repokit.ts"),
+                    )
+                    .as_str(),
+                );
+                Logger::exit_with_info("Please rename it");
+            }
+        }
+    }
+
+    fn detect_collisions_between_root_commands_and_externals(
+        &self,
+        externals: &Vec<RepoKitCommand>,
+    ) -> HashMap<String, RepoKitCommand> {
+        let mut map: HashMap<String, RepoKitCommand> = HashMap::new();
+        for command in externals {
+            if map.contains_key(&command.name) {
+                let original = map.get(&command.name).expect("existent key");
+                self.on_external_duplicate_collision(command, &original.location);
+            }
+            map.insert(command.name.clone(), command.clone());
+            if self.configuration.commands.contains_key(&command.name) {
+                self.on_external_root_collision(command);
+            }
+        }
+        map
+    }
+
+    fn on_external_root_collision(&self, command: &RepoKitCommand) {
+        Logger::info(format!(
+                "I encountered a package command named {} that conflicts with a command in your {} file",
+                Logger::blue_bright(&command.name),
+                Logger::blue_bright("repokit.ts")
+            )
+            .as_str(),
+        );
+        Logger::info("Here's where it's located:");
+        Logger::log_file_path(&command.location);
+        Logger::exit_with_info("Please rename one of these");
+    }
+
+    fn on_external_duplicate_collision(&self, command: &RepoKitCommand, collision_path: &str) {
+        Logger::info(
+            format!(
+                "I encountered two packages with the name {}",
+                Logger::blue_bright(&command.name),
+            )
+            .as_str(),
+        );
+        Logger::info("Here's where they're located:\n");
+        println!(
+            "{}1. {}",
+            Logger::indent(None),
+            Logger::blue_bright(collision_path)
+        );
+        println!(
+            "{}2. {}\n",
+            Logger::indent(None),
+            Logger::blue_bright(&command.location)
+        );
+        Logger::exit_with_info("Please rename one of these");
+    }
+}

package/workspaces/validations/mod.rs

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