cov-loupe 3.0.0 → 4.0.0.pre

data/lib/cov_loupe/paths/volume_case_sensitivity.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module CovLoupe
+  # Handles detection and caching of filesystem volume case sensitivity.
+  # Provides thread-safe case sensitivity detection with caching for performance.
+  module VolumeCaseSensitivity
+    # Mutex for thread-safe cache access
+    CACHE_MUTEX = Mutex.new
+
+    class << self
+      # Detects whether the volume at the given path is case-sensitive.
+      # Prefer using an existing file (via File.identical?) to avoid writing;
+      # fall back to a temporary file if no suitable file exists.
+      #
+      # This method caches results by path to avoid repeated filesystem checks,
+      # which can be expensive, especially on network-mounted volumes.
+      #
+      # @param path [String, nil] directory path to test (defaults to current directory)
+      # @return [Boolean] true if case-sensitive, false if case-insensitive or on error
+      def volume_case_sensitive?(path = nil)
+        require 'securerandom'
+
+        test_path = path ? File.absolute_path(path) : Dir.pwd
+        abs_path = File.absolute_path(test_path)
+
+        # Check cache first (thread-safe read)
+        cached_value = get_from_cache(abs_path)
+        return cached_value unless cached_value.nil?
+
+        # Return false if directory doesn't exist
+        return false unless File.directory?(abs_path)
+
+        result = detect_case_sensitivity?(abs_path)
+
+        # Store result in cache (thread-safe write)
+        set_in_cache(abs_path, result)
+
+        result
+      rescue SystemCallError, IOError
+        # Can't detect from filesystem, assume case-insensitive to be conservative
+        false
+      end
+
+      # Clears the case sensitivity cache (useful for testing)
+      #
+      # @return [void]
+      def clear_cache
+        CACHE_MUTEX.synchronize do
+          @cache = {}
+        end
+      end
+
+      # Returns the current cache contents (useful for testing)
+      #
+      # @return [Hash] cache contents
+      def cache
+        CACHE_MUTEX.synchronize do
+          @cache ||= {}
+          @cache.dup
+        end
+      end
+
+      # Retrieves a value from the cache (thread-safe)
+      #
+      # @param abs_path [String] absolute path to look up
+      # @return [Boolean, nil] cached value or nil if not found
+      def get_from_cache(abs_path)
+        CACHE_MUTEX.synchronize do
+          @cache ||= {}
+          @cache[abs_path]
+        end
+      end
+
+      # Stores a value in the cache (thread-safe)
+      #
+      # @param abs_path [String] absolute path to cache
+      # @param value [Boolean] value to cache
+      # @return [void]
+      def set_in_cache(abs_path, value)
+        CACHE_MUTEX.synchronize do
+          @cache ||= {}
+          @cache[abs_path] = value
+        end
+      end
+
+      # Detects case sensitivity for a given directory
+      #
+      # @param abs_path [String] absolute path to directory
+      # @return [Boolean] true if case-sensitive, false if case-insensitive
+      def detect_case_sensitivity?(abs_path)
+        # Try to use an existing file to avoid filesystem writes
+        existing_file = find_existing_file(abs_path)
+
+        if existing_file
+          detect_case_sensitive_using_existing_file?(abs_path, existing_file)
+        else
+          detect_case_sensitive_using_temp_file?(abs_path)
+        end
+      end
+
+      # Finds an existing file in the directory suitable for case sensitivity testing
+      #
+      # @param abs_path [String] absolute path to directory
+      # @return [String, nil] filename or nil if no suitable file found
+      def find_existing_file(abs_path)
+        Dir.children(abs_path).find do |name|
+          name.match?(/[A-Za-z]/) && File.file?(File.join(abs_path, name))
+        end
+      end
+
+      # Detects case sensitivity using an existing file in the directory
+      #
+      # @param abs_path [String] absolute path to directory
+      # @param existing_file [String] name of existing file
+      # @return [Boolean] true if case-sensitive, false if case-insensitive
+      def detect_case_sensitive_using_existing_file?(abs_path, existing_file)
+        require 'securerandom'
+
+        original = File.join(abs_path, existing_file)
+        alternate_name = existing_file.tr('A-Za-z', 'a-zA-Z')
+        alternate = File.join(abs_path, alternate_name)
+
+        if File.exist?(alternate)
+          # Same file -> case-insensitive, different files -> case-sensitive
+          !File.identical?(original, alternate)
+        else
+          true
+        end
+      end
+
+      # Detects case sensitivity using a temporary test file
+      #
+      # @param abs_path [String] absolute path to directory
+      # @return [Boolean] true if case-sensitive, false if case-insensitive
+      def detect_case_sensitive_using_temp_file?(abs_path)
+        require 'securerandom'
+
+        # Create a temporary test file with a unique name
+        test_file = generate_unique_test_filename(abs_path)
+
+        begin
+          FileUtils.touch(test_file)
+          variants = [test_file, test_file.upcase, test_file.downcase]
+          # Test if exactly one variant exists (case-sensitive) vs all exist (case-insensitive)
+          variants.one? { |variant| File.exist?(variant) }
+        ensure
+          # Clean up all potential variants
+          [test_file, test_file.upcase, test_file.downcase].each do |variant|
+            FileUtils.rm_f(variant)
+          end
+        end
+      end
+
+      # Generates a unique test filename that doesn't conflict with existing files
+      #
+      # @param abs_path [String] absolute path to directory
+      # @return [String] unique filename path
+      def generate_unique_test_filename(abs_path)
+        require 'securerandom'
+
+        test_file = nil
+        while test_file.nil?
+          candidate = File.join(abs_path, "CovLoupe_CaseSensitivity_Test_#{SecureRandom.hex(16)}.tmp")
+          variants = [candidate, candidate.upcase, candidate.downcase]
+          test_file = candidate if variants.none? { |v| File.exist?(v) }
+        end
+        test_file
+      end
+    end
+  end
+end

