cov-loupe 3.0.0 → 4.0.0.pre

data/spec/commands/totals_command_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require_relative '../shared_examples/formatted_command_examples'
-
-RSpec.describe CovLoupe::Commands::TotalsCommand do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-  let(:cli_context) { CovLoupe::CoverageCLI.new }
-  let(:command) { described_class.new(cli_context) }
-
-  before do
-    cli_context.config.root = root
-    cli_context.config.resultset = 'coverage'
-    cli_context.config.format = :table
-  end
-
-  describe '#execute' do
-    context 'with table format' do
-      it 'prints aggregated totals for the project' do
-        output = capture_command_output(command, [])
-
-        expect(output).to include('│', 'Lines', '50.00%')
-      end
-    end
-
-    it_behaves_like 'a command with formatted output', [], ['lines', 'files', 'percentage']
-
-    it 'raises when unexpected arguments are provided' do
-      expect do
-        command.execute(['extra'])
-      end.to raise_error(CovLoupe::UsageError, include('totals'))
-    end
-  end
-end

data/spec/commands/uncovered_command_spec.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require_relative '../shared_examples/formatted_command_examples'
-
-RSpec.describe CovLoupe::Commands::UncoveredCommand do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-  let(:cli_context) { CovLoupe::CoverageCLI.new }
-  let(:command) { described_class.new(cli_context) }
-
-  before do
-    cli_context.config.root = root
-    cli_context.config.resultset = 'coverage'
-    cli_context.config.format = :table
-    cli_context.config.source_mode = nil
-  end
-
-  describe '#execute' do
-    context 'with table format' do
-      it 'prints uncovered line numbers with the summary' do
-        output = capture_command_output(command, ['lib/bar.rb'])
-
-        expect(output).to include('│', 'lib/bar.rb', '33.33%')
-      end
-    end
-
-    context 'when the file is fully covered' do
-      before do
-        mock_presenter(
-          CovLoupe::Presenters::CoverageUncoveredPresenter,
-          absolute_payload: {
-            'file' => 'lib/perfect.rb',
-            'uncovered' => [],
-            'summary' => { 'covered' => 10, 'total' => 10, 'percentage' => 100.0 }
-          },
-          relative_path: 'lib/perfect.rb'
-        )
-      end
-
-      it 'prints a success message instead of a table' do
-        output = capture_command_output(command, ['lib/perfect.rb'])
-
-        expect(output).to include('All lines covered!', '100.00%')
-        expect(output).not_to include('│')
-      end
-    end
-
-    context 'with stale data' do
-      before { stub_staleness_check('L') }
-
-      it_behaves_like 'a command with formatted output', ['lib/foo.rb'],
-        { 'file' => 'lib/foo.rb', 'uncovered' => [2], 'summary' => nil, 'stale' => 'L' }
-    end
-  end
-end

