cov-loupe 3.0.0

data/spec/commands/version_command_spec.rb

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

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

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

data/spec/cov_loupe/formatters_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::Formatters do
+  describe '.formatter_for' do
+    it 'returns a lambda for known format' do
+      expect(described_class.formatter_for(:json)).to respond_to(:call)
+    end
+
+    it 'raises ArgumentError for unknown format' do
+      expect { described_class.formatter_for(:unknown) }
+        .to raise_error(ArgumentError, /Unknown format: unknown/)
+    end
+  end
+
+  describe '.ensure_requirements_for' do
+    it 'requires the library if needed' do
+      # We rely on the fact that 'yaml' is in FORMAT_REQUIRES
+      expect(described_class).to receive(:require).with('yaml')
+      described_class.ensure_requirements_for(:yaml)
+    end
+
+    it 'does nothing if no requirement' do
+      expect(described_class).not_to receive(:require)
+      described_class.ensure_requirements_for(:json) # JSON already required by app
+    end
+  end
+
+  describe '.format' do
+    let(:obj) { { 'foo' => 'bar' } }
+
+    [
+      [:json, '{"foo":"bar"}', :eq],
+      [:pretty_json, "{\n  \"foo\": \"bar\"\n}", :include],
+      [:table, { 'foo' => 'bar' }, :eq],
+      [:yaml, "---\nfoo: bar\n", :include]
+    ].each do |format, expected, matcher|
+      it "formats as #{format}" do
+        result = described_class.format(obj, format)
+        expect(result).to send(matcher, expected)
+      end
+    end
+
+    context 'when a required gem is missing' do
+      before do
+        error = LoadError.new('cannot load such file -- awesome_print')
+        allow(described_class).to receive(:require).with('awesome_print').and_raise(error)
+      end
+
+      it 'raises a helpful LoadError' do
+        expect { described_class.format(obj, :awesome_print) }
+          .to raise_error(LoadError, /requires the 'awesome_print' gem/)
+      end
+    end
+
+    context 'when awesome_print is available' do
+      before do
+        # Stub require on the module for ensure_requirements_for
+        allow(described_class).to receive(:require).with('awesome_print')
+
+        # Stub global require for the lambda's internal require
+        allow(Kernel).to receive(:require).and_call_original
+        allow(Kernel).to receive(:require).with('awesome_print').and_return(true)
+
+        # Mock .ai on the object
+        allow(obj).to receive(:ai).and_return('awesome output')
+      end
+
+      it 'formats using awesome_print' do
+        result = described_class.format(obj, :awesome_print)
+        expect(result).to eq('awesome output')
+      end
+    end
+  end
+end

data/spec/cov_loupe/presenters/base_coverage_presenter_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CovLoupe::Presenters::BaseCoveragePresenter do
+  let(:model) { instance_double(CovLoupe::CoverageModel) }
+  let(:path) { 'lib/foo.rb' }
+  let(:presenter) { described_class.new(model: model, path: path) }
+
+  describe '#initialize' do
+    it 'sets model and path' do
+      expect(presenter.model).to eq(model)
+      expect(presenter.path).to eq(path)
+    end
+  end
+
+  describe '#absolute_payload' do
+    it 'raises NotImplementedError because build_payload is abstract' do
+      expect { presenter.absolute_payload }.to raise_error(NotImplementedError)
+    end
+  end
+
+  context 'with a concrete implementation' do
+    let(:concrete_class) do
+      Class.new(described_class) do
+        # Provide a concrete implementation of the abstract build_payload method
+        # for testing the BaseCoveragePresenter functionality
+        def build_payload
+          { 'file' => path, 'data' => 'test' }
+        end
+      end
+    end
+    let(:presenter) { concrete_class.new(model: model, path: path) }
+    let(:payload_with_stale) { { 'file' => path, 'data' => 'test', 'stale' => false } }
+
+    before do
+      allow(model).to receive(:staleness_for).with(path).and_return(false)
+      allow(model).to receive(:relativize).with(payload_with_stale).and_return(payload_with_stale)
+    end
+
+    describe '#absolute_payload' do
+      it 'merges stale status into payload' do
+        expect(presenter.absolute_payload).to include('stale' => false)
+        expect(presenter.absolute_payload).to include('data' => 'test')
+      end
+
+      it 'caches the result' do
+        r1 = presenter.absolute_payload
+        r2 = presenter.absolute_payload
+        expect(r1).to equal(r2)
+      end
+    end
+
+    describe '#relativized_payload' do
+      it 'delegates to model.relativize' do
+        expect(model).to receive(:relativize).with(presenter.absolute_payload)
+        presenter.relativized_payload
+      end
+
+      it 'caches the result' do
+        presenter.relativized_payload
+        expect(model).to have_received(:relativize).once
+        presenter.relativized_payload
+      end
+    end
+
+    describe '#stale' do
+      it 'delegates to absolute_payload' do
+        expect(presenter.stale).to be(false)
+      end
+    end
+
+    describe '#relative_path' do
+      it 'delegates to relativized_payload' do
+        expect(presenter.relative_path).to eq('lib/foo.rb')
+      end
+    end
+  end
+end