@repokit/core 3.0.5 → 4.0.0

package/internals/internal_commands/upgrade_repokit.rs

@@ -6,24 +6,21 @@ use crate::{
     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 UpgradeRepoKit {
-    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl UpgradeRepoKit {
-    pub fn new(scope: &RepoKitScope) -> UpgradeRepoKit {
+    pub fn new() -> UpgradeRepoKit {
         UpgradeRepoKit {
-            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "upgrade",
                 description: "Upgrades your installation of repokit to the latest stable version",
@@ -32,50 +29,42 @@ impl UpgradeRepoKit {
         }
     }
 
-    pub fn static_execute(root: &str) {
+    pub fn static_execute(&self) {
         Logger::info("Upgrading installation");
         let handle = SpinnerBuilder::new()
             .spinner(&BOUNCING_BALL)
             .text(" Installing")
             .start();
-        let command_prefix = InternalFileSystem::get_install_command(root);
-        Executor::exec(
-            format!("{} @repokit/core@latest", command_prefix).as_str(),
-            |cmd| cmd.current_dir(root),
-        );
+        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>>) {
-        let internal_fs = InternalFileSystem::new(&self.scope.root);
-        let fallback = "unknown";
-        let runtime_version = internal_fs
-            .installed_repokit_version()
-            .unwrap_or(fallback.to_string());
-        UpgradeRepoKit::static_execute(&self.scope.root);
-        let installed_version = internal_fs
-            .installed_repokit_version()
-            .unwrap_or(fallback.to_string());
-        if runtime_version != installed_version {
-            Logger::info("Upgrade Complete!");
+        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(&installed_version))
+                    Logger::with_theme(|theme| theme.highlight(&new_version))
                 )
                 .as_str(),
             );
-        } else {
-            Logger::info("The latest version is already installed");
         }
     }
 
-    fn help(&self) {
-        Help::log_internal_command(&self.definition);
-    }
-
     fn get_definition(&self) -> &InternalExecutableDefinition {
         &self.definition
     }

package/internals/internal_filesystem/file_builder.rs

@@ -1,22 +1,19 @@
-use crate::post_processing::post_processor::PostProcessor;
 use std::{
     fs::{File, create_dir_all},
     io::{Error, copy},
     path::Path,
-    process::exit,
 };
 
 pub struct FileBuilder;
 
 impl FileBuilder {
-    pub fn open(source: &str, on_error: impl Fn(Error)) -> File {
+    pub fn open<P: AsRef<Path>>(source: P, on_error: impl Fn(Error)) -> File {
         let source = File::open(source);
         match source {
             Ok(file) => file,
             Err(error) => {
                 on_error(error);
-                PostProcessor::get().flush();
-                exit(0);
+                panic!();
             }
         }
     }
@@ -27,8 +24,7 @@ impl FileBuilder {
             Ok(file) => file,
             Err(error) => {
                 on_error(error);
-                PostProcessor::get().flush();
-                exit(0);
+                panic!();
             }
         }
     }
@@ -53,8 +49,7 @@ impl FileBuilder {
             Ok(result) => result,
             Err(error) => {
                 on_error(error);
-                PostProcessor::get().flush();
-                exit(0);
+                panic!();
             }
         }
     }

package/internals/internal_filesystem/mod.rs

@@ -1,2 +1 @@
 pub mod file_builder;
-pub mod internal_filesystem;

package/internals/logger/logger.rs

@@ -1,10 +1,11 @@
+use core::panic;
 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::repokit::repokit_runtime::RepoKitRuntime;
 use crate::themes::theme::Theme;
 use crate::themes::theme_registry::ThemeRegistry;
 
@@ -16,8 +17,16 @@ static THEMES: LazyLock<Mutex<ThemeRegistry>> = LazyLock::new(|| Mutex::new(Them
 pub struct Logger;
 
 impl Logger {
-    pub fn set_name(value: &str) {
-        *REGISTERED_NAME.lock().unwrap() = value.to_string();
+    pub fn initialize() {
+        RepoKitRuntime::with_runtime(|runtime| {
+            Logger::set_name(&runtime.configuration.project);
+            for theme in &runtime.configuration.themes {
+                Logger::with_registry(|mut registry| registry.register_user_theme(theme))
+            }
+            Logger::with_registry(|mut registry| {
+                registry.set_theme(&runtime.caches.settings_cache.theme_preference)
+            });
+        });
     }
 
     pub fn info(message: &str) {
@@ -30,12 +39,12 @@ impl Logger {
 
     pub fn exit_with_info(message: &str) {
         Logger::info(message);
-        PostProcessor::get().flush();
+        panic!();
     }
 
     pub fn exit_with_error(message: &str) {
         Logger::error(message);
-        PostProcessor::get().flush();
+        panic!();
     }
 
     pub fn list(items: &[&str], indentation: Option<i32>) {
@@ -121,7 +130,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();
-        PostProcessor::get().flush();
+        panic!();
     }
 
     fn info_prefix() -> String {
@@ -133,4 +142,8 @@ impl Logger {
             format!("{}: ", theme.error_prefix(&REGISTERED_NAME.lock().unwrap()))
         })
     }
+
+    fn set_name(value: &str) {
+        *REGISTERED_NAME.lock().unwrap() = value.to_string();
+    }
 }

package/internals/main.rs

@@ -1,11 +1,10 @@
-use crate::{
-    configuration::typescript_command::TypescriptCommand,
-    internal_filesystem::internal_filesystem::InternalFileSystem,
-    repokit::{repokit::RepoKit, runtime_compiler::RuntimeCompiler},
-};
+use std::panic;
+
+use crate::{post_processing::post_processor::PostProcessor, repokit::repokit::RepoKit};
 
 mod argv;
-mod configuration;
+mod caches;
+mod context;
 mod executables;
 mod executor;
 mod file_walker;
@@ -18,9 +17,7 @@ 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);
-    kit.invoke();
+    panic::set_hook(Box::new(|_| PostProcessor::get().flush()));
+    RepoKit::new().invoke();
+    PostProcessor::get().flush();
 }

package/internals/repokit/mod.rs

@@ -3,4 +3,4 @@ pub mod repokit;
 pub mod repokit_command;
 pub mod repokit_config;
 pub mod repokit_construct_validator;
-pub mod runtime_compiler;
+pub mod repokit_runtime;

package/internals/repokit/repokit.rs

@@ -1,77 +1,52 @@
 use std::{collections::HashMap, env::args, path::Path};
 
 use crate::{
-    executables::{
-        internal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
-    },
+    executables::internal_executable::InternalExecutable,
     executor::executor::Executor,
     internal_commands::help::Help,
-    internal_filesystem::internal_filesystem::InternalFileSystem,
     logger::logger::Logger,
-    post_processing::post_processor::PostProcessor,
-    repokit::{repokit_command::RepoKitCommand, repokit_config::RepoKitConfig},
+    repokit::{repokit_command::RepoKitCommand, repokit_runtime::RepoKitRuntime},
     validations::command_validations::CommandValidations,
 };
 
-pub struct RepoKit {
-    pub scope: RepoKitScope,
-}
+pub struct RepoKit {}
 
 impl 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));
-        RepoKit {
-            scope: RepoKitScope {
-                configuration,
-                root: root.to_string(),
-            },
-        }
+    pub fn new() -> RepoKit {
+        Logger::initialize();
+        RepoKit {}
     }
 
     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("known command");
-            return interface.run(args, &internals);
-        }
-        if self.scope.configuration.commands.contains_key(&command) {
-            let root_script = self
-                .scope
-                .configuration
-                .commands
-                .get(&command)
-                .expect("Unknown command");
-            return Executor::with_stdio(
-                format!("{} {}", root_script.command, &args.join(" ")),
-                |cmd| cmd.current_dir(Path::new(&self.scope.root)),
-            );
+        let internals = CommandValidations::collect_and_validate_internals();
+        if let Some(internal_command) = internals.get(&command) {
+            return internal_command.run(args, &internals);
         }
-        let externals = validator.collect_and_validate_externals();
+        RepoKitRuntime::with_runtime(|runtime| {
+            if let Some(root_script) = runtime.configuration.commands.get(&command) {
+                Executor::with_stdio(
+                    format!("{} {}", root_script.command, &args.join(" ")),
+                    |cmd| cmd.current_dir(&runtime.files.git_root_path),
+                );
+                panic!();
+            }
+        });
+        let externals = CommandValidations::collect_and_validate_externals();
         CommandValidations::detect_collisions_between_internals_and_externals(
             &internals, &externals,
         );
-        if externals.contains_key(&command) {
-            let interface = externals.get(&command).expect("Unknown command");
+        if let Some(interface) = externals.get(&command) {
             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("Unknown script");
-                let working_dir = Path::new(&interface.location)
-                    .parent()
-                    .expect("Working directory not found");
-                return Executor::with_stdio(
-                    format!("{} {}", &script.command, &args[1..].join(" ")),
-                    |cmd| cmd.current_dir(working_dir),
-                );
+            if let Some(script) = interface.commands.get(sub_command) {
+                let executable = format!("{} {}", &script.command, &args[1..].join(" "));
+                if let Some(working_dir) = Path::new(&interface.location).parent() {
+                    return Executor::with_stdio(executable, |cmd| cmd.current_dir(working_dir));
+                }
+                return self.working_directory_not_found(interface, &executable);
             }
             return self.subcommand_not_found(interface, sub_command);
         }
@@ -82,8 +57,8 @@ impl RepoKit {
         let argv: Vec<String> = args().collect();
         if argv.len() < 2 {
             let (internals, externals) = self.collect_and_validate();
-            Help::list_all(&self.scope.configuration.commands, &internals, &externals);
-            PostProcessor::get().flush();
+            Help::list_all(&internals, &externals);
+            panic!();
         }
         let command = &argv[1];
         let args = &(&argv)[2..];
@@ -96,9 +71,8 @@ impl RepoKit {
         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();
+        let internals = CommandValidations::collect_and_validate_internals();
+        let externals = CommandValidations::collect_and_validate_externals();
         CommandValidations::detect_collisions_between_internals_and_externals(
             &internals, &externals,
         );
@@ -111,7 +85,7 @@ impl RepoKit {
         internals: &HashMap<String, Box<dyn InternalExecutable>>,
         externals: &HashMap<String, RepoKitCommand>,
     ) {
-        Help::list_all(&self.scope.configuration.commands, internals, externals);
+        Help::list_all(internals, externals);
         Logger::info(
             format!(
                 "I'm not aware of a command named {}",
@@ -151,4 +125,22 @@ impl RepoKit {
         Help::log_external_subcommands(&command.commands, 3);
         println!();
     }
+
+    fn working_directory_not_found(&self, interface: &RepoKitCommand, executable: &str) {
+        Logger::info("I was unable to determine the working directory for this command");
+        Logger::info(
+            format!(
+                "This typically indicates a bug within {}",
+                Logger::with_theme(|theme| theme.highlight("Repokit"))
+            )
+            .as_str(),
+        );
+        Logger::info("Please file an issue at");
+        Logger::log_issue_link();
+        Logger::info("To run this command from your terminal, you can run:");
+        Logger::log_file_path(executable);
+        Logger::info("From the parent directory of");
+        Logger::log_file_path(&interface.location);
+        panic!();
+    }
 }

package/internals/repokit/repokit_command.rs

@@ -1,7 +1,4 @@
-use std::{
-    collections::HashMap,
-    sync::LazyLock,
-};
+use std::{collections::HashMap, sync::LazyLock};
 
 use jsonschema::Validator;
 use schemars::JsonSchema;
@@ -9,12 +6,11 @@ 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,
+        repokit_construct_validator::RepoKitConstructValidator, repokit_runtime::RepoKitRuntime,
     },
 };
 
@@ -31,37 +27,14 @@ 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 for RepoKitCommand {}
 
-impl RepoKitConstructValidator<Vec<Value>, Vec<RepoKitCommand>> for RepoKitCommand {
-    fn from_input(root: &str, input: Vec<Value>) -> Vec<RepoKitCommand> {
+impl RepoKitCommand {
+    pub fn from_input(input: Vec<Value>) -> Vec<RepoKitCommand> {
         let mut result: Vec<RepoKitCommand> = Vec::new();
         let mut failures = 0;
         let mut failed_paths: Vec<String> = Vec::new();
+        let git_root = RepoKitRuntime::with_runtime(|runtime| runtime.git.root.clone());
         for command in input {
             let repokit_command: Result<RepoKitCommand, serde_json::Error> =
                 from_value(command.clone());
@@ -69,28 +42,86 @@ impl RepoKitConstructValidator<Vec<Value>, Vec<RepoKitCommand>> for RepoKitComma
                 || repokit_command.is_err()
             {
                 failures += 1;
-                if let Some(path) = RepoKitCommand::on_parsing_error(root, command) {
+                if let Some(path) = RepoKitCommand::on_parsing_error(command) {
                     failed_paths.push(path);
                 }
             } else {
                 let mut valid_command = repokit_command.expect("assertion success");
-                valid_command.location = format!("{}/{}", root, valid_command.location);
+                valid_command.location = format!("{}/{}", git_root, valid_command.location);
                 result.push(valid_command);
             }
         }
         if failures != 0 {
-            RepoKitCommand::register_encountered_errors(root, failed_paths);
+            RepoKitCommand::register_encountered_errors(failed_paths);
         }
         result
     }
 
-    fn on_parsing_error(root: &str, command: Value) -> Option<String> {
+    pub fn on_parsing_error(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());
+            let path = RepoKitRuntime::with_runtime(|runtime| {
+                format!(
+                    "{}/{}",
+                    runtime.git.root,
+                    location.unwrap().as_str().unwrap()
+                )
+            });
             return Some(path);
         }
         None
     }
+
+    pub fn full_blown_crash() {
+        Logger::error("I hit a snag parsing your commands");
+        Logger::error(
+            format!(
+                "This kind of error is indicative of a bug within {}",
+                Logger::with_theme(|theme| theme.highlight("Repokit"))
+            )
+            .as_str(),
+        );
+        println!();
+        Logger::info("Let's blaim the AI's for this one");
+        let version = RepoKitRuntime::with_runtime(|runtime| {
+            runtime.caches.version_cache.installed_version.clone()
+        });
+        Logger::info(
+            format!(
+                "In the interim, please file a bug here and downgrade to the most recent version behind {}",
+                Logger::with_theme(|theme| theme.highlight(&version))
+            )
+            .as_str(),
+        );
+        Logger::log_issue_link();
+        Logger::info("We'll get a hotfix out asap!");
+        panic!();
+    }
+
+    fn register_encountered_errors(failed_paths: Vec<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");
+            let type_check_command = RepoKitRuntime::with_runtime(|mut runtime| {
+                runtime
+                    .node
+                    .get_typecheck_command("<optional-path-to-file>")
+            });
+            Logger::log_file_path(&type_check_command);
+        });
+    }
 }

package/internals/repokit/repokit_config.rs

@@ -1,19 +1,14 @@
-use std::{
-    collections::HashMap,
-    path::Path,
-    process::exit,
-    sync::LazyLock,
-};
-
+use core::panic;
 use jsonschema::Validator;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde_json::{Value, from_value, to_value};
+use std::{collections::HashMap, path::Path, sync::LazyLock};
 
 use crate::{
-    configuration::recovery::Recovery,
+    context::{file_system::FileSystem, node_scope::NodeScope},
+    internal_filesystem::file_builder::FileBuilder,
     logger::logger::Logger,
-    post_processing::post_processor::PostProcessor,
     repokit::{
         command_definition::CommandDefinition, repokit_command::RepoKitCommand,
         repokit_construct_validator::RepoKitConstructValidator,
@@ -52,24 +47,53 @@ 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 {
+impl RepoKitConstructValidator for RepoKitConfig {}
+
+impl RepoKitConfig {
+    pub fn from_input(root: &str, node: &mut NodeScope, 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);
+            RepoKitConfig::on_parsing_error(root, node, Value::Null);
         }
         repokit_config.expect("assertions succeeded")
     }
 
-    fn on_parsing_error(root: &str, _: Value) -> Option<String> {
+    pub fn on_parsing_error(root: &str, node: &mut NodeScope, _: 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);
+        node.type_check_file(path);
         println!();
         Logger::info("There was an error parsing your configuration");
-        recovery.prompt_to_fix_errors(path);
-        PostProcessor::get().flush();
-        exit(0);
+        NodeScope::prompt_to_fix_errors(path);
+        panic!();
+    }
+
+    pub fn create(files: &FileSystem) {
+        let file_path = format!("{}/repokit.ts", &files.git_root);
+        let path = Path::new(&file_path);
+        if path.exists() {
+            Logger::info(
+                format!(
+                    "I found a Repokit configuration without an exported {} instance",
+                    Logger::with_theme(|theme| theme.highlight("RepokitConfig"))
+                )
+                .as_str(),
+            );
+            return Logger::exit_with_info("Please create an instance and export it");
+        }
+        Logger::info("Welcome to Repokit! Let's get you setup");
+        Logger::info("Creating your configuration file:");
+        let mut source = files.resolve_template("configuration_template.txt");
+        let mut target = FileBuilder::create(path, |_| Logger::file_create_error());
+        FileBuilder::copy_to(&mut source, &mut target, |_| Logger::file_write_error());
+        Logger::info(
+            format!(
+                "Please fill out this file with your desired settings. Then run {}",
+                Logger::with_theme(|theme| theme.highlight("repokit onboard"))
+            )
+            .as_str(),
+        );
+        Logger::log_file_path(file_path.as_str());
+        panic!();
     }
 }

package/internals/repokit/repokit_construct_validator.rs

@@ -1,10 +1,7 @@
 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>;
-
+pub trait RepoKitConstructValidator {
     fn is_valid(validator: &Validator, input: &Value) -> bool {
         if validator.validate(input).is_err() {
             return false;