data/spec/commands/validate_command_spec.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'tempfile'
-
-RSpec.describe CovLoupe::Commands::ValidateCommand do
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-
-  def with_temp_predicate(content)
-    Tempfile.create(['predicate', '.rb']) do |file|
-      file.write(content)
-      file.flush
-      yield file.path
-    end
-  end
-
-  describe 'validate subcommand with file' do
-    it 'exits 0 when predicate returns truthy value' do
-      with_temp_predicate("->(model) { true }\n") do |path|
-        _out, _err, status = run_cli_with_status(
-          '--root', root,
-          '--resultset', 'coverage',
-          'validate', path
-        )
-        expect(status).to eq(0)
-      end
-    end
-
-    it 'exits 1 when predicate returns falsy value' do
-      with_temp_predicate("->(model) { false }\n") do |path|
-        _out, _err, status = run_cli_with_status(
-          '--root', root,
-          '--resultset', 'coverage',
-          'validate', path
-        )
-        expect(status).to eq(1)
-      end
-    end
-
-    it 'exits 2 when predicate raises an error' do
-      with_temp_predicate("->(model) { raise 'Boom!' }\n") do |path|
-        _out, err, status = run_cli_with_status(
-          '--root', root,
-          '--resultset', 'coverage',
-          'validate', path
-        )
-        expect(status).to eq(2)
-        expect(err).to include('Predicate error: Boom!')
-      end
-    end
-
-    it 'shows backtrace when predicate errors with --error-mode debug' do
-      with_temp_predicate("->(model) { raise 'Boom!' }\n") do |path|
-        _out, err, status = run_cli_with_status(
-          '--error-mode', 'debug',
-          '--root', root,
-          '--resultset', 'coverage',
-          'validate', path
-        )
-        expect(status).to eq(2)
-        expect(err).to include('Predicate error: Boom!')
-        # With trace mode, should show backtrace
-        expect(err).to match(/predicate.*\.rb:\d+/)
-      end
-    end
-
-    it 'exits 2 when predicate file is not found' do
-      _out, err, status = run_cli_with_status(
-        '--root', root,
-        '--resultset', 'coverage',
-        'validate', '/nonexistent/predicate.rb'
-      )
-      expect(status).to eq(2)
-      expect(err).to include('Predicate file not found')
-    end
-
-    it 'exits 2 when predicate has syntax error' do
-      with_temp_predicate("-> { this is invalid syntax\n") do |path|
-        _out, err, status = run_cli_with_status(
-          '--root', root,
-          '--resultset', 'coverage',
-          'validate', path
-        )
-        expect(status).to eq(2)
-        expect(err).to include('Syntax error in predicate file')
-      end
-    end
-
-    it 'exits 2 when predicate is not callable' do
-      with_temp_predicate("42\n") do |path|
-        _out, err, status = run_cli_with_status(
-          '--root', root,
-          '--resultset', 'coverage',
-          'validate', path
-        )
-        expect(status).to eq(2)
-        expect(err).to include('Predicate must be callable')
-      end
-    end
-
-    it 'provides model to predicate that can query coverage' do
-      # Test that the predicate receives a working CoverageModel
-      with_temp_predicate(<<~RUBY) do |path|
-        ->(model) do
-          # Access coverage data via the model
-          summary = model.summary_for('lib/foo.rb')
-          summary['summary']['percentage'] > 50  # Should be true for foo.rb
-        end
-      RUBY
-        _out, _err, status = run_cli_with_status(
-          '--root', root,
-          '--resultset', 'coverage',
-          'validate', path
-        )
-        expect(status).to eq(0)
-      end
-    end
-  end
-
-  describe 'validate subcommand with -i/--inline flag' do
-    it 'exits 0 when predicate code returns truthy value' do
-      _out, _err, status = run_cli_with_status(
-        '--root', root,
-        '--resultset', 'coverage',
-        'validate', '-i', '->(model) { true }'
-      )
-      expect(status).to eq(0)
-    end
-
-    it 'exits 1 when predicate code returns falsy value' do
-      _out, _err, status = run_cli_with_status(
-        '--root', root,
-        '--resultset', 'coverage',
-        'validate', '-i', '->(model) { false }'
-      )
-      expect(status).to eq(1)
-    end
-
-    it 'exits 2 when predicate code raises an error' do
-      _out, err, status = run_cli_with_status(
-        '--root', root,
-        '--resultset', 'coverage',
-        'validate', '-i', "->(model) { raise 'Boom!' }"
-      )
-      expect(status).to eq(2)
-      expect(err).to include('Predicate error: Boom!')
-    end
-
-    it 'exits 2 when predicate code has syntax error' do
-      _out, err, status = run_cli_with_status(
-        '--root', root,
-        '--resultset', 'coverage',
-        'validate', '-i', '-> { invalid syntax'
-      )
-      expect(status).to eq(2)
-      expect(err).to include('Syntax error in predicate code')
-    end
-
-    it 'exits 2 when predicate code is not callable' do
-      _out, err, status = run_cli_with_status(
-        '--root', root,
-        '--resultset', 'coverage',
-        'validate', '-i', '42'
-      )
-      expect(status).to eq(2)
-      expect(err).to include('Predicate must be callable')
-    end
-
-    it 'provides model to predicate that can query coverage' do
-      code = <<~RUBY.strip
-        ->(model) { model.summary_for('lib/foo.rb')['summary']['percentage'] > 50 }
-      RUBY
-      _out, _err, status = run_cli_with_status(
-        '--root', root,
-        '--resultset', 'coverage',
-        'validate', '-i', code
-      )
-      expect(status).to eq(0)
-    end
-  end
-
-  describe 'error handling' do
-    it 'raises error when no file or -i flag provided' do
-      _out, err, status = run_cli_with_status(
-        '--root', root,
-        '--resultset', 'coverage',
-        'validate'
-      )
-      expect(status).to eq(1)
-      expect(err).to include('validate <file> | -i <code>')
-    end
-
-    it 'raises error when -i flag provided without code' do
-      _out, err, status = run_cli_with_status(
-        '--root', root,
-        '--resultset', 'coverage',
-        'validate', '-i'
-      )
-      expect(status).to eq(1)
-      expect(err).to include('validate -i <code>')
-    end
-
-    it 'raises error when unknown option is provided' do
-      _out, err, status = run_cli_with_status(
-        '--root', root,
-        '--resultset', 'coverage',
-        'validate', '--unknown-option'
-      )
-      expect(status).to eq(1)
-      expect(err).to include('Unknown option for validate: --unknown-option')
-    end
-  end
-end

