makit 0.0.144 → 0.0.145

data/lib/makit/test_cache.rb

@@ -1,239 +1,239 @@
-# frozen_string_literal: true
-
-module Makit
-  class TestCache
-    # Cache configuration
-    CACHE_BASE_DIR = File.join(Makit::Directories::PROJECT_ARTIFACTS, "test_cache").freeze
-    CACHE_METADATA_FILE = ".cache_metadata.json"
-    DEFAULT_TTL = 3600 # 1 hour cache by default
-
-    class << self
-      def setup
-        FileUtils.mkdir_p(CACHE_BASE_DIR)
-      end
-
-      # Main caching method - wraps expensive test operations
-      def with_cache(test_instance, cache_key, dependencies: [], ttl: DEFAULT_TTL, &block)
-        return yield unless should_cache?
-
-        cache_dir = cache_directory_for(test_instance, cache_key)
-        metadata = read_cache_metadata(cache_dir)
-
-        if cache_valid?(cache_dir, metadata, dependencies, ttl)
-          skip_with_cache_message(test_instance, cache_key, metadata)
-          return :cached
-        end
-
-        # Cache miss or invalid - run the expensive operation
-        cleanup_cache_directory(cache_dir)
-        FileUtils.mkdir_p(cache_dir)
-
-        # Execute the block in the cache directory context
-        result = Dir.chdir(cache_dir, &block)
-
-        # Write cache metadata
-        write_cache_metadata(cache_dir, dependencies)
-
-        result
-      end
-
-      # Directory-based caching - checks if directory exists and is valid
-      def cache_directory(test_instance, cache_key, dependencies: [], ttl: DEFAULT_TTL)
-        return nil unless should_cache?
-
-        cache_dir = cache_directory_for(test_instance, cache_key)
-        metadata = read_cache_metadata(cache_dir)
-
-        if cache_valid?(cache_dir, metadata, dependencies, ttl)
-          skip_with_cache_message(test_instance, cache_key, metadata)
-          return cache_dir
-        end
-
-        # Prepare fresh cache directory
-        cleanup_cache_directory(cache_dir)
-        FileUtils.mkdir_p(cache_dir)
-
-        cache_dir
-      end
-
-      # File-based caching - checks if specific files exist and are valid
-      def cache_files(test_instance, cache_key, expected_files, dependencies: [], ttl: DEFAULT_TTL)
-        return false unless should_cache?
-
-        cache_dir = cache_directory_for(test_instance, cache_key)
-        metadata = read_cache_metadata(cache_dir)
-
-        # Check if all expected files exist
-        files_exist = expected_files.all? do |file|
-          File.exist?(File.join(cache_dir, file))
-        end
-
-        if files_exist && cache_valid?(cache_dir, metadata, dependencies, ttl)
-          skip_with_cache_message(test_instance, cache_key, metadata)
-          return true
-        end
-
-        false
-      end
-
-      # Clear all test caches
-      def clear_all
-        FileUtils.rm_rf(CACHE_BASE_DIR)
-        puts "🗑️  Cleared all test caches".colorize(:grey)
-      end
-
-      # Clear caches for specific test class
-      def clear_for_class(test_class)
-        class_cache_dir = File.join(CACHE_BASE_DIR, class_cache_key(test_class))
-        FileUtils.rm_rf(class_cache_dir)
-        puts "🗑️  Cleared test caches for #{test_class}".colorize(:grey)
-      end
-
-      # Get cache statistics
-      def cache_stats
-        return { total_size: 0, cache_count: 0, cache_dirs: [] } unless Dir.exist?(CACHE_BASE_DIR)
-
-        cache_dirs = Dir.glob(File.join(CACHE_BASE_DIR, "**", "*")).select { |d| Dir.exist?(d) }
-        total_size = cache_dirs.sum { |dir| directory_size(dir) }
-
-        {
-          total_size: total_size,
-          cache_count: cache_dirs.length,
-          cache_dirs: cache_dirs.map { |d| d.sub("#{CACHE_BASE_DIR}/", "") },
-        }
-      end
-
-      private
-
-      def should_cache?
-        # Don't cache in CI environments by default (ensures clean runs)
-        return false if ENV["CI"] == "true"
-
-        # Don't cache if explicitly disabled
-        return false if ENV["MAKIT_DISABLE_TEST_CACHE"] == "true"
-
-        # Don't cache during test development/debugging
-        return false if ENV["MAKIT_TEST_DEBUG"] == "true"
-
-        # Don't cache in test environment unless explicitly testing the cache
-        return false if ENV["MAKIT_TESTING"] == "true" && ENV["MAKIT_TESTING_CACHE"] != "true"
-
-        true
-      end
-
-      def cache_directory_for(test_instance, cache_key)
-        test_class = test_instance.class.name.gsub("::", "/")
-        test_method = test_instance.name
-
-        File.join(CACHE_BASE_DIR, test_class, test_method, cache_key)
-      end
-
-      def class_cache_key(test_class)
-        test_class.name.gsub("::", "/")
-      end
-
-      def cache_valid?(cache_dir, metadata, dependencies, ttl)
-        return false unless Dir.exist?(cache_dir)
-        return false unless metadata
-
-        # Check TTL
-        cache_age = Time.now - Time.parse(metadata["created_at"])
-        return false if cache_age > ttl
-
-        # Check dependencies
-        return false unless dependencies_current?(metadata["dependencies"], dependencies)
-
-        # Check if cache directory has content
-        entries = Dir.entries(cache_dir) - [".", "..", CACHE_METADATA_FILE]
-        entries.any?
-      end
-
-      def dependencies_current?(cached_deps, current_deps)
-        return true if current_deps.empty?
-
-        current_deps.each do |dep_file|
-          next unless File.exist?(dep_file)
-
-          current_mtime = File.mtime(dep_file).to_i
-          cached_mtime = cached_deps&.dig(dep_file)
-
-          return false if cached_mtime.nil? || current_mtime > cached_mtime
-        end
-
-        true
-      end
-
-      def read_cache_metadata(cache_dir)
-        metadata_file = File.join(cache_dir, CACHE_METADATA_FILE)
-        return nil unless File.exist?(metadata_file)
-
-        JSON.parse(File.read(metadata_file))
-      rescue JSON::ParserError
-        nil
-      end
-
-      def write_cache_metadata(cache_dir, dependencies)
-        metadata = {
-          created_at: Time.now.iso8601,
-          dependencies: dependencies.each_with_object({}) do |dep_file, hash|
-            hash[dep_file] = File.exist?(dep_file) ? File.mtime(dep_file).to_i : nil
-          end,
-        }
-
-        metadata_file = File.join(cache_dir, CACHE_METADATA_FILE)
-        File.write(metadata_file, JSON.pretty_generate(metadata))
-      end
-
-      def skip_with_cache_message(test_instance, cache_key, metadata)
-        cache_age = Time.now - Time.parse(metadata["created_at"])
-        age_text = format_duration(cache_age)
-
-        test_instance.skip("💨 Using cached result for '#{cache_key}' (cached #{age_text} ago)")
-      end
-
-      def cleanup_cache_directory(cache_dir)
-        FileUtils.rm_rf(cache_dir)
-      end
-
-      def directory_size(dir_path)
-        Dir.glob(File.join(dir_path, "**", "*"))
-           .select { |f| File.file?(f) }
-           .sum { |f| File.size(f) }
-      end
-
-      def format_duration(seconds)
-        if seconds < 60
-          "#{seconds.round}s"
-        elsif seconds < 3600
-          minutes = (seconds / 60).round
-          "#{minutes}m"
-        else
-          hours = (seconds / 3600).round
-          "#{hours}h"
-        end
-      end
-    end
-  end
-
-  # Mixin module for test classes to provide caching helpers
-  module TestCacheHelpers
-    def cache_expensive_operation(cache_key, dependencies: [], ttl: Makit::TestCache::DEFAULT_TTL, &block)
-      Makit::TestCache.with_cache(self, cache_key,
-                                  dependencies: dependencies,
-                                  ttl: ttl,
-        &block)
-    end
-
-    def cached_directory(cache_key, dependencies: [], ttl: Makit::TestCache::DEFAULT_TTL)
-      Makit::TestCache.cache_directory(self, cache_key,
-                                       dependencies: dependencies,
-                                       ttl: ttl)
-    end
-
-    def cached_files_exist?(cache_key, expected_files, dependencies: [], ttl: Makit::TestCache::DEFAULT_TTL)
-      Makit::TestCache.cache_files(self, cache_key, expected_files,
-                                   dependencies: dependencies,
-                                   ttl: ttl)
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Makit
+  class TestCache
+    # Cache configuration
+    CACHE_BASE_DIR = File.join(Makit::Directories::PROJECT_ARTIFACTS, "test_cache").freeze
+    CACHE_METADATA_FILE = ".cache_metadata.json"
+    DEFAULT_TTL = 3600 # 1 hour cache by default
+
+    class << self
+      def setup
+        FileUtils.mkdir_p(CACHE_BASE_DIR)
+      end
+
+      # Main caching method - wraps expensive test operations
+      def with_cache(test_instance, cache_key, dependencies: [], ttl: DEFAULT_TTL, &block)
+        return yield unless should_cache?
+
+        cache_dir = cache_directory_for(test_instance, cache_key)
+        metadata = read_cache_metadata(cache_dir)
+
+        if cache_valid?(cache_dir, metadata, dependencies, ttl)
+          skip_with_cache_message(test_instance, cache_key, metadata)
+          return :cached
+        end
+
+        # Cache miss or invalid - run the expensive operation
+        cleanup_cache_directory(cache_dir)
+        FileUtils.mkdir_p(cache_dir)
+
+        # Execute the block in the cache directory context
+        result = Dir.chdir(cache_dir, &block)
+
+        # Write cache metadata
+        write_cache_metadata(cache_dir, dependencies)
+
+        result
+      end
+
+      # Directory-based caching - checks if directory exists and is valid
+      def cache_directory(test_instance, cache_key, dependencies: [], ttl: DEFAULT_TTL)
+        return nil unless should_cache?
+
+        cache_dir = cache_directory_for(test_instance, cache_key)
+        metadata = read_cache_metadata(cache_dir)
+
+        if cache_valid?(cache_dir, metadata, dependencies, ttl)
+          skip_with_cache_message(test_instance, cache_key, metadata)
+          return cache_dir
+        end
+
+        # Prepare fresh cache directory
+        cleanup_cache_directory(cache_dir)
+        FileUtils.mkdir_p(cache_dir)
+
+        cache_dir
+      end
+
+      # File-based caching - checks if specific files exist and are valid
+      def cache_files(test_instance, cache_key, expected_files, dependencies: [], ttl: DEFAULT_TTL)
+        return false unless should_cache?
+
+        cache_dir = cache_directory_for(test_instance, cache_key)
+        metadata = read_cache_metadata(cache_dir)
+
+        # Check if all expected files exist
+        files_exist = expected_files.all? do |file|
+          File.exist?(File.join(cache_dir, file))
+        end
+
+        if files_exist && cache_valid?(cache_dir, metadata, dependencies, ttl)
+          skip_with_cache_message(test_instance, cache_key, metadata)
+          return true
+        end
+
+        false
+      end
+
+      # Clear all test caches
+      def clear_all
+        FileUtils.rm_rf(CACHE_BASE_DIR)
+        puts "🗑️  Cleared all test caches".colorize(:grey)
+      end
+
+      # Clear caches for specific test class
+      def clear_for_class(test_class)
+        class_cache_dir = File.join(CACHE_BASE_DIR, class_cache_key(test_class))
+        FileUtils.rm_rf(class_cache_dir)
+        puts "🗑️  Cleared test caches for #{test_class}".colorize(:grey)
+      end
+
+      # Get cache statistics
+      def cache_stats
+        return { total_size: 0, cache_count: 0, cache_dirs: [] } unless Dir.exist?(CACHE_BASE_DIR)
+
+        cache_dirs = Dir.glob(File.join(CACHE_BASE_DIR, "**", "*")).select { |d| Dir.exist?(d) }
+        total_size = cache_dirs.sum { |dir| directory_size(dir) }
+
+        {
+          total_size: total_size,
+          cache_count: cache_dirs.length,
+          cache_dirs: cache_dirs.map { |d| d.sub("#{CACHE_BASE_DIR}/", "") },
+        }
+      end
+
+      private
+
+      def should_cache?
+        # Don't cache in CI environments by default (ensures clean runs)
+        return false if ENV["CI"] == "true"
+
+        # Don't cache if explicitly disabled
+        return false if ENV["MAKIT_DISABLE_TEST_CACHE"] == "true"
+
+        # Don't cache during test development/debugging
+        return false if ENV["MAKIT_TEST_DEBUG"] == "true"
+
+        # Don't cache in test environment unless explicitly testing the cache
+        return false if ENV["MAKIT_TESTING"] == "true" && ENV["MAKIT_TESTING_CACHE"] != "true"
+
+        true
+      end
+
+      def cache_directory_for(test_instance, cache_key)
+        test_class = test_instance.class.name.gsub("::", "/")
+        test_method = test_instance.name
+
+        File.join(CACHE_BASE_DIR, test_class, test_method, cache_key)
+      end
+
+      def class_cache_key(test_class)
+        test_class.name.gsub("::", "/")
+      end
+
+      def cache_valid?(cache_dir, metadata, dependencies, ttl)
+        return false unless Dir.exist?(cache_dir)
+        return false unless metadata
+
+        # Check TTL
+        cache_age = Time.now - Time.parse(metadata["created_at"])
+        return false if cache_age > ttl
+
+        # Check dependencies
+        return false unless dependencies_current?(metadata["dependencies"], dependencies)
+
+        # Check if cache directory has content
+        entries = Dir.entries(cache_dir) - [".", "..", CACHE_METADATA_FILE]
+        entries.any?
+      end
+
+      def dependencies_current?(cached_deps, current_deps)
+        return true if current_deps.empty?
+
+        current_deps.each do |dep_file|
+          next unless File.exist?(dep_file)
+
+          current_mtime = File.mtime(dep_file).to_i
+          cached_mtime = cached_deps&.dig(dep_file)
+
+          return false if cached_mtime.nil? || current_mtime > cached_mtime
+        end
+
+        true
+      end
+
+      def read_cache_metadata(cache_dir)
+        metadata_file = File.join(cache_dir, CACHE_METADATA_FILE)
+        return nil unless File.exist?(metadata_file)
+
+        JSON.parse(File.read(metadata_file))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def write_cache_metadata(cache_dir, dependencies)
+        metadata = {
+          created_at: Time.now.iso8601,
+          dependencies: dependencies.each_with_object({}) do |dep_file, hash|
+            hash[dep_file] = File.exist?(dep_file) ? File.mtime(dep_file).to_i : nil
+          end,
+        }
+
+        metadata_file = File.join(cache_dir, CACHE_METADATA_FILE)
+        File.write(metadata_file, JSON.pretty_generate(metadata))
+      end
+
+      def skip_with_cache_message(test_instance, cache_key, metadata)
+        cache_age = Time.now - Time.parse(metadata["created_at"])
+        age_text = format_duration(cache_age)
+
+        test_instance.skip("💨 Using cached result for '#{cache_key}' (cached #{age_text} ago)")
+      end
+
+      def cleanup_cache_directory(cache_dir)
+        FileUtils.rm_rf(cache_dir)
+      end
+
+      def directory_size(dir_path)
+        Dir.glob(File.join(dir_path, "**", "*"))
+           .select { |f| File.file?(f) }
+           .sum { |f| File.size(f) }
+      end
+
+      def format_duration(seconds)
+        if seconds < 60
+          "#{seconds.round}s"
+        elsif seconds < 3600
+          minutes = (seconds / 60).round
+          "#{minutes}m"
+        else
+          hours = (seconds / 3600).round
+          "#{hours}h"
+        end
+      end
+    end
+  end
+
+  # Mixin module for test classes to provide caching helpers
+  module TestCacheHelpers
+    def cache_expensive_operation(cache_key, dependencies: [], ttl: Makit::TestCache::DEFAULT_TTL, &block)
+      Makit::TestCache.with_cache(self, cache_key,
+                                  dependencies: dependencies,
+                                  ttl: ttl,
+        &block)
+    end
+
+    def cached_directory(cache_key, dependencies: [], ttl: Makit::TestCache::DEFAULT_TTL)
+      Makit::TestCache.cache_directory(self, cache_key,
+                                       dependencies: dependencies,
+                                       ttl: ttl)
+    end
+
+    def cached_files_exist?(cache_key, expected_files, dependencies: [], ttl: Makit::TestCache::DEFAULT_TTL)
+      Makit::TestCache.cache_files(self, cache_key, expected_files,
+                                   dependencies: dependencies,
+                                   ttl: ttl)
+    end
+  end
+end

