rubocop-metz 0.5.2

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative "../../analyzers/repeated_branching"
+require_relative "../../analyzers/service_soup"
+require_relative "../../analyzers/inheritance_descendants"
+require_relative "../../analyzers/package_dependency_pressure"
+require_relative "../../analyzers/namespace_leak_pressure"
+require_relative "../../analyzers/implicit_context_pressure"
+require_relative "../../analyzers/repeated_query_criteria"
+require_relative "../../analyzers/subclass_override_pressure"
+require_relative "../../project_index"
+require_relative "runner"
+require_relative "project_analyzer_metadata"
+require_relative "project_analyzer_offenses"
+
+module MetzScan
+  module Commands
+    class Scan
+      # Runs wrapper-level project analyzers and merges their findings into the
+      # same report shape produced by RuboCop's JSON formatter.
+      module ProjectAnalyzerRunner
+        ANALYZERS = [
+          Analyzers::RepeatedBranching,
+          Analyzers::ServiceSoup,
+          Analyzers::InheritanceDescendants,
+          Analyzers::PackageDependencyPressure,
+          Analyzers::NamespaceLeakPressure,
+          Analyzers::ImplicitContextPressure,
+          Analyzers::RepeatedQueryCriteria,
+          Analyzers::SubclassOverridePressure
+        ].freeze
+        INDEX_BACKED_ANALYZERS = [Analyzers::InheritanceDescendants, Analyzers::PackageDependencyPressure,
+                                  Analyzers::NamespaceLeakPressure, Analyzers::SubclassOverridePressure].freeze
+        DEFAULT_OUTPUT_STATUS = "validated"
+        DEFAULT_OUTPUT_CONFIDENCE = "medium"
+        DEFAULT_OUTPUT_TRIAGE_SEVERITY = "design pressure"
+
+        module_function
+
+        def merge!(parsed, paths, **)
+          findings = project_findings_for(paths, **)
+          return parsed if findings.empty?
+
+          merge_findings(parsed, findings)
+          parsed
+        end
+
+        def project_findings_for(paths, index: nil, default_output: false, force_default_config: false)
+          paths = analyzer_paths(paths, index: index, force_default_config: force_default_config)
+          return [] if paths.empty? && !index
+
+          findings = project_findings(paths, index: index, default_output: default_output)
+          default_output ? findings.select { |finding| default_output_finding?(finding) } : findings
+        end
+
+        def merge_findings(parsed, findings)
+          offense_set = ProjectAnalyzerOffenses.build(findings)
+          merge_offenses(parsed, offense_set.by_path)
+          update_summary(parsed, findings, offense_set.offenses)
+        end
+
+        def project_findings(paths, index: nil, default_output: false)
+          analyzers = analyzers_for(default_output: default_output)
+          index = project_index_for(paths, index, analyzers)
+          analyzers.flat_map { |analyzer| analyzer.new(paths: paths, index: index).call }
+        end
+
+        def analyzers_for(default_output:)
+          return ANALYZERS unless default_output
+
+          ANALYZERS.select { |analyzer| default_output_analyzer?(analyzer) }
+        end
+
+        def default_output_analyzer?(analyzer)
+          analyzer.const_defined?(:DEFAULT_OUTPUT_ELIGIBLE) &&
+            analyzer::DEFAULT_OUTPUT_ELIGIBLE &&
+            analyzer.const_defined?(:PROJECT_ANALYZER_STATUS) &&
+            analyzer::PROJECT_ANALYZER_STATUS == DEFAULT_OUTPUT_STATUS
+        end
+
+        def project_index_for(paths, index, analyzers)
+          return index if index
+          return nil unless analyzers.any? { |analyzer| INDEX_BACKED_ANALYZERS.include?(analyzer) }
+
+          ProjectIndex.build(paths)
+        end
+
+        def default_output_finding?(finding)
+          finding.project_analyzer_status == DEFAULT_OUTPUT_STATUS &&
+            finding.confidence == DEFAULT_OUTPUT_CONFIDENCE &&
+            finding.triage_severity == DEFAULT_OUTPUT_TRIAGE_SEVERITY
+        end
+
+        def analyzer_paths(paths, index: nil, force_default_config: false)
+          return Array(paths) if index
+
+          rubocop_target_files(paths, force_default_config: force_default_config)
+        end
+
+        def rubocop_target_files(paths, force_default_config: false)
+          return TargetFileDiscovery.with_forced_defaults(paths) if force_default_config
+
+          TargetFileDiscovery.for_project_config(paths)
+        end
+
+        def merge_offenses(parsed, grouped_offenses)
+          grouped_offenses.each do |path, offenses|
+            file_for(parsed, path)["offenses"].concat(offenses)
+          end
+        end
+
+        def file_for(parsed, path)
+          files = parsed["files"] ||= []
+          files.find { |file| same_path?(file["path"], path) } || append_file(files, path)
+        end
+
+        def same_path?(left, right)
+          File.expand_path(left) == File.expand_path(right)
+        end
+
+        def append_file(files, path)
+          { "path" => display_path(path), "offenses" => [] }.tap { |file| files << file }
+        end
+
+        def display_path(path)
+          expanded_path = File.expand_path(path)
+          cwd = "#{File.expand_path(Dir.pwd)}#{File::SEPARATOR}"
+          return expanded_path.delete_prefix(cwd) if expanded_path.start_with?(cwd)
+
+          path
+        end
+
+        def update_summary(parsed, findings, project_offenses)
+          summary = parsed["summary"] ||= {}
+          files = Array(parsed["files"])
+          summary["offense_count"] = files.sum { |file| Array(file["offenses"]).size }
+          update_file_counts(summary, files.size)
+          summary["project_analyzers"] = ProjectAnalyzerMetadata.summary(findings, project_offenses)
+        end
+
+        def update_file_counts(summary, file_count)
+          summary["target_file_count"] = [summary["target_file_count"].to_i, file_count].max
+          summary["inspected_file_count"] = [summary["inspected_file_count"].to_i, file_count].max
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module MetzScan
+  module Commands
+    class Scan
+      class ProjectAnalyzerSummaryAggregateFormatter
+        def initialize(summary)
+          @summary = summary
+        end
+
+        def lines
+          [counts_line("Analyzer counts", analyzer_counts),
+           counts_line("Confidence counts", breakdown_counts("confidence")),
+           counts_line("Severity counts", breakdown_counts("triage_severity")),
+           counts_line("Category counts", category_counts)].compact
+        end
+
+        private
+
+        attr_reader :summary
+
+        def analyzer_counts
+          rules.to_h { |rule| [rule.fetch("cop_name"), rule.fetch("finding_count").to_i] }
+        end
+
+        def breakdown_counts(key)
+          counts = counts_from_rule_breakdowns(key)
+          counts.empty? ? counts_from_rule_field(key) : counts
+        end
+
+        def category_counts
+          counts = counts_from_rule_breakdowns("project_analyzer_category", metadata: true)
+          counts.empty? ? counts_from_all_metadata_breakdowns : counts
+        end
+
+        def counts_from_rule_breakdowns(key, metadata: false)
+          rules.each_with_object(Hash.new(0)) do |rule, counts|
+            entries = metadata ? rule.dig("breakdowns", "metadata", key) : rule.dig("breakdowns", key)
+            Array(entries).each { |entry| counts[entry.fetch("value")] += entry.fetch("finding_count").to_i }
+          end
+        end
+
+        def counts_from_all_metadata_breakdowns
+          rules.each_with_object(Hash.new(0)) do |rule, counts|
+            rule.dig("breakdowns", "metadata").to_h.each_value do |entries|
+              Array(entries).each { |entry| counts[entry.fetch("value")] += entry.fetch("finding_count").to_i }
+            end
+          end
+        end
+
+        def counts_from_rule_field(key)
+          rules.each_with_object(Hash.new(0)) do |rule, counts|
+            value = rule[key]
+            counts[value] += rule.fetch("finding_count").to_i if value
+          end
+        end
+
+        def counts_line(label, counts)
+          return if counts.empty?
+
+          "  #{label}: #{sorted_counts(counts).map { |value, count| "#{value}=#{count}" }.join(', ')}"
+        end
+
+        def sorted_counts(counts)
+          counts.sort_by { |value, count| [-count, value.to_s] }
+        end
+
+        def rules
+          @rules ||= Array(summary["rules"])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MetzScan
+  module Commands
+    class Scan
+      class ProjectAnalyzerSummaryBreakdownFormatter
+        def initialize(rule)
+          @rule = rule
+        end
+
+        def call
+          return if segments.empty?
+
+          "mix: #{segments.join('; ')}"
+        end
+
+        private
+
+        attr_reader :rule
+
+        def segments
+          [mixed_segment("severity", breakdowns["triage_severity"]),
+           *metadata_segments].compact
+        end
+
+        def breakdowns
+          rule.fetch("breakdowns", {})
+        end
+
+        def metadata_segments
+          breakdowns.fetch("metadata", {}).map { |key, values| mixed_segment(key, values) }
+        end
+
+        def mixed_segment(label, values)
+          return unless values.to_a.size > 1
+
+          "#{label} #{values.map { |value| label_for(value) }.join(', ')}"
+        end
+
+        def label_for(value)
+          "#{value.fetch('value')}=#{value.fetch('finding_count')}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module MetzScan
+  module Commands
+    class Scan
+      module ProjectAnalyzerTriageFormatter
+        module_function
+
+        def line(metadata)
+          return unless metadata
+
+          line_for(triage_details(metadata), metadata["triage_summary"])
+        end
+
+        def line_for(details, summary)
+          return unless details.any? || !blank?(summary)
+          return summary.to_s if details.empty?
+
+          ["Triage: #{details.join('; ')}.", summary].compact.join(" ")
+        end
+
+        def triage_details(metadata)
+          [
+            labeled("status", metadata["status"]),
+            labeled("confidence", metadata["confidence"]),
+            labeled("severity", metadata["triage_severity"])
+          ].compact
+        end
+
+        def labeled(name, value)
+          "#{name}: #{value}" unless blank?(value)
+        end
+
+        def blank?(value)
+          value.nil? || value.to_s.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module MetzScan
+  module Commands
+    class Scan
+      module ProjectAnalyzerTriagePriority
+        PRIORITIES = {
+          "status" => { "validated" => 0, "candidate" => 1, "experimental" => 2 },
+          "confidence" => { "high" => 0, "medium" => 1, "early" => 2, "low" => 3 },
+          "triage_severity" => {
+            "design pressure" => 0,
+            "manual review" => 1,
+            "context required" => 2,
+            "broad base" => 3,
+            "shared dependency" => 4,
+            "shared namespace" => 5,
+            "setup orchestration" => 6
+          }
+        }.freeze
+
+        module_function
+
+        def sort_key(metadata)
+          [
+            priority_for("status", metadata["status"]),
+            priority_for("confidence", metadata["confidence"]),
+            priority_for("triage_severity", metadata["triage_severity"])
+          ]
+        end
+
+        def priority_for(name, value)
+          priorities = PRIORITIES.fetch(name)
+          priorities.fetch(value, priorities.size)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "rubocop"
+
+module MetzScan
+  module Commands
+    class Scan
+      # DDR: docs/ddrs/2026-07-08-rubocop-scope-only-config.md explains why default mode bypasses ConfigStore here.
+      module ProjectConfigScope
+        SCOPE_KEYS = %w[Include Exclude Includes Excludes].freeze
+        ALL_COPS_PROJECT_KEYS = (SCOPE_KEYS + %w[RubyInterpreters TargetRubyVersion]).freeze
+        DEFAULT_FILE = RuboCop::ConfigLoader::DEFAULT_FILE
+
+        module_function
+
+        def store
+          ConfigStore.new
+        end
+
+        def target_ruby_version(paths)
+          TargetRubyVersion.new(paths).version
+        end
+
+        # Accumulates [config_path, gem_name] pairs whenever an `inherit_gem`
+        # reference can't be resolved during scope-only config loading, so
+        # Runner can warn once per gem after a scan (see Next Queue item 1).
+        def unresolved_inherit_gems
+          @unresolved_inherit_gems ||= []
+        end
+
+        def reset_unresolved_inherit_gems!
+          @unresolved_inherit_gems = []
+        end
+
+        # Default mode drops file-scope Exclude from an inherit_gem whose gem
+        # isn't installed (docs/ddrs/2026-07-08-rubocop-scope-only-config.md);
+        # this turns that silent degrade into a one-line stderr note per gem.
+        def warn_unresolved_inherit_gems(stderr)
+          unresolved_inherit_gems.uniq { |(_path, gem_name)| gem_name }.each do |(path, gem_name)|
+            stderr.puts(unresolved_inherit_gem_message(path, gem_name))
+          end
+        end
+
+        def unresolved_inherit_gem_message(path, gem_name)
+          "metz-scan: note: #{path} inherits from gem `#{gem_name}` which is not installed; " \
+            "its file-scope Exclude is not applied — install the gem or use --all-cops"
+        end
+
+        class TargetRubyVersion
+          def initialize(paths, store: ConfigStore.new, loader: ConfigLoader.new)
+            @paths = paths
+            @store = store
+            @loader = loader
+          end
+
+          def version
+            config.target_ruby_version
+          rescue RuboCop::Error, Psych::Exception
+            nil
+          end
+
+          private
+
+          attr_reader :paths, :store, :loader
+
+          def config
+            loaded = store.for(target_path)
+            return loaded unless loaded.loaded_path == DEFAULT_FILE
+
+            loader.default_for(target_dir)
+          end
+
+          def target_path
+            Array(paths).first || RuboCop::PathUtil.pwd
+          end
+
+          def target_dir
+            expanded = File.expand_path(target_path)
+            File.directory?(expanded) ? expanded : File.dirname(expanded)
+          end
+        end
+
+        class ConfigStore
+          def initialize(loader: ConfigLoader.new)
+            @loader = loader
+            @path_cache = {}
+            @object_cache = {}
+          end
+
+          def for_file(file)
+            for_dir(File.dirname(file))
+          end
+
+          def for_pwd
+            for_dir(RuboCop::PathUtil.pwd)
+          end
+
+          def for(file_or_dir)
+            for_dir(File.directory?(file_or_dir) ? file_or_dir : File.dirname(file_or_dir))
+          end
+
+          def for_dir(dir)
+            path = @path_cache[dir] ||= RuboCop::ConfigLoader.configuration_file_for(dir)
+            @object_cache[path] ||= @loader.load(path)
+          end
+        end
+
+        class ConfigLoader
+          def default_for(dir)
+            path = File.join(File.expand_path(dir), ".rubocop.yml")
+            config = RuboCop::Config.new({}, path)
+            RuboCop::ConfigLoader.merge_with_default(config, path)
+          end
+
+          def load(path)
+            return RuboCop::ConfigLoader.default_configuration if path == DEFAULT_FILE
+
+            config = RuboCop::Config.new(scope_hash(path), path)
+            config.deprecation_check { |_message| nil }
+            config.make_excludes_absolute
+            RuboCop::ConfigLoader.merge_with_default(config, path)
+          end
+
+          private
+
+          def scope_hash(path, seen = [])
+            absolute_path = File.expand_path(path)
+            return {} if seen.include?(absolute_path)
+
+            raw_hash = RuboCop::ConfigLoader.load_yaml_configuration(absolute_path)
+            inherited = inherited_scope_hash(raw_hash, absolute_path, [*seen, absolute_path])
+            RuboCop::ConfigLoader.merge(inherited, local_scope_hash(raw_hash))
+          end
+
+          def inherited_scope_hash(raw_hash, path, seen)
+            inherited_paths(raw_hash, path).each_with_object({}) do |inherited_path, merged|
+              merged.replace(RuboCop::ConfigLoader.merge(merged, scope_hash(inherited_path, seen)))
+            end
+          end
+
+          def inherited_paths(raw_hash, path)
+            gem_inherited_paths(raw_hash["inherit_gem"], path) + local_inherited_paths(raw_hash["inherit_from"], path)
+          end
+
+          def local_inherited_paths(inherit_from, path)
+            Array(inherit_from).compact.flat_map do |entry|
+              next [] if remote_config?(entry)
+
+              inherited_path = absolute_path?(entry) ? entry : File.expand_path(entry, File.dirname(path))
+              glob_path?(inherited_path) ? Dir.glob(inherited_path) : [inherited_path]
+            end
+          end
+
+          def gem_inherited_paths(inherit_gem, path)
+            return [] unless inherit_gem.is_a?(Hash)
+
+            inherit_gem.flat_map { |gem_name, config_paths| paths_for_gem(gem_name, config_paths, path) }
+          end
+
+          def paths_for_gem(gem_name, config_paths, path)
+            gem_dir = gem_dir_for(gem_name, path)
+            return [] unless gem_dir
+
+            Array(config_paths).map { |config_path| File.join(gem_dir, config_path) }
+          end
+
+          def gem_dir_for(gem_name, path)
+            bundled_spec = bundled_specs[gem_name].first if defined?(Bundler)
+            return bundled_spec.full_gem_path if bundled_spec
+
+            Gem::Specification.find_by_name(gem_name).gem_dir
+          rescue Gem::LoadError
+            record_unresolved_gem(gem_name, path)
+          end
+
+          def record_unresolved_gem(gem_name, path)
+            ProjectConfigScope.unresolved_inherit_gems << [path, gem_name]
+            nil
+          end
+
+          def bundled_specs
+            Bundler.load.specs
+          rescue StandardError
+            {}
+          end
+
+          def local_scope_hash(raw_hash)
+            raw_hash.each_with_object({}) do |(key, value), scope_hash|
+              scope = scope_for(key, value)
+              scope_hash[key] = scope unless scope.empty?
+            end
+          end
+
+          def scope_for(key, value)
+            return copy_value(value) if key == "inherit_mode" && value.is_a?(Hash)
+            return {} unless value.is_a?(Hash)
+
+            scoped_settings(key, value)
+          end
+
+          def scoped_settings(key, value)
+            keys = key == "AllCops" ? ALL_COPS_PROJECT_KEYS : SCOPE_KEYS
+            value.each_with_object({}) do |(setting, setting_value), scope|
+              scope[setting] = copy_value(setting_value) if keys.include?(setting)
+            end
+          end
+
+          def copy_value(value)
+            return value.map { |item| copy_value(item) } if value.is_a?(Array)
+            return value.transform_values { |item| copy_value(item) } if value.is_a?(Hash)
+
+            value
+          end
+
+          def remote_config?(path)
+            path.to_s.start_with?("http://", "https://")
+          end
+
+          def absolute_path?(path)
+            Pathname.new(path.to_s).absolute?
+          end
+
+          def glob_path?(path)
+            path.match?(/[*?{}\[\]]/)
+          end
+        end
+      end
+    end
+  end
+end