simplecov-mcp 0.3.0 → 1.0.0

data/lib/simplecov_mcp/model.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'json'
+
+require_relative 'util'
+require_relative 'errors'
+require_relative 'staleness_checker'
+require_relative 'path_relativizer'
+require_relative 'resultset_loader'
+
+module SimpleCovMcp
+  class CoverageModel
+    RELATIVIZER_SCALAR_KEYS = %w[file file_path].freeze
+    RELATIVIZER_ARRAY_KEYS = %w[newer_files missing_files deleted_files].freeze
+
+    attr_reader :relativizer
+
+    # 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
+      @relativizer = PathRelativizer.new(
+        root: @root,
+        scalar_keys: RELATIVIZER_SCALAR_KEYS,
+        array_keys: RELATIVIZER_ARRAY_KEYS
+      )
+
+      begin
+        rs = CovUtil.find_resultset(@root, resultset: resultset)
+        loaded = ResultsetLoader.load(resultset_path: rs)
+        coverage_map = loaded.coverage_map or raise CoverageDataError.new("No 'coverage' key found in resultset file: #{rs}")
+
+        @cov = coverage_map.transform_keys { |k| File.absolute_path(k, @root) }
+        @cov_timestamp = loaded.timestamp
+
+        @checker = StalenessChecker.new(
+          root: @root,
+          resultset: @resultset,
+          mode: staleness,
+          tracked_globs: tracked_globs,
+          timestamp: @cov_timestamp
+        )
+      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: #{e.message}")
+      rescue Errno::EACCES => e
+        raise FilePermissionError.new("Permission denied reading coverage data: #{e.message}")
+      rescue TypeError, NoMethodError => e
+        # These typically indicate the resultset has an unexpected structure
+        raise CoverageDataError.new("Invalid coverage data structure: #{e.message}")
+      rescue ArgumentError => e
+        # ArgumentError can occur from File.absolute_path or other path operations
+        raise CoverageDataError.new("Invalid path in coverage data: #{e.message}")
+      rescue RuntimeError => e
+        # RuntimeError from find_resultset or other operations
+        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
+
+    def relativize(payload)
+      relativizer.relativize(payload)
+    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 = build_staleness_checker(mode: 'off', tracked_globs: tracked_globs)
+
+      rows = @cov.map do |abs_path, _data|
+        begin
+          coverage_lines = CovUtil.lookup_lines(@cov, abs_path)
+        rescue FileError
+          next
+        end
+
+        s = CovUtil.summary(coverage_lines)
+        stale = stale_checker.stale_for_file?(abs_path, coverage_lines)
+        {
+          'file' => abs_path,
+          'covered' => s['covered'],
+          'total' => s['total'],
+          'percentage' => s['pct'],
+          'stale' => stale
+        }
+      end.compact
+
+      rows = filter_rows_by_globs(rows, tracked_globs)
+
+      if check_stale
+        build_staleness_checker(mode: 'error', tracked_globs: tracked_globs).check_project!(@cov)
+      end
+
+      sort_rows(rows, sort_order: sort_order)
+    end
+
+    def staleness_for(path)
+      file_abs = File.absolute_path(path, @root)
+      coverage_lines = CovUtil.lookup_lines(@cov, file_abs)
+      @checker.stale_for_file?(file_abs, coverage_lines)
+    rescue StandardError => e
+      # Log the error if possible
+      CovUtil.log("Failed to check staleness for #{path}: #{e.message}") rescue nil
+      false
+    end
+
+    # Returns formatted table string for all files coverage data
+    def format_table(rows = nil, sort_order: :ascending, check_stale: !@checker.off?,
+      tracked_globs: nil)
+      rows = prepare_rows(rows, sort_order: sort_order, check_stale: check_stale,
+        tracked_globs: tracked_globs)
+      return 'No coverage data found' if rows.empty?
+
+      widths = compute_table_widths(rows)
+      lines = []
+      lines << border_line(widths, '┌', '┬', '┐')
+      lines << header_row(widths)
+      lines << border_line(widths, '├', '┼', '┤')
+      rows.each { |file_data| lines << data_row(file_data, widths) }
+      lines << border_line(widths, '└', '┴', '┘')
+      lines << summary_counts(rows)
+      if rows.any? { |f| f['stale'] }
+        lines <<
+          'Staleness: M = Missing file, T = Timestamp (source newer), L = Line count mismatch'
+      end
+      lines.join("\n")
+    end
+
+    private
+
+    def build_staleness_checker(mode:, tracked_globs:)
+      StalenessChecker.new(
+        root: @root,
+        resultset: @resultset,
+        mode: mode,
+        tracked_globs: tracked_globs,
+        timestamp: @cov_timestamp
+      )
+    end
+
+    def prepare_rows(rows, sort_order:, check_stale:, tracked_globs:)
+      if rows.nil?
+        all_files(sort_order: sort_order, check_stale: check_stale, tracked_globs: tracked_globs)
+      else
+        rows = sort_rows(rows.dup, sort_order: sort_order)
+        filter_rows_by_globs(rows, tracked_globs)
+      end
+    end
+
+    def sort_rows(rows, sort_order: :ascending)
+      rows.sort do |a, b|
+        pct_cmp = (sort_order == :descending) \
+                    ? (b['percentage'] <=> a['percentage'])
+                    : (a['percentage'] <=> b['percentage'])
+        pct_cmp == 0 ? (a['file'] <=> b['file']) : pct_cmp
+      end
+    end
+
+    def compute_table_widths(rows)
+      max_file_length = rows.map { |f| f['file'].length }.max.to_i
+      file_width = [max_file_length, 'File'.length].max + 2
+      pct_width = 8
+      max_covered = rows.map { |f| f['covered'].to_s.length }.max
+      max_total = rows.map { |f| f['total'].to_s.length }.max
+      covered_width = [max_covered, 'Covered'.length].max + 2
+      total_width = [max_total, 'Total'.length].max + 2
+      stale_width = 'Stale'.length
+      {
+        file: file_width,
+        pct: pct_width,
+        covered: covered_width,
+        total: total_width,
+        stale: stale_width
+      }
+    end
+
+    def border_line(widths, left, middle, right)
+      h_line = ->(col_width) { '─' * (col_width + 2) }
+      left +
+        h_line.call(widths[:file]) +
+        middle + h_line.call(widths[:pct]) +
+        middle + h_line.call(widths[:covered]) +
+        middle + h_line.call(widths[:total]) +
+        middle + h_line.call(widths[:stale]) +
+        right
+    end
+
+    def header_row(widths)
+      sprintf(
+        "│ %-#{widths[:file]}s │ %#{widths[:pct]}s │ %#{widths[:covered]}s │ %#{widths[:total]}s │ %#{widths[:stale]}s │",
+        'File', ' %', 'Covered', 'Total', 'Stale'.center(widths[:stale])
+      )
+    end
+
+    def data_row(file_data, widths)
+      stale_text_str = file_data['stale'] ? file_data['stale'].to_s : ''
+      sprintf(
+        "│ %-#{widths[:file]}s │ %#{widths[:pct] - 1}.2f%% │ %#{widths[:covered]}d │ %#{widths[:total]}d │ %#{widths[:stale]}s │",
+        file_data['file'],
+        file_data['percentage'],
+        file_data['covered'],
+        file_data['total'],
+        stale_text_str.center(widths[:stale])
+      )
+    end
+
+    def summary_counts(rows)
+      total = rows.length
+      stale_count = rows.count { |f| f['stale'] }
+      ok_count = total - stale_count
+      "Files: total #{total}, ok #{ok_count}, stale #{stale_count}"
+    end
+
+    def filter_rows_by_globs(rows, tracked_globs)
+      patterns = Array(tracked_globs).compact.map(&:to_s).reject(&:empty?)
+      return rows if patterns.empty?
+
+      root_pathname = Pathname.new(@root)
+      flags = File::FNM_PATHNAME | File::FNM_EXTGLOB
+
+      rows.select do |row|
+        abs_path = row['file']
+        rel_path = begin
+          Pathname.new(abs_path).relative_path_from(root_pathname).to_s
+        rescue ArgumentError
+          abs_path
+        end
+
+        patterns.any? do |pattern|
+          target = Pathname.new(pattern).absolute? ? abs_path : rel_path
+          File.fnmatch?(pattern, target, flags)
+        end
+      end
+    end
+
+    def resolve(path)
+      file_abs = File.absolute_path(path, @root)
+      begin
+        coverage_lines = CovUtil.lookup_lines(@cov, file_abs)
+      rescue RuntimeError => e
+        raise FileError.new("No coverage data found for file: #{path}")
+      end
+      @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
+
+    # Detailed stale message construction moved to CoverageDataStaleError
+  end
+end

