@repokit/core 4.0.6 → 5.0.1

package/internals/caches/version_cache.rs

@@ -1,142 +0,0 @@
-use std::{
-    fs::File,
-    io::{BufRead, BufReader},
-    path::PathBuf,
-    sync::LazyLock,
-};
-
-use futures::{executor::block_on, join};
-use regex::Regex;
-
-use crate::{
-    caches::{
-        file_cache::FileCache, old_cache::OldCache,
-        repokit_version_resolver::RepoKitVersionResolver,
-    },
-    context::file_system::FileSystem,
-    logger::logger::Logger,
-};
-
-#[derive(Clone)]
-pub struct VersionCache {
-    pub runtime_version: String,
-    pub installed_version: String,
-    pub old_cache_path_version: String,
-    pub cache_directory: Option<PathBuf>,
-}
-
-pub static VERSION_REGEX: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r#"\d*\.\d*.\d*"#).unwrap());
-
-impl VersionCache {
-    pub fn new(cache_directory: &Option<PathBuf>) -> Self {
-        VersionCache {
-            runtime_version: "".to_string(),
-            installed_version: "".to_string(),
-            old_cache_path_version: "".to_string(),
-            cache_directory: cache_directory.clone(),
-        }
-    }
-
-    pub fn refresh_installed_version(&self, files: &FileSystem) -> Option<String> {
-        let installed_version = block_on(self.installed_repokit_version(files));
-        if let Some(version) = &installed_version
-            && *version != self.installed_version
-        {
-            return Some(version.to_string());
-        }
-        None
-    }
-
-    pub async fn initialize(&mut self, files: &FileSystem) {
-        let (runtime_result, install_result, old_cache_path_version) = join!(
-            self.runtime_version(),
-            self.installed_repokit_version(files),
-            self.get_old_cache_path_version(),
-        );
-        if let Some(installed_version) = install_result {
-            self.installed_version = installed_version;
-        }
-        if let Some(runtime_version) = runtime_result {
-            self.runtime_version = runtime_version;
-        }
-        if let Some(old_cache_version) = old_cache_path_version {
-            self.old_cache_path_version = old_cache_version;
-        }
-        if (self.installed_version != self.runtime_version)
-            || (self.installed_version != self.old_cache_path_version
-                && !self.old_cache_path_version.is_empty())
-                && VERSION_REGEX.is_match(&self.installed_version)
-        {
-            self.hop_to_installed_version(files);
-        }
-    }
-
-    fn hop_to_installed_version(&self, files: &FileSystem) {
-        Logger::info(
-            format!(
-                "Switching to version {}",
-                Logger::with_theme(|theme| theme.highlight(&self.installed_version))
-            )
-            .as_str(),
-        );
-        RepoKitVersionResolver::hop_to_installed_version(files);
-    }
-
-    async fn runtime_version(&self) -> Option<String> {
-        if let Some((mut lines, _)) = self.read() {
-            let last_known_version = self.unwrap_line(lines.nth(0), "");
-            if VERSION_REGEX.is_match(&last_known_version) {
-                return Some(last_known_version);
-            }
-            return None;
-        }
-        None
-    }
-
-    async fn installed_repokit_version(&self, files: &FileSystem) -> Option<String> {
-        let package_path = FileSystem::join_with(&files.package_directory, "package.json");
-        if !package_path.exists() || !package_path.is_file() {
-            return None;
-        }
-        let file = File::open(package_path);
-        if file.is_err() {
-            return None;
-        }
-        let lines = BufReader::new(file.unwrap()).lines();
-        let version_matcher = Regex::new(r#""([^"]*)""#).unwrap();
-        for line in lines.map_while(Result::ok) {
-            if line.contains("\"version\": ") {
-                let captures: Vec<String> = version_matcher
-                    .captures_iter(&line)
-                    .filter_map(|item| {
-                        item.get(1)
-                            .map(|match_text| match_text.as_str().to_string())
-                    })
-                    .collect();
-                if let Some(version) = captures.get(1)
-                    && VERSION_REGEX.is_match(version)
-                {
-                    return Some(version.to_string());
-                }
-                return None;
-            }
-        }
-        None
-    }
-
-    async fn get_old_cache_path_version(&self) -> Option<String> {
-        let old_cache = OldCache::new();
-        old_cache.get_version()
-    }
-}
-
-impl FileCache for VersionCache {
-    fn cache_file(&self) -> &str {
-        "../.version"
-    }
-
-    fn cache_directory(&self) -> &Option<PathBuf> {
-        &self.cache_directory
-    }
-}

package/internals/context/cache_scope.rs

@@ -1,71 +0,0 @@
-use futures::{executor::block_on, join};
-use std::{
-    env::home_dir,
-    fs::create_dir_all,
-    path::PathBuf,
-};
-
-use crate::{
-    caches::{
-        crawl_cache::CrawlCache, file_cache::FileCache,
-        settings_cache::SettingsCache, version_cache::VersionCache,
-    },
-    context::{file_system::FileSystem, git_scope::GitScope},
-};
-
-#[derive(Clone)]
-pub struct CacheScope {
-    pub crawl_cache: CrawlCache,
-    pub version_cache: VersionCache,
-    pub settings_cache: SettingsCache,
-}
-
-static CACHE_DIRECTORY: &str = ".repokit_cache";
-
-impl CacheScope {
-    pub fn new(git_scope: &GitScope, file_system: &FileSystem) -> CacheScope {
-        let home = home_dir();
-        let cache_directory =
-            CacheScope::resolve_cache_directory(&home, &git_scope.root_commit_hash);
-        let mut instance = CacheScope {
-            crawl_cache: CrawlCache::new(&cache_directory),
-            version_cache: VersionCache::new(&cache_directory),
-            settings_cache: SettingsCache::new(&cache_directory),
-        };
-        block_on(instance.initialize_all(git_scope, file_system));
-        instance
-    }
-
-    async fn initialize_all(&mut self, git_scope: &GitScope, file_system: &FileSystem) {
-        self.create_cache_files().await;
-        join!(
-            self.version_cache.initialize(file_system),
-            self.settings_cache.initialize(),
-            self.crawl_cache.initialize(git_scope),
-        );
-    }
-
-    async fn create_cache_files(&self) {
-        join!(
-            self.version_cache.create_cache_file_if_not_exists(),
-            self.settings_cache.create_cache_file_if_not_exists(),
-            self.crawl_cache.create_cache_file_if_not_exists(),
-        );
-    }
-
-    fn resolve_cache_directory(
-        home_path: &Option<PathBuf>,
-        root_commit: &Option<String>,
-    ) -> Option<PathBuf> {
-        if let Some(home) = home_path
-            && let Some(commit_hash) = root_commit
-        {
-            let cache_dir = home.join(CACHE_DIRECTORY).join(commit_hash);
-            if !cache_dir.exists() && create_dir_all(&cache_dir).is_err() {
-                return None;
-            }
-            return Some(cache_dir);
-        }
-        None
-    }
-}

package/internals/context/file_system.rs

@@ -1,66 +0,0 @@
-use normalize_path::NormalizePath;
-
-use std::{
-    fs::File,
-    path::{Path, PathBuf},
-};
-
-use crate::{internal_filesystem::file_builder::FileBuilder, logger::logger::Logger};
-
-#[derive(Clone)]
-pub struct FileSystem {
-    pub git_root: String,
-    pub git_root_path: PathBuf,
-    pub package_directory: PathBuf,
-    pub commands_directory: PathBuf,
-    pub templates_directory: PathBuf,
-    pub install_script_path: PathBuf,
-    pub install_script_location: &'static str,
-}
-
-static INSTALL_SCRIPT_LOCATION: &str = "installation/install.sh";
-static INSTALLED_PACKAGE_PATH: &str = "node_modules/@repokit/core";
-static TYPESCRIPT_COMMANDS: &str = "dist/commands";
-static TYPESCRIPT_TEMPLATES: &str = "externals/templates";
-
-impl FileSystem {
-    pub fn new(git_root: &str) -> FileSystem {
-        let git_root_path = Path::new(&git_root).normalize();
-        let package_directory = FileSystem::join_with(&git_root_path, INSTALLED_PACKAGE_PATH);
-        FileSystem {
-            git_root_path,
-            git_root: git_root.to_owned(),
-            install_script_path: FileSystem::join_with(&package_directory, INSTALL_SCRIPT_LOCATION),
-            commands_directory: FileSystem::join_with(&package_directory, TYPESCRIPT_COMMANDS),
-            templates_directory: FileSystem::join_with(&package_directory, TYPESCRIPT_TEMPLATES),
-            package_directory,
-            install_script_location: INSTALL_SCRIPT_LOCATION,
-        }
-    }
-
-    pub fn join_with(root: &PathBuf, segment: &str) -> PathBuf {
-        root.join(segment).normalize()
-    }
-
-    pub fn resolve_command(&self, command_name: &str) -> String {
-        FileSystem::path_buf_to_str(&FileSystem::join_with(
-            &self.commands_directory,
-            format!("{command_name}.mjs").as_str(),
-        ))
-    }
-
-    pub fn resolve_template(&self, file_name: &str) -> File {
-        FileBuilder::open(
-            FileSystem::join_with(&self.templates_directory, file_name),
-            |_| {
-                Logger::error(format!("Unable to locate internal {file_name}").as_str());
-                Logger::error("Please file a bug here");
-                Logger::log_issue_link();
-            },
-        )
-    }
-
-    pub fn path_buf_to_str(path: &PathBuf) -> String {
-        path.to_string_lossy().to_string()
-    }
-}

package/internals/context/git_scope.rs

@@ -1,55 +0,0 @@
-use std::path::Path;
-
-use futures::{executor::block_on, join};
-
-use crate::{executor::executor::Executor, logger::logger::Logger};
-
-#[derive(Clone)]
-pub struct GitScope {
-    pub root: String,
-    pub root_commit_hash: Option<String>,
-    pub head_commit_hash: Option<String>,
-}
-
-impl GitScope {
-    pub fn new() -> GitScope {
-        let mut instance = GitScope {
-            root: "".to_string(),
-            root_commit_hash: None,
-            head_commit_hash: None,
-        };
-        block_on(instance.resolve());
-        instance
-    }
-
-    async fn resolve(&mut self) {
-        let (root, root_commit, head_commit) = join!(
-            GitScope::find_root(),
-            GitScope::get_root_commit(),
-            GitScope::get_head_commit()
-        );
-        self.root = root;
-        self.root_commit_hash = root_commit;
-        self.head_commit_hash = head_commit;
-    }
-
-    async fn find_root() -> String {
-        if let Some(root) = Executor::exec_with_stdout("git rev-parse --show-toplevel", |cmd| cmd)
-            && !root.is_empty()
-            && Path::new(&root).exists()
-        {
-            return root;
-        }
-        Logger::info("Please initialize your repository by running");
-        Logger::log_file_path("git init");
-        panic!();
-    }
-
-    async fn get_head_commit() -> Option<String> {
-        Executor::exec_with_stdout("git rev-parse HEAD", |cmd| cmd)
-    }
-
-    async fn get_root_commit() -> Option<String> {
-        Executor::exec_with_stdout("git rev-list --parents HEAD | tail -1", |cmd| cmd)
-    }
-}

package/internals/context/mod.rs

@@ -1,5 +0,0 @@
-pub mod cache_scope;
-pub mod file_system;
-pub mod git_scope;
-pub mod node_scope;
-pub mod typescript_bridge;

package/internals/context/node_scope.rs

@@ -1,133 +0,0 @@
-use std::{collections::HashMap, path::Path};
-
-use normalize_path::NormalizePath;
-
-use crate::{
-    caches::version_cache::VERSION_REGEX, executor::executor::Executor, logger::logger::Logger,
-};
-
-#[derive(Clone)]
-pub struct NodeScope {
-    pub install_command: String,
-    pub command_executor: String,
-    pub package_manager: String,
-    pub resolved_typescript_version: Option<u32>,
-}
-
-impl NodeScope {
-    pub fn new(git_root: &str) -> NodeScope {
-        let package_manager = NodeScope::get_package_manager(git_root).to_string();
-        NodeScope {
-            resolved_typescript_version: None,
-            command_executor: NodeScope::get_node_executor(&package_manager).to_string(),
-            install_command: NodeScope::get_install_command(&package_manager).to_string(),
-            package_manager,
-        }
-    }
-
-    pub fn type_check_file(&mut self, file_path: &str) {
-        let command = self.get_typecheck_command(file_path);
-        Executor::with_stdio(command, |cmd| cmd);
-    }
-
-    pub fn get_typecheck_command(&mut self, file_path: &str) -> String {
-        let typescript_version = self.get_typescript_version();
-        let ignore_config = if typescript_version >= 6 {
-            " --ignoreConfig".to_string()
-        } else {
-            "".to_string()
-        };
-        let tsc_command = format!(
-            "{} tsc {} --noEmit{}",
-            self.command_executor, file_path, ignore_config
-        );
-        tsc_command
-    }
-
-    pub fn prompt_to_fix_errors(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);
-    }
-
-    fn get_typescript_version(&mut self) -> u32 {
-        if let Some(resolved_version) = self.resolved_typescript_version {
-            return resolved_version;
-        }
-        let stdout = Executor::exec(format!("{} tsc --version", self.command_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);
-        let major = semver
-            .chars()
-            .next()
-            .unwrap_or('5')
-            .to_digit(10)
-            .unwrap_or(5);
-        self.resolved_typescript_version = Some(major);
-        major
-    }
-
-    fn get_install_command(package_manager: &str) -> &str {
-        let npm_install = "npm i -D";
-        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)
-    }
-
-    fn get_node_executor(package_manager: &str) -> &str {
-        let npx = "npx";
-        let manager_map = HashMap::from([
-            ("npm", "npx"),
-            ("yarn", "yarn run -T"),
-            ("pnpm", "pnpm"),
-            ("bun", "bunx"),
-        ]);
-        manager_map.get(package_manager).unwrap_or(&npx)
-    }
-
-    fn get_package_manager(root: &str) -> &str {
-        let manager_map = HashMap::from([
-            ("npm", ["package-lock.json"].to_vec()),
-            ("yarn", ["yarn.lock"].to_vec()),
-            ("pnpm", ["pnpm-lock.yaml"].to_vec()),
-            ("bun", ["bun.lockb", "bun.lock"].to_vec()),
-        ]);
-        for (manager, lock_files) in manager_map {
-            for lock_file in lock_files {
-                let path = Path::new(root).join(lock_file).normalize();
-                if path.exists() && path.is_file() {
-                    return manager;
-                }
-            }
-        }
-        "npm"
-    }
-}

