coverband 6.1.6 → 6.1.7

data/lib/coverband/mcp.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+begin
+  require "mcp"
+rescue LoadError
+  raise LoadError, <<~MSG
+    The 'mcp' gem is required for MCP server support.
+    Add `gem 'mcp'` to your Gemfile and run `bundle install`.
+  MSG
+end
+
+require "coverband"
+require "coverband/utils/html_formatter"
+require "coverband/utils/result"
+require "coverband/utils/file_list"
+require "coverband/utils/source_file"
+require "coverband/utils/lines_classifier"
+require "coverband/utils/results"
+require "coverband/reporters/json_report"
+
+# Load dead methods support if available
+if defined?(RubyVM::AbstractSyntaxTree)
+  require "coverband/utils/dead_methods"
+end
+
+require_relative "mcp/server"
+require_relative "mcp/http_handler"

data/lib/coverband/reporters/base.rb

@@ -55,13 +55,11 @@ module Coverband
             fixed_report[name] = {}
             report.each_pair do |key, vals|
               filename = Coverband::Utils::AbsoluteFileConverter.convert(key)
-              fixed_report[name][filename] = if fixed_report[name].key?(filename) && fixed_report[name][filename][DATA_KEY] && vals[DATA_KEY]
+              if fixed_report[name].key?(filename) && fixed_report[name][filename][DATA_KEY] && vals[DATA_KEY]
                 merged_data = merge_arrays(fixed_report[name][filename][DATA_KEY], vals[DATA_KEY])
                 vals[DATA_KEY] = merged_data
-                vals
-              else
-                vals
               end
+              fixed_report[name][filename] = vals
             end
           end
         end

data/lib/coverband/reporters/web.rb

@@ -62,9 +62,9 @@ module Coverband
         Coverband.configuration.trackers.each do |tracker|
           if request_path_info.match(tracker.class::REPORT_ROUTE)
             tracker_route = true
-            if request_path_info =~ %r{\/clear_.*_key}
+            if request_path_info =~ %r{/clear_.*_key}
               return clear_abstract_tracking_key(tracker)
-            elsif request_path_info =~ %r{\/clear_.*}
+            elsif request_path_info =~ %r{/clear_.*}
               return clear_abstract_tracking(tracker)
             else
               return [200, {"content-type" => "text/html"}, [display_abstract_tracker(tracker)]]
@@ -75,9 +75,9 @@ module Coverband
         unless tracker_route
           if request.post?
             case request_path_info
-            when %r{\/clear_file}
+            when %r{/clear_file}
               clear_file
-            when %r{\/clear}
+            when %r{/clear}
               clear
             else
               [404, coverband_headers, ["404 error!"]]
@@ -86,21 +86,21 @@ module Coverband
             case request_path_info
             when /.*\.(css|js|gif|png)/
               @static.call(env)
-            when %r{\/settings}
+            when %r{/settings}
               [200, coverband_headers, [settings]]
-            when %r{\/view_tracker_data}
+            when %r{/view_tracker_data}
               [200, coverband_headers(content_type: "text/json"), [view_tracker_data]]
-            when %r{\/enriched_debug_data}
+            when %r{/enriched_debug_data}
               [200, coverband_headers(content_type: "text/json"), [enriched_debug_data]]
-            when %r{\/debug_data}
+            when %r{/debug_data}
               [200, coverband_headers(content_type: "text/json"), [debug_data]]
-            when %r{\/load_file_details}
+            when %r{/load_file_details}
               [200, coverband_headers(content_type: "text/json"), [load_file_details]]
-            when %r{\/json}
+            when %r{/json}
               [200, coverband_headers(content_type: "text/json"), [json]]
-            when %r{\/report_json}
+            when %r{/report_json}
               [200, coverband_headers(content_type: "text/json"), [report_json]]
-            when %r{\/$}
+            when %r{/$}
               [200, coverband_headers, [index]]
             else
               [404, coverband_headers, ["404 error!"]]
@@ -125,7 +125,10 @@ module Coverband
       end
 
       def json
-        Coverband::Reporters::JSONReport.new(Coverband.configuration.store).report
+        Coverband::Reporters::JSONReport.new(
+          Coverband.configuration.store,
+          line_coverage: request.params["line_coverage"] == "true"
+        ).report
       end
 
       def report_json
