cov-loupe 3.0.0

data/spec/presenters/project_coverage_presenter_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::Presenters::ProjectCoveragePresenter do
+  subject(:presenter) do
+    described_class.new(
+      model: model,
+      sort_order: sort_order,
+      check_stale: check_stale,
+      tracked_globs: tracked_globs
+    )
+  end
+
+  let(:model) { instance_double(CovLoupe::CoverageModel) }
+  let(:sort_order) { :ascending }
+  let(:check_stale) { true }
+  let(:tracked_globs) { ['lib/**/*.rb'] }
+  let(:files) do
+    [
+      {
+        'file' => '/abs/path/lib/foo.rb',
+        'covered' => 5,
+        'total' => 6,
+        'percentage' => 83.33,
+        'stale' => false
+      },
+      {
+        'file' => '/abs/path/lib/bar.rb',
+        'covered' => 1,
+        'total' => 6,
+        'percentage' => 16.67,
+        'stale' => 'L'
+      }
+    ]
+  end
+
+
+  before do
+    allow(model).to receive(:all_files).with(sort_order: sort_order, check_stale: check_stale,
+      tracked_globs: tracked_globs).and_return(files)
+    allow(model).to receive(:relativize) do |payload|
+      relativizer = CovLoupe::PathRelativizer.new(
+        root: '/abs/path',
+        scalar_keys: %w[file file_path],
+        array_keys: %w[newer_files missing_files deleted_files]
+      )
+      relativizer.relativize(payload)
+    end
+  end
+
+  describe '#absolute_payload' do
+    it 'returns files and counts with stale metadata' do
+      payload = presenter.absolute_payload
+
+      expect(payload['files']).to eq(files)
+      expect(payload['counts']).to eq({ 'total' => 2, 'ok' => 1, 'stale' => 1 })
+    end
+
+    it 'memoizes the computed payload' do
+      presenter.absolute_payload
+      presenter.absolute_payload
+
+      expect(model).to have_received(:all_files).once
+    end
+  end
+
+  describe '#relativized_payload' do
+    it 'relativizes the files list' do
+      relativized = presenter.relativized_payload
+
+      expect(relativized['files'].map { |f| f['file'] }).to eq(['lib/foo.rb', 'lib/bar.rb'])
+    end
+  end
+
+  describe '#relative_files' do
+    it 'returns the relativized file list' do
+      expect(presenter.relative_files.map { |f| f['file'] }).to eq(['lib/foo.rb', 'lib/bar.rb'])
+    end
+  end
+
+  describe '#relative_counts' do
+    it 'returns the relativized counts hash' do
+      expect(presenter.relative_counts).to eq({ 'total' => 2, 'ok' => 1, 'stale' => 1 })
+    end
+  end
+end

