simplecov-mcp 0.1.0 → 0.2.0

data/lib/simple_cov_mcp/errors.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+    # Base error class for all SimpleCov MCP errors
+    class Error < StandardError
+      attr_reader :original_error
+
+      def initialize(message = nil, original_error = nil)
+        @original_error = original_error
+        super(message)
+      end
+
+      def user_friendly_message
+        message
+      end
+    end
+
+    # Configuration or setup related errors
+    class ConfigurationError < Error
+      def user_friendly_message
+        "Configuration error: #{message}"
+      end
+    end
+
+    # File or path related errors
+    class FileError < Error
+      def user_friendly_message
+        "File error: #{message}"
+      end
+    end
+
+    # More specific file errors
+    class FileNotFoundError < FileError; end
+    class FilePermissionError < FileError; end
+    class NotAFileError < FileError; end
+    class ResultsetNotFoundError < FileError; end
+
+    # Coverage data related errors
+    class CoverageDataError < Error
+      def user_friendly_message
+        "Coverage data error: #{message}"
+      end
+    end
+
+    # Coverage data is present but appears stale compared to source files
+    class CoverageDataStaleError < CoverageDataError
+      attr_reader :file_path, :file_mtime, :cov_timestamp, :src_len, :cov_len, :resultset_path
+
+      def initialize(message = nil, original_error = nil, file_path: nil, file_mtime: nil, cov_timestamp: nil, src_len: nil, cov_len: nil, resultset_path: nil)
+        super(message, original_error)
+        @file_path = file_path
+        @file_mtime = file_mtime
+        @cov_timestamp = cov_timestamp
+        @src_len = src_len
+        @cov_len = cov_len
+        @resultset_path = resultset_path
+      end
+
+      def user_friendly_message
+        base = "Coverage data stale: #{message || default_message}"
+        base + build_details
+      end
+
+      private
+
+      def default_message
+        fp = file_path || 'file'
+        "Coverage data appears stale for #{fp}"
+      end
+
+      def build_details
+        file_utc, file_local = format_time_both(@file_mtime)
+        cov_utc,  cov_local  = format_epoch_both(@cov_timestamp)
+        delta_str = format_delta_seconds(@file_mtime, @cov_timestamp)
+        details = []
+        details << "\nFile     - time: #{file_utc || 'not found'} (local #{file_local || 'n/a'}), lines: #{@src_len}"
+        details << "\nCoverage - time: #{cov_utc  || 'not found'} (local #{cov_local  || 'n/a'}), lines: #{@cov_len}"
+        details << "\nDelta    - file is #{delta_str} newer than coverage" if delta_str
+        details << "\nResultset - #{@resultset_path}" if @resultset_path
+        details.join
+      end
+
+      def format_epoch_both(epoch_seconds)
+        return [nil, nil] unless epoch_seconds
+        t = Time.at(epoch_seconds.to_i)
+        [t.utc.iso8601, t.getlocal.iso8601]
+      rescue StandardError
+        [epoch_seconds.to_s, epoch_seconds.to_s]
+      end
+
+      def format_time_both(time)
+        return [nil, nil] unless time
+        t = time.is_a?(Time) ? time : Time.parse(time.to_s)
+        [t.utc.iso8601, t.getlocal.iso8601]
+      rescue StandardError
+        [time.to_s, time.to_s]
+      end
+
+      def format_delta_seconds(file_mtime, cov_timestamp)
+        return nil unless file_mtime && cov_timestamp
+        seconds = file_mtime.to_i - cov_timestamp.to_i
+        sign = seconds >= 0 ? '+' : '-'
+        "#{sign}#{seconds.abs}s"
+      rescue StandardError
+        nil
+      end
+    end
+
+    # Project-level stale coverage (global) — coverage timestamp older than
+    # one or more source files, or new tracked files missing from coverage.
+    class CoverageDataProjectStaleError < CoverageDataError
+      attr_reader :cov_timestamp, :newer_files, :missing_files, :deleted_files, :resultset_path
+
+      def initialize(message = nil, original_error = nil, cov_timestamp: nil, newer_files: [], missing_files: [], deleted_files: [], resultset_path: nil)
+        super(message, original_error)
+        @cov_timestamp = cov_timestamp
+        @newer_files = Array(newer_files)
+        @missing_files = Array(missing_files)
+        @deleted_files = Array(deleted_files)
+        @resultset_path = resultset_path
+      end
+
+      def user_friendly_message
+        base = "Coverage data stale (project): #{message || default_message}"
+        base + build_details
+      end
+
+      private
+
+      def default_message
+        'Coverage data appears stale for project'
+      end
+
+      def build_details
+        cov_utc, cov_local = format_epoch_both(@cov_timestamp)
+        parts = []
+        parts << "\nCoverage  - time: #{cov_utc || 'not found'} (local #{cov_local || 'n/a'})"
+        unless @newer_files.empty?
+          parts << "\nNewer files (#{@newer_files.size}):"
+          parts.concat(@newer_files.first(10).map { |f| "  - #{f}" })
+          parts << "  ..." if @newer_files.size > 10
+        end
+        unless @missing_files.empty?
+          parts << "\nMissing files (new in project, not in coverage, #{@missing_files.size}):"
+          parts.concat(@missing_files.first(10).map { |f| "  - #{f}" })
+          parts << "  ..." if @missing_files.size > 10
+        end
+        unless @deleted_files.empty?
+          parts << "\nCoverage-only files (deleted or moved in project, #{@deleted_files.size}):"
+          parts.concat(@deleted_files.first(10).map { |f| "  - #{f}" })
+          parts << "  ..." if @deleted_files.size > 10
+        end
+        parts << "\nResultset - #{@resultset_path}" if @resultset_path
+        parts.join
+      end
+
+      def format_epoch_both(epoch_seconds)
+        return [nil, nil] unless epoch_seconds
+        t = Time.at(epoch_seconds.to_i)
+        [t.utc.iso8601, t.getlocal.iso8601]
+      rescue StandardError
+        [epoch_seconds.to_s, epoch_seconds.to_s]
+      end
+    end
+
+    # Command line usage errors
+    class UsageError < Error
+      def self.for_subcommand(usage_fragment)
+        new("Usage: simplecov-mcp #{usage_fragment}")
+      end
+
+      def user_friendly_message
+        message
+      end
+    end
+end

