quality_gate 0.2.1 → 0.3.0

data/lib/quality_gate/adapters/database_consistency_report_item.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module QualityGate
+  module Adapters
+    # Validates one database_consistency report before mapping it to a finding.
+    class DatabaseConsistencyReportItem
+      FIELDS = %w[
+        checker_name table_or_model_name column_or_attribute_name status error_slug error_message
+      ].freeze
+      LOCATION = /\A(.+):([0-9]+)\z/
+      SEVERITIES = { "fail" => :error, "warning" => :warning }.freeze
+      private_constant :FIELDS, :LOCATION, :SEVERITIES
+
+      def initialize(report)
+        @report = report
+      end
+
+      def finding
+        validate!
+        return if @report.fetch("status") == "ok"
+
+        Finding.new(**attributes)
+      end
+
+      private
+
+      def validate!
+        invalid!("report must be an object") unless @report.is_a?(Hash)
+        validate_fields!
+        validate_values!
+      end
+
+      def validate_fields!
+        FIELDS.each { invalid!("report must include #{_1}") unless @report.key?(_1) }
+      end
+
+      def validate_values!
+        validate_names!
+        validate_status!
+        validate_message!
+        validate_location!
+      end
+
+      def validate_names!
+        string!(@report.fetch("checker_name"), "checker_name")
+        nullable_string!(@report.fetch("table_or_model_name"), "table_or_model_name")
+        nullable_string!(@report.fetch("column_or_attribute_name"), "column_or_attribute_name")
+      end
+
+      def validate_status!
+        status = @report.fetch("status")
+        return if status == "ok" || SEVERITIES.key?(status)
+
+        invalid!("status must be ok, fail, or warning")
+      end
+
+      def validate_message!
+        nullable_string!(@report.fetch("error_slug"), "error_slug")
+        nullable_string!(@report.fetch("error_message"), "error_message")
+        return if @report.fetch("status") == "ok" || usable_message?
+
+        invalid!("finding requires a non-empty error_message or error_slug")
+      end
+
+      def usable_message?
+        %w[error_message error_slug].any? { !@report.fetch(_1).to_s.strip.empty? }
+      end
+
+      def validate_location!
+        value = @report.fetch("source_location", nil)
+        return if value.nil?
+        return if value.is_a?(String) && (match = LOCATION.match(value)) && Integer(match[2], 10).positive?
+
+        invalid!("source_location must be nil or a path followed by a positive line number")
+      end
+
+      def attributes
+        file, line = location
+        {
+          tool: "database_consistency", file:, line:, rule: @report.fetch("checker_name"),
+          severity: SEVERITIES.fetch(@report.fetch("status")), message: message
+        }
+      end
+
+      def location
+        value = @report.fetch("source_location", nil)
+        return ["", 0] unless value
+
+        match = LOCATION.match(value)
+        [match[1], Integer(match[2], 10)]
+      end
+
+      def message
+        context = [@report.fetch("table_or_model_name"), @report.fetch("column_or_attribute_name")]
+                  .compact.reject { _1.strip.empty? }
+        detail = error_detail
+        context.empty? ? detail : "#{context.join(" ")}: #{detail}"
+      end
+
+      def error_detail
+        message = @report.fetch("error_message")
+        return message unless message.nil? || message.strip.empty?
+
+        @report.fetch("error_slug").tr("_", " ").strip
+      end
+
+      def string!(value, field)
+        invalid!("#{field} must be a non-empty string") unless value.is_a?(String) && !value.strip.empty?
+      end
+
+      def nullable_string!(value, field)
+        invalid!("#{field} must be a string or nil") unless value.nil? || value.is_a?(String)
+      end
+
+      def invalid!(reason)
+        raise ParseError.new(tool: "database_consistency", reason: reason)
+      end
+    end
+
+    private_constant :DatabaseConsistencyReportItem
+  end
+end