data/spec/presenters/project_totals_presenter_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::Presenters::ProjectTotalsPresenter do
+  subject(:presenter) do
+    described_class.new(
+      model: model,
+      check_stale: true,
+      tracked_globs: ['lib/**/*.rb']
+    )
+  end
+
+  let(:model) { instance_double(CovLoupe::CoverageModel) }
+  let(:raw_totals) do
+    {
+      'lines' => { 'total' => 100, 'covered' => 80, 'uncovered' => 20 },
+      'percentage' => 80.0,
+      'files' => { 'total' => 10, 'ok' => 9, 'stale' => 1 }
+    }
+  end
+
+  before do
+    allow(model).to receive(:project_totals)
+      .with(tracked_globs: ['lib/**/*.rb'], check_stale: true)
+      .and_return(raw_totals)
+    allow(model).to receive(:relativize) { |payload| payload }
+  end
+
+  describe '#initialize' do
+    it 'stores the model, check_stale, and tracked_globs options' do
+      expect(presenter.model).to eq(model)
+      expect(presenter.check_stale).to be(true)
+      expect(presenter.tracked_globs).to eq(['lib/**/*.rb'])
+    end
+  end
+
+  describe '#absolute_payload' do
+    it 'returns project totals from the model' do
+      result = presenter.absolute_payload
+
+      expect(result).to include('lines', 'percentage', 'files')
+      expect(result['lines']).to include('total' => 100, 'covered' => 80, 'uncovered' => 20)
+      expect(result['percentage']).to eq(80.0)
+      expect(result['files']).to include('total' => 10, 'ok' => 9, 'stale' => 1)
+    end
+
+    it 'caches the result on subsequent calls' do
+      presenter.absolute_payload
+      presenter.absolute_payload
+
+      expect(model).to have_received(:project_totals).once
+    end
+
+    it 'passes tracked_globs to the model' do
+      presenter.absolute_payload
+
+      expect(model).to have_received(:project_totals)
+        .with(tracked_globs: ['lib/**/*.rb'], check_stale: true)
+    end
+  end
+
+  describe '#relativized_payload' do
+    it 'returns the relativized payload from the model' do
+      result = presenter.relativized_payload
+
+      expect(result).to eq(raw_totals)
+    end
+
+    it 'calls relativize on the model' do
+      presenter.relativized_payload
+
+      expect(model).to have_received(:relativize).with(raw_totals)
+    end
+
+    it 'caches the result on subsequent calls' do
+      presenter.relativized_payload
+      presenter.relativized_payload
+
+      expect(model).to have_received(:relativize).once
+    end
+  end
+
+  context 'with check_stale: false' do
+    subject(:presenter) do
+      described_class.new(
+        model: model,
+        check_stale: false,
+        tracked_globs: nil
+      )
+    end
+
+    before do
+      allow(model).to receive(:project_totals)
+        .with(tracked_globs: nil, check_stale: false)
+        .and_return(raw_totals)
+    end
+
+    it 'passes check_stale: false to the model' do
+      presenter.absolute_payload
+
+      expect(model).to have_received(:project_totals)
+        .with(tracked_globs: nil, check_stale: false)
+    end
+  end
+
+  context 'with empty tracked_globs' do
+    subject(:presenter) do
+      described_class.new(
+        model: model,
+        check_stale: true,
+        tracked_globs: []
+      )
+    end
+
+    before do
+      allow(model).to receive(:project_totals)
+        .with(tracked_globs: [], check_stale: true)
+        .and_return(raw_totals)
+    end
+
+    it 'passes empty tracked_globs to the model' do
+      presenter.absolute_payload
+
+      expect(model).to have_received(:project_totals)
+        .with(tracked_globs: [], check_stale: true)
+    end
+  end
+
+  context 'with relativization that transforms data' do
+    before do
+      allow(model).to receive(:relativize) do |payload|
+        # Simulate relativization that might transform file paths in nested data
+        payload.merge('transformed' => true)
+      end
+    end
+
+    it 'applies the transformation from relativize' do
+      result = presenter.relativized_payload
+
+      expect(result['transformed']).to be(true)
+    end
+  end
+end