data/lib/simple_cov_mcp/mcp_server.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  class MCPServer
+      def initialize
+        # Configure error handling for MCP server mode using the factory
+        SimpleCovMcp.error_handler = ErrorHandlerFactory.for_mcp_server
+      end
+
+      def run
+        tools = [
+          Tools::AllFilesCoverageTool,
+          Tools::CoverageDetailedTool,
+          Tools::CoverageRawTool,
+          Tools::CoverageSummaryTool,
+          Tools::UncoveredLinesTool,
+          Tools::CoverageTableTool,
+          Tools::HelpTool,
+          Tools::VersionTool
+        ]
+
+        server = ::MCP::Server.new(
+          name:    'simplecov-mcp',
+          version: SimpleCovMcp::VERSION,
+          tools:   tools
+        )
+        ::MCP::Server::Transports::StdioTransport.new(server).open
+      end
+  end
+end

data/lib/simple_cov_mcp/model.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative 'util'
+require_relative 'errors'
+require_relative 'staleness_checker'
+
+module SimpleCovMcp
+  class CoverageModel
+    # Create a CoverageModel
+    #
+    # Params:
+    # - root: project root directory (default '.')
+    # - resultset: path or directory to .resultset.json
+      # - staleness: 'off' or 'error' (default 'off'). When 'error', raises
+      #   stale errors if sources are newer than coverage or line counts mismatch.
+      # - tracked_globs: only used for all_files project-level staleness.
+      def initialize(root: '.', resultset: nil, staleness: 'off', tracked_globs: nil)
+        @root = File.absolute_path(root || '.')
+        @resultset = resultset
+        @checker = StalenessChecker.new(root: @root, resultset: @resultset, mode: staleness, tracked_globs: tracked_globs)
+      begin
+        @cov  = CovUtil.load_latest_coverage(@root, resultset: resultset)
+      rescue Errno::ENOENT => e
+        raise FileError.new("Coverage data not found at #{resultset || @root}")
+      rescue JSON::ParserError => e
+        raise CoverageDataError.new("Invalid coverage data format")
+      rescue => e
+        raise CoverageDataError.new("Failed to load coverage data: #{e.message}")
+      end
+    end
+
+    # Returns { 'file' => <absolute_path>, 'lines' => [hits|nil,...] }
+    def raw_for(path)
+      file_abs, coverage_lines = resolve(path)
+      { 'file' => file_abs, 'lines' => coverage_lines }
+    end
+
+    # Returns { 'file' => <absolute_path>, 'summary' => {'covered'=>, 'total'=>, 'pct'=>} }
+    def summary_for(path)
+      file_abs, coverage_lines = resolve(path)
+      { 'file' => file_abs, 'summary' => CovUtil.summary(coverage_lines) }
+    end
+
+    # Returns { 'file' => <absolute_path>, 'uncovered' => [line,...], 'summary' => {...} }
+    def uncovered_for(path)
+      file_abs, coverage_lines = resolve(path)
+      { 'file' => file_abs, 'uncovered' => CovUtil.uncovered(coverage_lines), 'summary' => CovUtil.summary(coverage_lines) }
+    end
+
+    # Returns { 'file' => <absolute_path>, 'lines' => [{'line'=>,'hits'=>,'covered'=>},...], 'summary' => {...} }
+    def detailed_for(path)
+      file_abs, coverage_lines = resolve(path)
+      { 'file' => file_abs, 'lines' => CovUtil.detailed(coverage_lines), 'summary' => CovUtil.summary(coverage_lines) }
+    end
+
+    # Returns [ { 'file' =>, 'covered' =>, 'total' =>, 'percentage' =>, 'stale' => }, ... ]
+      def all_files(sort_order: :ascending, check_stale: !@checker.off?, tracked_globs: nil)
+        stale_checker = StalenessChecker.new(root: @root, resultset: @resultset, mode: 'off', tracked_globs: tracked_globs)
+        rows = @cov.map do |abs_path, data|
+          next unless data['lines'].is_a?(Array)
+          s = CovUtil.summary(data['lines'])
+          stale = stale_checker.stale_for_file?(abs_path, data['lines'])
+          { 'file' => abs_path, 'covered' => s['covered'], 'total' => s['total'], 'percentage' => s['pct'], 'stale' => stale }
+        end.compact
+
+        if check_stale
+          StalenessChecker.new(root: @root, resultset: @resultset, mode: 'error', tracked_globs: tracked_globs)
+                           .check_project!(@cov)
+        end
+
+        rows.sort! do |a, b|
+          pct_cmp = (sort_order.to_s == 'descending') ? (b['percentage'] <=> a['percentage']) : (a['percentage'] <=> b['percentage'])
+          pct_cmp == 0 ? (a['file'] <=> b['file']) : pct_cmp
+        end
+        rows
+      end
+
+    private
+
+    def resolve(path)
+      file_abs = File.absolute_path(path, @root)
+      coverage_lines = CovUtil.lookup_lines(@cov, file_abs)
+        @checker.check_file!(file_abs, coverage_lines) unless @checker.off?
+      if coverage_lines.nil?
+        raise FileError.new("No coverage data found for file: #{path}")
+      end
+      [file_abs, coverage_lines]
+      rescue Errno::ENOENT => e
+        raise FileNotFoundError.new("File not found: #{path}")
+    end
+
+      # staleness handled by StalenessChecker
+
+      def check_all_files_staleness!(cov_timestamp, tracked_globs: nil)
+        # handled by StalenessChecker
+      end
+
+      def rel_to_root(path)
+        Pathname.new(path).relative_path_from(Pathname.new(File.absolute_path(@root))).to_s
+      end
+
+    # Detailed stale message construction moved to CoverageDataStaleError
+  end
+end

