@repokit/core 4.0.5 → 5.0.0

package/internals/internal_filesystem/file_builder.rs

@@ -1,56 +0,0 @@
-use std::{
-    fs::{File, create_dir_all},
-    io::{Error, copy},
-    path::Path,
-};
-
-pub struct FileBuilder;
-
-impl FileBuilder {
-    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);
-                panic!();
-            }
-        }
-    }
-
-    pub fn create(destination: &Path, on_error: impl Fn(Error)) -> File {
-        let source = File::create(destination);
-        match source {
-            Ok(file) => file,
-            Err(error) => {
-                on_error(error);
-                panic!();
-            }
-        }
-    }
-
-    pub fn copy_to(source: &mut File, target: &mut File, on_error: impl Fn(Error)) {
-        let result = copy(source, target);
-        match result {
-            Ok(_) => {
-                let sync = target.sync_all();
-                match sync {
-                    Ok(_) => {}
-                    Err(err) => on_error(err),
-                }
-            }
-            Err(err) => on_error(err),
-        }
-    }
-
-    pub fn create_dir_all(path: &Path, on_error: impl Fn(Error)) {
-        let source = create_dir_all(path);
-        match source {
-            Ok(result) => result,
-            Err(error) => {
-                on_error(error);
-                panic!();
-            }
-        }
-    }
-}

package/internals/internal_filesystem/mod.rs

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

package/internals/logger/logger.rs

