@repokit/core 3.0.2 → 3.0.4

package/internals/internal_filesystem/file_builder.rs

@@ -1,3 +1,4 @@
+use crate::post_processing::post_processor::PostProcessor;
 use std::{
     fs::{File, create_dir_all},
     io::{Error, copy},
@@ -14,6 +15,7 @@ impl FileBuilder {
             Ok(file) => file,
             Err(error) => {
                 on_error(error);
+                PostProcessor::get().flush();
                 exit(0);
             }
         }
@@ -25,6 +27,7 @@ impl FileBuilder {
             Ok(file) => file,
             Err(error) => {
                 on_error(error);
+                PostProcessor::get().flush();
                 exit(0);
             }
         }
@@ -50,6 +53,7 @@ impl FileBuilder {
             Ok(result) => result,
             Err(error) => {
                 on_error(error);
+                PostProcessor::get().flush();
                 exit(0);
             }
         }

package/internals/internal_filesystem/internal_filesystem.rs

@@ -3,9 +3,11 @@ use normalize_path::NormalizePath;
 use regex::Regex;
 use shellexpand::tilde;
 use std::{
+    collections::HashMap,
     fs::{self, File},
     io::{BufRead, BufReader, Lines},
     path::{Path, PathBuf},
+    sync::LazyLock,
 };
 
 use crate::{
@@ -13,6 +15,9 @@ use crate::{
     logger::logger::Logger,
 };
 
+pub static VERSION_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r#"\d*\.\d*.\d*"#).unwrap());
+
 pub struct InternalFileSystem {
     root: String,
 }
@@ -114,6 +119,77 @@ impl InternalFileSystem {
         None
     }
 
+    pub fn get_package_manager(root: &str) -> &str {
+        let manager_map = HashMap::from([
+            ("npm", "package-lock.json"),
+            ("yarn", "yarn.lock"),
+            ("pnpm", "pnpm-lock.yaml"),
+            ("bun", "bun.lockb"),
+        ]);
+        for (manager, lock_file) in manager_map {
+            let path = Path::new(&root).join(lock_file).normalize();
+            if path.exists() && path.is_file() {
+                return manager;
+            }
+        }
+        "npm"
+    }
+
+    pub fn get_install_command(root: &str) -> &str {
+        let npm_install = "npm i -D";
+        let package_manager = InternalFileSystem::get_package_manager(root);
+        let manager_map = HashMap::from([
+            ("npm", npm_install),
+            ("yarn", "yarn add -D"),
+            ("pnpm", "pnpm i -D"),
+            ("bun", "bun add -D"),
+        ]);
+        manager_map.get(package_manager).unwrap_or(&npm_install)
+    }
+
+    pub fn get_node_executor(root: &str) -> &str {
+        let npx = "npx";
+        let package_manager = InternalFileSystem::get_package_manager(root);
+        let manager_map = HashMap::from([
+            ("npm", "npx"),
+            ("yarn", "yarn run -T"),
+            ("pnpm", "pnpm run"),
+            ("bun", "bunx"),
+        ]);
+        manager_map.get(package_manager).unwrap_or(&npx)
+    }
+
+    pub fn get_typescript_version(node_executor: &str) -> u32 {
+        let stdout = Executor::exec(format!("{} tsc --version", node_executor), |cmd| cmd);
+        let lines: Vec<&str> = stdout
+            .split("\n")
+            .filter_map(|s| {
+                let trimmed = s.trim();
+                if trimmed.is_empty() {
+                    return None;
+                }
+                Some(trimmed)
+            })
+            .collect();
+        let fallback_version = "5.0.0";
+        let version = lines.last().unwrap_or(&fallback_version);
+        let captures: Vec<String> = VERSION_REGEX
+            .captures_iter(version)
+            .filter_map(|item| {
+                item.get(0)
+                    .map(|match_text| match_text.as_str().to_string())
+            })
+            .collect();
+        let fallback_version_str = fallback_version.to_string();
+        let semver = captures.first().unwrap_or(&fallback_version_str);
+        semver
+            .chars()
+            .next()
+            .unwrap_or('5')
+            .to_digit(10)
+            .unwrap_or(5)
+    }
+
     fn commands_directory(&self) -> PathBuf {
         self.absolute(format!("{}/dist/commands", self.package_directory()).as_str())
     }
@@ -122,7 +198,7 @@ impl InternalFileSystem {
         self.absolute(format!("{}/externals/templates", self.package_directory()).as_str())
     }
 
-    fn package_directory(&self) -> String {
+    pub fn package_directory(&self) -> String {
         format!("./node_modules/{}", self.package_name())
     }
 
@@ -142,7 +218,7 @@ impl InternalFileSystem {
             Some(home) => {
                 let dot_file_path = home.join(".repokit");
                 if !&dot_file_path.exists() {
-                    let found_version = self.current_version();
+                    let found_version = self.installed_repokit_version();
                     found_version.as_ref()?;
                     let version_string = found_version.unwrap();
                     let result = fs::write(&dot_file_path, format!("{version_string}\n"));
@@ -171,7 +247,7 @@ impl InternalFileSystem {
         }
     }
 
-    pub fn current_version(&self) -> Option<String> {
+    pub fn installed_repokit_version(&self) -> Option<String> {
         let package_path = Path::new(&self.root)
             .join(InternalFileSystem::package_directory(self))
             .normalize();
@@ -182,7 +258,7 @@ impl InternalFileSystem {
         }
         let lines = BufReader::new(file.unwrap()).lines();
         let version_matcher = Regex::new(r#""([^"]*)""#).unwrap();
-        for line in lines.flatten() {
+        for line in lines.map_while(Result::ok) {
             if line.contains("\"version\": ") {
                 let captures: Vec<String> = version_matcher
                     .captures_iter(&line)
@@ -191,12 +267,28 @@ impl InternalFileSystem {
                             .map(|match_text| match_text.as_str().to_string())
                     })
                     .collect();
-                let version = captures.get(1);
-                if version.is_some() {
-                    return Some(version.unwrap().to_string());
-                } else {
-                    return None;
+                if let Some(version) = captures.get(1)
+                    && VERSION_REGEX.is_match(version)
+                {
+                    return Some(version.to_string());
                 }
+                return None;
+            }
+        }
+        None
+    }
+
+    pub fn runtime_repokit_version() -> Option<String> {
+        if let Some(home) = InternalFileSystem::home() {
+            let version = Executor::exec(
+                format!(
+                    "head -n 1 {}",
+                    home.join(".repokit").normalize().to_str().unwrap()
+                ),
+                |cmd| cmd,
+            );
+            if VERSION_REGEX.is_match(&version) {
+                return Some(version);
             }
         }
         None

package/internals/logger/logger.rs

@@ -1,10 +1,10 @@
-use std::process::exit;
 use std::sync::LazyLock;
 use std::sync::Mutex;
 use std::sync::MutexGuard;
 
 use colored::{ColoredString, Colorize};
 
+use crate::post_processing::post_processor::PostProcessor;
 use crate::themes::theme::Theme;
 use crate::themes::theme_registry::ThemeRegistry;
 
@@ -13,7 +13,7 @@ static REGISTERED_NAME: LazyLock<Mutex<String>> =
 
 static THEMES: LazyLock<Mutex<ThemeRegistry>> = LazyLock::new(|| Mutex::new(ThemeRegistry::new()));
 
-pub struct Logger {}
+pub struct Logger;
 
 impl Logger {
     pub fn set_name(value: &str) {
@@ -30,20 +30,18 @@ impl Logger {
 
     pub fn exit_with_info(message: &str) {
         Logger::info(message);
-        exit(0);
+        PostProcessor::get().flush();
     }
 
     pub fn exit_with_error(message: &str) {
         Logger::error(message);
-        exit(0);
+        PostProcessor::get().flush();
     }
 
     pub fn list(items: &[&str], indentation: Option<i32>) {
         Logger::with_surrounding_space(|| {
-            let mut pointer = 0;
-            for item in items {
-                println!("{}{}. {}", Logger::indent(indentation), pointer + 1, item);
-                pointer += 1
+            for (index, item) in items.iter().enumerate() {
+                println!("{}{}. {}", Logger::indent(indentation), index + 1, item);
             }
         })
     }
@@ -60,11 +58,25 @@ impl Logger {
     }
 
     pub fn log_file_path(path: &str) {
-        println!(
-            "\n{}{}\n",
-            Logger::indent(None),
-            Logger::with_theme(|theme| theme.highlight(path))
-        );
+        Logger::with_surrounding_space(|| {
+            println!(
+                "{}{}",
+                Logger::indent(None),
+                Logger::with_theme(|theme| theme.highlight(path))
+            );
+        })
+    }
+
+    pub fn list_file_paths(paths: &Vec<String>) {
+        Logger::with_surrounding_space(|| {
+            for path in paths {
+                println!(
+                    "{}{}",
+                    Logger::indent(None),
+                    Logger::with_theme(|theme| theme.highlight(path))
+                );
+            }
+        })
     }
 
     pub fn indent(times: Option<i32>) -> String {
@@ -109,7 +121,7 @@ impl Logger {
         Logger::info(format!("I was unable to {operation} in your repository").as_str());
         Logger::error("Please verify the permissions on your working directory or file a bug here");
         Logger::log_issue_link();
-        exit(0);
+        PostProcessor::get().flush();
     }
 
     fn info_prefix() -> String {

package/internals/main.rs

@@ -1,6 +1,7 @@
 use crate::{
-    internal_commands::typescript_command::TypescriptCommand,
-    internal_filesystem::internal_filesystem::InternalFileSystem, repokit::repokit::RepoKit,
+    configuration::typescript_command::TypescriptCommand,
+    internal_filesystem::internal_filesystem::InternalFileSystem,
+    repokit::{repokit::RepoKit, runtime_compiler::RuntimeCompiler},
 };
 
 mod argv;
@@ -11,13 +12,15 @@ mod file_walker;
 mod internal_commands;
 mod internal_filesystem;
 mod logger;
+mod post_processing;
 mod repokit;
 mod themes;
 mod validations;
 
 fn main() {
     let root = InternalFileSystem::find_root();
+    RuntimeCompiler::hop_to_runtime_version(&root);
     let config = TypescriptCommand::new(&root).parse_configuration();
-    let kit = RepoKit::new(root, config);
+    let kit = RepoKit::new(&root, config);
     kit.invoke();
 }

package/internals/post_processing/mod.rs

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

package/internals/post_processing/post_processor.rs

@@ -0,0 +1,37 @@
+use std::{
+    process::exit,
+    sync::{LazyLock, Mutex, MutexGuard},
+};
+
+pub struct PostProcessor {
+    tasks: Vec<Box<dyn Fn() + Send + 'static>>,
+}
+
+impl PostProcessor {
+    pub fn new() -> Self {
+        PostProcessor { tasks: Vec::new() }
+    }
+
+    pub fn get() -> MutexGuard<'static, PostProcessor> {
+        REPOKIT_POST_PROCESSOR.lock().unwrap()
+    }
+
+    pub fn register_task<F>(&mut self, task: F)
+    where
+        F: Fn() + Send + 'static,
+    {
+        self.tasks.push(Box::new(task));
+    }
+
+    pub fn flush(&mut self) {
+        for task in self.tasks.iter() {
+            task();
+        }
+        self.tasks.clear();
+        self.tasks.shrink_to_fit();
+        exit(0);
+    }
+}
+
+static REPOKIT_POST_PROCESSOR: LazyLock<Mutex<PostProcessor>> =
+    LazyLock::new(|| Mutex::new(PostProcessor::new()));

package/internals/repokit/command_definition.rs

@@ -0,0 +1,11 @@
+use std::collections::HashMap;
+
+use schemars::JsonSchema;
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Clone, JsonSchema)]
+pub struct CommandDefinition {
+    pub command: String,
+    pub description: String,
+    pub args: Option<HashMap<String, String>>,
+}

package/internals/repokit/mod.rs

@@ -1,2 +1,6 @@
-pub mod interfaces;
+pub mod command_definition;
 pub mod repokit;
+pub mod repokit_command;
+pub mod repokit_config;
+pub mod repokit_construct_validator;
+pub mod runtime_compiler;

package/internals/repokit/repokit.rs

@@ -1,19 +1,15 @@
-use std::{
-    collections::HashMap,
-    env::args,
-    path::Path,
-    process::{self},
-};
+use std::{collections::HashMap, env::args, path::Path};
 
 use crate::{
     executables::{
-        intenal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
+        internal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
     },
     executor::executor::Executor,
     internal_commands::help::Help,
     internal_filesystem::internal_filesystem::InternalFileSystem,
     logger::logger::Logger,
-    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
+    post_processing::post_processor::PostProcessor,
+    repokit::{repokit_command::RepoKitCommand, repokit_config::RepoKitConfig},
     validations::command_validations::CommandValidations,
 };
 
@@ -22,17 +18,17 @@ pub struct RepoKit {
 }
 
 impl RepoKit {
-    pub fn new(root: String, configuration: RepoKitConfig) -> RepoKit {
+    pub fn new(root: &str, configuration: RepoKitConfig) -> RepoKit {
         Logger::set_name(&configuration.project);
         for theme in &configuration.themes {
             Logger::with_registry(|mut registry| registry.register_user_theme(theme))
         }
-        let theme = InternalFileSystem::new(&root).read_theme_preference();
-        Logger::with_registry(|mut registry| registry.set_theme(&root, &theme));
+        let theme = InternalFileSystem::new(root).read_theme_preference();
+        Logger::with_registry(|mut registry| registry.set_theme(root, &theme));
         RepoKit {
             scope: RepoKitScope {
-                root,
                 configuration,
+                root: root.to_string(),
             },
         }
     }
@@ -42,7 +38,7 @@ impl RepoKit {
         let validator = CommandValidations::from(self);
         let internals = validator.collect_and_validate_internals();
         if internals.contains_key(&command) {
-            let interface = internals.get(&command).expect("Unknown command");
+            let interface = internals.get(&command).expect("known command");
             return interface.run(args, &internals);
         }
         if self.scope.configuration.commands.contains_key(&command) {
@@ -87,7 +83,7 @@ impl RepoKit {
         if argv.len() < 2 {
             let (internals, externals) = self.collect_and_validate();
             Help::list_all(&self.scope.configuration.commands, &internals, &externals);
-            process::exit(0);
+            PostProcessor::get().flush();
         }
         let command = &argv[1];
         let args = &(&argv)[2..];

package/internals/repokit/repokit_command.rs

@@ -0,0 +1,96 @@
+use std::{
+    collections::HashMap,
+    sync::LazyLock,
+};
+
+use jsonschema::Validator;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde_json::{Value, from_value, to_value};
+
+use crate::{
+    configuration::recovery::Recovery,
+    logger::logger::Logger,
+    post_processing::post_processor::PostProcessor,
+    repokit::{
+        command_definition::CommandDefinition,
+        repokit_construct_validator::RepoKitConstructValidator,
+    },
+};
+
+#[derive(Debug, Deserialize, Clone, JsonSchema)]
+pub struct RepoKitCommand {
+    pub name: String,
+    pub owner: String,
+    pub location: String,
+    pub description: String,
+    pub commands: HashMap<String, CommandDefinition>,
+}
+
+static REPOKIT_COMMAND_VALIDATOR: LazyLock<Validator> = LazyLock::new(|| {
+    Validator::new(&to_value(schemars::schema_for!(RepoKitCommand)).unwrap()).unwrap()
+});
+
+impl RepoKitCommand {
+    fn register_encountered_errors(root: &str, failed_paths: Vec<String>) {
+        let root_clone = root.to_string();
+        PostProcessor::get().register_task(move || {
+            println!();
+            if !failed_paths.is_empty() {
+                let appendage = if failed_paths.len() != 1 { "s" } else { "" };
+                Logger::error(
+                    format!(
+                        "I encountered an error in the following command{}",
+                        appendage
+                    )
+                    .as_str(),
+                );
+                Logger::list_file_paths(&failed_paths);
+            } else {
+                Logger::info("There was an error parsing one or more of your commands");
+            }
+            Logger::info("You can validate a command file's syntactical correctness by running");
+            Logger::log_file_path(
+                &Recovery::new(&root_clone).get_typecheck_command("<optional-path-to-file>"),
+            );
+        });
+    }
+}
+
+impl RepoKitConstructValidator<Vec<Value>, Vec<RepoKitCommand>> for RepoKitCommand {
+    fn from_input(root: &str, input: Vec<Value>) -> Vec<RepoKitCommand> {
+        let mut result: Vec<RepoKitCommand> = Vec::new();
+        let mut failures = 0;
+        let mut failed_paths: Vec<String> = Vec::new();
+        for command in input {
+            let repokit_command: Result<RepoKitCommand, serde_json::Error> =
+                from_value(command.clone());
+            if !RepoKitCommand::is_valid(&REPOKIT_COMMAND_VALIDATOR, &command)
+                || repokit_command.is_err()
+            {
+                failures += 1;
+                if let Some(path) = RepoKitCommand::on_parsing_error(root, command) {
+                    failed_paths.push(path);
+                }
+            } else {
+                let mut valid_command = repokit_command.expect("assertion success");
+                valid_command.location = format!("{}/{}", root, valid_command.location);
+                result.push(valid_command);
+            }
+        }
+        if failures != 0 {
+            RepoKitCommand::register_encountered_errors(root, failed_paths);
+        }
+        result
+    }
+
+    fn on_parsing_error(root: &str, command: Value) -> Option<String> {
+        let location = command.get("location");
+        println!();
+        if location.is_some_and(|v| v.is_string()) {
+            let path = format!("{}/{}", &root, location.unwrap().as_str().unwrap());
+            return Some(path);
+        }
+        None
+    }
+}

package/internals/repokit/repokit_config.rs

@@ -0,0 +1,75 @@
+use std::{
+    collections::HashMap,
+    path::Path,
+    process::exit,
+    sync::LazyLock,
+};
+
+use jsonschema::Validator;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde_json::{Value, from_value, to_value};
+
+use crate::{
+    configuration::recovery::Recovery,
+    logger::logger::Logger,
+    post_processing::post_processor::PostProcessor,
+    repokit::{
+        command_definition::CommandDefinition, repokit_command::RepoKitCommand,
+        repokit_construct_validator::RepoKitConstructValidator,
+    },
+    themes::theme_inputs::RepoKitTheme,
+};
+
+#[derive(Debug, Deserialize, Clone, JsonSchema)]
+pub struct RootCommand {
+    pub name: String,
+    pub command: String,
+    pub description: String,
+    pub args: Option<HashMap<String, String>>,
+}
+
+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(),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Clone, JsonSchema)]
+pub struct RepoKitConfig {
+    pub project: String,
+    pub thirdParty: Vec<RepoKitCommand>,
+    pub commands: HashMap<String, CommandDefinition>,
+    pub themes: Vec<RepoKitTheme>,
+}
+
+static REPOKIT_CONFIG_VALIDATOR: LazyLock<Validator> = LazyLock::new(|| {
+    Validator::new(&to_value(schemars::schema_for!(RepoKitConfig)).unwrap()).unwrap()
+});
+
+impl RepoKitConstructValidator<Value, RepoKitConfig> for RepoKitConfig {
+    fn from_input(root: &str, input: Value) -> RepoKitConfig {
+        let repokit_config: Result<RepoKitConfig, serde_json::Error> = from_value(input.clone());
+        if !RepoKitConfig::is_valid(&REPOKIT_CONFIG_VALIDATOR, &input) || repokit_config.is_err() {
+            RepoKitConfig::on_parsing_error(root, Value::Null);
+        }
+        repokit_config.expect("assertions succeeded")
+    }
+
+    fn on_parsing_error(root: &str, _: Value) -> Option<String> {
+        let path_buf = Path::new(&root).join("repokit.ts");
+        let path = path_buf.to_str().expect("exists");
+        let mut recovery = Recovery::new(root);
+        recovery.run(path);
+        println!();
+        Logger::info("There was an error parsing your configuration");
+        recovery.prompt_to_fix_errors(path);
+        PostProcessor::get().flush();
+        exit(0);
+    }
+}

package/internals/repokit/repokit_construct_validator.rs

@@ -0,0 +1,14 @@
+use jsonschema::Validator;
+use serde_json::Value;
+
+pub trait RepoKitConstructValidator<T, V> {
+    fn from_input(root: &str, input: T) -> V;
+    fn on_parsing_error(root: &str, value: Value) -> Option<String>;
+
+    fn is_valid(validator: &Validator, input: &Value) -> bool {
+        if validator.validate(input).is_err() {
+            return false;
+        }
+        true
+    }
+}

package/internals/repokit/runtime_compiler.rs

@@ -0,0 +1,61 @@
+use std::{env::args, path::PathBuf, process::exit};
+
+use normalize_path::NormalizePath;
+use terminal_spinners::{BOUNCING_BALL, SpinnerBuilder};
+
+use crate::{
+    executor::executor::Executor, internal_filesystem::internal_filesystem::InternalFileSystem,
+    logger::logger::Logger,
+};
+
+pub struct RuntimeCompiler;
+
+impl RuntimeCompiler {
+    pub fn hop_to_runtime_version(root: &str) {
+        RuntimeCompiler::with_version_mismatch(root, |installed_version, fs| {
+            let package_path = fs.absolute(&fs.package_directory());
+            let install_path = package_path.join("installation/install.sh").normalize();
+            if install_path.is_absolute() && install_path.exists() {
+                Logger::info(
+                    format!(
+                        "Switching to version {}",
+                        Logger::with_theme(|theme| theme.highlight(installed_version))
+                    )
+                    .as_str(),
+                );
+                if let Some(errors) = RuntimeCompiler::run_post_install(&package_path) {
+                    println!("{errors}");
+                } else {
+                    RuntimeCompiler::re_run_command();
+                }
+            }
+        });
+    }
+
+    fn with_version_mismatch(root: &str, func: impl Fn(&str, InternalFileSystem)) {
+        let scoped_fs = InternalFileSystem::new(root);
+        if let Some(installed_version) = scoped_fs.installed_repokit_version()
+            && let Some(runtime_version) = InternalFileSystem::runtime_repokit_version()
+            && runtime_version != installed_version
+        {
+            func(&installed_version, scoped_fs);
+        }
+    }
+
+    fn run_post_install(cwd: &PathBuf) -> Option<String> {
+        let handle = SpinnerBuilder::new()
+            .spinner(&BOUNCING_BALL)
+            .text(" Installing")
+            .start();
+        let result =
+            Executor::exec_with_errors("./installation/install.sh", |cmd| cmd.current_dir(cwd));
+        handle.done();
+        result
+    }
+
+    fn re_run_command() {
+        let args: Vec<String> = args().collect();
+        Executor::with_stdio(args.join(" "), |cmd| cmd);
+        exit(0);
+    }
+}