data/lib/simple_cov_mcp/staleness_checker.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module SimpleCovMcp
+  # Lightweight service object to check staleness of coverage vs. sources
+  class StalenessChecker
+    MODES = %w[off error].freeze
+
+    def initialize(root:, resultset:, mode: 'off', tracked_globs: nil)
+      @root = File.absolute_path(root || '.')
+      @resultset = resultset
+      @mode = (mode || 'off').to_s
+      @tracked_globs = tracked_globs
+      @cov_timestamp = nil
+      @resultset_path = nil
+    end
+
+    def off?
+      @mode == 'off'
+    end
+
+    # Raise CoverageDataStaleError if stale (only in error mode)
+    def check_file!(file_abs, coverage_lines)
+      return if off?
+      ts = coverage_timestamp
+      fm = File.mtime(file_abs) if File.file?(file_abs)
+      cov_len = coverage_lines.respond_to?(:length) ? coverage_lines.length : 0
+      src_len = safe_count_lines(file_abs)
+      if (fm && fm.to_i > ts.to_i) || (cov_len.positive? && src_len != cov_len)
+        raise CoverageDataStaleError.new(
+          nil,
+          nil,
+          file_path: rel(file_abs),
+          file_mtime: fm,
+          cov_timestamp: ts,
+          src_len: src_len,
+          cov_len: cov_len,
+          resultset_path: resultset_path
+        )
+      end
+    end
+
+    # Compute whether a specific file appears stale relative to coverage.
+    # Ignores mode and never raises; returns true when:
+    # - the file is missing/deleted, or
+    # - the file mtime is newer than the coverage timestamp, or
+    # - the source line count differs from the coverage lines array length (when present).
+    def stale_for_file?(file_abs, coverage_lines)
+      ts = coverage_timestamp
+      return true unless File.file?(file_abs)
+
+      fm = File.mtime(file_abs)
+      cov_len = coverage_lines.respond_to?(:length) ? coverage_lines.length : 0
+      src_len = safe_count_lines(file_abs)
+      (fm && fm.to_i > ts.to_i) || (cov_len.positive? && src_len != cov_len)
+    rescue StandardError
+      # Be conservative: if we cannot determine, mark as stale
+      true
+    end
+
+    # Raise CoverageDataProjectStaleError if any covered file is newer or if
+    # tracked files are missing from coverage, or coverage includes deleted files.
+    def check_project!(coverage_map)
+      return if off?
+      ts = coverage_timestamp
+      newer = []
+      deleted = []
+      coverage_files = coverage_map.keys
+      coverage_files.each do |abs|
+        if File.file?(abs)
+          newer << rel(abs) if File.mtime(abs).to_i > ts.to_i
+        else
+          deleted << rel(abs)
+        end
+      end
+
+      missing = []
+      if @tracked_globs && !Array(@tracked_globs).empty?
+        patterns = Array(@tracked_globs).map { |g| File.absolute_path(g, @root) }
+        tracked = patterns.flat_map { |p| Dir.glob(p, File::FNM_EXTGLOB | File::FNM_PATHNAME) }
+                          .select { |p| File.file?(p) }
+        covered_set = coverage_files.to_set rescue coverage_files
+        tracked.each do |abs|
+          missing << rel(abs) unless covered_set.include?(abs)
+        end
+      end
+
+      if !newer.empty? || !missing.empty? || !deleted.empty?
+        raise CoverageDataProjectStaleError.new(
+          nil,
+          nil,
+          cov_timestamp: ts,
+          newer_files: newer,
+          missing_files: missing,
+          deleted_files: deleted,
+          resultset_path: resultset_path
+        )
+      end
+    end
+
+    private
+
+    def coverage_timestamp
+      @cov_timestamp ||= CovUtil.latest_timestamp(@root, resultset: @resultset)
+    end
+
+    def resultset_path
+      @resultset_path ||= CovUtil.find_resultset(@root, resultset: @resultset)
+    rescue StandardError
+      nil
+    end
+
+    def safe_count_lines(path)
+      return 0 unless File.file?(path)
+      File.foreach(path).count
+    rescue StandardError
+      0
+    end
+
+    def rel(path)
+      Pathname.new(path).relative_path_from(Pathname.new(@root)).to_s
+    end
+  end
+end

