pronto-rubycritic 0.12.0

data/lib/pronto/rubycritic/formatter.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Pronto
+  class RubyCritic < Runner
+    # Chooses output markup based on CI environment. GitHub renders rich
+    # markdown (headings, tables, <details>) in PR review comments; GitLab
+    # does not render <details> reliably in MR / commit comments so plain
+    # markdown is used there.
+    class Formatter
+      GITHUB = :github
+      GITLAB = :gitlab
+      PLAIN  = :plain
+
+      SEVERITY_EMOJI = {
+        info: '💡',
+        warning: '⚠️',
+        error: '🔴',
+        fatal: '🚨'
+      }.freeze
+
+      BRAND_NAME = 'pronto-rubycritic'
+      BRAND_URL  = 'https://github.com/Rishabhs343/custom-pronto-gem'
+
+      def self.detect(env: ENV, severity: :warning)
+        style = if env['GITHUB_ACTIONS'] then GITHUB
+                elsif env['GITLAB_CI']   then GITLAB
+                else PLAIN
+                end
+        new(style: style, severity: severity)
+      end
+
+      def initialize(style: PLAIN, severity: :warning)
+        @style    = style
+        @severity = severity
+      end
+
+      attr_reader :style, :severity
+
+      def call(mod, smell)
+        case @style
+        when GITHUB then format_github(mod, smell)
+        when GITLAB then format_gitlab(mod, smell)
+        else             format_plain(mod, smell)
+        end
+      end
+
+      private
+
+      def format_github(mod, smell)
+        <<~MARKDOWN.strip
+          #{severity_emoji} **#{escape_html(smell.type)}** · `#{escape_html(smell.context)}` <sub>#{analyser_badge(smell)}</sub>
+
+          > #{escape_html(smell.message)}
+
+          <details><summary>📊 Module metrics</summary>
+
+          | Metric | Value |
+          |---|---:|
+          | Complexity  | #{fmt(mod.complexity)} |
+          | Duplication | #{fmt(mod.duplication)} |
+          | Methods     | #{fmt(mod.methods_count)} |
+          | Cost        | #{fmt(mod.cost)} |
+          | Churn       | #{fmt(mod.churn)} |
+
+          </details>
+
+          #{doc_link(smell)}
+
+          <sub>🧰 reported by <a href="#{BRAND_URL}"><b>#{BRAND_NAME}</b></a> · severity: <code>#{@severity}</code></sub>
+        MARKDOWN
+      end
+
+      def format_gitlab(mod, smell)
+        # GitLab MR comments don't render <details> reliably — use a flat
+        # markdown layout that still scans well in GitLab discussion threads.
+        <<~MARKDOWN.strip
+          #{severity_emoji} **#{safe(smell.type)}** · `#{safe(smell.context)}` (_#{analyser_text(smell)}_)
+
+          > #{safe(smell.message)}
+
+          | Complexity | Duplication | Methods | Cost | Churn |
+          |---:|---:|---:|---:|---:|
+          | #{fmt(mod.complexity)} | #{fmt(mod.duplication)} | #{fmt(mod.methods_count)} | #{fmt(mod.cost)} | #{fmt(mod.churn)} |
+
+          #{doc_link(smell)}
+
+          _reported by [**#{BRAND_NAME}**](#{BRAND_URL}) · severity: `#{@severity}`_
+        MARKDOWN
+      end
+
+      def format_plain(mod, smell)
+        doc = doc_url_of(smell)
+        lines = [
+          "[#{@severity}] #{safe(smell.type)} — #{safe(smell.context)} (#{analyser_text(smell)})",
+          "  Message:     #{safe(smell.message)}",
+          "  Locations:   #{format_locations(smell)}",
+          "  Complexity:  #{fmt(mod.complexity)}  Duplication: #{fmt(mod.duplication)}  " \
+          "Methods: #{fmt(mod.methods_count)}  Cost: #{fmt(mod.cost)}  Churn: #{fmt(mod.churn)}"
+        ]
+        lines << "  Docs:        #{doc}" unless doc.nil? || doc.to_s.empty?
+        lines.join("\n")
+      end
+
+      def severity_emoji
+        SEVERITY_EMOJI.fetch(@severity, SEVERITY_EMOJI[:warning])
+      end
+
+      def analyser_badge(smell)
+        "analyser: <code>#{analyser_text(smell)}</code>"
+      end
+
+      def analyser_text(smell)
+        return 'unknown' unless smell.respond_to?(:analyser)
+
+        value = smell.analyser.to_s
+        value.empty? ? 'unknown' : value
+      rescue StandardError
+        'unknown'
+      end
+
+      def doc_link(smell)
+        url = doc_url_of(smell)
+        return '' if url.nil? || url.to_s.empty?
+
+        "📚 [Docs for **#{safe(smell.type)}** →](#{url})"
+      end
+
+      def format_locations(smell)
+        locations = Array(smell.locations)
+        return 'N/A' if locations.empty?
+
+        locations.map { |l| "#{l.pathname}:#{l.line}" }.join(', ')
+      end
+
+      def doc_url_of(smell)
+        smell.respond_to?(:doc_url) ? smell.doc_url : nil
+      rescue StandardError
+        nil
+      end
+
+      def fmt(value)
+        return 'N/A' if value.nil?
+
+        str = value.to_s
+        return 'N/A' if str.empty?
+        return str   unless value.is_a?(Float)
+        return str   if value.nan? || value.infinite?
+
+        format('%.2f', value)
+      end
+
+      def safe(value)
+        return 'N/A' if value.nil?
+
+        str = value.to_s
+        str.empty? ? 'N/A' : str
+      end
+
+      # GitHub renders smell text inside HTML (<details>, <sub>, code spans).
+      # Smell context/message come from analysed source (method names — which
+      # can be operators like `<=>` — and free-text), so escape the HTML-
+      # significant characters to stop them breaking the comment's structure.
+      def escape_html(value)
+        safe(value).gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+      end
+    end
+  end
+end

data/lib/pronto/rubycritic/message_builder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Pronto
+  class RubyCritic < Runner
+    # Builds Pronto::Message objects for smells that overlap with added lines
+    # in the current PR. Uses a pre-computed relative-path index so lookup is
+    # O(1) per smell, not O(N*M) across patches x smells.
+    class MessageBuilder
+      def initialize(runner:, patches:, severity_level:, formatter: nil)
+        @runner         = runner
+        @patches        = patches
+        @severity_level = severity_level
+        @formatter      = formatter || Formatter.detect(severity: severity_level)
+        @patch_index    = build_patch_index(patches)
+      end
+
+      def call(modules)
+        Array(modules).flat_map { |mod| messages_for(mod) }.compact.uniq
+      end
+
+      private
+
+      def messages_for(mod)
+        Array(mod.smells).filter_map do |smell|
+          patch = patch_for_smell(smell)
+          next nil unless patch
+
+          added_line = locate_added_line(patch, smell)
+          next nil unless added_line
+
+          build_message(mod, smell, added_line)
+        end
+      end
+
+      def build_message(mod, smell, line)
+        Pronto::Message.new(
+          line.patch.new_file_path,
+          line,
+          @severity_level,
+          @formatter.call(mod, smell),
+          nil,
+          @runner.class
+        )
+      end
+
+      def build_patch_index(patches)
+        Array(patches).each_with_object({}) do |patch, acc|
+          key = relative(patch.new_file_full_path)
+          acc[key] = patch
+        end
+      end
+
+      def patch_for_smell(smell)
+        loc = Array(smell.locations).first
+        return nil unless loc.respond_to?(:pathname)
+
+        @patch_index[relative(loc.pathname)]
+      end
+
+      def locate_added_line(patch, smell)
+        smell_lines = Array(smell.locations).map(&:line)
+        return nil if smell_lines.empty?
+
+        smell_line_set = Set.new(smell_lines)
+        Array(patch.added_lines).find { |l| smell_line_set.include?(l.new_lineno) }
+      end
+
+      def relative(path)
+        return '' if path.nil?
+
+        pn = path.is_a?(Pathname) ? path : Pathname.new(path.to_s)
+        return pn.to_s unless pn.absolute?
+
+        pn.relative_path_from(Pathname.pwd).to_s
+      rescue ArgumentError
+        pn.to_s
+      end
+    end
+  end
+end

data/lib/pronto/rubycritic/smell_filter.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Pronto
+  class RubyCritic < Runner
+    # Applies user-provided filters from .rubycritic-pronto.yml to the list of
+    # analysed modules. Only implements filters that map to real RubyCritic
+    # attributes. See CHANGELOG for features dropped in 0.12.0 (reek.min_severity).
+    #
+    # Every config value is consumed defensively: a malformed section (non-Hash)
+    # or a wrong-typed value (non-numeric threshold, scalar `exclude`, junk
+    # `max_smells`) is ignored rather than raising. A raise here would be
+    # swallowed by the runner's top-level rescue and silently turn the whole
+    # quality gate into a false "all clear" — the worst failure mode for a linter.
+    class SmellFilter
+      SMELL_FILTER_KEYS = %w[flay flog reek].freeze
+
+      def initialize(config)
+        @config = config.is_a?(Hash) ? config : {}
+      end
+
+      def call(modules)
+        # Fast path: an empty/nil config is semantically transparent — never
+        # mutate input modules, never call mod.smells=. This lets the filter
+        # be chained harmlessly.
+        return Array(modules) if @config.empty?
+
+        Array(modules).filter_map { |mod| filter_module(mod) }
+      end
+
+      private
+
+      def filter_module(mod)
+        return nil unless module_within_thresholds?(mod)
+
+        filtered = filter_smells(Array(mod.smells))
+        return nil if filtered.empty? && any_smell_filter?
+
+        mod.smells = filtered if mod.respond_to?(:smells=)
+        mod
+      end
+
+      def filter_smells(smells)
+        smells = by_analyser_exclude(smells, 'flay')
+        smells = by_analyser_exclude(smells, 'flog')
+        smells = by_analyser_max_score(smells, 'flay')
+        smells = by_analyser_max_score(smells, 'flog')
+        smells = by_reek_smell_types(smells)
+        limited(smells)
+      end
+
+      def module_within_thresholds?(mod)
+        return false if above_threshold?('complexity', mod, :complexity)
+        return false if above_threshold?('churn',      mod, :churn)
+
+        true
+      end
+
+      def above_threshold?(name, mod, attr)
+        # Float(_, exception: false) returns nil for non-numeric config (e.g.
+        # `complexity.max: high`), so a bad value disables the filter instead of
+        # silently coercing to 0.0 (which would drop every module) or raising.
+        max = Float(section(name)['max'], exception: false)
+        return false if max.nil?
+        return false unless mod.respond_to?(attr)
+
+        value = mod.public_send(attr)
+        return false unless value.respond_to?(:to_f)
+
+        value.to_f > max
+      end
+
+      def by_analyser_max_score(smells, analyser)
+        max = Float(section(analyser)['max_score'], exception: false)
+        return smells if max.nil?
+
+        smells.reject do |s|
+          smell_from_analyser?(s, analyser) &&
+            s.respond_to?(:score) && s.score.to_f > max
+        end
+      end
+
+      def by_analyser_exclude(smells, analyser)
+        # Normalise to non-empty glob strings so a scalar (`exclude: '*.rb'`) or
+        # a list with non-string entries never reaches String#any? / fnmatch.
+        patterns = Array(section(analyser)['exclude']).map(&:to_s).reject(&:empty?)
+        return smells if patterns.empty?
+
+        smells.reject do |s|
+          smell_from_analyser?(s, analyser) && matches_any_pattern?(s, patterns)
+        end
+      end
+
+      def by_reek_smell_types(smells)
+        allowed = Array(section('reek')['smell_types']).map(&:to_s).reject(&:empty?)
+        return smells if allowed.empty?
+
+        smells.select do |s|
+          next true unless smell_from_analyser?(s, 'reek')
+
+          allowed.include?(s.type.to_s)
+        end
+      end
+
+      def limited(smells)
+        max = section('reek')['max_smells']
+        return smells if max.nil?
+
+        count = Integer(max, exception: false)
+        return smells if count.nil? || count.negative?
+
+        smells.first(count)
+      end
+
+      # Returns the named config section only when it is a Hash; a scalar/array/
+      # bool value (a plausible YAML typo like `reek: false` or `complexity: 10`)
+      # is treated as "no config for that section" so Hash#dig never raises.
+      def section(name)
+        value = @config[name]
+        value.is_a?(Hash) ? value : {}
+      end
+
+      def smell_from_analyser?(smell, analyser)
+        smell.respond_to?(:analyser) && smell.analyser.to_s == analyser
+      end
+
+      def matches_any_pattern?(smell, patterns)
+        location = Array(smell.locations).first
+        return false unless location.respond_to?(:pathname)
+
+        relative = to_relative(location.pathname.to_s)
+        patterns.any? do |pattern|
+          File.fnmatch(pattern, relative, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+        end
+      end
+
+      def to_relative(path)
+        pn = Pathname.new(path)
+        return path unless pn.absolute?
+
+        pn.relative_path_from(Pathname.pwd).to_s
+      rescue ArgumentError
+        path
+      end
+
+      def any_smell_filter?
+        SMELL_FILTER_KEYS.any? { |k| !section(k).empty? }
+      end
+    end
+  end
+end

data/lib/pronto/rubycritic/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pronto
+  # Version module loaded by the gemspec before Pronto::Runner is available.
+  # A separate module is used (instead of Pronto::RubyCritic::VERSION) because
+  # the main runner class inherits from Pronto::Runner, which is not yet loaded
+  # at gemspec-build time.
+  module RubyCriticVersion
+    VERSION = '0.12.0'
+  end
+end

data/lib/pronto/rubycritic.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Pronto runner for RubyCritic. Analyses Ruby files changed in a PR and reports
+# reek/flay/flog/complexity/churn smells via Pronto::Message — only on lines that
+# were added or modified in the diff.
+
+require 'pronto'
+require 'rubycritic'
+require 'rubycritic/analysers_runner'
+
+require_relative 'rubycritic/version'
+require_relative 'rubycritic/config_loader'
+require_relative 'rubycritic/analyser'
+require_relative 'rubycritic/smell_filter'
+require_relative 'rubycritic/formatter'
+require_relative 'rubycritic/message_builder'
+
+module Pronto
+  class RubyCritic < Runner
+    VERSION        = RubyCriticVersion::VERSION
+    VALID_LEVELS   = %i[info warning error fatal].freeze
+    DEFAULT_LEVEL  = :warning
+    CONFIG_FILE    = '.rubycritic-pronto.yml'
+    SEVERITY_ENV   = 'PRONTO_RUBYCRITIC_SEVERITY_LEVEL'
+    LEGACY_ENV     = 'PRONTO_REEK_SEVERITY_LEVEL'
+    RAISE_ENV      = 'PRONTO_RUBYCRITIC_RAISE_ERRORS'
+    DEBUG_ENV      = 'PRONTO_RUBYCRITIC_DEBUG'
+
+    def run
+      patches = ruby_patches
+      return [] if patches.nil? || patches.empty?
+
+      process(patches)
+    rescue Errno::ENOENT => e
+      handle_missing_file(e)
+      []
+    rescue StandardError => e
+      report_error(e)
+      raise if truthy_env?(RAISE_ENV)
+
+      []
+    end
+
+    private
+
+    # Boolean env vars are opt-in: only 1/true/yes/on enable them. A bare
+    # presence check would treat PRONTO_RUBYCRITIC_RAISE_ERRORS=0 (or =false,
+    # or an empty value) as "on", which is the opposite of what a user setting
+    # it in a CI matrix expects.
+    def truthy_env?(name)
+      %w[1 true yes on].include?(ENV.fetch(name, '').to_s.strip.downcase)
+    end
+
+    def process(patches)
+      modules  = Analyser.new(file_paths).call
+      filtered = SmellFilter.new(runner_config).call(modules)
+      MessageBuilder.new(
+        runner: self,
+        patches: patches,
+        severity_level: severity_level
+      ).call(filtered)
+    end
+
+    # Pronto's ruby_executable? helper does File.read(path, 2) on every
+    # patched path to check for a shebang; when the working tree is missing
+    # a file that's in the diff range, it raises Errno::ENOENT. Translate
+    # that into a human-readable message that points at `git status`.
+    def handle_missing_file(error)
+      warn(
+        'pronto-rubycritic: working tree is missing a file referenced in ' \
+        "the diff: #{error.message}. Run `git status` to reconcile."
+      )
+      raise if truthy_env?(RAISE_ENV)
+    end
+
+    def file_paths
+      @file_paths ||= ruby_patches.map { |p| p.new_file_full_path.to_s }
+    end
+
+    def runner_config
+      @runner_config ||= ConfigLoader.load_runner_config(CONFIG_FILE)
+    end
+
+    def pronto_config
+      @pronto_config ||= ConfigLoader.load_pronto_config
+    end
+
+    def severity_level
+      @severity_level ||= ConfigLoader.resolve_severity(
+        env_value: ENV[SEVERITY_ENV] || legacy_severity_env,
+        pronto_config: pronto_config,
+        valid_levels: VALID_LEVELS,
+        default: DEFAULT_LEVEL
+      )
+    end
+
+    def legacy_severity_env
+      value = ENV.fetch(LEGACY_ENV, nil)
+      return nil if value.nil? || value.to_s.strip.empty?
+
+      warn("pronto-rubycritic: #{LEGACY_ENV} is deprecated; use #{SEVERITY_ENV}.")
+      value
+    end
+
+    def report_error(error)
+      warn("pronto-rubycritic: #{error.class}: #{error.message} " \
+           '(no messages reported for this run)')
+      return unless truthy_env?(DEBUG_ENV)
+
+      warn(Array(error.backtrace).first(10).join("\n"))
+    end
+  end
+end

data/pronto-rubycritic.gemspec

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'pronto/rubycritic/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'pronto-rubycritic'
+  s.version  = Pronto::RubyCriticVersion::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors  = ['Rishabh Singh']
+  s.email    = ['rishabhs343@gmail.com']
+  s.summary  = 'Pronto runner for RubyCritic code quality reports.'
+  s.description = <<~DESC
+    pronto-rubycritic integrates RubyCritic into the Pronto workflow, reporting
+    reek / flay / flog / complexity / churn smells only on lines added or
+    modified in a pull request. Supports configurable per-analyser filters and
+    GitHub/GitLab output formatting.
+  DESC
+  s.homepage = 'https://github.com/Rishabhs343/custom-pronto-gem'
+  s.licenses = ['MIT']
+
+  s.required_ruby_version     = '>= 3.2.2'
+  s.required_rubygems_version = '>= 3.2.3'
+
+  s.metadata = {
+    'homepage_uri' => s.homepage,
+    'source_code_uri' => "#{s.homepage}/tree/main",
+    'bug_tracker_uri' => "#{s.homepage}/issues",
+    'changelog_uri' => "#{s.homepage}/blob/main/CHANGELOG.md",
+    'documentation_uri' => "#{s.homepage}#readme",
+    'rubygems_mfa_required' => 'true'
+  }
+
+  s.files = Dir.chdir(__dir__) do
+    Dir.glob(%w[
+               lib/**/*.rb
+               CHANGELOG.md
+               CONTRIBUTING.md
+               LICENSE
+               README.md
+               pronto-rubycritic.gemspec
+               .rubycritic-pronto.yml
+             ])
+  end
+  s.require_paths    = ['lib']
+  s.extra_rdoc_files = %w[LICENSE README.md CHANGELOG.md]
+
+  # base64 was removed from Ruby's default gems in 3.4. Pronto's transitive
+  # dependency chain (via gitlab 4.20.x → base64) still requires it, so users
+  # on 3.4+ need this gem or they hit LoadError when requiring 'pronto'.
+  s.add_dependency 'base64',     '~> 0.2'
+  s.add_dependency 'pronto',     '>= 0.11', '< 2.0'
+  s.add_dependency 'rubycritic', '>= 4.9',  '< 6.0'
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: pronto-rubycritic
+version: !ruby/object:Gem::Version
+  version: 0.12.0
+platform: ruby
+authors:
+- Rishabh Singh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: pronto
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.11'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.11'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rubycritic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: |
+  pronto-rubycritic integrates RubyCritic into the Pronto workflow, reporting
+  reek / flay / flog / complexity / churn smells only on lines added or
+  modified in a pull request. Supports configurable per-analyser filters and
+  GitHub/GitLab output formatting.
+email:
+- rishabhs343@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+- CHANGELOG.md
+files:
+- ".rubycritic-pronto.yml"
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
+- README.md
+- lib/pronto/rubycritic.rb
+- lib/pronto/rubycritic/analyser.rb
+- lib/pronto/rubycritic/config_loader.rb
+- lib/pronto/rubycritic/formatter.rb
+- lib/pronto/rubycritic/message_builder.rb
+- lib/pronto/rubycritic/smell_filter.rb
+- lib/pronto/rubycritic/version.rb
+- pronto-rubycritic.gemspec
+homepage: https://github.com/Rishabhs343/custom-pronto-gem
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Rishabhs343/custom-pronto-gem
+  source_code_uri: https://github.com/Rishabhs343/custom-pronto-gem/tree/main
+  bug_tracker_uri: https://github.com/Rishabhs343/custom-pronto-gem/issues
+  changelog_uri: https://github.com/Rishabhs343/custom-pronto-gem/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/Rishabhs343/custom-pronto-gem#readme
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.3
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Pronto runner for RubyCritic code quality reports.
+test_files: []