@repokit/core 4.0.5 → 5.0.0

package/internals/executor/executor.rs

@@ -1,88 +0,0 @@
-use std::ffi::OsStr;
-use std::process::Command;
-use std::str;
-
-pub struct Executor {}
-
-impl Executor {
-    pub fn exec<T: AsRef<OsStr>>(
-        command: T,
-        composer: impl Fn(&mut Command) -> &mut Command,
-    ) -> String {
-        let output = composer(&mut Executor::spawn(command))
-            .output()
-            .expect("command failed to execute");
-        if output.status.success() {
-            return Executor::unwrap(&output.stdout);
-        }
-        Executor::unwrap(&output.stderr)
-    }
-
-    pub fn exec_with_errors<T: AsRef<OsStr>>(
-        command: T,
-        composer: impl Fn(&mut Command) -> &mut Command,
-    ) -> Option<String> {
-        let output = composer(&mut Executor::spawn(command))
-            .output()
-            .expect("command failed to execute");
-        if output.status.success() {
-            return None;
-        }
-        Some(Executor::unwrap(&output.stderr))
-    }
-
-    pub fn exec_with_stdout<T: AsRef<OsStr>>(
-        command: T,
-        composer: impl Fn(&mut Command) -> &mut Command,
-    ) -> Option<String> {
-        let output = composer(&mut Executor::spawn(command))
-            .output()
-            .expect("command failed to execute");
-        if output.status.success() {
-            return Some(Executor::unwrap(&output.stdout));
-        }
-        None
-    }
-
-    pub fn with_stdio<T: AsRef<OsStr>>(
-        command: T,
-        composer: impl Fn(&mut Command) -> &mut Command,
-    ) {
-        let mut child = composer(&mut Executor::spawn(command))
-            .spawn()
-            .expect("Failed to execute");
-        child.wait().expect("failed to wait on child process");
-    }
-
-    pub fn spawn<T: AsRef<OsStr>>(program: T) -> Command {
-        let mut command = Executor::platform_command();
-        command.arg(program);
-        command
-    }
-
-    fn platform_command() -> Command {
-        if cfg!(target_os = "windows") {
-            return Executor::windows_command();
-        }
-        Executor::unix_command()
-    }
-
-    fn windows_command() -> Command {
-        let mut child_process = Command::new("cmd");
-        child_process.arg("/C");
-        child_process
-    }
-
-    fn unix_command() -> Command {
-        let mut child_process = Command::new("sh");
-        child_process.arg("-c");
-        child_process
-    }
-
-    fn unwrap(io: &[u8]) -> String {
-        str::from_utf8(io)
-            .expect("Invalid output")
-            .trim()
-            .to_string()
-    }
-}

package/internals/executor/mod.rs

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

package/internals/file_walker/file_walker.rs

@@ -1,69 +0,0 @@
-use std::sync::{Arc, Mutex, MutexGuard};
-
-use ignore::WalkBuilder;
-
-use crate::{
-    file_walker::walker::{TSFileVisitor, TSFileVisitorBuilder},
-    repokit::repokit_runtime::RepoKitRuntime,
-};
-
-pub struct FileWalker {
-    pub command_paths: Arc<Mutex<Vec<String>>>,
-}
-
-impl FileWalker {
-    pub fn new() -> Self {
-        let instance = FileWalker {
-            command_paths: Arc::new(Mutex::new(Vec::new())),
-        };
-        instance.resolve();
-        instance
-    }
-
-    pub fn get(&self) -> MutexGuard<'_, Vec<String>> {
-        self.command_paths.lock().unwrap()
-    }
-
-    fn resolve(&self) {
-        if RepoKitRuntime::with_runtime(|runtime| runtime.caches.crawl_cache.crawl_cache_enabled())
-        {
-            self.from_cache();
-        } else {
-            self.crawl_file_system();
-        }
-    }
-
-    fn crawl_file_system(&self) {
-        RepoKitRuntime::with_runtime(|runtime| {
-            let mut visitor = TSFileVisitorBuilder::new(&runtime.git.root, &self.command_paths);
-            WalkBuilder::new(&runtime.files.git_root_path)
-                .build_parallel()
-                .visit(&mut visitor);
-            if let Some(head_commit) = &runtime.git.head_commit_hash {
-                let files = self.command_paths.lock().unwrap();
-                runtime
-                    .caches
-                    .crawl_cache
-                    .cache_crawl_results([head_commit.to_owned(), files.join("\n")].join("\n"));
-            }
-        });
-    }
-
-    fn from_cache(&self) {
-        RepoKitRuntime::with_runtime(|runtime| {
-            let mut paths_to_search = self.command_paths.lock().unwrap();
-            if let Some(files_to_crawl) = &runtime.caches.crawl_cache.files_to_crawl {
-                for file in files_to_crawl {
-                    paths_to_search.push(file.to_owned());
-                }
-            }
-            if let Some(changed_files) = &runtime.caches.crawl_cache.changed_files {
-                let mut paths_to_import =
-                    TSFileVisitor::traverse_list(&runtime.git.root, changed_files.to_owned());
-                if !paths_to_import.is_empty() {
-                    paths_to_search.append(&mut paths_to_import);
-                }
-            }
-        });
-    }
-}

