@repokit/core 4.0.6 → 5.0.1

package/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "repokit"
-version = "4.0.6"
-edition = "2024"
-
-[[bin]]
-name = "repokit"
-path = "internals/main.rs"
-
-[dependencies]
-jsonschema = { version = "0.46.2", default-features = false }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-colored = "3"
-normalize-path = "0.2.1"
-alphanumeric-sort = "1.5.6"
-ignore = "0.4.25"
-regex = { version = "1.12.3", features = ["std", "unicode"] }
-shellexpand = "3.1.2"
-schemars = "1.2.1"
-terminal-spinners = "0.3.2"
-futures = "0.3.32"
-tokio = { version = "1.52.1", features = ["full"] }

package/installation/install.sh

@@ -1,99 +0,0 @@
-CURRENT_VERSION="4.0.6"
-CWD=$(pwd)
-
-REPLACEMENT="/node_modules"
-FALLBACK_ROOT="${CWD%${REPLACEMENT}*}"
-
-GIT_ROOT=$(git rev-parse --show-toplevel)
-REPO_ROOT=${GIT_ROOT:-$FALLBACK_ROOT}
-
-if [[ "$CWD" != *"$REPLACEMENT"* ]]; then
-    exit 0;
-fi
-
-
-cd $REPO_ROOT
-
-command_exists() {
-    command -v "$1" > /dev/null 2>&1
-}
-
-if command_exists rustc && command_exists cargo; then
-    echo "Rust is installed."
-else
-    echo "Installing rust"
-    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-fi
-
-echo "Installing Repokit CLI"
-
-ROOT_COMMIT=$(git rev-list --parents HEAD | tail -1) || ROOT_COMMIT=""
-
-cd
-
-OLD_CACHE_FILE=".repokit";
-CACHE_DIRECTORY=".repokit_cache";
-VERSION_FILE=".version"
-SETTINGS_FILE=".settings"
-REPO_CACHE_DIRECTORY="$CACHE_DIRECTORY/$ROOT_COMMIT"
-
-OLD_SCHEMA_CACHED_THEME=""
-OLD_SCHEMA_CACHED_VERSION="$CURRENT_VERSION"
-
-if [ -f "$OLD_CACHE_FILE" ]; then
-    {
-        read -r OLD_SCHEMA_CACHED_VERSION
-        read -r OLD_SCHEMA_CACHED_THEME
-    } < "$OLD_CACHE_FILE"
-    if [ -n "$ROOT_COMMIT" ] && [ -f "$REPO_CACHE_DIRECTORY/$SETTINGS_FILE" ]; then
-        OLD_SCHEMA_CACHED_THEME=""
-    fi
-fi 
-
-if [ ! -d "$CACHE_DIRECTORY" ]; then 
-    mkdir "$CACHE_DIRECTORY"    
-fi 
-
-cd "$CACHE_DIRECTORY"
-
-if [ -n "$ROOT_COMMIT" ]; then
-    if [ ! -d "$ROOT_COMMIT" ]; then
-        mkdir "$ROOT_COMMIT"
-    fi
-    cd $ROOT_COMMIT;
-    if [ ! -f "$SETTINGS_FILE" ]; then
-        touch "$SETTINGS_FILE"
-    fi
-    if [ -n "$OLD_SCHEMA_CACHED_THEME" ]; then
-        echo "$OLD_SCHEMA_CACHED_THEME\n" > "$SETTINGS_FILE"
-    fi
-    cd "../"
-fi
-
-if [ -f $VERSION_FILE ]; then
-    read -r CACHED_VERSION < "$VERSION_FILE"
-    if [ "$CACHED_VERSION" == "$CURRENT_VERSION" ] && [ "$CACHED_VERSION" == "$OLD_SCHEMA_CACHED_VERSION" ]; then
-        exit 0;    
-    fi
-else 
-    touch "$VERSION_FILE"
-fi 
-
-echo "$CURRENT_VERSION\n" > "$VERSION_FILE"
-
-cd ../
-
-if [ -f "$OLD_CACHE_FILE" ]; then
-    TEMP_FILE=".repokit_tmp";
-    printf "$CURRENT_VERSION\n" > "$TEMP_FILE"
-    tail +2 "$OLD_CACHE_FILE" >> "$TEMP_FILE"
-    mv "$TEMP_FILE" "$OLD_CACHE_FILE"
-fi
-
-cd $CWD
-
-echo "Compiling from $CWD"
-
-. "$HOME/.cargo/env"
-RUSTFLAGS="-Awarnings" cargo build --release
-cargo install --path .