data/lib/cov_loupe/presenters/base_coverage_presenter.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require_relative 'payload_caching'
+
 module CovLoupe
   module Presenters
     # Shared presenter behavior for single-file coverage payloads.
     class BaseCoveragePresenter
+      include PayloadCaching
+
       attr_reader :model, :path
 
       def initialize(model:, path:)
@@ -11,19 +15,6 @@ module CovLoupe
         @path = path
       end
 
-      # Returns the absolute-path payload augmented with stale metadata.
-      def absolute_payload
-        @absolute_payload ||= begin
-          payload = build_payload
-          payload.merge('stale' => model.staleness_for(path))
-        end
-      end
-
-      # Returns the payload with file paths relativized for presentation.
-      def relativized_payload
-        @relativized_payload ||= model.relativize(absolute_payload)
-      end
-
       # Returns the cached stale status for the file.
       def stale
         absolute_payload['stale']
@@ -34,6 +25,11 @@ module CovLoupe
         relativized_payload['file']
       end
 
+      private def compute_absolute_payload
+        payload = build_payload
+        payload.merge('stale' => model.staleness_for(path))
+      end
+
       private def build_payload
         raise NotImplementedError, "#{self.class} must implement #build_payload"
       end

data/lib/cov_loupe/presenters/coverage_payload_presenter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base_coverage_presenter'
+
+module CovLoupe
+  module Presenters
+    # Provides shared single-file coverage payloads for CLI and MCP callers.
+    class CoveragePayloadPresenter < BaseCoveragePresenter
+      def initialize(model:, path:, payload_method:, raise_on_stale: nil)
+        super(model: model, path: path)
+        @payload_method = payload_method
+        @raise_on_stale = raise_on_stale
+      end
+
+      private def build_payload
+        args = { raise_on_stale: @raise_on_stale }.compact
+        model.public_send(@payload_method, path, **args)
+      end
+    end
+  end
+end

data/lib/cov_loupe/presenters/payload_caching.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CovLoupe
+  module Presenters
+    # Shared memoization logic for coverage payloads.
+    module PayloadCaching
+      # Returns the absolute-path payload.
+      # Consumers must implement #compute_absolute_payload.
+      def absolute_payload
+        @absolute_payload ||= compute_absolute_payload
+      end
+
+      # Returns the payload with file paths relativized for presentation.
+      def relativized_payload
+        @relativized_payload ||= model.relativize(absolute_payload)
+      end
+
+      private def compute_absolute_payload
+        raise NotImplementedError, "#{self.class} must implement #compute_absolute_payload"
+      end
+    end
+  end
+end

