cov-loupe 3.0.0 → 4.0.0.pre

data/spec/presenters/project_coverage_presenter_spec.rb

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

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

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

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

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