data/lib/simple_cov_mcp/tools/all_files_coverage_tool.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../model'
+require_relative '../base_tool'
+
+module SimpleCovMcp
+  module Tools
+    class AllFilesCoverageTool < BaseTool
+      description <<~DESC
+        Use this when the user wants coverage percentages for every tracked file in the project.
+        Do not use this for single-file stats; prefer coverage.summary or coverage.uncovered_lines for that.
+        Inputs: optional project root, alternate .resultset path, sort order, staleness mode, and tracked_globs to alert on new files.
+        Output: JSON {"files": [{"file","covered","total","percentage","stale"}, ...], "counts": {"total", "ok", "stale"}} sorted as requested. "stale" is a boolean.
+        Examples: "List files with the lowest coverage"; "Show repo coverage sorted descending".
+      DESC
+      input_schema(
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          root: {
+            type: 'string',
+            description: 'Project root used to resolve relative inputs.',
+            default: '.'
+          },
+          resultset: {
+            type: 'string',
+            description: 'Path to the SimpleCov .resultset.json file.'
+          },
+          sort_order: {
+            type: 'string',
+            description: "Sort order for coverage percentages. 'ascending' highlights the riskiest files first.",
+            default: 'ascending',
+            enum: ['ascending', 'descending']
+          },
+          stale: {
+            type: 'string',
+            description: "How to handle missing/outdated coverage data. 'off' skips checks; 'error' raises.",
+            enum: ['off', 'error'],
+            default: 'off'
+          },
+          tracked_globs: {
+            type: 'array',
+            description: 'Glob patterns for files that should exist in the coverage report (helps flag new files).',
+            items: { type: 'string' }
+          }
+        }
+      )
+      class << self
+        def call(root: '.', resultset: nil, sort_order: 'ascending', stale: 'off', tracked_globs: nil, server_context:)
+          model = CoverageModel.new(root: root, resultset: resultset, staleness: stale, tracked_globs: tracked_globs)
+          files = model.all_files(sort_order: sort_order, check_stale: (stale.to_s == 'error'), tracked_globs: tracked_globs)
+          total = files.length
+          stale_count = files.count { |f| f['stale'] }
+          ok_count = total - stale_count
+          payload = { files: files, counts: { total: total, ok: ok_count, stale: stale_count } }
+          ::MCP::Tool::Response.new([{ type: 'text', text: JSON.pretty_generate(payload) }])
+        rescue => e
+          handle_mcp_error(e, 'AllFilesCoverageTool')
+        end
+      end
+    end
+  end
+end