data/spec/resolvers/coverage_line_resolver_spec.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::Resolvers::CoverageLineResolver do
+  describe '#lookup_lines' do
+    context 'with direct path matching' do
+      it 'returns lines array for exact path match' do
+        abs_path = '/project/lib/foo.rb'
+        cov_data = {
+          abs_path => { 'lines' => [1, 0, nil, 2] }
+        }
+
+        resolver = described_class.new(cov_data)
+        lines = resolver.lookup_lines(abs_path)
+
+        expect(lines).to eq([1, 0, nil, 2])
+      end
+
+      it 'returns lines array when entry has lines directly' do
+        path = '/tmp/test.rb'
+        cov_data = {
+          path => { 'lines' => [1, 1, 1] }
+        }
+
+        resolver = described_class.new(cov_data)
+        expect(resolver.lookup_lines(path)).to eq([1, 1, 1])
+      end
+    end
+
+    context 'with CWD stripping fallback' do
+      it 'finds relative path when absolute path includes CWD' do
+        cwd = Dir.pwd
+        relative_path = 'lib/bar.rb'
+        abs_path = File.join(cwd, relative_path)
+        cov_data = {
+          relative_path => { 'lines' => [1, 0, 1] }
+        }
+
+        resolver = described_class.new(cov_data)
+        lines = resolver.lookup_lines(abs_path)
+
+        expect(lines).to eq([1, 0, 1])
+      end
+
+      it 'does not match when absolute path does not start with CWD' do
+        cov_data = {
+          'lib/baz.rb' => { 'lines' => [1, 1] }
+        }
+
+        resolver = described_class.new(cov_data)
+
+        expect do
+          resolver.lookup_lines('/other/directory/lib/baz.rb')
+        end.to raise_error(CovLoupe::FileError, /No coverage entry found/)
+      end
+    end
+
+    context 'when handling errors' do
+      it 'raises FileError when file is not found in coverage data' do
+        cov_data = {
+          '/project/lib/foo.rb' => { 'lines' => [1, 0] }
+        }
+
+        resolver = described_class.new(cov_data)
+
+        expect do
+          resolver.lookup_lines('/project/lib/missing.rb')
+        end.to raise_error(CovLoupe::FileError, /No coverage entry found/)
+      end
+
+      it 'raises FileError when coverage data is empty' do
+        resolver = described_class.new({})
+
+        expect do
+          resolver.lookup_lines('/any/path.rb')
+        end.to raise_error(CovLoupe::FileError, /No coverage entry found/)
+      end
+
+      it 'raises FileError when entry exists but has no lines or branches' do
+        cov_data = {
+          '/project/lib/foo.rb' => { 'other_key' => 'value' }
+        }
+
+        resolver = described_class.new(cov_data)
+
+        expect do
+          resolver.lookup_lines('/project/lib/foo.rb')
+        end.to raise_error(CovLoupe::FileError, /No coverage entry found/)
+      end
+    end
+
+    context 'with branch-only coverage synthesis' do
+      it 'synthesizes line hits when only branch coverage exists' do
+        abs_path = '/tmp/branch_only.rb'
+        branch_cov = {
+          abs_path => {
+            'lines' => nil,
+            'branches' => {
+              '[:if, 0, 5, 2, 8, 5]' => {
+                '[:then, 1, 6, 4, 6, 15]' => 3,
+                '[:else, 2, 7, 4, 7, 15]' => 0
+              },
+              '[:case, 3, 12, 2, 17, 5]' => {
+                '[:when, 4, 13, 4, 13, 14]' => 0,
+                '[:when, 5, 14, 4, 14, 14]' => 2,
+                '[:else, 6, 16, 4, 16, 12]' => 2
+              }
+            }
+          }
+        }
+
+        resolver = described_class.new(branch_cov)
+        lines = resolver.lookup_lines(abs_path)
+
+        expect(lines[5]).to eq(3)  # line 6
+        expect(lines[6]).to eq(0)  # line 7
+        expect(lines[12]).to eq(0) # line 13
+        expect(lines[13]).to eq(2) # line 14
+        expect(lines[15]).to eq(2) # line 16
+        expect(lines.count { |v| !v.nil? }).to eq(5)
+      end
+
+      it 'aggregates hits for multiple branches on the same line' do
+        path = '/tmp/duplicated.rb'
+        branch_cov = {
+          path => {
+            'lines' => nil,
+            'branches' => {
+              '[:if, 0, 3, 2, 3, 12]' => {
+                '[:then, 1, 3, 2, 3, 12]' => 2,
+                '[:else, 2, 3, 2, 3, 12]' => 3
+              }
+            }
+          }
+        }
+
+        resolver = described_class.new(branch_cov)
+        lines = resolver.lookup_lines(path)
+
+        expect(lines[2]).to eq(5) # line 3 with summed hits
+      end
+
+      it 'handles array-style branch metadata' do
+        path = '/tmp/array_style.rb'
+        cov_data = {
+          path => {
+            'lines' => nil,
+            'branches' => {
+              [:if, 0, 5, 2, 8, 5] => {
+                [:then, 1, 6, 4, 6, 15] => 2
+              }
+            }
+          }
+        }
+
+        resolver = described_class.new(cov_data)
+        lines = resolver.lookup_lines(path)
+
+        expect(lines[5]).to eq(2) # line 6
+      end
+
+      it 'returns nil for entries with empty branches' do
+        path = '/tmp/empty_branches.rb'
+        cov_data = {
+          path => {
+            'lines' => nil,
+            'branches' => {}
+          }
+        }
+
+        resolver = described_class.new(cov_data)
+
+        expect do
+          resolver.lookup_lines(path)
+        end.to raise_error(CovLoupe::FileError)
+      end
+
+      it 'skips malformed branch entries' do
+        path = '/tmp/malformed.rb'
+        cov_data = {
+          path => {
+            'lines' => nil,
+            'branches' => {
+              '[:if, 0, 5, 2, 8, 5]' => {
+                '[:then, 1, 6, 4, 6, 15]' => 2
+              },
+              'malformed_key' => 'not_a_hash',
+              '[:if, 1, 10]' => { # missing elements in tuple
+                '[:then]' => 1 # also malformed
+              }
+            }
+          }
+        }
+
+        resolver = described_class.new(cov_data)
+        lines = resolver.lookup_lines(path)
+
+        # Should still get line 6 from the valid branch
+        expect(lines[5]).to eq(2)
+      end
+    end
+
+    context 'with extract_line_number edge cases' do
+      let(:resolver) { described_class.new({}) }
+
+      it 'extracts line number from array metadata' do
+        result = resolver.send(:extract_line_number, [:if, 0, 10, 2, 15, 5])
+        expect(result).to eq(10)
+      end
+
+      it 'extracts line number from stringified array metadata' do
+        result = resolver.send(:extract_line_number, '[:if, 0, 15, 2, 20, 5]')
+        expect(result).to eq(15)
+      end
+
+      it 'returns nil for short array' do
+        result = resolver.send(:extract_line_number, [:if, 0])
+        expect(result).to be_nil
+      end
+
+      it 'returns nil for short string' do
+        result = resolver.send(:extract_line_number, '[:if, 0]')
+        expect(result).to be_nil
+      end
+
+      it 'returns nil for non-numeric line element in array' do
+        result = resolver.send(:extract_line_number, [:if, 0, 'not_a_number', 2])
+        expect(result).to be_nil
+      end
+
+      it 'returns nil for non-numeric line element in string' do
+        result = resolver.send(:extract_line_number, '[:if, 0, abc, 2]')
+        expect(result).to be_nil
+      end
+
+      it 'handles empty string' do
+        result = resolver.send(:extract_line_number, '')
+        expect(result).to be_nil
+      end
+
+      it 'handles nil input' do
+        result = resolver.send(:extract_line_number, nil)
+        expect(result).to be_nil
+      end
+
+      # The rescue block catches ArgumentError/TypeError from malformed metadata
+      # that can't be converted to line numbers.
+      [ArgumentError, TypeError].each do |error_class|
+        it "returns nil when string operations raise #{error_class}" do
+          weird_object = Object.new
+          allow(weird_object).to receive(:to_s).and_raise(error_class, 'test error')
+
+          result = resolver.send(:extract_line_number, weird_object)
+          expect(result).to be_nil
+        end
+      end
+    end
+
+    context 'with preference for lines over branches' do
+      it 'prefers lines array when both lines and branches exist' do
+        path = '/tmp/both.rb'
+        cov_data = {
+          path => {
+            'lines' => [1, 2, 3],
+            'branches' => {
+              '[:if, 0, 100, 2, 105, 5]' => {
+                '[:then, 1, 101, 4, 101, 15]' => 99
+              }
+            }
+          }
+        }
+
+        resolver = described_class.new(cov_data)
+        lines = resolver.lookup_lines(path)
+
+        # Should return the lines array, not synthesized branch data
+        expect(lines).to eq([1, 2, 3])
+      end
+    end
+  end
+end