@@ -241,7 +244,7 @@ module Coverband
       # %r{\/.*\/}.match?(request.path) ? request.path.match("\/.*\/")[0] : "/"
       # ^^ the above is NOT valid Ruby 2.3/2.4 even though rubocop / standard think it is
       def base_path
-        (request.path =~ %r{\/.*\/}) ? request.path.match("/.*/")[0] : "/"
+        (request.path =~ %r{/.*/}) ? request.path.match("/.*/")[0] : "/"
       end
     end
   end

data/lib/coverband/utils/lines_classifier.rb

@@ -23,7 +23,7 @@ module Coverband
       WHITESPACE_OR_COMMENT_LINE = Regexp.union(WHITESPACE_LINE, COMMENT_LINE)
 
       def self.no_cov_line
-        /^(\s*)#(\s*)(\:nocov\:)/o
+        /^(\s*)#(\s*)(:nocov:)/o
       end
 
       def self.no_cov_line?(line)

data/lib/coverband/utils/result.rb

@@ -14,12 +14,13 @@ module Coverband
   module Utils
     class Result
       extend Forwardable
+
       # Returns the original Coverage.result used for this instance of Coverband::Result
       attr_reader :original_result
       # Returns all files that are applicable to this result (sans filters!)
       # as instances of Coverband::SourceFile. Aliased as :source_files
       attr_reader :files
-      alias source_files files
+      alias_method :source_files, :files
       # Explicitly set the Time this result has been created
       attr_writer :created_at
 

data/lib/coverband/utils/source_file.rb

@@ -29,9 +29,9 @@ module Coverband
         attr_reader :coverage_posted
 
         # Lets grab some fancy aliases, shall we?
-        alias source src
-        alias line line_number
-        alias number line_number
+        alias_method :source, :src
+        alias_method :line, :line_number
+        alias_method :number, :line_number
 
         def initialize(src, line_number, coverage, coverage_posted = nil)
           raise ArgumentError, "Only String accepted for source" unless src.is_a?(String)
@@ -132,14 +132,14 @@ module Coverband
         # suppress reading unused source code.
         @src ||= File.open(filename, "rb", &:readlines)
       end
-      alias source src
+      alias_method :source, :src
 
       # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
       # and thus including coverage data. Aliased as :source_lines
       def lines
         @lines ||= build_lines
       end
-      alias source_lines lines
+      alias_method :source_lines, :lines
 
       def build_lines
         coverage_exceeding_source_warn if coverage.size > src.size

data/lib/coverband/utils/tasks.rb

@@ -126,6 +126,37 @@ namespace :coverband do
       Port: ENV.fetch("COVERBAND_COVERAGE_PORT", 9022).to_i
   end
 
+  desc "Start MCP server for AI assistant integration (set COVERBAND_MCP_HTTP=true for HTTP mode)"
+  task :mcp do
+    if Rake::Task.task_defined?("environment")
+      Rake.application["environment"].invoke
+    end
+
+    begin
+      require "coverband/mcp"
+    rescue LoadError
+      abort "The 'mcp' gem is required for MCP server support. Add `gem 'mcp'` to your Gemfile."
+    end
+
+    server = Coverband::MCP::Server.new
+
+    if ENV["COVERBAND_MCP_HTTP"]
+      # HTTP mode with Streamable HTTP transport (SSE)
+      begin
+        require "rackup"
+      rescue LoadError
+        abort "The 'rackup' gem is required for HTTP mode. Add `gem 'rackup'` to your Gemfile."
+      end
+
+      port = ENV.fetch("COVERBAND_MCP_PORT", 9023).to_i
+      host = ENV.fetch("COVERBAND_MCP_HOST", "localhost")
+      server.run_http(port: port, host: host)
+    else
+      # Default stdio mode
+      server.run_stdio
+    end
+  end
+
   # experimental dead method detection using RubyVM::AbstractSyntaxTree
   # combined with the coverband coverage.
   if defined?(RubyVM::AbstractSyntaxTree)

data/lib/coverband/version.rb

@@ -5,5 +5,5 @@
 # use format "4.2.1.rc.1" ~> 4.2.1.rc to prerelease versions like v4.2.1.rc.2 and v4.2.1.rc.3
 ###
 module Coverband
-  VERSION = "6.1.6"
+  VERSION = "6.1.7"
 end

data/lib/coverband.rb

@@ -51,8 +51,8 @@ module Coverband
       yield(configuration)
     elsif File.exist?(configuration_file)
       load configuration_file