package/internals/file_walker/mod.rs

@@ -1,2 +0,0 @@
-pub mod file_walker;
-pub mod walker;

package/internals/file_walker/walker.rs

@@ -1,114 +0,0 @@
-use std::{
-    fs::File,
-    io::{BufRead, BufReader},
-    path::Path,
-    sync::{Arc, LazyLock, Mutex},
-};
-
-use ignore::{DirEntry, Error, ParallelVisitor, ParallelVisitorBuilder, WalkState};
-use regex::Regex;
-use tokio::task::JoinSet;
-
-use crate::{internal_filesystem::file_builder::FileBuilder, logger::logger::Logger};
-
-pub struct TSFileVisitor {
-    root: String,
-    paths: Arc<Mutex<Vec<String>>>,
-}
-
-static REPOKIT_IMPORT_MATCHER: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new(r#"(require\(|from[\s*]?)['"]@repokit/core["'][\)]?[;]?$"#).unwrap()
-});
-
-impl ParallelVisitor for TSFileVisitor {
-    fn visit(&mut self, entry: Result<DirEntry, Error>) -> WalkState {
-        let root_replacer = format!("{}/", self.root);
-        if let Ok(file_entry) = entry
-            && file_entry.file_type().is_some_and(|ft| ft.is_file())
-            && file_entry.file_name().to_string_lossy().ends_with(".ts")
-            && let Some(matched_path) = TSFileVisitor::on_file(file_entry.path())
-        {
-            let mut vector = self.paths.lock().unwrap();
-            vector.push(matched_path.to_string_lossy().replace(&root_replacer, ""));
-        }
-
-        WalkState::Continue
-    }
-}
-
-impl TSFileVisitor {
-    #[tokio::main]
-    pub async fn traverse_list(root: &str, path_list: Vec<String>) -> Vec<String> {
-        let mut handles = JoinSet::new();
-        let root_replacer = format!("{}/", root);
-        for path in path_list {
-            handles.spawn(async move {
-                if let Some(result) = TSFileVisitor::on_file(Path::new(&path)) {
-                    return Some(result.to_owned());
-                }
-                None
-            });
-        }
-        handles
-            .join_all()
-            .await
-            .iter()
-            .filter_map(|result| {
-                result
-                    .as_ref()
-                    .map(|path| path.to_string_lossy().replace(&root_replacer, ""))
-            })
-            .collect()
-    }
-
-    pub fn on_file(path: &Path) -> Option<&Path> {
-        let mut open_comment = false;
-        let file: File = FileBuilder::open(path, |_| Logger::open_file_error());
-        let reader: BufReader<File> = BufReader::new(file);
-        for line_result in reader.lines() {
-            let unwrapped = line_result.unwrap();
-            let line = unwrapped.trim();
-            if !open_comment && line.starts_with("/*") {
-                open_comment = true;
-                continue;
-            }
-            if open_comment {
-                if line.ends_with("*/") {
-                    open_comment = false;
-                }
-                continue;
-            }
-            if REPOKIT_IMPORT_MATCHER.is_match(line) {
-                return Some(path);
-            }
-            if !line.is_empty()
-                && !line.starts_with("import ")
-                && !line.contains("require(")
-                && !(line.starts_with("//") || line.starts_with("/*"))
-            {
-                break;
-            }
-        }
-        None
-    }
-}
-
-pub struct TSFileVisitorBuilder<'a> {
-    pub root: &'a str,
-    pub paths: &'a Arc<Mutex<Vec<String>>>,
-}
-
-impl<'a> TSFileVisitorBuilder<'a> {
-    pub fn new(root: &'a str, paths: &'a Arc<Mutex<Vec<String>>>) -> TSFileVisitorBuilder<'a> {
-        TSFileVisitorBuilder { paths, root }
-    }
-}
-
-impl<'s> ParallelVisitorBuilder<'s> for TSFileVisitorBuilder<'s> {
-    fn build(&mut self) -> Box<dyn ParallelVisitor + 's> {
-        Box::new(TSFileVisitor {
-            root: self.root.to_string(),
-            paths: self.paths.clone(),
-        })
-    }
-}