package/internals/context/typescript_bridge.rs

@@ -1,84 +0,0 @@
-use core::panic;
-use std::{
-    path::{Path, PathBuf},
-    sync::{LazyLock, MutexGuard},
-};
-
-use regex::Regex;
-use serde_json::{Value, from_str};
-
-use crate::{
-    context::{file_system::FileSystem, node_scope::NodeScope},
-    executor::executor::Executor,
-    logger::logger::Logger,
-    repokit::{
-        repokit_command::RepoKitCommand, repokit_config::RepoKitConfig,
-        repokit_runtime::RepoKitRuntime,
-    },
-};
-
-static BRIDGE_PARSING_REGEX: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new(r#"=============== REPOKIT PARSE FLAG ===============(.*)=============== REPOKIT PARSE FLAG ==============="#).unwrap()
-});
-
-pub struct TypeScriptBridge;
-
-impl TypeScriptBridge {
-    pub fn parse_configuration(files: &FileSystem, node: &mut NodeScope) -> RepoKitConfig {
-        let executable = files.resolve_command("parse_configuration");
-        let stdout = TypeScriptBridge::execute_with_node(
-            &files.git_root_path,
-            format!("{executable} --root {}", &files.git_root).as_str(),
-        );
-        if stdout.is_empty() {
-            RepoKitConfig::create(files);
-        }
-        if let Some(parsed_config) = TypeScriptBridge::unwrap_stdout(&stdout) {
-            let parse_result: Result<Value, serde_json::Error> = from_str(parsed_config);
-            if let Ok(config) = parse_result {
-                return RepoKitConfig::from_input(&files.git_root, node, config);
-            }
-        }
-        Logger::parse_error("configuration", &stdout);
-        panic!();
-    }
-
-    pub fn parse_commands(path_list: &MutexGuard<Vec<String>>) -> Vec<RepoKitCommand> {
-        let paths = path_list.join(",");
-        let stdout = RepoKitRuntime::with_runtime(|runtime| {
-            let executable = runtime.files.resolve_command("parse_commands");
-            TypeScriptBridge::execute_with_node(
-                &runtime.files.git_root_path,
-                format!(
-                    "{executable} --paths {paths} --root {}",
-                    runtime.files.git_root
-                )
-                .as_str(),
-            )
-        });
-        if let Some(parsed_commands) = TypeScriptBridge::unwrap_stdout(&stdout) {
-            let parse_result: Result<Vec<Value>, serde_json::Error> =
-                serde_json::from_str(parsed_commands);
-            if let Ok(commands) = parse_result {
-                return RepoKitCommand::from_input(commands);
-            }
-        }
-        Logger::parse_error("commands", &stdout);
-        panic!();
-    }
-
-    fn execute_with_node(root: &PathBuf, args: &str) -> String {
-        Executor::exec(format!("node {args}"), |cmd| {
-            cmd.current_dir(Path::new(root))
-        })
-    }
-
-    fn unwrap_stdout(stdout: &str) -> Option<&str> {
-        if let Some(capture) = BRIDGE_PARSING_REGEX.captures(stdout)
-            && let Some(result) = capture.get(1)
-        {
-            return Some(result.as_str());
-        }
-        None
-    }
-}