-    else
-      configuration.logger.debug("using default configuration") if Coverband.configuration.verbose
+    elsif Coverband.configuration.verbose
+      configuration.logger.debug("using default configuration")
     end
     @@configured = true
     coverage_instance.reset_instance

data/test/coverband/file_store_integration_test.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class FileStoreIntegrationTest < Minitest::Test
+  def setup
+    super
+    # Reset state
+    Thread.current[:coverband_instance] = nil
+    Coverband.class_variable_set(:@@configured, false)
+  end
+
+  def teardown
+    super
+    Thread.current[:coverband_instance] = nil
+    Coverband.configure do |config|
+      # Reset to default
+    end
+    Coverband.class_variable_set(:@@configured, false)
+  end
+
+  test "auto-start with FileStore configuration does not try Redis" do
+    # Clear any existing store to simulate fresh start
+    Coverband.configuration.instance_variable_set(:@store, nil)
+
+    # This simulates the typical user setup
+    Coverband.configure do |config|
+      config.root = Dir.pwd
+      config.background_reporting_enabled = false
+      config.store = Coverband::Adapters::FileStore.new("tmp/integration_test_coverage")
+      config.logger = Logger.new($stdout)
+      config.verbose = false
+    end
+
+    # Start coverband - this should work without Redis errors
+    begin
+      Coverband.start
+      Coverband.report_coverage
+    rescue Redis::CannotConnectError => e
+      flunk "Should not try to connect to Redis when FileStore is configured: #{e.message}"
+    rescue => e
+      flunk "Unexpected error: #{e.class}: #{e.message}"
+    end
+
+    # Verify we're using the correct store
+    assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+  end
+
+  test "store fallback works even in auto-start scenario" do
+    # Backup original ENV to avoid side effects
+    original_disable = ENV["COVERBAND_DISABLE_AUTO_START"]
+
+    begin
+      # Enable auto-start
+      ENV.delete("COVERBAND_DISABLE_AUTO_START")
+
+      # Clear configuration state
+      Coverband.configuration.instance_variable_set(:@store, nil)
+      Coverband.class_variable_set(:@@configured, false)
+
+      # Mock Redis to fail
+      Redis.expects(:new).raises(Redis::CannotConnectError.new("Connection refused")).at_least_once
+
+      # This should not raise an error even with Redis unavailable
+      store = Coverband.configuration.store
+
+      assert_instance_of Coverband::Adapters::NullStore, store
+    ensure
+      ENV["COVERBAND_DISABLE_AUTO_START"] = original_disable
+    end
+  end
+end

data/test/coverband/file_store_redis_error_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class FileStoreRedisErrorTest < Minitest::Test
+  def setup
+    super
+    # Reset the singleton instance to ensure clean state
+    Coverband::Collectors::Coverage.instance.reset_instance
+  end
+
+  def teardown
+    super
+    Thread.current[:coverband_instance] = nil
+    Coverband.configure do |config|
+      # Reset to default redis store
+    end
+    Coverband::Collectors::Coverage.instance.reset_instance
+  end
+
+  test "Default store gracefully handles Redis connection failure" do
+    # Clear any existing store configuration
+    Coverband.configuration.instance_variable_set(:@store, nil)
+
+    # Mock Redis to simulate connection failure
+    Redis.expects(:new).raises(Redis::CannotConnectError.new("Connection refused"))
+
+    # This should not raise an error, instead it should fall back to NullStore
+    store = Coverband.configuration.store
+
+    assert_instance_of Coverband::Adapters::NullStore, store
+  end
+
+  test "FileStore configuration overrides default store" do
+    # Clear any existing store
+    Coverband.configuration.instance_variable_set(:@store, nil)
+
+    file_store = Coverband::Adapters::FileStore.new("tmp/test_coverage")
+    Coverband.configure do |config|
+      config.store = file_store
+    end
+
+    assert_same file_store, Coverband.configuration.store
+    assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+  end
+
+  test "FileStore is properly set after configuration" do
+    store_path = "tmp/test_coverage"
+    Coverband.configure do |config|
+      config.store = Coverband::Adapters::FileStore.new(store_path)
+    end
+
+    assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+    refute Coverband.configuration.store.is_a?(Coverband::Adapters::RedisStore)
+  end
+end

