coverband 6.1.5 → 6.1.7

data/lib/coverband/mcp/tools/get_uncovered_files.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Coverband
+  module MCP
+    module Tools
+      class GetUncoveredFiles < ::MCP::Tool
+        description "Get files with coverage below a specified threshold. " \
+                    "Useful for finding code that may need more production testing or could be dead code."
+
+        input_schema(
+          properties: {
+            threshold: {
+              type: "number",
+              description: "Coverage percentage threshold (default: 50). Files below this are returned."
+            },
+            include_never_loaded: {
+              type: "boolean",
+              description: "Include files that were never loaded in production (default: true)"
+            }
+          }
+        )
+
+        def self.call(server_context:, threshold: 50, include_never_loaded: true, **)
+          store = Coverband.configuration.store
+          report = Coverband::Reporters::JSONReport.new(store, line_coverage: false)
+          data = JSON.parse(report.report)
+
+          files = data["files"] || {}
+
+          uncovered = files.select do |_path, file_data|
+            percent = file_data["covered_percent"] || 0
+            never_loaded = file_data["never_loaded"]
+
+            if include_never_loaded
+              percent < threshold || never_loaded
+            else
+              percent < threshold && !never_loaded
+            end
+          end
+
+          # Sort by coverage percentage ascending (least covered first)
+          sorted = uncovered.sort_by { |_path, data| data["covered_percent"] || 0 }
+
+          result = sorted.map do |path, file_data|
+            {
+              file: path,
+              covered_percent: file_data["covered_percent"],
+              lines_of_code: file_data["lines_of_code"],
+              lines_covered: file_data["lines_covered"],
+              lines_missed: file_data["lines_missed"],
+              never_loaded: file_data["never_loaded"]
+            }
+          end
+
+          ::MCP::Tool::Response.new([{
+            type: "text",
+            text: JSON.pretty_generate({
+              threshold: threshold,
+              include_never_loaded: include_never_loaded,
+              total_uncovered_files: result.length,
+              files: result
+            })
+          }])
+        rescue => e
+          ::MCP::Tool::Response.new([{
+            type: "text",
+            text: "Error getting uncovered files: #{e.message}"
+          }])
+        end
+      end
+    end
+  end
+end

data/lib/coverband/mcp/tools/get_view_tracker_data.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Coverband
+  module MCP
+    module Tools
+      class GetViewTrackerData < ::MCP::Tool
+        description "Get Rails view template usage tracking data. Shows which view templates " \
+                    "have been rendered in production and which have never been accessed."
+
+        input_schema(
+          properties: {
+            show_unused_only: {
+              type: "boolean",
+              description: "Only return unused views (default: false)"
+            }
+          }
+        )
+
+        def self.call(server_context:, show_unused_only: false, **)
+          tracker = Coverband.configuration.view_tracker
+
+          unless tracker
+            return ::MCP::Tool::Response.new([{
+              type: "text",
+              text: "View tracking is not enabled. Enable it with `config.track_views = true` in your coverband configuration."
+            }])
+          end
+
+          data = JSON.parse(tracker.as_json)
+
+          result = if show_unused_only
+            {
+              tracking_since: tracker.tracking_since,
+              unused_views: data["unused_keys"] || [],
+              total_unused: data["unused_keys"]&.length || 0
+            }
+          else
+            {
+              tracking_since: tracker.tracking_since,
+              used_views: data["used_keys"] || [],
+              unused_views: data["unused_keys"] || [],
+              total_used: data["used_keys"]&.length || 0,
+              total_unused: data["unused_keys"]&.length || 0
+            }
+          end
+
+          ::MCP::Tool::Response.new([{
+            type: "text",
+            text: JSON.pretty_generate(result)
+          }])
+        rescue => e
+          ::MCP::Tool::Response.new([{
+            type: "text",
+            text: "Error getting view tracker data: #{e.message}"
+          }])
+        end
+      end
+    end
+  end
+end

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/railtie.rb