data/lib/simple_cov_mcp/tools/coverage_detailed_tool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../base_tool'
+require_relative '../model'
+
+module SimpleCovMcp
+  module Tools
+    class CoverageDetailedTool < BaseTool
+      description <<~DESC
+        Use this when the user needs per-line coverage data for a single file.
+        Do not use this for high-level counts; coverage.summary is cheaper for aggregate numbers.
+        Inputs: file path (required) plus optional root/resultset/stale mode inherited from BaseTool.
+        Output: JSON object with "file", "lines" => [{"line": 12, "hits": 0, "covered": false}], plus "summary" with totals.
+        Example: "Show detailed coverage for lib/simple_cov_mcp/model.rb".
+      DESC
+      input_schema(**input_schema_def)
+      class << self
+        def call(path:, root: '.', resultset: nil, stale: 'off', server_context:)
+          mode = stale
+          model = CoverageModel.new(root: root, resultset: resultset, staleness: mode)
+          data = model.detailed_for(path)
+          ::MCP::Tool::Response.new([{ type: 'text', text: JSON.pretty_generate(data) }])
+        rescue => e
+          handle_mcp_error(e, 'CoverageDetailedTool')
+        end
+      end
+    end
+  end
+end

data/lib/simple_cov_mcp/tools/coverage_raw_tool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../base_tool'
+require_relative '../model'
+
+module SimpleCovMcp
+  module Tools
+    class CoverageRawTool < BaseTool
+      description <<~DESC
+        Use this when you need the raw SimpleCov `lines` array for a file exactly as stored on disk.
+        Do not use this for human-friendly explanations; choose coverage.detailed or coverage.summary instead.
+        Inputs: file path (required) plus optional root/resultset/stale mode inherited from BaseTool.
+        Output: JSON object with "file" and "lines" (array of integers/nulls) mirroring SimpleCov's native structure.
+        Example: "Fetch the raw coverage array for spec/support/foo_helper.rb".
+      DESC
+      input_schema(**input_schema_def)
+      class << self
+        def call(path:, root: '.', resultset: nil, stale: 'off', server_context:)
+          mode = stale
+          model = CoverageModel.new(root: root, resultset: resultset, staleness: mode)
+          data = model.raw_for(path)
+          ::MCP::Tool::Response.new([{ type: 'text', text: JSON.pretty_generate(data) }])
+        rescue => e
+          handle_mcp_error(e, 'CoverageRawTool')
+        end
+      end
+    end
+  end
+end