data/lib/makit/tree.rb

@@ -1,37 +1,37 @@
-# frozen_string_literal: true
-
-# This module provides classes for the Makit gem.
-module Makit
-  class Tree
-    def get_source_tree
-      files = `git ls-files`.split("\n")
-      tree = {}
-
-      # Build a nested hash representing the file structure
-      files.each do |file|
-        parts = file.split("/")
-        current = tree
-
-        parts.each_with_index do |part, index|
-          current[part] ||= (index == parts.length - 1 ? nil : {})
-          current = current[part] unless current[part].nil?
-        end
-      end
-
-      generate_tree_string(tree)
-    end
-
-    def generate_tree_string(tree, indent = "")
-      result = ""
-      tree.each do |key, value|
-        if value.is_a?(Hash)
-          result << "#{indent}#{key}/\n"
-          result << generate_tree_string(value, "#{indent}  ")
-        else
-          result << "#{indent}#{key}\n"
-        end
-      end
-      result
-    end
-  end
-end
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  class Tree
+    def get_source_tree
+      files = `git ls-files`.split("\n")
+      tree = {}
+
+      # Build a nested hash representing the file structure
+      files.each do |file|
+        parts = file.split("/")
+        current = tree
+
+        parts.each_with_index do |part, index|
+          current[part] ||= (index == parts.length - 1 ? nil : {})
+          current = current[part] unless current[part].nil?
+        end
+      end
+
+      generate_tree_string(tree)
+    end
+
+    def generate_tree_string(tree, indent = "")
+      result = ""
+      tree.each do |key, value|
+        if value.is_a?(Hash)
+          result << "#{indent}#{key}/\n"
+          result << generate_tree_string(value, "#{indent}  ")
+        else
+          result << "#{indent}#{key}\n"
+        end
+      end
+      result
+    end
+  end
+end