@repokit/core 3.0.6 → 4.0.0

package/Cargo.lock

@@ -293,6 +293,94 @@ dependencies = [
  "num",
 ]
 
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -900,10 +988,11 @@ checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
 
 [[package]]
 name = "repokit"
-version = "3.0.6"
+version = "4.0.0"
 dependencies = [
  "alphanumeric-sort",
  "colored",
+ "futures",
  "ignore",
  "jsonschema",
  "normalize-path",
@@ -913,7 +1002,6 @@ dependencies = [
  "serde_json",
  "shellexpand",
  "terminal-spinners",
- "tokio",
 ]
 
 [[package]]
@@ -1056,6 +1144,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
 [[package]]
 name = "smallvec"
 version = "1.15.1"
@@ -1173,15 +1267,6 @@ dependencies = [
  "zerovec",
 ]
 
-[[package]]
-name = "tokio"
-version = "1.50.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
-dependencies = [
- "pin-project-lite",
-]
-
 [[package]]
 name = "unicode-general-category"
 version = "1.1.0"

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "repokit"
-version = "3.0.6"
+version = "4.0.0"
 edition = "2024"
 
 [[bin]]
@@ -14,9 +14,9 @@ serde_json = "1.0"
 colored = "3"
 normalize-path = "0.2.1"
 alphanumeric-sort = "1.5.5"
-tokio = "1.50.0"
 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"

package/installation/install.sh

@@ -1,10 +1,10 @@
-CURRENT_VERSION="3.0.6"
+CURRENT_VERSION="4.0.0"
 CWD=$(pwd)
 
 REPLACEMENT="/node_modules"
 FALLBACK_ROOT="${CWD%${REPLACEMENT}*}"
 
-GIT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null)
+GIT_ROOT=$(git rev-parse --show-toplevel)
 REPO_ROOT=${GIT_ROOT:-$FALLBACK_ROOT}
 
 if [[ "$CWD" != *"$REPLACEMENT"* ]]; then
@@ -31,39 +31,50 @@ ROOT_COMMIT=$(git rev-list --parents HEAD | tail -1) || ROOT_COMMIT=""
 
 cd
 
-CACHE_FILE=".repokit";
+OLD_CACHE_FILE=".repokit";
 CACHE_DIRECTORY=".repokit_cache";
-NEW_SETTINGS_FILE=".settings"
+VERSION_FILE=".version"
+SETTINGS_FILE=".settings"
 REPO_CACHE_DIRECTORY="$CACHE_DIRECTORY/$ROOT_COMMIT"
-LAST_THEME_USED=""
-BACK_PORTING=0
-
-if [ -n "$ROOT_COMMIT" ] && [ -f "$REPO_CACHE_DIRECTORY/$NEW_SETTINGS_FILE" ]; then
-    BACK_PORTING=1
-    cd "$REPO_CACHE_DIRECTORY"
-    read -r LAST_THEME_USED < "$NEW_SETTINGS_FILE"
-    rm "$NEW_SETTINGS_FILE"
-    cd
-fi
 
-if [ ! -f "$CACHE_FILE" ]; then
-    touch "$CACHE_FILE"
-elif [ "$BACK_PORTING" == 0 ]; then
-    read -r LAST_VERSION_USED < "$CACHE_FILE"
-    if [ "$LAST_VERSION_USED" == "$CURRENT_VERSION" ]; then
-        exit 0
+CACHED_THEME=""
+
+if [ -f "$OLD_CACHE_FILE" ] && [ -n "$ROOT_COMMIT" ] && [ ! -f "$REPO_CACHE_DIRECTORY/$SETTINGS_FILE" ]; then
+    {
+        read -r
+        read -r CACHED_THEME
+    } < "$OLD_CACHE_FILE"
+    echo "CACHED THEME $CACHED_THEME"
+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 [ -n "$CACHED_THEME" ] && [ ! -f "$SETTINGS_FILE" ]; then
+        touch "$SETTINGS_FILE"
+        echo "$CACHED_THEME\n" > "$SETTINGS_FILE"
+    fi
+    cd "../"
 fi
 
-if [ -n "$LAST_THEME_USED" ]; then 
-    echo "$CURRENT_VERSION\n$LAST_THEME_USED\n" > "$CACHE_FILE"
-else
-    TEMP_FILE=".repokit_tmp";
-    printf "$CURRENT_VERSION\n" > "$TEMP_FILE"
-    tail +2 "$CACHE_FILE" >> "$TEMP_FILE"
-    mv "$TEMP_FILE" "$CACHE_FILE"
-fi
+if [ -f $VERSION_FILE ]; then
+    read -r CACHED_VERSION < "$VERSION_FILE"
+    if [ "$CACHED_VERSION" == "$CURRENT_VERSION" ]; then
+        exit 0;    
+    fi
+else 
+    touch "$VERSION_FILE"
+fi 
 
+echo "$CURRENT_VERSION\n" > "$VERSION_FILE"
 
 cd $CWD
 

package/internals/caches/crawl_cache.rs

@@ -0,0 +1,124 @@
+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 files_to_crawl: Option<Vec<String>>,
+}
+
+impl CrawlCache {
+    pub fn new(cache_directory: &Option<PathBuf>) -> Self {
+        CrawlCache {
+            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 mut 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);
+                }
+            }
+            for line in changed_files {
+                lines.push(line);
+            }
+            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

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

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

package/internals/caches/repokit_version_resolver.rs

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

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