data/lib/quality_gate/adapters/debride.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "debride_report"
+
+module QualityGate
+  module Adapters
+    # Runs Debride project-wide and reports possible unused methods as warnings.
+    class Debride < Adapter
+      DEFAULT_LAUNCHER = ["debride"].freeze
+      private_constant :DEFAULT_LAUNCHER
+
+      def name = "debride"
+
+      def command
+        launcher = config.fetch(:commands).fetch(:deep, {}).fetch(:debride, DEFAULT_LAUNCHER)
+        launcher.dup.concat(["--json", "."])
+      end
+
+      def call = run_safely(name)
+
+      def parse(stdout)
+        DebrideReport.new(stdout).findings
+      rescue JSON::ParserError, KeyError, TypeError, ArgumentError => e
+        raise ParseError.new(tool: name, reason: e.message)
+      end
+
+      private
+
+      def run_safely(tool)
+        stderr = +""
+        execute { stderr = _1 }
+      rescue StandardError => e
+        [failure_finding(tool, e, stderr)]
+      end
+
+      def execute
+        stdout, stderr, status = capture(validated_command, resolved_timeout(name))
+        yield stderr
+        validate_process!(status, stderr)
+        normalize(stdout)
+      end
+
+      def normalize(stdout)
+        findings = parse(stdout)
+        validate_findings!(findings, expected_tool: name)
+        findings
+      end
+
+      def validate_process!(status, stderr)
+        validate_successful_exit!(status)
+        validate_stderr!(stderr)
+      end
+
+      def validate_successful_exit!(status)
+        return if status&.exited? && status.exitstatus.zero?
+
+        raise ParseError.new(tool: name, reason: "process did not exit normally with status 0")
+      end
+
+      def validate_stderr!(stderr)
+        return if stderr.strip.empty?
+
+        raise ParseError.new(tool: name, reason: "process wrote diagnostics to stderr")
+      end
+    end
+  end
+end

data/lib/quality_gate/adapters/debride_report.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "json"
+
+module QualityGate
+  module Adapters
+    # Validates Debride's JSON report before converting candidates into findings.
+    class DebrideReport
+      LOCATION = /\A(.+):([1-9]\d*)(?:-([1-9]\d*))?\z/
+      private_constant :LOCATION
+
+      def initialize(json)
+        @report = JSON.parse(json)
+      end
+
+      def findings
+        validate_report!
+        @report.fetch("missing").flat_map { |scope, candidates| scope_findings(scope, candidates) }
+      end
+
+      private
+
+      def validate_report!
+        raise TypeError, "report must be a JSON object" unless @report.is_a?(Hash)
+        raise TypeError, "missing must be a JSON object" unless @report.fetch("missing").is_a?(Hash)
+      end
+
+      def scope_findings(scope, candidates)
+        require_string!(scope, "scope")
+        raise TypeError, "candidates must be an array" unless candidates.is_a?(Array)
+
+        candidates.map { |candidate| candidate_finding(scope, candidate) }
+      end
+
+      def candidate_finding(scope, candidate)
+        validate_candidate!(candidate)
+        method, location = candidate
+        file, line = parse_location(location)
+        build_finding(scope, method, file, line)
+      end
+
+      def validate_candidate!(candidate)
+        unless candidate.is_a?(Array) && candidate.length == 2
+          raise TypeError, "candidate must be a [name, location] pair"
+        end
+
+        require_string!(candidate.fetch(0), "candidate name")
+        require_string!(candidate.fetch(1), "candidate location")
+      end
+
+      def parse_location(location)
+        match = LOCATION.match(location)
+        raise ArgumentError, "invalid candidate location #{location.inspect}" unless match
+
+        first = Integer(match[2], 10)
+        validate_range!(first, match[3])
+        [match[1], first]
+      end
+
+      def validate_range!(first, last_text)
+        return unless last_text
+
+        raise ArgumentError, "candidate line range is reversed" if Integer(last_text, 10) < first
+      end
+
+      def build_finding(scope, method, file, line)
+        Finding.new(
+          tool: "debride", file:, line:, rule: "potentially_unused_method", severity: :warning,
+          message: "#{scope}: #{method} is potentially unused"
+        )
+      end
+
+      def require_string!(value, label)
+        raise TypeError, "#{label} must be a non-empty String" unless value.is_a?(String) && !value.empty?
+      end
+    end
+
+    private_constant :DebrideReport
+  end
+end