package/internals/internal_commands/help.rs

@@ -1,174 +0,0 @@
-use std::collections::HashMap;
-
-use alphanumeric_sort::{sort_slice_by_str_key, sort_str_slice};
-
-use crate::{
-    executables::{
-        internal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
-    },
-    logger::logger::Logger,
-    repokit::{
-        command_definition::CommandDefinition, repokit_command::RepoKitCommand,
-        repokit_config::RootCommand, repokit_runtime::RepoKitRuntime,
-    },
-};
-
-pub struct Help;
-
-impl Help {
-    pub fn list_all(
-        internals: &HashMap<String, Box<dyn InternalExecutable>>,
-        externals: &HashMap<String, RepoKitCommand>,
-    ) {
-        Help::log_internal_commands(internals);
-        RepoKitRuntime::with_runtime(|runtime| {
-            Help::log_root_commands(&runtime.configuration.commands);
-        });
-        Help::log_external_commands(externals);
-    }
-
-    pub fn log_internal_command(command: &InternalExecutableDefinition) {
-        Logger::with_theme(|theme| {
-            println!(
-                "{}{} {}",
-                Logger::indent(Some(3)),
-                theme.command(&command.name),
-                theme.description(&command.description),
-            );
-        });
-        Help::log_args(&command.args, None);
-    }
-
-    pub fn log_root_command(command: &RootCommand) {
-        Logger::with_theme(|theme| {
-            println!(
-                "{}{} {}",
-                Logger::indent(Some(3)),
-                theme.command(&command.name),
-                theme.description(&command.description),
-            );
-        });
-        Help::log_args(&command.args, None)
-    }
-
-    pub fn log_external_command(command: &RepoKitCommand) {
-        Logger::with_theme(|theme| {
-            println!(
-                "{}{} {}",
-                Logger::indent(Some(3)),
-                theme.command(&command.name),
-                theme.description(&command.description),
-            );
-        });
-        println!();
-        Help::log_external_subcommands(&command.commands, 6);
-        if !command.owner.is_empty() {
-            Logger::with_theme(|theme| {
-                println!(
-                    "\n{}{}{}",
-                    Logger::indent(Some(9)),
-                    theme.description("Owned by: "),
-                    Logger::cyan(&command.owner),
-                );
-            });
-        }
-    }
-
-    pub fn log_external_subcommands(map: &HashMap<String, CommandDefinition>, indentation: i32) {
-        for (name, command) in map {
-            Logger::with_theme(|theme| {
-                println!(
-                    "{}{}: {}",
-                    Logger::indent(Some(indentation)),
-                    theme.sub_command(name),
-                    theme.description(&command.description),
-                );
-            });
-            Help::log_args(&command.args, Some(indentation + 3));
-        }
-    }
-
-    pub fn log_internal_commands(internals: &HashMap<String, Box<dyn InternalExecutable>>) {
-        if internals.is_empty() {
-            return;
-        }
-        let sorted_internals = Help::sort_internal(internals);
-        Logger::space_around("Internal Commands:");
-        for internal in sorted_internals {
-            Help::log_internal_command(internal.get_definition());
-            println!();
-        }
-    }
-
-    pub fn log_root_commands(root_commands: &HashMap<String, CommandDefinition>) {
-        if root_commands.is_empty() {
-            return;
-        }
-        Logger::info("Project Level Commands:");
-        Logger::with_surrounding_space(|| {
-            let sorted_commands = Help::sort_root_commands(root_commands);
-            for command in sorted_commands {
-                Help::log_root_command(&command);
-            }
-        });
-    }
-
-    pub fn log_external_commands(externals: &HashMap<String, RepoKitCommand>) {
-        if externals.is_empty() {
-            return;
-        }
-        let sorted_externals = Help::sort_external(externals);
-        Logger::info("Registered Commands:");
-        println!();
-        for external in sorted_externals {
-            Help::log_external_command(external);
-            println!();
-        }
-    }
-
-    fn log_args(map: &Option<HashMap<String, String>>, indentation: Option<i32>) {
-        Logger::with_theme(|theme| {
-            if let Some(args) = map {
-                for (name, description) in args {
-                    println!(
-                        "{}{} {}",
-                        Logger::indent(Some(indentation.unwrap_or(6))),
-                        theme.arg(name),
-                        theme.description(description)
-                    );
-                }
-            }
-        });
-    }
-
-    fn sort_internal(
-        commands: &HashMap<String, Box<dyn InternalExecutable>>,
-    ) -> Vec<&Box<dyn InternalExecutable>> {
-        let mut vector: Vec<&Box<dyn InternalExecutable>> = commands.values().collect();
-        sort_slice_by_str_key(&mut vector, |x| &x.get_definition().name);
-        vector
-    }
-
-    fn sort_external(commands: &HashMap<String, RepoKitCommand>) -> Vec<&RepoKitCommand> {
-        let mut vector: Vec<&RepoKitCommand> = (commands).values().collect();
-        sort_slice_by_str_key(&mut vector, |x| &x.name);
-        vector
-    }
-
-    fn sort_root_commands(commands: &HashMap<String, CommandDefinition>) -> Vec<RootCommand> {
-        let mut vector: Vec<&String> = (commands).keys().collect();
-        sort_str_slice(&mut vector);
-        vector
-            .iter()
-            .map(|&name| {
-                RootCommand::from(
-                    name,
-                    commands
-                        .get(name)
-                        .expect("iteration is over known keys only"),
-                )
-            })
-            .collect()
-    }
-}