data/spec/commands/version_command_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require_relative '../shared_examples/formatted_command_examples'
-
-RSpec.describe CovLoupe::Commands::VersionCommand do
-  let(:cli_context) { CovLoupe::CoverageCLI.new }
-  let(:command) { described_class.new(cli_context) }
-
-  before do
-    cli_context.config.format = :table
-  end
-
-  describe '#execute' do
-    context 'with table format' do
-      it 'prints version, gem root, and documentation info in text mode' do
-        output = capture_command_output(command, [])
-
-        expect(output).to include('│', CovLoupe::VERSION, 'Gem Root', 'Documentation',
-          'README.md')
-      end
-
-      it 'includes a valid gem root path that exists' do
-        output = capture_command_output(command, [])
-
-        # Extract gem root from table output
-        gem_root_line = output.lines.find { |line| line.include?('Gem Root') }
-        expect(gem_root_line).not_to be_nil
-
-        parts = gem_root_line.split('│')
-        gem_root = parts[-2].strip
-        expect(File.directory?(gem_root)).to be true
-      end
-    end
-
-    it_behaves_like 'a command with formatted output', [], ['version', 'gem_root']
-  end
-end

data/spec/constants_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::Constants do
-  describe 'OPTIONS_EXPECTING_ARGUMENT' do
-    subject(:options) { described_class::OPTIONS_EXPECTING_ARGUMENT }
-
-    it 'exists' do
-      expect(options).not_to be_nil
-    end
-
-    it 'is frozen' do
-      expect(options).to be_frozen
-    end
-
-    it 'contains expected CLI options' do
-      expected_options = %w[
-        -r --resultset
-        -R --root
-        -f --format
-        -o --sort-order
-        -s --source
-        -c --context-lines
-        -S --staleness
-        -g --tracked-globs
-        -l --log-file
-        --error-mode
-      ]
-
-      expect(options).to eq(expected_options)
-    end
-
-    it 'contains only strings' do
-      expect(options).to all(be_a(String))
-    end
-
-    it 'contains options that start with dashes' do
-      expect(options).to all(start_with('-'))
-    end
-  end
-
-  describe 'usage by other classes' do
-    it 'is used by ModeDetector' do
-      expect(CovLoupe::ModeDetector::OPTIONS_EXPECTING_ARGUMENT)
-        .to equal(CovLoupe::Constants::OPTIONS_EXPECTING_ARGUMENT)
-    end
-
-    it 'is used by CoverageCLI' do
-      expect(CovLoupe::CoverageCLI::OPTIONS_EXPECTING_ARGUMENT)
-        .to equal(CovLoupe::Constants::OPTIONS_EXPECTING_ARGUMENT)
-    end
-
-    it 'ensures both classes reference the same object' do
-      cli_options = CovLoupe::CoverageCLI::OPTIONS_EXPECTING_ARGUMENT
-      detector_options = CovLoupe::ModeDetector::OPTIONS_EXPECTING_ARGUMENT
-
-      expect(cli_options).to equal(detector_options)
-    end
-  end
-end

data/spec/cov_loupe/formatters/source_formatter_spec.rb

