@repokit/core 3.0.6 → 4.0.0

package/internals/repokit/repokit_runtime.rs

@@ -0,0 +1,43 @@
+use std::sync::{LazyLock, Mutex, MutexGuard};
+
+
+use crate::{
+    context::{
+        cache_scope::CacheScope, file_system::FileSystem, git_scope::GitScope,
+        node_scope::NodeScope, typescript_bridge::TypeScriptBridge,
+    },
+    repokit::repokit_config::RepoKitConfig,
+};
+
+pub struct RepoKitRuntime {
+    pub git: GitScope,
+    pub node: NodeScope,
+    pub files: FileSystem,
+    pub caches: CacheScope,
+    pub configuration: RepoKitConfig,
+}
+
+static REPOKIT_RUNTIME: LazyLock<Mutex<RepoKitRuntime>> =
+    LazyLock::new(|| Mutex::new(RepoKitRuntime::new()));
+
+impl RepoKitRuntime {
+    pub fn new() -> RepoKitRuntime {
+        let git = GitScope::new();
+        let files = FileSystem::new(&git.root);
+        let caches = CacheScope::new(&git, &files);
+        let mut node = NodeScope::new(&git.root);
+        let configuration = TypeScriptBridge::parse_configuration(&files, &mut node);
+        RepoKitRuntime {
+            git,
+            node,
+            files,
+            caches,
+            configuration,
+        }
+    }
+
+    pub fn with_runtime<R>(mut func: impl FnMut(MutexGuard<'_, RepoKitRuntime>) -> R) -> R {
+        let registry = REPOKIT_RUNTIME.lock().unwrap();
+        func(registry)
+    }
+}

package/internals/themes/theme_registry.rs

@@ -1,14 +1,11 @@
 use std::collections::HashMap;
 
-use crate::{
-    internal_filesystem::internal_filesystem::InternalFileSystem,
-    themes::{
+use crate::themes::{
         built_in_themes::{money::MONEY, seeing_red::SEEING_RED, the_blues::THE_BLUES},
         theme::Theme,
         theme_colors::ThemeColors,
         theme_inputs::{RepoKitTheme, ThemeInputColors},
-    },
-};
+    };
 
 pub struct ThemeRegistry {
     pub theme: String,
@@ -26,11 +23,12 @@ impl ThemeRegistry {
         }
     }
 
-    pub fn set_theme(&mut self, root: &str, theme: &str) {
+    pub fn set_theme(&mut self, theme: &str) -> bool {
         if self.themes.contains_key(theme) && self.theme != theme {
             self.theme = theme.to_string();
-            InternalFileSystem::new(root).store_theme_preference(theme);
+            return true;
         }
+        false
     }
 
     pub fn current_theme(&self) -> &Theme {

package/internals/validations/command_validations.rs

@@ -1,54 +1,31 @@
-use std::{
-    collections::HashMap,
-    sync::{Arc, Mutex},
-};
-
-use ignore::WalkBuilder;
+use std::collections::HashMap;
 
 use crate::{
-    configuration::typescript_command::TypescriptCommand,
-    executables::{
-        internal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
-    },
-    file_walker::walker::TSFileVisitorBuilder,
-    internal_commands::internal_registry::InternalRegistry,
+    context::typescript_bridge::TypeScriptBridge,
+    executables::internal_executable::InternalExecutable,
+    file_walker::file_walker::FileWalker,
+    internal_commands::internal_registry::InternalCommandRegistry,
     logger::logger::Logger,
-    repokit::{repokit::RepoKit, repokit_command::RepoKitCommand},
+    repokit::{repokit_command::RepoKitCommand, repokit_runtime::RepoKitRuntime},
 };
 
-pub struct CommandValidations {
-    scope: RepoKitScope,
-}
+pub struct CommandValidations;
 
 impl CommandValidations {
-    pub fn new(scope: &RepoKitScope) -> CommandValidations {
-        CommandValidations {
-            scope: scope.clone(),
-        }
-    }
-
-    pub fn from(kit: &RepoKit) -> CommandValidations {
-        CommandValidations {
-            scope: kit.scope.clone(),
-        }
-    }
-
-    pub fn collect_and_validate_internals(&self) -> HashMap<String, Box<dyn InternalExecutable>> {
-        let internals = InternalRegistry::new(&self.scope).get_all();
-        self.detect_collisions_between_internals_and_root_commands(&internals);
+    pub fn collect_and_validate_internals() -> HashMap<String, Box<dyn InternalExecutable>> {
+        let internals = InternalCommandRegistry::new().get_all();
+        CommandValidations::detect_collisions_between_internals_and_root_commands(&internals);
         internals
     }
 
-    pub fn collect_and_validate_externals(&self) -> HashMap<String, RepoKitCommand> {
-        let paths: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
-        let mut visitor = TSFileVisitorBuilder::new(&self.scope.root, &paths);
-        WalkBuilder::new(&self.scope.root)
-            .build_parallel()
-            .visit(&mut visitor);
-        let result = paths.lock().unwrap();
-        let externals = TypescriptCommand::new(&self.scope.root).parse_commands(&result);
-        let all = [&externals[..], &self.scope.configuration.thirdParty[..]].concat();
-        self.detect_collisions_between_root_commands_and_externals(&all)
+    pub fn collect_and_validate_externals() -> HashMap<String, RepoKitCommand> {
+        let walker = FileWalker::new();
+        let result = walker.get();
+        let externals = TypeScriptBridge::parse_commands(&result);
+        let all = RepoKitRuntime::with_runtime(|runtime| {
+            [&externals[..], &runtime.configuration.thirdParty[..]].concat()
+        });
+        CommandValidations::detect_collisions_between_root_commands_and_externals(&all)
     }
 
     pub fn detect_collisions_between_internals_and_externals(
@@ -72,11 +49,12 @@ impl CommandValidations {
     }
 
     fn detect_collisions_between_internals_and_root_commands(
-        &self,
         internals: &HashMap<String, Box<dyn InternalExecutable>>,
     ) {
         for name in internals.keys() {
-            if self.scope.configuration.commands.contains_key(name) {
+            if RepoKitRuntime::with_runtime(|runtime| {
+                runtime.configuration.commands.contains_key(name)
+            }) {
                 Logger::info(
                     format!(
                         "I encountered a command named {} in your {} file that conflicts with one of my internals",
@@ -91,29 +69,28 @@ impl CommandValidations {
     }
 
     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("Unknown command");
-                self.on_external_duplicate_collision(command, &original.location);
+        RepoKitRuntime::with_runtime(|runtime| {
+            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("Unknown command");
+                    CommandValidations::on_external_duplicate_collision(
+                        command,
+                        &original.location,
+                    );
+                }
+                map.insert(command.name.clone(), command.clone());
+                if runtime.configuration.commands.contains_key(&command.name) {
+                    CommandValidations::on_external_root_collision(command);
+                }
             }
-            map.insert(command.name.clone(), command.clone());
-            if self
-                .scope
-                .configuration
-                .commands
-                .contains_key(&command.name)
-            {
-                self.on_external_root_collision(command);
-            }
-        }
-        map
+            map
+        })
     }
 
-    fn on_external_root_collision(&self, command: &RepoKitCommand) {
+    fn on_external_root_collision(command: &RepoKitCommand) {
         Logger::info(format!(
                 "I encountered a package command named {} that conflicts with a command in your {} file",
                 Logger::with_theme(|theme|theme.highlight(&command.name)),
@@ -126,7 +103,7 @@ impl CommandValidations {
         Logger::exit_with_info("Please rename one of these");
     }
 
-    fn on_external_duplicate_collision(&self, command: &RepoKitCommand, collision_path: &str) {
+    fn on_external_duplicate_collision(command: &RepoKitCommand, collision_path: &str) {
         Logger::info(
             format!(
                 "I encountered two packages with the name {}",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "3.0.6",
+  "version": "4.0.0",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "keywords": [
     "cli",
@@ -63,9 +63,9 @@
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "eslint-plugin-unused-imports": "^4.4.1",
-    "oxfmt": "^0.42.0",
+    "oxfmt": "^0.43.0",
     "oxlint": "^1.42.0",
-    "oxlint-tsgolint": "^0.18.1",
+    "oxlint-tsgolint": "^0.19.0",
     "tsdown": "^0.21.0",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2"

package/internals/configuration/configuration.rs

@@ -1,45 +0,0 @@
-use std::path::Path;
-
-use crate::{
-    internal_filesystem::{file_builder::FileBuilder, internal_filesystem::InternalFileSystem},
-    logger::logger::Logger,
-    post_processing::post_processor::PostProcessor,
-};
-
-pub struct Configuration;
-
-impl Configuration {
-    pub fn create(root: &str) {
-        let file_path = format!("{root}/repokit.ts");
-        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");
-        }
-        Configuration::welcome();
-        let mut source =
-            InternalFileSystem::new(root).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());
-        PostProcessor::get().flush();
-    }
-
-    fn welcome() {
-        Logger::info("Welcome to Repokit! Let's get you setup");
-        Logger::info("Creating your configuration file:");
-    }
-}

package/internals/configuration/mod.rs

@@ -1,3 +0,0 @@
-pub mod configuration;
-pub mod recovery;
-pub mod typescript_command;

package/internals/configuration/recovery.rs

@@ -1,42 +0,0 @@
-use crate::{
-    executor::executor::Executor, internal_filesystem::internal_filesystem::InternalFileSystem,
-    logger::logger::Logger,
-};
-
-pub struct Recovery {
-    root: String,
-}
-
-impl Recovery {
-    pub fn new(root: &str) -> Recovery {
-        Recovery {
-            root: root.to_owned(),
-        }
-    }
-
-    pub fn run(&mut self, file_path: &str) {
-        let command = self.get_typecheck_command(file_path);
-        Executor::with_stdio(command, |cmd| cmd);
-    }
-
-    pub fn get_typecheck_command(&self, file_path: &str) -> String {
-        let executor = InternalFileSystem::get_node_executor(&self.root);
-        let typescript_version = InternalFileSystem::get_typescript_version(executor);
-        let ignore_config = if typescript_version >= 6 {
-            " --ignoreConfig".to_string()
-        } else {
-            "".to_string()
-        };
-        let tsc_command = format!("{} tsc {} --noEmit{}", executor, file_path, ignore_config);
-        tsc_command
-    }
-
-    pub fn prompt_to_fix_errors(&self, config_path: &str) {
-        Logger::info(
-            "Please fix the above type-errors and rerun your command"
-                .to_string()
-                .as_str(),
-        );
-        Logger::log_file_path(config_path);
-    }
-}

package/internals/configuration/typescript_command.rs

@@ -1,65 +0,0 @@
-use std::{path::Path, process::exit, sync::MutexGuard};
-
-use serde_json::{Value, from_str};
-
-use crate::{
-    configuration::configuration::Configuration,
-    executor::executor::Executor,
-    internal_filesystem::internal_filesystem::InternalFileSystem,
-    post_processing::post_processor::PostProcessor,
-    repokit::{
-        repokit_command::RepoKitCommand, repokit_config::RepoKitConfig,
-        repokit_construct_validator::RepoKitConstructValidator,
-    },
-};
-
-pub struct TypescriptCommand {
-    root: String,
-}
-
-impl TypescriptCommand {
-    pub fn new(root: &str) -> TypescriptCommand {
-        TypescriptCommand {
-            root: root.to_owned(),
-        }
-    }
-
-    pub fn parse_configuration(&self) -> RepoKitConfig {
-        let executable = InternalFileSystem::new(&self.root).resolve_command("parse_configuration");
-        let stdout = self.execute(format!("{executable} --root {}", &self.root).as_str());
-        if stdout.is_empty() {
-            Configuration::create(&self.root);
-        }
-        let result: Result<Value, serde_json::Error> = from_str(stdout.as_str());
-        match result {
-            Ok(config) => RepoKitConfig::from_input(&self.root, config),
-            Err(_) => {
-                RepoKitConfig::on_parsing_error(&self.root, Value::Null);
-                PostProcessor::get().flush();
-                exit(0)
-            }
-        }
-    }
-
-    pub fn parse_commands(&self, path_list: &MutexGuard<Vec<String>>) -> Vec<RepoKitCommand> {
-        let paths = path_list.join(",");
-        let executable = InternalFileSystem::new(&self.root).resolve_command("parse_commands");
-        let stdout =
-            self.execute(format!("{executable} --paths {paths} --root {}", self.root).as_str());
-        let result: Result<Vec<Value>, serde_json::Error> = serde_json::from_str(&stdout);
-        match result {
-            Ok(commands) => RepoKitCommand::from_input(&self.root, commands),
-            Err(_) => {
-                RepoKitCommand::on_parsing_error(&self.root, Value::Null);
-                PostProcessor::get().flush();
-                exit(0);
-            }
-        }
-    }
-
-    fn execute(&self, args: &str) -> String {
-        Executor::exec(format!("node {args}"), |cmd| {
-            cmd.current_dir(Path::new(&self.root))
-        })
-    }
-}