package/internals/internal_commands/internal_registry.rs

@@ -1,34 +0,0 @@
-use std::collections::HashMap;
-
-use crate::{
-    executables::internal_executable::InternalExecutable,
-    internal_commands::{
-        list_commands::ListCommands, list_owners::ListOwners, list_themes::ListThemes,
-        list_version::ListVersion, locate_command::LocateCommand, onboarder::Onboarder,
-        register_command::RegisterCommand, search_commands::SearchCommands,
-        upgrade_repokit::UpgradeRepoKit,
-    },
-};
-
-pub struct InternalCommandRegistry;
-
-impl InternalCommandRegistry {
-    pub fn new() -> InternalCommandRegistry {
-        InternalCommandRegistry {}
-    }
-
-    pub fn get_all(&self) -> HashMap<String, Box<dyn InternalExecutable>> {
-        let internals: [Box<dyn InternalExecutable>; 9] = [
-            Box::new(Onboarder::new()),
-            Box::new(ListCommands::new()),
-            Box::new(SearchCommands::new()),
-            Box::new(ListOwners::new()),
-            Box::new(LocateCommand::new()),
-            Box::new(RegisterCommand::new()),
-            Box::new(UpgradeRepoKit::new()),
-            Box::new(ListThemes::new()),
-            Box::new(ListVersion::new()),
-        ];
-        HashMap::from(internals.map(|x| (x.get_definition().name.to_string(), x)))
-    }
-}

package/internals/internal_commands/list_commands.rs