@@ -1,267 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe CovLoupe::Formatters::SourceFormatter do
-  subject(:formatter) { described_class.new(color_enabled: color_enabled) }
-
-  let(:color_enabled) { false }
-  let(:model) { instance_double(CovLoupe::CoverageModel) }
-  let(:path) { 'lib/foo.rb' }
-  let(:abs_path) { File.expand_path(path) }
-  let(:source_content) do
-    <<~RUBY
-      class Foo
-        def bar
-          puts 'bar'
-        end
-      end
-    RUBY
-  end
-  let(:coverage_lines) { [1, 1, 0, nil, nil] } # Line 3 is uncovered
-
-  before do
-    allow(model).to receive(:raw_for).with(path).and_return(
-      'file' => abs_path,
-      'lines' => coverage_lines
-    )
-    allow(File).to receive(:file?).with(abs_path).and_return(true)
-    allow(File).to receive(:readlines).with(abs_path, chomp: true)
-      .and_return(source_content.lines(chomp: true))
-  end
-
-  describe '#format_source_for' do
-    context 'when source is available' do
-      it 'renders formatted source lines with line numbers and markers' do
-        # Full mode should print every line with coverage markers and numbering.
-        result = formatter.format_source_for(model, path, mode: :full)
-
-        expect(result.lines(chomp: true)).to eq(
-          [
-            '  Line     | Source',
-            '------  ---+-------------------------------------------------------------',
-            '     1   ✓ | class Foo',
-            '     2   ✓ |   def bar',
-            "     3   · |     puts 'bar'",
-            '     4     |   end',
-            '     5     | end'
-          ]
-        )
-      end
-
-      it 'marks covered lines with a checkmark' do
-        # Two covered lines should each get a ✓ in the rendered output.
-        result = formatter.format_source_for(model, path, mode: :full)
-        # covered: true -> '✓', false -> '·', nil -> ' '
-        expect(result.count('✓')).to eq(2)
-        expect(result.lines[2]).to match(/\b1\s+✓ \| class Foo/)
-        expect(result.lines[3]).to match(/\b2\s+✓ \|   def bar/)
-      end
-
-      it 'marks uncovered lines with a dot' do
-        # The single uncovered line should be marked with a dot.
-        result = formatter.format_source_for(model, path, mode: :full)
-        expect(result.count('·')).to eq(1)
-        expect(result.lines[4]).to match(/\b3\s+· \|     puts 'bar'/)
-      end
-
-      it 'returns only header when mode is nil (default)' do
-        # Default mode skips body rows but still emits the header scaffold.
-        result = formatter.format_source_for(model, path)
-        # Example header-only output:
-        #   Line     | Source
-        # ------  ---+-------------------------------------------------------------
-        expect(result).not_to include('class Foo')
-        expect(result).to include('Line', 'Source')
-      end
-    end
-
-    context 'when source file is not found' do
-      it 'returns fallback message' do
-        # Simulate missing file; formatter should not raise and should return a placeholder.
-        allow(File).to receive(:file?).with(abs_path).and_return(false)
-        expect(formatter.format_source_for(model, path)).to eq('[source not available]')
-      end
-    end
-
-    context 'when raw coverage data is missing' do
-      it 'returns fallback message' do
-        # No coverage entry for the path should also trigger the placeholder.
-        allow(model).to receive(:raw_for).with(path).and_return(nil)
-        expect(formatter.format_source_for(model, path)).to eq('[source not available]')
-      end
-    end
-
-    context 'when an error occurs during formatting' do
-      it 'returns fallback message instead of crashing' do
-        # Create a pathological coverage array with an object that raises on to_i
-        bad_object = Object.new
-        def bad_object.to_i = raise(StandardError, 'Bad data')
-        def bad_object.nil? = false
-
-        bad_coverage = [1, 1, bad_object, nil, nil]
-
-        allow(model).to receive(:raw_for).with(path)
-          .and_return('file' => abs_path, 'lines' => bad_coverage)
-
-        result = formatter.format_source_for(model, path, mode: :full)
-        expect(result).to eq('[source not available]')
-      end
-
-      it 'propagates ArgumentError' do
-        expect do
-          formatter.format_source_for(model, path, mode: :full, context: -1)
-        end.to raise_error(ArgumentError, 'Context lines cannot be negative')
-      end
-    end
-
-    context 'with color enabled' do
-      let(:color_enabled) { true }
-
-      it 'includes ANSI color codes' do
-        # Markers should be wrapped with green/red ANSI sequences when colors are on.
-        # Example colored line: "     1  \e[32m✓\e[0m | class Foo"
-        result = formatter.format_source_for(model, path, mode: :full)
-        expect(result).to include("\e[32m", "\e[31m") # green for checkmark, red for dot
-        expect(result.lines[2]).to include("\e[32m✓\e[0m") # line 1 checkmark is green
-        expect(result.lines[3]).to include("\e[32m✓\e[0m") # line 2 checkmark is green
-        expect(result.lines[4]).to include("\e[31m·\e[0m") # line 3 dot is red
-      end
-    end
-  end
-
-  describe '#build_source_payload' do
-    it 'returns row data when source is available' do
-      # Payload should mirror the row hashes used by CLI formatting.
-      result = formatter.build_source_payload(model, path, mode: :full)
-      expect(result).to be_a(Array)
-      expect(result.size).to eq(5)
-      expect(result.first).to include('code' => 'class Foo', 'line' => 1)
-    end
-
-    it 'returns nil when raw coverage is missing' do
-      # Without coverage data, there is no payload to build.
-      allow(model).to receive(:raw_for).with(path).and_return(nil)
-      expect(formatter.build_source_payload(model, path)).to be_nil
-    end
-
-    it 'returns nil when source file is missing' do
-      # Missing source file should also produce a nil payload.
-      allow(File).to receive(:file?).with(abs_path).and_return(false)
-      expect(formatter.build_source_payload(model, path)).to be_nil
-    end
-  end
-
-  describe '#build_source_rows' do
-    it 'raises error for negative context count' do
-      # Negative context should raise ArgumentError
-      expect do
-        formatter.build_source_rows(
-          source_content.lines(chomp: true),
-          coverage_lines,
-          mode: :uncovered,
-          context: -1
-        )
-      end.to raise_error(ArgumentError, 'Context lines cannot be negative')
-    end
-
-    it 'handles default context (2 lines)' do
-      # With the default context of 2, uncovered lines pull in surrounding rows.
-      rows = formatter.build_source_rows(
-        source_content.lines(chomp: true),
-        coverage_lines,
-        mode: :uncovered,
-        context: 2
-      )
-      # Uncovered is line 3. Context 2 means lines 1..5 (indexes 0..4).
-      # Total line count is 5, so all lines should be included.
-      expect(rows.size).to eq(5)
-    end
-
-    it 'handles bad context input (non-numeric)' do
-      # Non-numeric context coerces to 0 via to_i, so only the miss is included.
-      rows = formatter.build_source_rows(
-        source_content.lines(chomp: true),
-        coverage_lines,
-        mode: :uncovered,
-        context: 'bad'
-      )
-      # "bad".to_i is 0 so context should be 0.
-      # Uncovered is line 3.
-      expect(rows.size).to eq(1)
-      expect(rows.first['line']).to eq(3)
-    end
-
-    it 'handles context input that raises error on to_i conversion' do
-      # Create an object where to_i raises an error
-      bad_context = Object.new
-      def bad_context.to_i = raise(StandardError, 'Cannot convert')
-
-      # Falling back to default context should still include surrounding lines.
-      rows = formatter.build_source_rows(
-        source_content.lines(chomp: true),
-        coverage_lines,
-        mode: :uncovered,
-        context: bad_context
-      )
-      # Should fall back to default context of 2
-      # Uncovered is line 3. Context 2 means lines 1..5 (indexes 0..4).
-      # Total lines is 5. So all lines should be included.
-      expect(rows.size).to eq(5)
-    end
-
-    it 'handles nil coverage lines defensively' do
-      # Nil coverage array should not raise; hits/covered become nil.
-      # This covers the "coverage data missing entirely" path; in real coverage we'd see 1/0 hits.
-      # Expected rows when coverage is nil:
-      # [
-      #   { 'line' => 1, 'code' => 'class Foo', 'hits' => nil, 'covered' => nil },
-      #   { 'line' => 2, 'code' => '  def bar', 'hits' => nil, 'covered' => nil },
-      #   { 'line' => 3, 'code' => "    puts 'bar'", 'hits' => nil, 'covered' => nil },
-      #   { 'line' => 4, 'code' => '  end', 'hits' => nil, 'covered' => nil },
-      #   { 'line' => 5, 'code' => 'end', 'hits' => nil, 'covered' => nil }
-      # ]
-      # And the formatted output (markers blank because coverage is missing) would be:
-      #   Line     | Source
-      # ------  ---+-------------------------------------------------------------
-      #      1     | class Foo
-      #      2     |   def bar
-      #      3     |     puts 'bar'
-      #      4     |   end
-      #      5     | end
-      rows = formatter.build_source_rows(
-        source_content.lines(chomp: true),
-        nil,
-        mode: :full,
-        context: 2
-      )
-      expect(rows.size).to eq(5)
-      expect(rows.first['hits']).to be_nil
-    end
-  end
-
-  describe '#format_detailed_rows' do
-    it 'formats rows into a table' do
-      # Detailed mode should align numeric columns and boolean covered flags.
-      rows = [
-        { 'line' => 1, 'hits' => 5, 'covered' => true },
-        { 'line' => 2, 'hits' => 0, 'covered' => false }
-      ]
-      # Expected table:
-      #   Line    Hits  Covered
-      #   -----   ----  -------
-      #       1      5      yes
-      #       2      0       no
-      result = formatter.format_detailed_rows(rows)
-      expect(result).to include('Line', 'Hits', 'Covered', '5', 'yes', 'no')
-    end
-  end
-
-  describe 'private #fetch_raw error handling' do
-    it 'returns nil if model raises error' do
-      # fetch_raw should swallow model errors and return nil instead of propagating.
-      allow(model).to receive(:raw_for).and_raise(StandardError)
-      expect(formatter.send(:fetch_raw, model, path)).to be_nil
-    end
-  end
-end