data/lib/simplecov_mcp/option_normalizers.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  # Shared normalization logic for CLI options.
+  # Provides both strict (raise on invalid) and lenient (default on invalid) modes.
+  module OptionNormalizers
+    SORT_ORDER_MAP = {
+      'a' => :ascending,
+      'ascending' => :ascending,
+      'd' => :descending,
+      'descending' => :descending
+    }.freeze
+
+    SOURCE_MODE_MAP = {
+      'f' => :full,
+      'full' => :full,
+      'u' => :uncovered,
+      'uncovered' => :uncovered
+    }.freeze
+
+    STALE_MODE_MAP = {
+      'o' => :off,
+      'off' => :off,
+      'e' => :error,
+      'error' => :error
+    }.freeze
+
+    ERROR_MODE_MAP = {
+      'off' => :off,
+      'on' => :on,
+      't' => :trace,
+      'trace' => :trace
+    }.freeze
+
+    module_function
+
+    # Normalize sort order value.
+    # @param value [String, Symbol] The value to normalize
+    # @param strict [Boolean] If true, raises on invalid value; if false, returns nil
+    # @return [Symbol, nil] The normalized symbol or nil if invalid and not strict
+    # @raise [OptionParser::InvalidArgument] If strict and value is invalid
+    def normalize_sort_order(value, strict: true)
+      normalized = SORT_ORDER_MAP[value.to_s.downcase]
+      return normalized if normalized
+      raise OptionParser::InvalidArgument, "invalid argument: #{value}" if strict
+
+      nil
+    end
+
+    # Normalize source mode value.
+    # @param value [String, Symbol, nil] The value to normalize
+    # @param strict [Boolean] If true, raises on invalid value; if false, returns nil
+    # @return [Symbol, nil] The normalized symbol or nil if invalid and not strict
+    # @raise [OptionParser::InvalidArgument] If strict and value is invalid
+    def normalize_source_mode(value, strict: true)
+      return :full if value.nil? || value == ''
+
+      normalized = SOURCE_MODE_MAP[value.to_s.downcase]
+      return normalized if normalized
+      raise OptionParser::InvalidArgument, "invalid argument: #{value}" if strict
+
+      nil
+    end
+
+    # Normalize stale mode value.
+    # @param value [String, Symbol] The value to normalize
+    # @param strict [Boolean] If true, raises on invalid value; if false, returns nil
+    # @return [Symbol, nil] The normalized symbol or nil if invalid and not strict
+    # @raise [OptionParser::InvalidArgument] If strict and value is invalid
+    def normalize_stale_mode(value, strict: true)
+      normalized = STALE_MODE_MAP[value.to_s.downcase]
+      return normalized if normalized
+      raise OptionParser::InvalidArgument, "invalid argument: #{value}" if strict
+
+      nil
+    end
+
+    # Normalize error mode value.
+    # @param value [String, Symbol, nil] The value to normalize
+    # @param strict [Boolean] If true, raises on invalid value; if false, returns default
+    # @param default [Symbol] The default value to return if invalid and not strict
+    # @return [Symbol] The normalized symbol or default if invalid and not strict
+    # @raise [OptionParser::InvalidArgument] If strict and value is invalid
+    def normalize_error_mode(value, strict: true, default: :on)
+      normalized = ERROR_MODE_MAP[value&.downcase]
+      return normalized if normalized
+      raise OptionParser::InvalidArgument, "invalid argument: #{value}" if strict
+
+      default
+    end
+  end
+end