data/test/coverband/github_issue_586_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# This test demonstrates the fix for GitHub issue #586
+# https://github.com/danmayer/coverband/issues/586
+
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class GitHubIssue586Test < Minitest::Test
+  def setup
+    super
+    # Reset the singleton instance to ensure clean state
+    Coverband::Collectors::Coverage.instance.reset_instance
+  end
+
+  def teardown
+    super
+    Thread.current[:coverband_instance] = nil
+    Coverband.configure do |config|
+      # Reset to default
+    end
+    Coverband::Collectors::Coverage.instance.reset_instance
+  end
+
+  test "GitHub issue #586: FileStore should not cause Redis connection errors" do
+    # This reproduces the exact configuration from the GitHub issue
+    Coverband.configure do |config|
+      config.root = Dir.pwd
+      config.background_reporting_enabled = false
+      config.store = Coverband::Adapters::FileStore.new("tmp/coverband_log")
+      config.logger = Logger.new($stdout)
+      config.verbose = false
+    end
+
+    # This should not raise Redis connection errors
+    begin
+      # Simulate running ruby code to analyze
+      Coverband.start
+      Coverband.report_coverage
+
+      # Verify the store is what the user configured
+      assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+    rescue Redis::CannotConnectError => e
+      flunk "Should not get Redis connection error when using FileStore: #{e.message}"
+    end
+  end
+end

data/test/coverband/initialization_timing_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# This test simulates the exact scenario from GitHub issue #586
+# to verify the timing and sequence of initialization
+
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class InitializationTimingTest < Minitest::Test
+  def setup
+    super
+    # Clear all state to simulate fresh require
+    Thread.current[:coverband_instance] = nil
+    Coverband.class_variable_set(:@@configured, false)
+    Coverband.configuration.instance_variable_set(:@store, nil)
+  end
+
+  def teardown
+    super
+    Thread.current[:coverband_instance] = nil
+    Coverband.configure do |config|
+      # Reset to default
+    end
+    Coverband.class_variable_set(:@@configured, false)
+  end
+
+  test "simulate auto-start before user configuration" do
+    # Clear configuration to simulate fresh require
+    Coverband.configuration.instance_variable_set(:@store, nil)
+    Coverband.class_variable_set(:@@configured, false)
+
+    # Mock Redis to fail when auto-start tries to create default store
+    Redis.expects(:new).raises(Redis::CannotConnectError.new("Connection refused")).once
+
+    # This simulates what happens during auto-start (configure + start)
+    # before user has configured anything
+    Coverband.configure  # No block, no file
+    Coverband.start
+
+    # At this point, the store should have fallen back to NullStore
+    assert_instance_of Coverband::Adapters::NullStore, Coverband.configuration.store
+
+    # Now user tries to configure with FileStore
+    Coverband.configure do |config|
+      config.store = Coverband::Adapters::FileStore.new("coverband/log")
+    end
+
+    # Should now use the configured FileStore
+    assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+  end
+
+  test "check what happens if store is accessed before user configures it" do
+    # Clear configuration to simulate unconfigured state
+    Coverband.configuration.instance_variable_set(:@store, nil)
+    Coverband.class_variable_set(:@@configured, false)
+
+    # Mock Redis to fail
+    Redis.expects(:new).raises(Redis::CannotConnectError.new("Connection refused")).once
+
+    # Access store before configuration - should trigger fallback
+    store = Coverband.configuration.store
+    assert_instance_of Coverband::Adapters::NullStore, store
+
+    # Now configure with FileStore
+    Coverband.configure do |config|
+      config.store = Coverband::Adapters::FileStore.new("coverband/log")
+    end
+
+    # Should now use the configured FileStore
+    assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+  end
+end