package/internals/argv/argv.rs

@@ -1,132 +0,0 @@
-use std::{collections::HashMap, env};
-
-use crate::logger::logger::Logger;
-
-#[derive(Clone)]
-pub enum ArgvType {
-    String,
-    Boolean,
-}
-
-#[derive(Clone)]
-pub struct ArgvOption {
-    pub value_type: ArgvType,
-    pub short: Option<&'static str>,
-    pub name: &'static str,
-    pub multiple: Option<bool>,
-}
-
-pub struct Argv {
-    pub values: HashMap<String, Vec<String>>,
-    pub positionals: Vec<String>,
-    lookup_table: HashMap<String, ArgvOption>,
-}
-
-impl Argv {
-    pub fn new<const N: usize>(schema: [ArgvOption; N], args: Option<Vec<String>>) -> Argv {
-        let mut argv = Argv {
-            values: HashMap::new(),
-            positionals: Vec::new(),
-            lookup_table: Argv::build_option_table(&schema),
-        };
-        argv.parse(args);
-        argv
-    }
-
-    pub fn has(&self, key: &str) -> bool {
-        let fallback_bucket = Vec::new();
-        let values = self.values.get(key).unwrap_or(&fallback_bucket);
-        !values.is_empty()
-    }
-
-    pub fn get_first(&self, key: &str) -> String {
-        let fallback_bucket = Vec::new();
-        let values = self.values.get(key).unwrap_or(&fallback_bucket);
-        if values.is_empty() {
-            return "".to_string();
-        }
-        values[0].clone()
-    }
-
-    pub fn get_all(&mut self, key: &str) -> &mut Vec<String> {
-        self.values.entry(key.to_string()).or_default()
-    }
-
-    fn parse(&mut self, argv: Option<Vec<String>>) {
-        let args = argv.unwrap_or(env::args().collect());
-        let mut pointer = 0;
-        let length = args.len();
-        while pointer < length {
-            let arg = &args[pointer];
-            if self.lookup_table.contains_key(arg) {
-                let schema = self.lookup_table.get(arg).expect("arg exists");
-                let values = self.values.entry(schema.name.to_string()).or_default();
-                match schema.value_type {
-                    ArgvType::Boolean => {
-                        values.push("1".to_string());
-                        pointer += 1;
-                        continue;
-                    }
-                    ArgvType::String => {
-                        let mut current = pointer + 1;
-                        while current < length {
-                            let value = &args[current];
-                            if self.lookup_table.contains_key(value) {
-                                break;
-                            }
-                            let values_for_argument = values.len();
-                            if values_for_argument == 0 || schema.multiple.is_some_and(|v| v) {
-                                values.push(value.to_string());
-                                current += 1;
-                            } else {
-                                break;
-                            }
-                        }
-                    }
-                }
-            } else {
-                self.positionals.push(arg.to_owned());
-            }
-            pointer += 1;
-        }
-    }
-
-    fn build_option_table<const N: usize>(
-        options: &[ArgvOption; N],
-    ) -> HashMap<String, ArgvOption> {
-        let mut table: HashMap<String, ArgvOption> = HashMap::new();
-        for option in options {
-            if option.name.len() < 2 {
-                Logger::exit_with_error("Option names must be at least 2 characters");
-            }
-            let first_char = option
-                .name
-                .chars()
-                .next()
-                .expect("already checked for emptiness")
-                .to_string();
-            let short_flag = option.short.unwrap_or(&first_char);
-            let flags = [format!("--{}", option.name), format!("-{}", short_flag)];
-            for flag in flags {
-                if table.contains_key(&flag) {
-                    Logger::error(
-                        format!(
-                            "I encountered the flag {} more than once.",
-                            Logger::with_theme(|theme| theme.highlight(&flag)),
-                        )
-                        .as_str(),
-                    );
-                    Logger::error(
-                        format!(
-                            "Short flags will default to the first letter of the option's name. If two options begin with the same letter, please specify the {} option for one of them.",
-                            Logger::with_theme(|theme| theme.highlight("short")),
-                        )
-                        .as_str(),
-                    );
-                }
-                table.insert(flag, option.clone());
-            }
-        }
-        table
-    }
-}