data/spec/resolvers/resolver_factory_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+
+RSpec.describe CovLoupe::Resolvers::ResolverFactory do
+  describe '.create_resultset_resolver' do
+    it 'uses provided candidates when present' do
+      custom_candidates = ['alt/.resultset.json']
+      resolver = described_class.create_resultset_resolver(
+        root: '/tmp/sample',
+        candidates: custom_candidates
+      )
+
+      expect(resolver).to be_a(CovLoupe::Resolvers::ResultsetPathResolver)
+      expect(resolver.instance_variable_get(:@root)).to eq('/tmp/sample')
+      expect(resolver.instance_variable_get(:@candidates)).to eq(custom_candidates)
+    end
+
+    it 'falls back to default candidates when none provided' do
+      resolver = described_class.create_resultset_resolver(root: '/tmp/sample')
+
+      expect(resolver.instance_variable_get(:@candidates)).to eq(
+        CovLoupe::Resolvers::ResultsetPathResolver::DEFAULT_CANDIDATES
+      )
+    end
+  end
+
+  describe '.create_coverage_resolver' do
+    it 'wraps coverage data in a CoverageLineResolver' do
+      cov = { '/tmp/foo.rb' => { 'lines' => [1, 0] } }
+      resolver = described_class.create_coverage_resolver(cov)
+
+      expect(resolver).to be_a(CovLoupe::Resolvers::CoverageLineResolver)
+      expect(resolver.lookup_lines('/tmp/foo.rb')).to eq([1, 0])
+    end
+  end
+
+  describe '.find_resultset' do
+    it 'locates default resultset within the provided root' do
+      Dir.mktmpdir do |dir|
+        resultset_path = File.join(dir, '.resultset.json')
+        File.write(resultset_path, '{}')
+
+        resolved = described_class.find_resultset(dir)
+
+        expect(resolved).to eq(resultset_path)
+      end
+    end
+  end
+
+  describe '.lookup_lines' do
+    it 'delegates to CoverageLineResolver for lookups' do
+      cov = { '/tmp/bar.rb' => { 'lines' => [0, 1] } }
+
+      expect(
+        described_class.lookup_lines(cov, '/tmp/bar.rb')
+      ).to eq([0, 1])
+    end
+  end
+end

