rubocop-metz 0.5.2

data/lib/metz_scan/commands/scan/auto_fix.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "open3"
+require "stringio"
+require "tempfile"
+
+module MetzScan
+  module Commands
+    class Scan
+      class AutoFix
+        SAFE_FLAG = "-a"
+        UNSAFE_FLAG = "-A"
+        CommandResult = Struct.new(:status, :stdout, :stderr, keyword_init: true)
+
+        def initialize(stdout:, stderr:)
+          @stdout = stdout
+          @stderr = stderr
+        end
+
+        def run(options)
+          require "rubocop-metz"
+          options.dry_run ? run_dry(options) : run_in_place(options)
+        end
+
+        private
+
+        attr_reader :stdout, :stderr
+
+        def run_in_place(options)
+          with_redirected_io { RuboCop::CLI.new.run(rubocop_argv(options)) }
+        end
+
+        def with_redirected_io
+          previous = redirect_to(stdout, stderr)
+          yield
+        ensure
+          restore_io(previous) if previous
+        end
+
+        def redirect_to(out, err)
+          previous = [$stdout, $stderr]
+          $stdout = out
+          $stderr = err
+          previous
+        end
+
+        def restore_io(previous)
+          $stdout = previous[0]
+          $stderr = previous[1]
+        end
+
+        def run_dry(options)
+          snapshot = capture_files(options.paths)
+          dry_run_result(snapshot, capture_rubocop(rubocop_argv(options)))
+        ensure
+          restore_files(snapshot)
+        end
+
+        def dry_run_result(snapshot, result)
+          print_diffs(snapshot)
+          print_rubocop_failure(result) unless result.status.zero?
+          result.status
+        end
+
+        def rubocop_argv(options)
+          flag = options.unsafe ? UNSAFE_FLAG : SAFE_FLAG
+          ["--plugin", "rubocop-metz", *Runner.cop_selection_argv(options.all_cops), flag, *options.paths]
+        end
+
+        def capture_rubocop(argv)
+          out = StringIO.new
+          err = StringIO.new
+          status = with_captured_io(out, err) { RuboCop::CLI.new.run(argv) }
+          CommandResult.new(status: status, stdout: out.string, stderr: err.string)
+        end
+
+        def with_captured_io(out, err)
+          previous = redirect_to(out, err)
+          yield
+        ensure
+          restore_io(previous) if previous
+        end
+
+        def capture_files(paths)
+          files_under(paths).to_h { |path| [path, File.binread(path)] }
+        end
+
+        def files_under(paths)
+          paths.flat_map { |path| File.directory?(path) ? regular_files_in(path) : [path] }
+        end
+
+        def regular_files_in(dir)
+          Dir.glob(File.join(dir, "**/*")).select { |entry| File.file?(entry) }
+        end
+
+        def print_diffs(snapshot)
+          snapshot.each { |path, original| print_file_diff(path, original) }
+        end
+
+        def print_rubocop_failure(result)
+          stderr.print(result.stderr) unless result.stderr.empty?
+          stderr.print(result.stdout) unless result.stdout.empty?
+        end
+
+        def print_file_diff(path, original)
+          return unless File.exist?(path)
+          return if File.binread(path) == original
+
+          stdout.puts diff_against(path, original)
+        end
+
+        def diff_against(path, original)
+          Tempfile.create(["metz-orig-", File.basename(path)]) do |orig|
+            write_tempfile(orig, original)
+            run_diff(orig.path, path)
+          end
+        end
+
+        def write_tempfile(file, content)
+          file.binmode
+          file.write(content)
+          file.flush
+        end
+
+        def run_diff(orig_path, new_path)
+          labels = ["--label", "a/#{new_path}", "--label", "b/#{new_path}"]
+          Open3.capture3("diff", "-u", *labels, orig_path, new_path).first
+        end
+
+        def restore_files(snapshot)
+          return unless snapshot
+
+          snapshot.each { |path, content| File.binwrite(path, content) }
+        end
+      end
+    end
+  end
+end