data/lib/simple_cov_mcp/tools/coverage_summary_tool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../base_tool'
+require_relative '../model'
+
+module SimpleCovMcp
+  module Tools
+    class CoverageSummaryTool < BaseTool
+      description <<~DESC
+        Use this when the user asks for the covered/total line counts and percentage for a specific file.
+        Do not use this for multi-file reports; coverage.all_files or coverage.table handle those.
+        Inputs: file path (required) plus optional root/resultset/stale mode inherited from BaseTool.
+        Output: JSON object {"file": String, "summary": {"covered": Integer, "total": Integer, "pct": Float}}.
+        Examples: "What is the coverage for lib/simple_cov_mcp/tools/all_files_coverage_tool.rb?".
+      DESC
+      input_schema(**input_schema_def)
+      class << self
+        def call(path:, root: '.', resultset: nil, stale: 'off', server_context:)
+          mode = stale
+          model = CoverageModel.new(root: root, resultset: resultset, staleness: mode)
+          data = model.summary_for(path)
+          ::MCP::Tool::Response.new([{ type: 'text', text: JSON.pretty_generate(data) }])
+        rescue => e
+          handle_mcp_error(e, 'CoverageSummaryTool')
+        end
+      end
+    end
+  end
+end

data/lib/simple_cov_mcp/tools/coverage_table_tool.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require_relative '../cli'
+require_relative '../base_tool'
+
+module SimpleCovMcp
+  module Tools
+    class CoverageTableTool < BaseTool
+      description <<~DESC
+        Use this when a user wants the plain text coverage table exactly like `simplecov-mcp --table` would print (no ANSI colors).
+        Do not use this for machine-readable data; coverage.all_files returns structured JSON.
+        Inputs: optional project root/resultset path/sort order/staleness mode matching the CLI flags.
+        Output: text block containing the formatted coverage table with headers and percentages.
+        Example: "Show me the CLI coverage table sorted descending".
+      DESC
+      input_schema(
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          root: {
+            type: 'string',
+            description: 'Project root used to resolve relative inputs.',
+            default: '.'
+          },
+          resultset: {
+            type: 'string',
+            description: 'Path to the SimpleCov .resultset.json file.'
+          },
+          sort_order: {
+            type: 'string',
+            description: "Sort order for the printed coverage table (ascending or descending).",
+            default: 'ascending',
+            enum: ['ascending', 'descending']
+          },
+          stale: {
+            type: 'string',
+            description: "How to handle missing/outdated coverage data. 'off' skips checks; 'error' raises.",
+            enum: ['off', 'error'],
+            default: 'off'
+          }
+        }
+      )
+
+      class << self
+        def call(root: '.', resultset: nil, sort_order: 'ascending', stale: 'off', server_context:)
+          # Capture the output of the CLI's table report while honoring CLI options
+          output = StringIO.new
+          cli = CoverageCLI.new
+          cli.instance_variable_set(:@root, root || '.')
+          cli.instance_variable_set(:@resultset, resultset)
+          cli.instance_variable_set(:@stale_mode, (stale || 'off').to_s)
+          cli.show_default_report(sort_order: sort_order.to_sym, output: output)
+          ::MCP::Tool::Response.new([{ type: 'text', text: output.string }])
+        rescue => e
+          handle_mcp_error(e, 'CoverageTableTool')
+        end
+      end
+    end
+  end
+end