data/lib/simplecov_mcp/option_parser_builder.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'option_normalizers'
+
+module SimpleCovMcp
+  class OptionParserBuilder
+    HORIZONTAL_RULE = '-' * 79
+    SUBCOMMANDS = %w[list summary raw uncovered detailed version].freeze
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def build_option_parser
+      require 'optparse'
+      OptionParser.new do |o|
+        configure_banner(o)
+        define_subcommands_help(o)
+        define_options(o)
+        define_examples(o)
+        add_help_handler(o)
+      end
+    end
+
+    private
+
+    def configure_banner(o)
+      o.banner = <<~BANNER
+        #{HORIZONTAL_RULE}
+        Usage:      simplecov-mcp [subcommand] [options] [args]
+        Repository: https://github.com/keithrbennett/simplecov-mcp
+        Version:    #{SimpleCovMcp::VERSION}
+        #{HORIZONTAL_RULE}
+
+        BANNER
+    end
+
+    def define_subcommands_help(o)
+      o.separator <<~SUBCOMMANDS
+        Subcommands:
+          list                    Show files coverage (table or --json)
+          summary <path>          Show covered/total/% for a file
+          raw <path>              Show the SimpleCov 'lines' array
+          uncovered <path>        Show uncovered lines and a summary
+          detailed <path>         Show per-line rows with hits/covered
+          version                 Show version information
+
+        SUBCOMMANDS
+    end
+
+    def define_options(o)
+      o.separator 'Options:'
+      o.on('-r', '--resultset PATH', String,
+        'Path or directory that contains .resultset.json (default: coverage/.resultset.json)') \
+      do |v|
+        config.resultset = v
+      end
+      o.on('-R', '--root PATH', String, 'Project root (default: .)') { |v| config.root = v }
+      o.on('-j', '--json', 'Output JSON for machine consumption') { config.json = true }
+      o.on('-o', '--sort-order ORDER', String,
+        'Sort order for list: a[scending]|d[escending] (default ascending)') do |v|
+        config.sort_order = normalize_sort_order(v)
+      end
+      o.on('-s', '--source[=MODE]', String,
+        'Include source (MODE: f[ull]|u[ncovered]; default full)') do |v|
+        config.source_mode = normalize_source_mode(v)
+      end
+      o.on('-c', '--source-context N', Integer,
+        'For --source=uncovered, show N context lines (default: 2)') do |v|
+        config.source_context = v
+      end
+      o.on('--color', 'Enable ANSI colors for source output') { config.color = true }
+      o.on('--no-color', 'Disable ANSI colors') { config.color = false }
+      o.on('-S', '--stale MODE', String,
+        'Staleness mode: o[ff]|e[rror] (default off)') do |v|
+        config.stale_mode = normalize_stale_mode(v)
+      end
+      o.on('-g', '--tracked-globs x,y,z', Array,
+        'Globs for filtering files (list subcommand)') do |v|
+        config.tracked_globs = v
+      end
+      o.on('-l', '--log-file PATH', String,
+        'Log file path (default ./simplecov_mcp.log, use stdout/stderr for streams)') do |v|
+        config.log_file = v
+      end
+      o.on('--error-mode MODE', String,
+        'Error handling mode: off|on|t[trace] (default on)') do |v|
+        config.error_mode = normalize_error_mode(v)
+      end
+      o.on('--force-cli', 'Force CLI mode (useful in scripts where auto-detection fails)') do
+        # This flag is mainly for mode detection - no action needed here
+      end
+      o.on('--success-predicate FILE', String,
+        'Ruby file returning callable; exits 0 if truthy, 1 if falsy') do |v|
+        config.success_predicate = v
+      end
+    end
+
+    def define_examples(o)
+      o.separator <<~EXAMPLES
+
+        Examples:
+          simplecov-mcp list --resultset coverage
+          simplecov-mcp summary lib/foo.rb --json --resultset coverage
+          simplecov-mcp uncovered lib/foo.rb --source=uncovered --source-context 2
+        EXAMPLES
+    end
+
+    def add_help_handler(o)
+      o.on('-h', '--help', 'Show help') do
+        puts o
+        exit 0
+      end
+    end
+
+    def normalize_sort_order(v)
+      OptionNormalizers.normalize_sort_order(v, strict: true)
+    end
+
+    def normalize_source_mode(v)
+      OptionNormalizers.normalize_source_mode(v, strict: true)
+    end
+
+    def normalize_stale_mode(v)
+      OptionNormalizers.normalize_stale_mode(v, strict: true)
+    end
+
+    def normalize_error_mode(v)
+      OptionNormalizers.normalize_error_mode(v, strict: true)
+    end
+  end
+end