@@ -7,7 +7,7 @@ module Coverband
       super
     end
   end
-  Rails::Engine.prepend(RailsEagerLoad)
+  Rails::Engine.prepend(RailsEagerLoad) if defined? ::Rails::Engine
 
   class Railtie < Rails::Railtie
     initializer "coverband.configure" do |app|

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.5"
+  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
@@ -107,16 +107,16 @@ module Coverband
   # @raise [ArgumentError] If the tracker_type is not supported
   def self.track_key(tracker_type, key)
     return false unless key
-    
+
     supported_trackers = [:view_tracker, :translations_tracker, :routes_tracker]
-    
+
     unless supported_trackers.include?(tracker_type)
-      raise ArgumentError, "Unsupported tracker type: #{tracker_type}. Must be one of: #{supported_trackers.join(', ')}"
+      raise ArgumentError, "Unsupported tracker type: #{tracker_type}. Must be one of: #{supported_trackers.join(", ")}"
     end
-    
+
     begin
       tracker = configuration.send(tracker_type)
-      return false unless tracker && tracker.respond_to?(:track_key)
+      return false unless tracker&.respond_to?(:track_key)
 
       tracker.track_key(key)
       true

data/test/benchmarks/benchmark.rake

@@ -102,7 +102,7 @@ namespace :benchmarks do
     lines = 45
     non_nil_lines = 18
     lines.times.map do |line|
-      coverage = (line < non_nil_lines) ? rand(5) : nil
+      (line < non_nil_lines) ? rand(5) : nil
     end
   end
 
@@ -146,7 +146,7 @@ namespace :benchmarks do
       x.report("store_reports_all") { store.save_report(report) }
     end
     keys_subset = report.keys.first(100)
-    report_subset = report.select { |key, _value| keys_subset.include?(key) }
+    report_subset = report.slice(*keys_subset)
     Benchmark.ips do |x|
       x.config(time: 20, warmup: 5)
       x.report("store_reports_subset") { store.save_report(report_subset) }
@@ -183,7 +183,7 @@ namespace :benchmarks do
 
   def measure_memory_report_coverage
     require "memory_profiler"
-    report = fake_report
+    fake_report
     store = benchmark_redis_store
     store.clear!
     mock_files(store)
@@ -258,37 +258,29 @@ namespace :benchmarks do
     # about 2mb
     puts(ObjectSpace.memsize_of(data) / 2**20)
 
-    json_data = JSON.parse(data)
+    JSON.parse(data)
     # this seems to just show the value of the pointer
     # puts(ObjectSpace.memsize_of(json_data) / 2**20)
     # implies json takes 10-12 mb
     puts(ObjectSpace.memsize_of_all / 2**20)
-
-    json_data = nil
     GC.start
-    json_data = JSON.parse(data)
+    JSON.parse(data)
     # this seems to just show the value of the pointer
     # puts(ObjectSpace.memsize_of(json_data) / 2**20)
     # implies json takes 10-12 mb
     puts(ObjectSpace.memsize_of_all / 2**20)
-
-    json_data = nil
     GC.start
-    json_data = JSON.parse(data)
+    JSON.parse(data)
     # this seems to just show the value of the pointer
     # puts(ObjectSpace.memsize_of(json_data) / 2**20)
     # implies json takes 10-12 mb
     puts(ObjectSpace.memsize_of_all / 2**20)
-
-    json_data = nil
     GC.start
-    json_data = JSON.parse(data)
+    JSON.parse(data)
     # this seems to just show the value of the pointer
     # puts(ObjectSpace.memsize_of(json_data) / 2**20)
     # implies json takes 10-12 mb
     puts(ObjectSpace.memsize_of_all / 2**20)
-
-    json_data = nil
     GC.start
     puts(ObjectSpace.memsize_of_all / 2**20)
 

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