data/lib/cov_loupe/presenters/project_coverage_presenter.rb

@@ -1,35 +1,24 @@
 # frozen_string_literal: true
 
+require_relative 'payload_caching'
+
+require_relative '../staleness/stale_status'
+
 module CovLoupe
   module Presenters
     # Provides repository-wide coverage summaries shared by CLI and MCP surfaces.
     class ProjectCoveragePresenter
-      attr_reader :model, :sort_order, :check_stale, :tracked_globs
+      include PayloadCaching
+
+      attr_reader :model, :sort_order, :raise_on_stale, :tracked_globs
 
-      def initialize(model:, sort_order:, check_stale:, tracked_globs:)
+      def initialize(model:, sort_order:, raise_on_stale:, tracked_globs:)
         @model = model
         @sort_order = sort_order
-        @check_stale = check_stale
+        @raise_on_stale = raise_on_stale
         @tracked_globs = tracked_globs
       end
 
-      # Returns the absolute-path payload including counts.
-      def absolute_payload
-        @absolute_payload ||= begin
-          files = model.all_files(
-            sort_order: sort_order,
-            check_stale: check_stale,
-            tracked_globs: tracked_globs
-          )
-          { 'files' => files, 'counts' => build_counts(files) }
-        end
-      end
-
-      # Returns the payload with file paths relativized for presentation.
-      def relativized_payload
-        @relativized_payload ||= model.relativize(absolute_payload)
-      end
-
       # Returns the relativized file rows.
       def relative_files
         relativized_payload['files']
@@ -40,9 +29,72 @@ module CovLoupe
         relativized_payload['counts']
       end
 
+      # Returns the relativized skipped files.
+      def relative_skipped_files
+        relativized_payload['skipped_files']
+      end
+
+      # Returns the relativized missing tracked files.
+      def relative_missing_tracked_files
+        relativized_payload['missing_tracked_files']
+      end
+
+      # Returns the relativized newer files.
+      def relative_newer_files
+        relativized_payload['newer_files']
+      end
+
+      # Returns the relativized deleted files.
+      def relative_deleted_files
+        relativized_payload['deleted_files']
+      end
+
+      # Returns the relativized length-mismatch files.
+      def relative_length_mismatch_files
+        relativized_payload['length_mismatch_files']
+      end
+
+      # Returns the relativized unreadable files.
+      def relative_unreadable_files
+        relativized_payload['unreadable_files']
+      end
+
+      # Returns the timestamp status indicating whether coverage timestamps are available.
+      # Can be 'ok' (timestamps available) or 'missing' (no timestamps, staleness checks skipped).
+      def timestamp_status
+        relativized_payload['timestamp_status']
+      end
+
+      private def compute_absolute_payload
+        list_result = model.list(
+          sort_order: sort_order,
+          raise_on_stale: raise_on_stale,
+          tracked_globs: tracked_globs
+        )
+        files = list_result['files']
+        skipped_files = list_result['skipped_files']
+        missing_tracked_files = list_result['missing_tracked_files']
+        newer_files = list_result['newer_files']
+        deleted_files = list_result['deleted_files']
+        length_mismatch_files = list_result['length_mismatch_files']
+        unreadable_files = list_result['unreadable_files']
+        timestamp_status = list_result['timestamp_status']
+        {
+          'files' => files,
+          'skipped_files' => skipped_files,
+          'missing_tracked_files' => missing_tracked_files,
+          'newer_files' => newer_files,
+          'deleted_files' => deleted_files,
+          'length_mismatch_files' => length_mismatch_files,
+          'unreadable_files' => unreadable_files,
+          'timestamp_status' => timestamp_status,
+          'counts' => build_counts(files)
+        }
+      end
+
       private def build_counts(files)
         total = files.length