data/lib/simplecov_mcp/option_parsers/env_options_parser.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+require_relative '../option_normalizers'
+
+module SimpleCovMcp
+  module OptionParsers
+    class EnvOptionsParser
+      ENV_VAR = 'SIMPLECOV_MCP_OPTS'
+
+      def initialize(env_var: ENV_VAR)
+        @env_var = env_var
+      end
+
+      def parse_env_opts
+        opts_string = ENV[@env_var]
+        return [] unless opts_string && !opts_string.empty?
+
+        begin
+          Shellwords.split(opts_string)
+        rescue ArgumentError => e
+          raise SimpleCovMcp::ConfigurationError, "Invalid #{@env_var} format: #{e.message}"
+        end
+      end
+
+      def pre_scan_error_mode(argv, error_mode_normalizer: method(:normalize_error_mode))
+        # Quick scan for --error-mode to ensure early errors are logged correctly
+        argv.each_with_index do |arg, i|
+          if arg == '--error-mode' && argv[i + 1]
+            return error_mode_normalizer.call(argv[i + 1])
+          elsif arg.start_with?('--error-mode=')
+            value = arg.split('=', 2)[1]
+            return nil if value.to_s.empty?
+            return error_mode_normalizer.call(value) if value
+          end
+        end
+        nil
+      rescue StandardError
+        # Ignore errors during pre-scan; they'll be caught during actual parsing
+        nil
+      end
+
+      private
+
+      def normalize_error_mode(value)
+        OptionNormalizers.normalize_error_mode(value, strict: false, default: :on)
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/option_parsers/error_helper.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  module OptionParsers
+    class ErrorHelper
+      SUBCOMMANDS = %w[list summary raw uncovered detailed version].freeze
+
+      def initialize(subcommands = SUBCOMMANDS)
+        @subcommands = subcommands
+      end
+
+      def handle_option_parser_error(error, argv: [], usage_hint: "Run '#{program_name} --help' for usage information.")
+        message = error.message.to_s
+        # Suggest a subcommand when an invalid option matches a known subcommand
+        option = extract_invalid_option(message)
+
+        if option && option.start_with?('--') && @subcommands.include?(option[2..-1])
+          suggest_subcommand(option)
+        else
+          # Generic message from OptionParser
+          warn "Error: #{message}"
+          # Attempt to derive a helpful hint for enumerated options
+          if (hint = build_enum_value_hint(argv))
+            warn hint
+          end
+        end
+        warn usage_hint
+        exit 1
+      end
+
+      private
+
+      def extract_invalid_option(message)
+        message.match(/invalid option: (.+)/)[1] rescue nil
+      end
+
+      def suggest_subcommand(option)
+        subcommand = option[2..-1]
+        warn "Error: '#{option}' is not a valid option. Did you mean the '#{subcommand}' subcommand?"
+        warn "Try: #{program_name} #{subcommand} [args]"
+      end
+
+      def build_enum_value_hint(argv)
+        rules = enumerated_option_rules
+        tokens = Array(argv)
+        rules.each do |rule|
+          hint = build_hint_for_rule(rule, tokens)
+          return hint if hint
+        end
+        nil
+      end
+
+      def build_hint_for_rule(rule, tokens)
+        switches = rule[:switches]
+        allowed = rule[:values]
+        display = rule[:display] || allowed.join(', ')
+        preferred = switches.find { |s| s.start_with?('--') } || switches.first
+
+        tokens.each_with_index do |tok, i|
+          # --opt=value form
+          if equal_form_match?(tok, switches, preferred)
+            hint = handle_equal_form(tok, switches, preferred, display, allowed)
+            return hint if hint
+          end
+
+          # --opt value or -o value form
+          if switches.include?(tok)
+            hint = handle_space_form(tokens, i, preferred, display, allowed)
+            return hint if hint
+          end
+        end
+        nil
+      end
+
+      def equal_form_match?(token, switches, preferred)
+        token.start_with?(preferred + '=') || switches.any? { |s| token.start_with?(s + '=') }
+      end
+
+      def handle_equal_form(token, switches, preferred, display, allowed)
+        sw = switches.find { |s| token.start_with?(s + '=') } || preferred
+        val = token.split('=', 2)[1]
+        "Valid values for #{sw}: #{display}" if val && !allowed.include?(val)
+      end
+
+      def handle_space_form(tokens, index, preferred, display, allowed)
+        val = tokens[index + 1]
+        # If missing value, provide hint; if present and invalid, also hint
+        if val.nil? || val.start_with?('-') || !allowed.include?(val)
+          "Valid values for #{preferred}: #{display}"
+        end
+      end
+
+      def enumerated_option_rules
+        [
+          { switches: ['-S', '--stale'], values: %w[off o error e], display: 'o[ff]|e[rror]' },
+          { switches: ['-s', '--source'], values: %w[full f uncovered u],
+            display: 'f[ull]|u[ncovered]' },
+          { switches: ['--error-mode'], values: %w[off on trace t], display: 'off|on|t[race]' },
+          { switches: ['-o', '--sort-order'], values: %w[a d ascending descending],
+            display: 'a[scending]|d[escending]' }
+        ]
+      end
+
+      def program_name
+        'simplecov-mcp'
+      end
+    end
+  end
+end