data/lib/quality_gate/adapters/herb.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require "json"
+
+module QualityGate
+  module Adapters
+    class HerbReport
+      SEVERITIES = { "error" => :error, "warning" => :warning, "info" => :info, "hint" => :info }.freeze
+
+      def self.validate_status!(status, findings)
+        validate_normal_exit!(status)
+        validate_exit_findings!(status, findings)
+      end
+
+      def self.validate_normal_exit!(status)
+        return if status&.exited? && [0, 1].include?(status.exitstatus)
+
+        raise ParseError.new(tool: "herb", reason: "process did not exit normally with status 0 or 1")
+      end
+
+      def self.validate_exit_findings!(status, findings)
+        valid = status.exitstatus.zero? ? findings.none? { _1.severity == :error } : findings.any?
+        return if valid
+
+        raise ParseError.new(tool: "herb", reason: "exit status #{status.exitstatus} conflicts with the report")
+      end
+
+      def initialize(report)
+        @report = report
+      end
+
+      def parse
+        validate_envelope!
+        offenses = @report.fetch("offenses")
+        findings = build_findings(offenses)
+        HerbSummary.validate!(@report.fetch("summary"), offenses, @report.fetch("clean"))
+        findings
+      end
+
+      private
+
+      def validate_envelope!
+        raise TypeError, "report must be a JSON object" unless @report.is_a?(Hash)
+        raise TypeError, "completed must be true" unless @report.fetch("completed") == true
+        raise TypeError, "clean must be a Boolean" unless [true, false].include?(@report.fetch("clean"))
+      end
+
+      def build_findings(offenses)
+        raise TypeError, "offenses must be an array" unless offenses.is_a?(Array)
+
+        offenses.map { build_finding(_1) }
+      end
+
+      def build_finding(offense)
+        raise TypeError, "offense must be an object" unless offense.is_a?(Hash)
+
+        Finding.new(tool: "herb", **finding_attributes(offense))
+      end
+
+      def finding_attributes(offense)
+        offense_identity(offense).merge(offense_location(offense)).merge(offense_severity(offense))
+      end
+
+      def offense_identity(offense)
+        { file: required_string(offense.fetch("filename"), "filename"),
+          rule: required_string(offense.fetch("code"), "code"),
+          message: offense_message(offense.fetch("message")) }
+      end
+
+      def offense_location(offense)
+        location = offense.fetch("location")
+        raise TypeError, "location must be an object" unless location.is_a?(Hash)
+
+        start = location.fetch("start")
+        raise TypeError, "location start must be an object" unless start.is_a?(Hash)
+
+        { line: positive_line(start.fetch("line")) }
+      end
+
+      def offense_severity(offense)
+        { severity: SEVERITIES.fetch(offense.fetch("severity")) }
+      end
+
+      def required_string(value, field)
+        return value if value.is_a?(String) && !value.empty?
+
+        raise TypeError, "#{field} must be a non-empty String"
+      end
+
+      def positive_line(value)
+        return value if value.is_a?(Integer) && value.positive?
+
+        raise TypeError, "line must be a positive Integer"
+      end
+
+      def offense_message(value)
+        return value if value.is_a?(String)
+
+        raise TypeError, "message must be a String"
+      end
+    end
+    private_constant :HerbReport
+
+    class HerbSummary
+      def self.validate!(summary, offenses, clean)
+        validate_summary_object!(summary)
+        counts = offenses.map { _1.fetch("severity") }.tally
+        validate_error_counts!(summary, counts)
+        validate_other_counts!(summary, counts)
+        validate_clean!(counts, clean)
+      end
+
+      def self.validate_summary_object!(summary)
+        raise TypeError, "summary must be an object" unless summary.is_a?(Hash)
+      end
+
+      def self.validate_clean!(counts, clean)
+        actionable = counts.fetch("error", 0) + counts.fetch("warning", 0)
+        raise TypeError, "clean does not match offense summary" unless clean == actionable.zero?
+      end
+
+      def self.validate_error_counts!(summary, counts)
+        errors = counts.fetch("error", 0)
+        warnings = counts.fetch("warning", 0)
+        validate_count!(summary, "totalErrors", errors)
+        validate_count!(summary, "totalWarnings", warnings)
+        validate_count!(summary, "totalOffenses", errors + warnings)
+      end
+
+      def self.validate_other_counts!(summary, counts)
+        validate_optional_count!(summary, "totalInfo", counts.fetch("info", 0))
+        validate_optional_count!(summary, "totalHints", counts.fetch("hint", 0))
+        validate_optional_count!(summary, "totalNotReported", 0)
+      end
+
+      def self.validate_count!(summary, key, expected)
+        return if valid_count?(summary.fetch(key), expected)
+
+        raise TypeError, "summary #{key} does not match offenses"
+      end
+
+      def self.validate_optional_count!(summary, key, expected)
+        return unless summary.key?(key)
+
+        validate_count!(summary, key, expected)
+      end
+
+      def self.valid_count?(value, expected)
+        value.is_a?(Integer) && value >= 0 && value == expected
+      end
+    end
+    private_constant :HerbSummary
+
+    class HerbExcludedSelection
+      PREFIX = "⚠️  File "
+      SUFFIX = " is excluded by configuration patterns."
+      INSTRUCTIONS = "   Use --force to lint it anyway."
+
+      def self.paths(stdout:, stderr:, status:, requested_paths:)
+        new(stdout:, stderr:, status:, requested_paths:).paths
+      end
+
+      def initialize(stdout:, stderr:, status:, requested_paths:)
+        @stdout = stdout
+        @stderr = stderr
+        @status = status
+        @requested_paths = requested_paths
+      end
+
+      def paths
+        return unless intentional_skip?
+
+        skipped = diagnostic_paths
+        return unless skipped.any? && skipped.uniq == skipped && skipped.all? { selected_files.include?(_1) }
+
+        skipped
+      end
+
+      private
+
+      def intentional_skip?
+        @stdout.empty? && @status&.exited? && @status.exitstatus.zero? && @stderr.end_with?("\n\n")
+      end
+
+      def diagnostic_paths
+        blocks = @stderr.split("\n\n", -1)
+        blocks[0...-1].map { excluded_path(_1) }
+      end
+
+      def excluded_path(block)
+        lines = block.lines(chomp: true)
+        return unless lines.length == 2 && lines.last == INSTRUCTIONS
+
+        first = lines.first
+        return unless first.start_with?(PREFIX) && first.end_with?(SUFFIX)
+
+        first.delete_prefix(PREFIX).delete_suffix(SUFFIX)
+      end
+
+      def selected_files
+        @requested_paths.select { File.file?(_1) && File.extname(_1).downcase == ".erb" }
+      end
+    end
+    private_constant :HerbExcludedSelection
+
+    # Runs the optional Herb CLI and validates its structured ERB lint report.
+    class Herb < Adapter
+      CLI_FLAGS = %w[--json --no-github --no-timing --log-level hint].freeze
+      private_constant :CLI_FLAGS
+
+      def name = "herb"
+
+      def command = command_for(resolved_paths)
+
+      def call
+        scan_selected_paths
+      rescue StandardError => e
+        [failure_finding(name, e, "")]
+      end
+
+      def parse(stdout)
+        report = JSON.parse(stdout)
+        HerbReport.new(report).parse
+      rescue JSON::ParserError, KeyError, TypeError, ArgumentError => e
+        raise ParseError.new(tool: name, reason: e.message)
+      end
+
+      private
+
+      def scan_selected_paths
+        paths = resolved_paths.dup
+        return [] if files.any? && paths.empty?
+
+        scan(paths)
+      end
+
+      def scan(paths)
+        deadline = monotonic_deadline(resolved_timeout(name))
+        scan_until_complete(paths, deadline)
+      end
+
+      def scan_until_complete(paths, deadline)
+        loop do
+          result = scan_iteration(paths, deadline)
+          return result.fetch(:findings) if result.key?(:findings)
+          return [] if (paths = result.fetch(:paths)).empty?
+        end
+      end
+
+      def scan_iteration(paths, deadline)
+        stdout, stderr, status = capture_scan(paths, deadline)
+        iteration_result(paths, stdout, stderr, status)
+      rescue StandardError => e
+        { findings: [failure_finding(name, e, stderr)] }
+      end
+
+      def iteration_result(paths, stdout, stderr, status)
+        excluded = excluded_paths(stdout, stderr, status, paths)
+        return { paths: paths - excluded } if excluded
+
+        { findings: findings_for(stdout, status) }
+      end
+
+      def capture_scan(paths, deadline)
+        remaining = remaining_before(deadline)
+        raise ParseError.new(tool: name, reason: "timeout during exclusion retry") unless remaining.positive?
+
+        capture(command_for(paths), remaining)
+      end
+
+      def excluded_paths(stdout, stderr, status, paths)
+        HerbExcludedSelection.paths(stdout:, stderr:, status:, requested_paths: paths)
+      end
+
+      def findings_for(stdout, status)
+        findings = parse(stdout)
+        validate_findings!(findings, expected_tool: name)
+        HerbReport.validate_status!(status, findings)
+        findings
+      end
+
+      def command_for(paths)
+        argv = configured_launcher + CLI_FLAGS
+        argv.concat(paths.empty? && files.empty? ? ["."] : paths)
+      end
+
+      def configured_launcher
+        config.fetch(:commands).fetch(:fast).fetch(:herb, ["herb-lint"])
+      end
+
+      def resolved_paths
+        files.filter_map { existing_herb_path(_1) }.freeze
+      end
+
+      def existing_herb_path(path)
+        return unless File.exist?(path)
+        return if File.file?(path) && File.extname(path).downcase != ".erb"
+
+        path.start_with?("-") ? File.join(".", path) : path
+      end
+    end
+  end
+end