data/spec/resolvers/resultset_path_resolver_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.describe CovLoupe::Resolvers::ResultsetPathResolver do
+  describe '#find_resultset' do
+    let(:root) { Dir.mktmpdir }
+    let(:resolver) { described_class.new(root: root) }
+
+    after do
+      FileUtils.remove_entry(root) if root && Dir.exist?(root)
+    end
+
+    it 'raises when a specified resultset file cannot be found' do
+      expect do
+        resolver.find_resultset(resultset: 'missing.json')
+      end.to raise_error(RuntimeError, /Specified resultset not found/)
+    end
+
+    it 'raises when a specified directory does not contain .resultset.json' do
+      nested_dir = File.join(root, 'coverage')
+      Dir.mkdir(nested_dir)
+
+      expect do
+        resolver.find_resultset(resultset: nested_dir)
+      end.to raise_error(RuntimeError, /No .resultset.json found in directory/)
+    end
+
+    it 'returns the resolved path when a valid resultset file is provided' do
+      file = File.join(root, 'custom.json')
+      File.write(file, '{}')
+
+      expect(resolver.find_resultset(resultset: file)).to eq(file)
+    end
+
+    it 'raises a helpful error when no fallback candidates are found' do
+      expect do
+        resolver.find_resultset
+      end.to raise_error(RuntimeError, /Could not find .resultset.json/)
+    end
+
+    it 'accepts a resultset path already nested under the provided root without double-prefixing' do
+      project_root = (FIXTURES_DIR / 'project1').to_s
+      resolver = described_class.new(root: project_root)
+
+      resolved = resolver.find_resultset(resultset: 'spec/fixtures/project1/coverage')
+
+      expect(resolved).to eq(File.join(project_root, 'coverage', '.resultset.json'))
+    end
+
+    # In non-strict mode, resolve_candidate returns nil instead of raising
+    # when the path doesn't exist, allowing fallback resolution to continue.
+    it 'returns nil for non-existent path in non-strict mode' do
+      result = resolver.send(:resolve_candidate, '/nonexistent/path.json', strict: false)
+      expect(result).to be_nil
+    end
+  end
+end