data/lib/metz_scan/commands/scan/compliance_scorecard.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module MetzScan
+  module Commands
+    class Scan
+      class ComplianceScorecard
+        RULE_COP_PREFIX = "Metz/"
+        TOP_FILE_LIMIT = 5
+
+        def self.add_to_summary!(parsed)
+          new(parsed).add_to_summary!
+        end
+
+        def initialize(parsed)
+          @parsed = parsed
+        end
+
+        def add_to_summary!
+          writable_summary["clean_file_count"] = clean_file_count
+          writable_summary["files_with_offenses"] = files_with_rule_offenses
+          writable_summary["offenses_by_cop"] = offenses_by_cop
+          parsed
+        end
+
+        def lines
+          ["Summary", "-------", compliance_line, *offense_summary_lines]
+        end
+
+        private
+
+        attr_reader :parsed
+
+        def offense_summary_lines
+          return ["No offenses found."] if offense_count.zero?
+
+          [offense_total_line, "", "By cop:", *formatted_rows(sorted_cop_counts), "",
+           "Most offenses:", *formatted_rows(top_file_counts)]
+        end
+
+        def compliance_line
+          return "Metz compliance: n/a (no files scanned)" if inspected_file_count.zero?
+
+          "Metz compliance: #{compliance_percentage}% (#{clean_file_count}/#{inspected_file_count} files clean)"
+        end
+
+        def compliance_percentage
+          ((clean_file_count.to_f / inspected_file_count) * 100).round
+        end
+
+        def clean_file_count
+          inspected_file_count - files_with_rule_offenses
+        end
+
+        def files_with_rule_offenses
+          files.count { |file| rule_offenses?(file) }
+        end
+
+        def rule_offenses?(file)
+          Array(file["offenses"]).any? { |offense| offense.fetch("cop_name").start_with?(RULE_COP_PREFIX) }
+        end
+
+        def offense_total_line
+          "#{count_label(offense_count, 'offense')} across #{count_label(sorted_cop_counts.size, 'cop')}"
+        end
+
+        def offense_count
+          offenses_by_cop.values.sum
+        end
+
+        def offenses_by_cop
+          @offenses_by_cop ||= sorted_cop_counts.to_h
+        end
+
+        def sorted_cop_counts
+          @sorted_cop_counts ||= cop_counts.sort_by { |cop_name, count| [-count, cop_name] }
+        end
+
+        def cop_counts
+          offenses.each_with_object(Hash.new(0)) { |offense, counts| counts[offense.fetch("cop_name")] += 1 }
+        end
+
+        def top_file_counts
+          file_counts.sort_by { |path, count| [-count, path] }.first(TOP_FILE_LIMIT)
+        end
+
+        def file_counts
+          files.filter_map do |file|
+            count = Array(file["offenses"]).size
+            [file.fetch("path"), count] if count.positive?
+          end
+        end
+
+        def formatted_rows(rows)
+          width = rows.map { |label, _count| label.length }.max
+          rows.map { |label, count| "  #{label.ljust(width)}  #{count}" }
+        end
+
+        def count_label(count, noun)
+          "#{count} #{noun}#{'s' unless count == 1}"
+        end
+
+        def offenses
+          @offenses ||= files.flat_map { |file| Array(file["offenses"]) }
+        end
+
+        def files
+          @files ||= Array(parsed["files"])
+        end
+
+        def inspected_file_count
+          @inspected_file_count ||= summary.fetch("inspected_file_count", files.size).to_i
+        end
+
+        def summary
+          @summary ||= parsed.fetch("summary", {}) || {}
+        end
+
+        def writable_summary
+          parsed["summary"] ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/metz_scan/commands/scan/github_annotations_renderer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "offense_extractor"
+require_relative "project_analyzer_triage_formatter"
+
+module MetzScan
+  module Commands
+    class Scan
+      class GithubAnnotationsRenderer
+        ERROR_SEVERITIES = %w[error fatal].freeze
+
+        def initialize(stdout, parsed)
+          @stdout = stdout
+          @parsed = parsed
+        end
+
+        def render
+          OffenseExtractor.offenses(@parsed).each { |offense| stdout.puts annotation_for(offense) }
+        end
+
+        private
+
+        attr_reader :stdout
+
+        def annotation_for(offense)
+          "::#{level_for(offense)} #{properties_for(offense)}::#{escape_data(message_for(offense))}"
+        end
+
+        def level_for(offense)
+          ERROR_SEVERITIES.include?(offense[:severity].to_s) ? "error" : "warning"
+        end
+
+        def properties_for(offense)
+          annotation_properties(offense).map { |key, value| "#{key}=#{escape_property(value)}" }.join(",")
+        end
+
+        def annotation_properties(offense)
+          { file: offense[:path], line: offense[:line], col: offense[:column], title: offense[:cop_name] }.compact
+        end
+
+        def message_for(offense)
+          [offense[:message], ProjectAnalyzerTriageFormatter.line(offense[:project_analyzer])].compact.join("\n")
+        end
+
+        def escape_property(value)
+          escape_data(value).gsub(":", "%3A").gsub(",", "%2C")
+        end
+
+        def escape_data(value)
+          value.to_s.gsub("%", "%25").gsub("\r", "%0D").gsub("\n", "%0A")
+        end
+      end
+    end
+  end
+end