@@ -1,97 +0,0 @@
-use std::collections::HashMap;
-
-use crate::{
-    executables::{
-        internal_executable::InternalExecutable,
-        internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
-        },
-    },
-    internal_commands::help::Help,
-    logger::logger::Logger,
-    repokit::{repokit_command::RepoKitCommand, repokit_runtime::RepoKitRuntime},
-    validations::command_validations::CommandValidations,
-};
-
-pub struct ListCommands {
-    pub definition: InternalExecutableDefinition,
-}
-
-static SCOPES: [&str; 4] = ["internal", "registered", "root", "<owner>"];
-
-impl ListCommands {
-    pub fn new() -> ListCommands {
-        ListCommands {
-            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
-                name: "list",
-                description: "List commands based on their scope of definition",
-                args: [(
-                    "<scope>",
-                    format!(
-                        "The scope of the commands you wish to list. Specify one of {}",
-                        Logger::with_theme(|theme| theme.highlight(SCOPES.join(" | ").as_str()))
-                    )
-                    .as_str(),
-                )],
-            }),
-        }
-    }
-
-    fn exit_on_invalid_scope(&self) {
-        Logger::exit_with_info(
-            format!(
-                "Please specify a scope to list the commands of. Select one of {}",
-                Logger::with_theme(|theme| theme.highlight(SCOPES.join(" | ").as_str()))
-            )
-            .as_str(),
-        );
-    }
-}
-
-impl InternalExecutable for ListCommands {
-    fn run(&self, args: Vec<String>, internals: &HashMap<String, Box<dyn InternalExecutable>>) {
-        if args.is_empty() {
-            return self.exit_on_invalid_scope();
-        }
-        let query = args[0].as_str();
-        let scope = &query.to_lowercase();
-        if scope == SCOPES[0] {
-            return Help::log_internal_commands(internals);
-        }
-        if scope == SCOPES[2] {
-            return RepoKitRuntime::with_runtime(|runtime| {
-                Help::log_root_commands(&runtime.configuration.commands)
-            });
-        }
-        let registered_commands = CommandValidations::collect_and_validate_externals();
-        if scope == SCOPES[1] {
-            return Help::log_external_commands(&registered_commands);
-        }
-        let full_query = args.join(" ");
-        let full_scope = &full_query.to_lowercase();
-        Logger::info("Searching registered commands");
-        let matches: HashMap<String, RepoKitCommand> = registered_commands
-            .iter()
-            .filter_map(|(name, x)| {
-                if x.owner.to_lowercase().contains(full_scope) {
-                    return Some((name.clone(), x.clone()));
-                }
-                None
-            })
-            .collect();
-        if matches.is_empty() {
-            Logger::exit_with_info(
-                format!(
-                    "I could not find any commands matching {}",
-                    Logger::with_theme(|theme| theme.highlight(&full_query))
-                )
-                .as_str(),
-            );
-        }
-        Help::log_external_commands(&matches);
-    }
-
-    fn get_definition(&self) -> &InternalExecutableDefinition {
-        &self.definition
-    }
-}

package/internals/internal_commands/list_owners.rs

@@ -1,61 +0,0 @@
-use std::collections::{HashMap, HashSet};
-
-use alphanumeric_sort::sort_str_slice;
-
-use crate::{
-    executables::{
-        internal_executable::InternalExecutable,
-        internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
-        },
-    },
-    logger::logger::Logger,
-    validations::command_validations::CommandValidations,
-};
-
-pub struct ListOwners {
-    pub definition: InternalExecutableDefinition,
-}
-
-impl ListOwners {
-    pub fn new() -> ListOwners {
-        ListOwners {
-            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
-                name: "owners",
-                description: "Lists all registered command owners",
-                args: [],
-            }),
-        }
-    }
-}
-
-impl InternalExecutable for ListOwners {
-    fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
-        let registered_commands = CommandValidations::collect_and_validate_externals();
-        Logger::info("Listing all command owners");
-        let mut owners: HashSet<String> = HashSet::new();
-        for (_, command) in registered_commands {
-            if !command.owner.is_empty() {
-                owners.insert(command.owner);
-            }
-        }
-        if owners.is_empty() {
-            return Logger::exit_with_info("No owners found");
-        }
-        let mut list: Vec<String> = owners.into_iter().collect();
-        Logger::with_surrounding_space(|| {
-            sort_str_slice(&mut list);
-            for (index, owner) in list.iter().enumerate() {
-                println!(
-                    "{}{}",
-                    Logger::indent(None),
-                    Logger::cyan(format!("{}. {}", index + 1, &owner).as_str()),
-                );
-            }
-        });
-    }
-
-    fn get_definition(&self) -> &InternalExecutableDefinition {
-        &self.definition
-    }
-}