-        stale = files.count { |f| f['stale'] }
+        stale = files.count { |f| StaleStatus.stale?(f['stale']) }
         { 'total' => total, 'ok' => total - stale, 'stale' => stale }
       end
     end

data/lib/cov_loupe/presenters/project_totals_presenter.rb

@@ -1,26 +1,32 @@
 # frozen_string_literal: true
 
+require_relative 'payload_caching'
+
 module CovLoupe
   module Presenters
     # Provides aggregated line totals and average coverage across the project.
     class ProjectTotalsPresenter
-      attr_reader :model, :check_stale, :tracked_globs
+      include PayloadCaching
+
+      attr_reader :model, :raise_on_stale, :tracked_globs
 
-      def initialize(model:, check_stale:, tracked_globs:)
+      def initialize(model:, raise_on_stale:, tracked_globs:)
         @model = model
-        @check_stale = check_stale
+        @raise_on_stale = raise_on_stale
         @tracked_globs = tracked_globs
       end
 
-      def absolute_payload
-        @absolute_payload ||= model.project_totals(
-          tracked_globs: tracked_globs,
-          check_stale: check_stale
-        )
+      # Returns the timestamp status indicating whether coverage timestamps are available.
+      # Can be 'ok' (timestamps available) or 'missing' (no timestamps, staleness checks skipped).
+      def timestamp_status
+        relativized_payload['timestamp_status']
       end
 
-      def relativized_payload
-        @relativized_payload ||= model.relativize(absolute_payload)
+      private def compute_absolute_payload
+        model.project_totals(
+          tracked_globs: tracked_globs,
+          raise_on_stale: raise_on_stale
+        )
       end
     end
   end