@@ -1,163 +0,0 @@
-use core::panic;
-use std::sync::LazyLock;
-use std::sync::Mutex;
-use std::sync::MutexGuard;
-
-use colored::{ColoredString, Colorize};
-
-use crate::repokit::repokit_runtime::RepoKitRuntime;
-use crate::themes::theme::Theme;
-use crate::themes::theme_registry::ThemeRegistry;
-
-static REGISTERED_NAME: LazyLock<Mutex<String>> =
-    LazyLock::new(|| Mutex::new("Repokit".to_string()));
-
-static THEMES: LazyLock<Mutex<ThemeRegistry>> = LazyLock::new(|| Mutex::new(ThemeRegistry::new()));
-
-pub struct Logger;
-
-impl Logger {
-    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) {
-        println!("{}{}", Logger::info_prefix(), message);
-    }
-
-    pub fn error(message: &str) {
-        eprintln!("{}{}", Logger::error_prefix(), message);
-    }
-
-    pub fn exit_with_info(message: &str) {
-        Logger::info(message);
-        panic!();
-    }
-
-    pub fn exit_with_error(message: &str) {
-        Logger::error(message);
-        panic!();
-    }
-
-    pub fn list(items: &[&str], indentation: Option<i32>) {
-        Logger::with_surrounding_space(|| {
-            for (index, item) in items.iter().enumerate() {
-                println!("{}{}. {}", Logger::indent(indentation), index + 1, item);
-            }
-        })
-    }
-
-    pub fn parse_error(file_type: &str, stdout: &str) {
-        Logger::info(format!("There was an error parsing your {}", file_type).as_str());
-        Logger::info(
-            "This can occur when RepoKit attempts to parse a TypeScript file that can terminate the process upon evaluation",
-        );
-        Logger::info("Please file a bug to with any related error or stack trace found below");
-        Logger::log_issue_link();
-        println!();
-        if !stdout.is_empty() {
-            println!("{stdout}");
-        }
-        panic!();
-    }
-
-    pub fn space_around(message: &str) {
-        println!("\n{}{}\n", Logger::info_prefix(), message);
-    }
-
-    pub fn with_surrounding_space<F>(mut func: impl FnMut() -> F) -> F {
-        println!();
-        let result = func();
-        println!();
-        result
-    }
-
-    pub fn log_file_path(path: &str) {
-        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 {
-        let indentation: i32 = times.unwrap_or(5);
-        " ".repeat(indentation.try_into().unwrap())
-    }
-
-    pub fn cyan(message: &str) -> ColoredString {
-        message.cyan()
-    }
-
-    pub fn file_create_error() {
-        Logger::file_error("create a file");
-    }
-
-    pub fn file_directory_error() {
-        Logger::file_error("create a directory");
-    }
-
-    pub fn open_file_error() {
-        Logger::file_error("read a file");
-    }
-
-    pub fn file_write_error() {
-        Logger::file_error("write to a file");
-    }
-
-    pub fn log_issue_link() {
-        Logger::log_file_path("https://github.com/alexfigliolia/repokit/issues");
-    }
-
-    pub fn with_theme<R>(func: impl Fn(&Theme) -> R) -> R {
-        Logger::with_registry(|registry| func(registry.current_theme()))
-    }
-
-    pub fn with_registry<R>(func: impl Fn(MutexGuard<'_, ThemeRegistry>) -> R) -> R {
-        let registry = THEMES.lock().unwrap();
-        func(registry)
-    }
-
-    fn file_error(operation: &str) {
-        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();
-        panic!();
-    }
-
-    fn info_prefix() -> String {
-        Logger::with_theme(|theme| format!("{}: ", theme.prefix(&REGISTERED_NAME.lock().unwrap())))
-    }
-
-    fn error_prefix() -> String {
-        Logger::with_theme(|theme| {
-            format!("{}: ", theme.error_prefix(&REGISTERED_NAME.lock().unwrap()))
-        })
-    }
-
-    fn set_name(value: &str) {
-        *REGISTERED_NAME.lock().unwrap() = value.to_string();
-    }
-}

package/internals/logger/mod.rs

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

package/internals/main.rs

@@ -1,23 +0,0 @@
-use std::panic;
-
-use crate::{post_processing::post_processor::PostProcessor, repokit::repokit::RepoKit};
-
-mod argv;
-mod caches;
-mod context;
-mod executables;
-mod executor;
-mod file_walker;
-mod internal_commands;
-mod internal_filesystem;
-mod logger;
-mod post_processing;
-mod repokit;
-mod themes;
-mod validations;
-
-fn main() {
-    panic::set_hook(Box::new(|_| PostProcessor::get().flush()));
-    RepoKit::new().invoke();
-    PostProcessor::get().flush();
-}

package/internals/post_processing/mod.rs

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

package/internals/post_processing/post_processor.rs

@@ -1,37 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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,6 +0,0 @@
-pub mod command_definition;
-pub mod repokit;
-pub mod repokit_command;
-pub mod repokit_config;
-pub mod repokit_construct_validator;
-pub mod repokit_runtime;

package/internals/repokit/repokit.rs

@@ -1,146 +0,0 @@
-use std::{collections::HashMap, env::args, path::Path};
-
-use crate::{
-    executables::internal_executable::InternalExecutable,
-    executor::executor::Executor,
-    internal_commands::help::Help,
-    logger::logger::Logger,
-    repokit::{repokit_command::RepoKitCommand, repokit_runtime::RepoKitRuntime},
-    validations::command_validations::CommandValidations,
-};
-
-pub struct RepoKit {}
-
-impl RepoKit {
-    pub fn new() -> RepoKit {
-        Logger::initialize();
-        RepoKit {}
-    }
-
-    pub fn invoke(&self) {
-        let (command, args) = self.parse();
-        let internals = CommandValidations::collect_and_validate_internals();
-        if let Some(internal_command) = internals.get(&command) {
-            return internal_command.run(args, &internals);
-        }
-        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 let Some(interface) = externals.get(&command) {
-            if args.is_empty() {
-                return self.log_external_command(interface);
-            }
-            let sub_command = &args[0];
-            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);
-        }
-        self.command_not_found(&command, &internals, &externals)
-    }
-
-    fn parse(&self) -> (String, Vec<String>) {
-        let argv: Vec<String> = args().collect();
-        if argv.len() < 2 {
-            let (internals, externals) = self.collect_and_validate();
-            Help::list_all(&internals, &externals);
-            panic!();
-        }
-        let command = &argv[1];
-        let args = &(&argv)[2..];
-        (command.clone(), args.to_vec())
-    }
-
-    fn collect_and_validate(
-        &self,
-    ) -> (
-        HashMap<String, Box<dyn InternalExecutable>>,
-        HashMap<String, RepoKitCommand>,
-    ) {
-        let internals = CommandValidations::collect_and_validate_internals();
-        let externals = CommandValidations::collect_and_validate_externals();
-        CommandValidations::detect_collisions_between_internals_and_externals(
-            &internals, &externals,
-        );
-        (internals, externals)
-    }
-
-    fn command_not_found(
-        &self,
-        command: &str,
-        internals: &HashMap<String, Box<dyn InternalExecutable>>,
-        externals: &HashMap<String, RepoKitCommand>,
-    ) {
-        Help::list_all(internals, externals);
-        Logger::info(
-            format!(
-                "I'm not aware of a command named {}",
-                Logger::with_theme(|theme| theme.highlight(command))
-            )
-            .as_str(),
-        );
-    }
-
-    fn subcommand_not_found(&self, command: &RepoKitCommand, sub_command: &str) {
-        Logger::info(
-            format!(
-                "The command {} was not found on {}",
-                Logger::with_theme(|theme| theme.highlight(sub_command)),
-                Logger::with_theme(|theme| theme.highlight(&command.name))
-            )
-            .as_str(),
-        );
-        Logger::info(
-            format!(
-                "Here are the commands that belong to {}",
-                Logger::with_theme(|theme| theme.highlight(&command.name))
-            )
-            .as_str(),
-        );
-        Help::log_external_subcommands(&command.commands, 3);
-    }
-
-    fn log_external_command(&self, command: &RepoKitCommand) {
-        Logger::info(
-            format!(
-                "Listing available commands for {}\n",
-                Logger::with_theme(|theme| theme.command(&command.name))
-            )
-            .as_str(),
-        );
-        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,101 +0,0 @@
-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::{
-    logger::logger::Logger,
-    post_processing::post_processor::PostProcessor,
-    repokit::{
-        command_definition::CommandDefinition,
-        repokit_construct_validator::RepoKitConstructValidator, repokit_runtime::RepoKitRuntime,
-    },
-};
-
-#[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 RepoKitConstructValidator for 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());
-            if !RepoKitCommand::is_valid(&REPOKIT_COMMAND_VALIDATOR, &command)
-                || repokit_command.is_err()
-            {
-                failures += 1;
-                if let Some(path) = RepoKitCommand::on_parsing_error(command) {
-                    failed_paths.push(path);
-                }
-            } else {
-                let mut valid_command = repokit_command.expect("parse success");
-                valid_command.location = format!("{}/{}", git_root, valid_command.location);
-                result.push(valid_command);
-            }
-        }
-        if failures != 0 {
-            RepoKitCommand::register_encountered_errors(failed_paths);
-        }
-        result
-    }
-
-    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 = RepoKitRuntime::with_runtime(|runtime| {
-                format!(
-                    "{}/{}",
-                    runtime.git.root,
-                    location.unwrap().as_str().unwrap()
-                )
-            });
-            return Some(path);
-        }
-        None
-    }
-
-    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,101 +0,0 @@
-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::{
-    context::{file_system::FileSystem, node_scope::NodeScope},
-    internal_filesystem::file_builder::FileBuilder,
-    logger::logger::Logger,
-    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 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, node, Value::Null);
-        }
-        repokit_config.expect("assertions succeeded")
-    }
-
-    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");
-        node.type_check_file(path);
-        println!();
-        Logger::info("There was an error parsing your configuration");
-        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 but could not resolve the exported {} instance",
-                    Logger::with_theme(|theme| theme.highlight("RepokitConfig"))
-                )
-                .as_str(),
-            );
-            Logger::exit_with_info(
-                "Please double check that your config file is free of any sideffects that can cause the parser to crash",
-            );
-        }
-        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,11 +0,0 @@
-use jsonschema::Validator;
-use serde_json::Value;
-
-pub trait RepoKitConstructValidator {
-    fn is_valid(validator: &Validator, input: &Value) -> bool {
-        if validator.validate(input).is_err() {
-            return false;
-        }
-        true
-    }
-}