data/lib/metz_scan/commands/scan/offense_extractor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MetzScan
+  module Commands
+    class Scan
+      module OffenseExtractor
+        module_function
+
+        def offenses(parsed)
+          Array(parsed["files"]).flat_map { |file| file_offenses(file) }
+        end
+
+        def file_offenses(file)
+          Array(file["offenses"]).map { |o| offense_struct(file["path"], o) }
+        end
+
+        def offense_struct(path, offense)
+          loc = offense["location"] || {}
+          base_offense(path, offense).merge(location_fields(loc))
+        end
+
+        def base_offense(path, offense)
+          { path: path, cop_name: offense["cop_name"], severity: offense["severity"],
+            message: offense["message"], why_it_matters: offense["why_it_matters"],
+            project_analyzer: offense["project_analyzer"] }
+        end
+
+        def location_fields(location)
+          { line: location_value(location, "start_line", "line"),
+            column: location_value(location, "start_column", "column") }
+        end
+
+        def location_value(location, primary_key, fallback_key)
+          return location[primary_key] if location.key?(primary_key)
+          return location[fallback_key] if location.key?(fallback_key)
+
+          raise KeyError, "RuboCop JSON location missing #{primary_key}/#{fallback_key}"
+        end
+      end
+    end
+  end
+end

data/lib/metz_scan/commands/scan/project_analyzer_breakdown.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module MetzScan
+  module Commands
+    class Scan
+      class ProjectAnalyzerBreakdown
+        def initialize(findings)
+          @findings = findings
+        end
+
+        def to_h
+          { "cop_name" => breakdown_for(&:rule_id),
+            "confidence" => breakdown_for { |finding| optional_value(finding, :confidence) },
+            "triage_severity" => breakdown_for { |finding| optional_value(finding, :triage_severity) },
+            "metadata" => metadata_breakdowns }.compact.reject { |_key, values| values.empty? }
+        end
+
+        private
+
+        attr_reader :findings
+
+        def metadata_breakdowns
+          category_metadata_keys.to_h { |key| [key, metadata_breakdown_for(key)] }
+                                .reject { |_key, values| values.empty? }
+                                .then { |values| values unless values.empty? }
+        end
+
+        def category_metadata_keys
+          ProjectAnalyzerMetadata.category_metadata_keys
+        end
+
+        def metadata_breakdown_for(key)
+          breakdown_for { |finding| analyzer_metadata(finding)[key] }
+        end
+
+        def analyzer_metadata(finding)
+          return {} unless finding.respond_to?(:project_analyzer_metadata)
+
+          finding.project_analyzer_metadata || {}
+        end
+
+        def breakdown_for(&block)
+          findings.filter_map { |finding| block.call(finding) }
+                  .tally
+                  .sort_by { |value, _count| value.to_s }
+                  .map { |value, count| { "value" => value, "finding_count" => count } }
+        end
+
+        def optional_value(finding, name)
+          finding.public_send(name) if finding.respond_to?(name)
+        end
+      end
+    end
+  end
+end