data/lib/quality_gate/adapters/reek.rb

@@ -38,7 +38,8 @@ module QualityGate
       def command
         argv = ["reek", "--format", "json"]
         argv.concat(["--config", CONFIG_PATH]) unless host_config?
-        argv.concat(resolved_paths_for_command)
+        paths = resolved_paths_for_command
+        argv.concat(paths.empty? && files.empty? ? ["."] : paths)
       end
 
       def parse(stdout)
@@ -52,8 +53,26 @@ module QualityGate
 
       private
 
+      def capture(*arguments, **options)
+        output = super(*arguments, **options)
+        validate_run!(output.last, output.fetch(1))
+        output
+      end
+
+      def validate_run!(status, stderr)
+        code = status.exitstatus
+        raise Error, "unsupported Reek exit status #{code || "unknown"}" unless [0, 2].include?(code)
+
+        raise Error, "source cannot be processed by Reek" if stderr.include?("cannot be processed by Reek")
+      end
+
       def existing_paths
-        files.filter_map { |path| positional_path(path) if File.exist?(path) }.freeze
+        files.filter_map do |path|
+          next unless File.exist?(path)
+          next if File.file?(path) && File.extname(path).downcase == ".erb"
+
+          positional_path(path)
+        end.freeze
       end
 
       def positional_path(path) = path.start_with?("-") ? File.join(".", path) : path