package/internals/argv/mod.rs

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

package/internals/caches/crawl_cache.rs

@@ -1,126 +0,0 @@
-use std::{
-    collections::HashSet,
-    path::{Path, PathBuf},
-};
-
-use regex::Regex;
-
-use crate::{
-    caches::file_cache::FileCache, context::git_scope::GitScope, executor::executor::Executor,
-    logger::logger::Logger, post_processing::post_processor::PostProcessor,
-};
-
-#[derive(Clone)]
-pub struct CrawlCache {
-    pub cache_directory: Option<PathBuf>,
-    pub changed_files: Option<Vec<String>>,
-    pub files_to_crawl: Option<Vec<String>>,
-}
-
-impl CrawlCache {
-    pub fn new(cache_directory: &Option<PathBuf>) -> Self {
-        CrawlCache {
-            changed_files: None,
-            files_to_crawl: None,
-            cache_directory: cache_directory.clone(),
-        }
-    }
-
-    pub async fn initialize(&mut self, git_scope: &GitScope) {
-        let head_commit = git_scope
-            .head_commit_hash
-            .to_owned()
-            .unwrap_or("".to_string());
-        if let Some((mut lines, path)) = self.read() {
-            let commit_hash = self.unwrap_line(lines.nth(0), "non_existent_hash");
-            if commit_hash != head_commit {
-                return;
-            }
-            let lines = self.line_buffer_to_vec(lines);
-            if lines.is_empty() {
-                return;
-            }
-            let (git_ignore_changed, mut changed_files) = self.get_changed_files(&git_scope.root);
-            if git_ignore_changed {
-                CrawlCache::clear_cache_file(path.to_owned(), false);
-                return;
-            }
-            for line in &lines {
-                if changed_files.contains(line) {
-                    changed_files.remove(line);
-                }
-            }
-            if !changed_files.is_empty() {
-                self.changed_files = Some(changed_files.into_iter().collect());
-            }
-            self.files_to_crawl = Some(lines);
-        }
-    }
-
-    pub fn crawl_cache_enabled(&self) -> bool {
-        self.files_to_crawl.is_some()
-    }
-
-    pub fn cache_crawl_results(&self, results: String) {
-        self.write(&results, |_| {
-            self.on_crawl_cache_storage_error();
-        });
-    }
-
-    fn on_crawl_cache_storage_error(&self) {
-        if let Some(storage_path) = self.storage_path() {
-            PostProcessor::get().register_task(move || {
-            Logger::info(
-                "I attempted to cache the results of a file crawl, but couldn't write to disk",
-            );
-            CrawlCache::log_cache_write_error();
-            Logger::info(
-                "To avoid issues with stale caches I'm going to delete what's currently on disk",
-            );
-            CrawlCache::clear_cache_file(storage_path.clone(), true);
-        });
-        }
-    }
-
-    fn get_changed_files(&self, git_root: &str) -> (bool, HashSet<String>) {
-        let mut contains_git_ignore = false;
-        let file_path_matcher = Regex::new(r#"^.*\s(.*\.ts)$"#).unwrap();
-        let stdout = Executor::exec("git status --porcelain -uall", |cmd| cmd);
-        let git_root_path = Path::new(git_root);
-        let files: HashSet<String> = stdout
-            .split("\n")
-            .filter_map(|file| {
-                if !contains_git_ignore && file.ends_with(".gitignore") {
-                    contains_git_ignore = true;
-                    return None;
-                }
-                let matches: Vec<&str> = file_path_matcher
-                    .captures_iter(file)
-                    .filter_map(|entry| {
-                        if let Some(match_result) = entry.get(1) {
-                            return Some(match_result.as_str());
-                        }
-                        None
-                    })
-                    .collect();
-                if let Some(file_path) = matches.first()
-                    && git_root_path.join(file_path).exists()
-                {
-                    return Some(file_path.to_string());
-                }
-                None
-            })
-            .collect();
-        (contains_git_ignore, files)
-    }
-}
-
-impl FileCache for CrawlCache {
-    fn cache_file(&self) -> &str {
-        ".crawl_cache"
-    }
-
-    fn cache_directory(&self) -> &Option<PathBuf> {
-        &self.cache_directory
-    }
-}

package/internals/caches/file_cache.rs

@@ -1,104 +0,0 @@
-use std::{
-    fs::{File, write},
-    io::{BufRead, BufReader, Error, Lines},
-    path::PathBuf,
-};
-
-use normalize_path::NormalizePath;
-
-use crate::{logger::logger::Logger, post_processing::post_processor::PostProcessor};
-
-pub trait FileCache {
-    fn cache_file(&self) -> &str;
-
-    fn cache_directory(&self) -> &Option<PathBuf>;
-
-    fn storage_path(&self) -> Option<PathBuf> {
-        if let Some(storage_path) = self.perspective_path()
-            && storage_path.exists()
-        {
-            return Some(storage_path);
-        }
-        None
-    }
-
-    fn perspective_path(&self) -> Option<PathBuf> {
-        if let Some(cache_dir) = &self.cache_directory() {
-            return Some(cache_dir.join(self.cache_file()).normalize());
-        }
-        None
-    }
-
-    async fn create_cache_file_if_not_exists(&self) -> Option<PathBuf> {
-        if let Some(storage_path) = self.perspective_path()
-            && !&storage_path.exists()
-            && write(&storage_path, "").is_ok()
-        {
-            return Some(storage_path);
-        }
-        None
-    }
-
-    fn read(&self) -> Option<(Lines<BufReader<File>>, PathBuf)> {
-        if let Some(path) = self.storage_path()
-            && let Ok(file) = File::open(&path)
-        {
-            return Some((BufReader::new(file).lines(), path));
-        }
-        None
-    }
-
-    fn write(&self, content: &str, on_error: impl Fn(Error)) {
-        if let Some(path) = self.storage_path()
-            && let Err(error) = write(path, content)
-        {
-            on_error(error);
-        }
-    }
-
-    fn line_buffer_to_vec(&self, lines: Lines<BufReader<File>>) -> Vec<String> {
-        lines.filter_map(Result::ok).collect()
-    }
-
-    fn insert_as_first_line(&self, lines: Lines<BufReader<File>>, value: String) -> Vec<String> {
-        let mut lines: Vec<String> = self.line_buffer_to_vec(lines);
-        if !lines.is_empty() {
-            lines[0] = value;
-        } else {
-            lines.push(value);
-        }
-        lines
-    }
-
-    fn unwrap_line(&self, line_result: Option<Result<String, Error>>, fallback: &str) -> String {
-        line_result
-            .and_then(|r| r.ok())
-            .unwrap_or(fallback.to_string())
-    }
-
-    fn clear_cache_file(path: PathBuf, notify: bool) {
-        // This is post-processed so it doesn't block the command the user is executing
-        PostProcessor::get().register_task(move || {
-            if write(&path, "").is_err() {
-                Logger::error("I was unable to remove a cache on disk");
-                Logger::error("To correct this, please run");
-                Logger::log_file_path(format!("rm {}", path.to_string_lossy()).as_str())
-            } else if notify {
-                Logger::info("Cache deleted!");
-            }
-        });
-    }
-
-    fn log_cache_write_error() {
-        Logger::info("This is typically a permission-related issue on the operating system");
-        Logger::info(
-            format!(
-                "If you believe this to be a bug within {}",
-                Logger::with_theme(|theme| theme.highlight("Repokit"))
-            )
-            .as_str(),
-        );
-        Logger::info("Please file an issue here");
-        Logger::log_issue_link();
-    }
-}

package/internals/caches/mod.rs

@@ -1,6 +0,0 @@
-pub mod crawl_cache;
-pub mod file_cache;
-pub mod old_cache;
-pub mod repokit_version_resolver;
-pub mod settings_cache;
-pub mod version_cache;

package/internals/caches/old_cache.rs

@@ -1,35 +0,0 @@
-use std::{env::home_dir, path::PathBuf, sync::LazyLock};
-
-use crate::caches::{file_cache::FileCache, version_cache::VERSION_REGEX};
-
-static OLD_CACHE_FILE: &str = ".repokit";
-
-static OLD_CACHE_FILE_PATH: LazyLock<Option<PathBuf>> = LazyLock::new(home_dir);
-
-pub struct OldCache;
-
-impl FileCache for OldCache {
-    fn cache_file(&self) -> &str {
-        OLD_CACHE_FILE
-    }
-
-    fn cache_directory(&self) -> &Option<PathBuf> {
-        &OLD_CACHE_FILE_PATH
-    }
-}
-
-impl OldCache {
-    pub fn new() -> Self {
-        OldCache {}
-    }
-
-    pub fn get_version(&self) -> Option<String> {
-        if let Some((mut lines, _)) = self.read() {
-            let version = self.unwrap_line(lines.nth(0), "");
-            if VERSION_REGEX.is_match(&version) {
-                return Some(version);
-            }
-        }
-        None
-    }
-}

package/internals/caches/repokit_version_resolver.rs

@@ -1,50 +0,0 @@
-use std::env::args;
-
-use terminal_spinners::{BOUNCING_BALL, SpinnerBuilder};
-
-use crate::{
-    context::file_system::FileSystem, executor::executor::Executor, logger::logger::Logger,
-};
-
-pub struct RepoKitVersionResolver;
-
-impl RepoKitVersionResolver {
-    pub fn hop_to_installed_version(files: &FileSystem) {
-        if files.install_script_path.is_absolute() && files.install_script_path.exists() {
-            if let Some(errors) = RepoKitVersionResolver::run_post_install(files) {
-                println!("{errors}");
-                Logger::error("My installer failed");
-                RepoKitVersionResolver::on_error();
-            } else {
-                RepoKitVersionResolver::re_run_command();
-            }
-        } else {
-            Logger::error("I couldn't find my installer");
-            RepoKitVersionResolver::on_error();
-        }
-        panic!();
-    }
-
-    fn run_post_install(files: &FileSystem) -> Option<String> {
-        let handle = SpinnerBuilder::new()
-            .spinner(&BOUNCING_BALL)
-            .text(" Installing")
-            .start();
-        let result =
-            Executor::exec_with_errors(format!("./{}", files.install_script_location), |cmd| {
-                cmd.current_dir(&files.package_directory)
-            });
-        handle.done();
-        result
-    }
-
-    fn re_run_command() {
-        let args: Vec<String> = args().collect();
-        Executor::with_stdio(args.join(" "), |cmd| cmd);
-    }
-
-    fn on_error() {
-        Logger::info("Please file a bug here");
-        Logger::log_issue_link();
-    }
-}

package/internals/caches/settings_cache.rs

@@ -1,73 +0,0 @@
-use std::path::PathBuf;
-
-use crate::{
-    caches::file_cache::FileCache, logger::logger::Logger,
-    post_processing::post_processor::PostProcessor,
-};
-
-#[derive(Clone)]
-pub struct SettingsCache {
-    pub cache_directory: Option<PathBuf>,
-    pub theme_preference: String,
-}
-
-impl SettingsCache {
-    pub fn new(cache_directory: &Option<PathBuf>) -> Self {
-        SettingsCache {
-            cache_directory: cache_directory.clone(),
-            theme_preference: Logger::with_registry(|registry| registry.default_theme.to_owned()),
-        }
-    }
-
-    pub async fn initialize(&mut self) {
-        if let Some((mut lines, _)) = self.read()
-            && let Some(result) = lines.nth(0)
-            && let Ok(theme) = result
-        {
-            self.theme_preference = theme;
-        }
-    }
-
-    pub fn store_theme_preference(&self, theme: &str) {
-        self.write(format!("{theme}\n").as_str(), |_| {
-            self.on_theme_storage_error(theme);
-        });
-    }
-
-    fn on_theme_storage_error(&self, theme: &str) {
-        if let Some(storage_path) = self.storage_path() {
-            let theme_clone = theme.to_string();
-            PostProcessor::get().register_task(move || {
-                Logger::info("I failed to write your theme preference to the file system");
-                Logger::info(
-                    format!(
-                        "This usually indicates a bug within {}",
-                        Logger::with_theme(|theme| theme.highlight("Repokit"))
-                    )
-                    .as_str(),
-                );
-                Logger::info("Please file an issue here");
-                Logger::log_issue_link();
-                Logger::info("To repair this manually you can run");
-                Logger::log_file_path(
-                    format!(
-                        "printf \"{}\n\" > {}",
-                        theme_clone,
-                        storage_path.to_string_lossy(),
-                    )
-                    .as_str(),
-                );
-            });
-        }
-    }
-}
-
-impl FileCache for SettingsCache {
-    fn cache_file(&self) -> &str {
-        ".settings"
-    }
-
-    fn cache_directory(&self) -> &Option<PathBuf> {
-        &self.cache_directory
-    }
-}