data/test/coverband/mcp/http_handler_test.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+require "rack/test"
+
+begin
+  require "coverband/mcp"
+rescue LoadError
+  puts "MCP gem not available, skipping MCP HTTP handler tests"
+end
+
+if defined?(Coverband::MCP)
+  class MCPHttpHandlerTest < Minitest::Test
+    include Rack::Test::Methods
+
+    def setup
+      super
+      Coverband.configure do |config|
+        config.store = Coverband::Adapters::RedisStore.new(Redis.new(db: 2))
+        config.mcp_enabled = true  # Enable MCP for testing
+      end
+    end
+
+    def teardown
+      super
+      Coverband.configuration.store&.clear!
+    end
+
+    def app
+      @app ||= Coverband::MCP::HttpHandler.new
+    end
+
+    def app_with_wrapped_handler
+      @wrapped_app ||= begin
+        mock_app = lambda { |env| [200, {"Content-Type" => "text/plain"}, ["wrapped app response"]] }
+        Coverband::MCP::HttpHandler.new(mock_app)
+      end
+    end
+
+    test "handles MCP requests at /mcp endpoint" do
+      # Mock the server to return a simple response
+      server_mock = mock("server")
+      server_mock.expects(:handle_json).returns({"result" => "success"})
+
+      handler = Coverband::MCP::HttpHandler.new
+      handler.expects(:mcp_server).returns(server_mock)
+
+      @app = handler
+
+      json_request = {
+        "jsonrpc" => "2.0",
+        "method" => "tools/list",
+        "id" => 1
+      }.to_json
+
+      post "/mcp", json_request, {"CONTENT_TYPE" => "application/json"}
+
+      assert_equal 200, last_response.status
+      assert_equal "application/json", last_response.content_type
+
+      # Check CORS headers
+      assert_equal "*", last_response.headers["Access-Control-Allow-Origin"]
+      assert_equal "POST, OPTIONS", last_response.headers["Access-Control-Allow-Methods"]
+      assert_equal "Content-Type", last_response.headers["Access-Control-Allow-Headers"]
+    end
+
+    test "returns 404 for non-MCP requests when no wrapped app" do
+      get "/other-path"
+
+      assert_equal 404, last_response.status
+      assert_equal "text/plain", last_response.content_type
+      assert_equal "Not Found", last_response.body
+    end
+
+    test "delegates non-MCP requests to wrapped app" do
+      @app = app_with_wrapped_handler
+
+      get "/other-path"
+
+      assert_equal 200, last_response.status
+      assert_equal "wrapped app response", last_response.body
+    end
+
+    test "only responds to POST requests for MCP endpoint" do
+      get "/mcp"
+
+      assert_equal 404, last_response.status
+    end
+
+    test "handles invalid JSON gracefully" do
+      post "/mcp", "invalid json", {"CONTENT_TYPE" => "application/json"}
+
+      assert_equal 400, last_response.status
+      assert_equal "application/json", last_response.content_type
+
+      response = JSON.parse(last_response.body)
+      assert_includes response["error"], "Invalid JSON"
+    end
+
+    test "handles server errors gracefully" do
+      # Mock server to raise an error
+      server_mock = mock("server")
+      server_mock.expects(:handle_json).raises(StandardError.new("Test error"))
+
+      handler = Coverband::MCP::HttpHandler.new
+      handler.expects(:mcp_server).returns(server_mock)
+
+      @app = handler
+
+      json_request = {"test" => "request"}.to_json
+      post "/mcp", json_request, {"CONTENT_TYPE" => "application/json"}
+
+      assert_equal 500, last_response.status
+
+      response = JSON.parse(last_response.body)
+      assert_includes response["error"], "Server error: Test error"
+    end
+
+    test "mcp_server is lazily initialized" do
+      handler = Coverband::MCP::HttpHandler.new
+
+      # First call creates the server
+      server1 = handler.send(:mcp_server)
+      assert_instance_of Coverband::MCP::Server, server1
+
+      # Second call returns the same instance
+      server2 = handler.send(:mcp_server)
+      assert_same server1, server2
+    end
+
+    test "mcp_request? correctly identifies MCP requests" do
+      handler = Coverband::MCP::HttpHandler.new
+
+      # POST request to /mcp path
+      env = Rack::MockRequest.env_for("/mcp", method: "POST")
+      request = Rack::Request.new(env)
+      assert handler.send(:mcp_request?, request)
+
+      # POST request to /some-path/mcp (ends with /mcp)
+      env = Rack::MockRequest.env_for("/some-path/mcp", method: "POST")
+      request = Rack::Request.new(env)
+      assert handler.send(:mcp_request?, request)
+
+      # GET request to /mcp
+      env = Rack::MockRequest.env_for("/mcp", method: "GET")
+      request = Rack::Request.new(env)
+      refute handler.send(:mcp_request?, request)
+
+      # POST request to /other-path
+      env = Rack::MockRequest.env_for("/other-path", method: "POST")
+      request = Rack::Request.new(env)
+      refute handler.send(:mcp_request?, request)
+    end
+
+    test "constant MCP_PATH is defined" do
+      assert_equal "/mcp", Coverband::MCP::HttpHandler::MCP_PATH
+    end
+  end
+end