package/internals/executables/internal_executable.rs

@@ -1,15 +0,0 @@
-use std::collections::HashMap;
-
-use crate::{
-    executables::internal_executable_definition::InternalExecutableDefinition,
-    internal_commands::help::Help,
-};
-
-pub trait InternalExecutable {
-    fn run(&self, args: Vec<String>, internals: &HashMap<String, Box<dyn InternalExecutable>>);
-    fn get_definition(&self) -> &InternalExecutableDefinition;
-
-    fn help(&self) {
-        Help::log_internal_command(self.get_definition());
-    }
-}

package/internals/executables/internal_executable_definition.rs

@@ -1,40 +0,0 @@
-use std::collections::HashMap;
-
-#[derive(Clone)]
-pub struct InternalExecutableDefinition {
-    pub name: String,
-    pub description: String,
-    pub args: Option<HashMap<String, String>>,
-}
-
-pub struct InternalExecutableDefinitionInput<'a, const N: usize> {
-    pub name: &'a str,
-    pub description: &'a str,
-    pub args: [(&'a str, &'a str); N],
-}
-
-impl InternalExecutableDefinition {
-    pub fn define<const N: usize>(
-        definition: InternalExecutableDefinitionInput<N>,
-    ) -> InternalExecutableDefinition {
-        let InternalExecutableDefinitionInput {
-            name,
-            description,
-            args,
-        } = definition;
-        InternalExecutableDefinition {
-            name: String::from(name),
-            description: String::from(description),
-            args: InternalExecutableDefinition::args(args),
-        }
-    }
-
-    pub fn args<const N: usize>(tuples: [(&str, &str); N]) -> Option<HashMap<String, String>> {
-        if tuples.is_empty() {
-            return None;
-        }
-        Some(HashMap::from(tuples.map(|(key, value)| {
-            (String::from(key), String::from(value))
-        })))
-    }
-}

package/internals/executables/mod.rs

@@ -1,2 +0,0 @@
-pub mod internal_executable;
-pub mod internal_executable_definition;