data/lib/quality_gate/adapters/rubocop.rb

@@ -5,8 +5,22 @@ require "pathname"
 
 module QualityGate
   module Adapters
+    module RuboCopProcessStatus
+      private
+
+      def capture(*arguments, **options)
+        output = super(*arguments, **options)
+        code = output.last.exitstatus
+        raise Error, "unsupported RuboCop exit status #{code || "unknown"}" unless [0, 1].include?(code)
+
+        output
+      end
+    end
+    private_constant :RuboCopProcessStatus
+
     # Runs RuboCop with project-aware configuration and normalizes its JSON report.
     class RuboCop < Adapter
+      include RuboCopProcessStatus
       SEVERITY_MAP = {
         "info" => :info,
         "refactor" => :info,
@@ -57,7 +71,9 @@ module QualityGate
       end
 
       def parse(stdout)
-        report = parse_report(stdout)
+        report = JSON.parse(stdout)
+        raise TypeError, "report must be a JSON object" unless report.is_a?(Hash)
+
         parse_files(report.fetch("files"))
       rescue JSON::ParserError, KeyError, TypeError, ArgumentError => e
         raise ParseError.new(tool: name, reason: e.message)
@@ -66,7 +82,12 @@ module QualityGate
       private
 
       def existing_paths
-        files.filter_map { |path| positional_path(path) if File.exist?(path) }.freeze
+        files.filter_map do |path|
+          next unless File.exist?(path)
+          next if File.file?(path) && File.extname(path).downcase == ".erb"
+
+          positional_path(path)
+        end.freeze
       end
 
       def positional_path(path) = path.start_with?("-") ? File.join(".", path) : path
@@ -96,13 +117,6 @@ module QualityGate
 
       def resolved_paths_for_command = @resolved_paths_for_call || existing_paths
 
-      def parse_report(stdout)
-        report = JSON.parse(stdout)
-        raise TypeError, "report must be a JSON object" unless report.is_a?(Hash)
-
-        report
-      end
-
       def parse_files(entries)
         raise TypeError, "files must be an array" unless entries.is_a?(Array)