data/lib/metz_scan/commands/scan/project_analyzer_metadata.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "project_analyzer_breakdown"
+require_relative "project_analyzer_triage_priority"
+
+module MetzScan
+  module Commands
+    class Scan
+      module ProjectAnalyzerMetadata
+        CATEGORY_METADATA_KEY = "project_analyzer_category"
+
+        module_function
+
+        def category_metadata_keys = [CATEGORY_METADATA_KEY]
+
+        def category_for(finding)
+          analyzer_metadata(finding)[CATEGORY_METADATA_KEY]
+        end
+
+        def offense_metadata(finding)
+          triage_metadata(finding).merge(analyzer_metadata(finding))
+        end
+
+        def summary(findings, offenses)
+          rules = rule_summaries(findings, offenses)
+          { "finding_count" => findings.size,
+            "offense_count" => rules.sum { |rule| rule.fetch("offense_count") },
+            "rules" => rules }
+        end
+
+        def triage_metadata(finding)
+          { "status" => optional_value(finding, :project_analyzer_status),
+            "confidence" => optional_value(finding, :confidence),
+            "triage_severity" => optional_value(finding, :triage_severity),
+            "triage_summary" => optional_value(finding, :triage_summary) }.compact
+        end
+
+        def analyzer_metadata(finding)
+          return {} unless finding.respond_to?(:project_analyzer_metadata)
+
+          finding.project_analyzer_metadata || {}
+        end
+
+        def rule_summaries(findings, offenses)
+          findings.group_by(&:rule_id).sort.map do |rule_id, rule_findings|
+            rule_summary(rule_id, rule_findings, offenses)
+          end
+        end
+
+        def rule_summary(rule_id, findings, offenses)
+          summary_metadata(findings).merge(rule_count_metadata(rule_id, findings, offenses),
+                                           "breakdowns" => ProjectAnalyzerBreakdown.new(findings).to_h)
+        end
+
+        def rule_count_metadata(rule_id, findings, offenses)
+          { "cop_name" => rule_id, "finding_count" => findings.size,
+            "offense_count" => offense_count(rule_id, offenses) }
+        end
+
+        def summary_metadata(findings)
+          triage_metadata(priority_finding(findings)).slice("status", "confidence", "triage_severity")
+        end
+
+        def priority_finding(findings)
+          Array(findings).min_by { |finding| ProjectAnalyzerTriagePriority.sort_key(triage_metadata(finding)) }
+        end
+
+        def offense_count(rule_id, offenses)
+          offenses.count { |offense| offense.fetch("cop_name") == rule_id }
+        end
+
+        def optional_value(finding, name)
+          finding.public_send(name) if finding.respond_to?(name)
+        end
+      end
+    end
+  end
+end

data/lib/metz_scan/commands/scan/project_analyzer_offenses.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "project_analyzer_metadata"
+
+module MetzScan
+  module Commands
+    class Scan
+      module ProjectAnalyzerOffenses
+        OffenseSet = Struct.new(:by_path, :offenses, keyword_init: true)
+
+        module_function
+
+        def build(findings)
+          entries = entries_for(findings)
+          OffenseSet.new(by_path: offenses_by_path(entries), offenses: entries.map { |entry| entry.fetch(:offense) })
+        end
+
+        def entries_for(findings)
+          findings.flat_map { |finding| offenses_for(finding) }
+        end
+
+        def offenses_for(finding)
+          locations_for(finding).map do |location|
+            { path: location.path, offense: offense_for(finding, location) }
+          end
+        end
+
+        def locations_for(finding)
+          Array(finding.report_occurrences).compact.uniq
+        end
+
+        def offense_for(finding, occurrence)
+          offense_metadata(finding, occurrence).merge("location" => location_hash(occurrence.report_line))
+        end
+
+        def offense_metadata(finding, occurrence)
+          add_project_analyzer_metadata(common_offense_metadata(finding), finding, occurrence)
+        end
+
+        def common_offense_metadata(finding)
+          basic_offense_metadata(finding).merge(explanation_metadata(finding))
+        end
+
+        def basic_offense_metadata(finding)
+          { "cop_name" => finding.rule_id, "message" => finding.message,
+            "severity" => "refactor", "corrected" => false, "correctable" => false }
+        end
+
+        def explanation_metadata(finding)
+          { "why_it_matters" => finding.why_it_matters, "fix_safety" => "manual",
+            "suggested_next_moves" => suggested_next_moves_for(finding) }
+        end
+
+        def add_project_analyzer_metadata(metadata, finding, occurrence)
+          project_metadata = ProjectAnalyzerMetadata.offense_metadata(finding)
+          return metadata if project_metadata.empty?
+
+          metadata.merge("project_analyzer" => project_metadata.merge(report_location_metadata(occurrence)))
+        end
+
+        def report_location_metadata(occurrence)
+          { "report_location" => { "line_source" => occurrence.line_source,
+                                   "context" => occurrence.context }.compact }
+        end
+
+        def suggested_next_moves_for(finding)
+          return [] unless finding.respond_to?(:suggested_next_moves)
+
+          Array(finding.suggested_next_moves).map(&:to_s)
+        end
+
+        def location_hash(line)
+          line ||= 1
+          { "start_line" => line, "start_column" => 1, "last_line" => line,
+            "last_column" => 1, "length" => 1, "line" => line, "column" => 1 }
+        end
+
+        def offenses_by_path(entries)
+          entries.group_by { |entry| entry.fetch(:path) }
+                 .transform_values { |grouped_entries| grouped_entries.map { |entry| entry.fetch(:offense) } }
+        end
+      end
+    end
+  end
+end