data/lib/cov_loupe/repositories/coverage_repository.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../resolvers/resolver_helpers'
+require_relative '../loaders/resultset_loader'
+require_relative '../errors/errors'
+require_relative '../paths/path_utils'
+
+module CovLoupe
+  module Repositories
+    # CoverageRepository handles the discovery, loading, and normalization of SimpleCov
+    # coverage data. It decouples data access concerns from the domain logic in CoverageModel.
+    #
+    # Its primary responsibilities are:
+    # 1. Locating the .resultset.json file using ResolverHelpers.
+    # 2. Loading and parsing the JSON data using ResultsetLoader (handling suite merging if needed).
+    # 3. Normalizing all coverage map keys to absolute paths relative to the project root.
+    #
+    # @attr_reader coverage_map [Hash] A map of absolute file paths to coverage data.
+    # @attr_reader timestamp [Integer] The latest timestamp from the loaded coverage suites.
+    # @attr_reader resultset_path [String] The resolved absolute path to the .resultset.json file.
+    class CoverageRepository
+      attr_reader :coverage_map, :timestamp, :resultset_path
+
+      def initialize(root:, resultset_path: nil, logger: nil)
+        @root = root
+        @logger = logger || CovLoupe.logger
+
+        begin
+          # 1. Locate the file
+          @resultset_path = resolve_resultset_path(resultset_path)
+
+          # 2. Load the data
+          loaded_data = load_data
+
+          # 3. Detect volume case sensitivity from project root
+          @volume_case_sensitive = detect_volume_case_sensitivity
+
+          # 4. Normalize keys to absolute paths
+          @coverage_map = normalize_paths(loaded_data.coverage_map)
+          @timestamp = loaded_data.timestamp
+        rescue CovLoupe::Error
+          raise # Re-raise our own errors as-is
+        rescue => e
+          raise ErrorHandler.new.convert_standard_error(e, context: :coverage_loading)
+        end
+      end
+
+      private def resolve_resultset_path(path_arg)
+        Resolvers::ResolverHelpers.find_resultset(@root, resultset: path_arg)
+      end
+
+      private def load_data
+        ResultsetLoader.load(resultset_path: @resultset_path, logger: @logger)
+      end
+
+      # Detects volume case sensitivity from the project root directory.
+      # Uses @root because coverage map keys are paths to source files in the project.
+      #
+      # Falls back to assuming case-insensitive if @root doesn't exist (test scenarios)
+      # or isn't accessible. This conservative fallback catches more potential collisions.
+      #
+      # @return [Boolean] true if volume is case-sensitive
+      private def detect_volume_case_sensitivity
+        return false unless File.directory?(@root)
+
+        PathUtils.volume_case_sensitive?(@root)
+      rescue SystemCallError, IOError
+        # Can't detect from filesystem, assume case-insensitive to be conservative
+        false
+      end
+
+      # Normalizes all coverage map keys to absolute paths and detects collisions.
+      #
+      # This method transforms relative and mixed-case paths to their canonical absolute
+      # form. If multiple original keys normalize to the same path (e.g., "lib/foo.rb" and
+      # "/full/path/lib/foo.rb"), this indicates corrupt or problematic coverage data that
+      # would otherwise silently overwrite earlier entries.
+      #
+      # On case-insensitive volumes, paths that differ only in case (e.g., "Foo.rb" and
+      # "foo.rb") are detected as collisions. The original case is preserved in stored keys
+      # for correct display in error messages and reports.
+      #
+      # @param map [Hash] Original coverage map with potentially relative/mixed keys
+      # @return [Hash] Normalized coverage map with absolute path keys (preserving original case)
+      # @raise [CoverageDataError] If duplicate keys normalize to the same path
+      private def normalize_paths(map)
+        return {} unless map
+
+        result = {}
+        # Track which original keys map to each normalized key to detect collisions
+        # Example: { "/abs/path/lib/foo.rb" => ["lib/foo.rb", "/abs/path/lib/foo.rb"] }
+        provided_paths_by_normalized_path = Hash.new { |h, k| h[k] = [] }
+        # Track the expanded (but not case-normalized) key for storage
+        # Example: { "/abs/path/lib/foo.rb" => "/full/path/lib/foo.rb" }
+        expanded_by_normalized = {}
+
+        # First pass: normalize all keys and track the mapping
+        map.each do |original_key, value|
+          # Expand to absolute path first
+          expanded_key = PathUtils.expand(original_key, @root)
+
+          # Then apply case normalization for collision detection only
+          # Pass root to ensure case-sensitivity is derived from root's volume
+          normalized_key = PathUtils.normalize(
+            expanded_key,
+            normalize_case: !@volume_case_sensitive,
+            root: @root
+          )
+
+          provided_paths_by_normalized_path[normalized_key] << original_key
+          # Store using expanded key (preserves original case) for display purposes
+          expanded_by_normalized[normalized_key] ||= expanded_key
+          result[expanded_by_normalized[normalized_key]] = value
+        end
+
+        # Second pass: detect collisions (any normalized key with multiple original keys)
+        collisions = provided_paths_by_normalized_path.select do |_norm_key, orig_keys|
+          orig_keys.size > 1
+        end
+
+        collisions.empty? ? result : raise_collision_error(collisions, expanded_by_normalized)
+      end
+
+      # Raises a CoverageDataError with details about path normalization collisions.
+      #
+      # Formats collision data as parseable JSON with each collision on one line:
+      #   {
+      #     "/full/path/lib/foo.rb": ["lib/foo.rb", "/full/path/lib/foo.rb"],
+      #     "/full/path/lib/bar.rb": ["lib/bar.rb", "/full/path/lib/bar.rb"]
+      #   }
+      #
+      # @param collisions [Hash] Map of normalized paths to arrays of original keys
+      # @param expanded_by_normalized [Hash] Map of normalized paths to case-preserved expanded paths
+      # @raise [CoverageDataError] Always raises with formatted collision details
+      private def raise_collision_error(collisions, expanded_by_normalized)
+        json_lines = collisions.map do |norm_key, orig_keys|
+          # Use the case-preserved expanded key instead of the normalized key
+          expanded_key = expanded_by_normalized[norm_key]
+          "  #{JSON.generate(expanded_key)}: #{JSON.generate(orig_keys)}"
+        end
+        details = "{\n#{json_lines.join(",\n")}\n}"
+
+        raise CoverageDataError,
+          "Duplicate paths detected after normalization. The following keys normalize to the same path:\n#{details}"
+      end
+    end
+  end
+end