solid_score 0.2.0

data/lib/solid_score/analyzers/srp_analyzer.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Analyzers
+    class SrpAnalyzer < BaseAnalyzer
+      include Mitigations
+
+      LCOM4_SCORES = {
+        1 => 100,
+        2 => 60,
+        3 => 30
+      }.freeze
+
+      def analyze(class_info)
+        analyze_with_breakdown(class_info)[:score]
+      end
+
+      # Issue #13: Returns the score together with a per-step breakdown so
+      # diff-mode output can split structural changes from mechanical ones.
+      def analyze_with_breakdown(class_info)
+        methods = analyzable_methods(class_info)
+        return { score: 100, breakdown: { base: 100 } } if methods.empty?
+
+        lcom4 = calculate_lcom4(class_info)
+        base_score = lcom4_to_score(lcom4)
+        base_score = mitigate_data_class(base_score, class_info) if class_info.data_class?
+
+        wmc = wmc_penalty(class_info)
+        statement_penalty = effective_statement_penalty(class_info)
+        pre_mitigation = base_score - wmc - statement_penalty
+
+        after_framework = mitigate_framework_base(pre_mitigation, class_info)
+        after_api = mitigate_api_client(after_framework, class_info)
+        after_inspection = mitigate_inspection(after_api, class_info)
+
+        {
+          score: clamp_score(after_inspection),
+          breakdown: {
+            base: base_score,
+            wmc_penalty: wmc,
+            effective_statement_penalty: statement_penalty,
+            mitigation_framework_base: after_framework - pre_mitigation,
+            mitigation_api_client: after_api - after_framework,
+            mitigation_inspection: after_inspection - after_api
+          }
+        }
+      end
+
+      # LCOM4（Lack of Cohesion of Methods）を計算する。
+      # インスタンスメソッドのみを対象とする。クラスメソッドは
+      # インスタンス変数を共有しないため凝集度の概念が異なり、
+      # 含めるとスコアが不当に低下する。
+      # NOTE: ISP Analyzerからも呼ばれるためpublic
+      def calculate_lcom4(class_info)
+        methods = analyzable_methods(class_info).select(&:instance_method?)
+        return 1 if methods.size <= 1
+
+        # Phase 2c: 小規模クラス（メソッド数≤3）はLCOM4を1に固定
+        # 少ないメソッドで凝集度を測定しても統計的に意味がない
+        return 1 if methods.size <= 3
+
+        graph = build_method_graph(methods)
+        count_connected_components(graph, methods)
+      end
+
+      private
+
+      def analyzable_methods(class_info)
+        class_info.methods.reject { |m| m.name == :initialize || m.empty? }
+      end
+
+      def build_method_graph(methods)
+        adjacency = Hash.new { |h, k| h[k] = Set.new }
+
+        methods.each_with_index do |m1, i|
+          methods[(i + 1)..].each do |m2|
+            if share_instance_variables?(m1, m2) || call_each_other?(m1, m2)
+              adjacency[m1.name] << m2.name
+              adjacency[m2.name] << m1.name
+            end
+          end
+        end
+
+        adjacency
+      end
+
+      def share_instance_variables?(m1, m2)
+        m1.instance_variables.intersect?(m2.instance_variables)
+      end
+
+      def call_each_other?(m1, m2)
+        m1.called_methods.include?(m2.name) || m2.called_methods.include?(m1.name)
+      end
+
+      def count_connected_components(graph, methods)
+        visited = Set.new
+        components = 0
+
+        methods.each do |method|
+          next if visited.include?(method.name)
+
+          bfs(method.name, graph, visited)
+          components += 1
+        end
+
+        components
+      end
+
+      def bfs(start, graph, visited)
+        queue = [start]
+
+        while (current = queue.shift)
+          next if visited.include?(current)
+
+          visited << current
+          graph[current].each { |neighbor| queue << neighbor unless visited.include?(neighbor) }
+        end
+      end
+
+      def lcom4_to_score(lcom4)
+        LCOM4_SCORES.fetch(lcom4, 0)
+      end
+
+      def mitigate_data_class(score, _class_info)
+        [score, 90].max
+      end
+
+      # Phase 2c: フレームワーク基盤クラス (ApplicationController等) の最低スコア保証
+      # Railsの規約として共通ロジック集約は許容される
+      def mitigate_framework_base(score, class_info)
+        return score unless class_info.framework_base_class?
+
+        [score, 70].max
+      end
+
+      # Phase 2c: APIクライアントパターンの最低スコア保証
+      # 全publicメソッドが共通のHTTPクライアント変数を参照する構造は
+      # 「1つの外部サービスとの通信」という単一責務
+      def mitigate_api_client(score, class_info)
+        return score unless class_info.http_client_pattern?
+
+        [score, 80].max
+      end
+
+      def wmc_penalty(class_info)
+        wmc = class_info.methods.sum(&:cyclomatic_complexity)
+
+        if wmc > 40
+          20
+        elsif wmc > 20
+          10
+        else
+          0
+        end
+      end
+
+      # Issue #10: Penalise based on effective statement count from the AST.
+      # Replaces the old line-count heuristic so that stylistic refactors
+      # (e.g. expanding `raise X, msg` into `if cond; raise X.new(msg); end`)
+      # do not change the SRP score when the semantics are unchanged.
+      EFFECTIVE_STATEMENT_HIGH_THRESHOLD = 200
+      EFFECTIVE_STATEMENT_LOW_THRESHOLD = 100
+
+      def effective_statement_penalty(class_info)
+        total = class_info.methods.sum(&:effective_statement_count)
+
+        if total > EFFECTIVE_STATEMENT_HIGH_THRESHOLD
+          20
+        elsif total > EFFECTIVE_STATEMENT_LOW_THRESHOLD
+          10
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/solid_score/cli.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module SolidScore
+  class CLI
+    def run(args)
+      options = parse_options(args)
+      return 0 if options[:exit]
+
+      config = load_config(options)
+      config.merge_cli_options(options)
+
+      paths = args.reject { |a| a.start_with?("-") }
+      config.paths = paths unless paths.empty?
+
+      runner = Runner.new(config)
+      runner.run
+
+      puts runner.formatted_output
+
+      runner.passing? ? 0 : 1
+    end
+
+    private
+
+    def parse_options(args)
+      options = {}
+
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: solid-score [path] [options]"
+
+        opts.on("--format FORMAT", %w[text json html], "Output format (text|json|html)") do |f|
+          options[:format] = f.to_sym
+        end
+
+        opts.on("--config FILE", "Config file path") do |f|
+          options[:config] = f
+        end
+
+        opts.on("--min-score SCORE", Integer, "Minimum total score (CI)") do |s|
+          options[:min_score] = s
+        end
+
+        %w[srp ocp lsp isp dip].each do |principle|
+          opts.on("--min-#{principle} SCORE", Integer, "Minimum #{principle.upcase} score") do |s|
+            options[:"min_#{principle}"] = s
+          end
+        end
+
+        opts.on("--diff REF", "Diff base reference") do |r|
+          options[:diff_ref] = r
+        end
+
+        opts.on("--max-decrease SCORE", Integer, "Max score decrease per class") do |s|
+          options[:max_decrease] = s
+        end
+
+        opts.on("--exclude PATTERN", "Exclude patterns (comma-separated)") do |p|
+          options[:exclude] = p
+        end
+
+        opts.on("--version", "Show version") do
+          puts "solid-score v#{VERSION}"
+          options[:exit] = true
+        end
+
+        opts.on("-h", "--help", "Show help") do
+          puts opts
+          options[:exit] = true
+        end
+      end
+
+      parser.parse!(args)
+      options
+    end
+
+    def load_config(options)
+      config_path = options[:config] || ".solid-score.yml"
+      Configuration.from_file(config_path)
+    end
+  end
+end

data/lib/solid_score/configuration.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module SolidScore
+  class Configuration
+    DEFAULT_WEIGHTS = {
+      srp: 0.30,
+      ocp: 0.15,
+      lsp: 0.10,
+      isp: 0.20,
+      dip: 0.25
+    }.freeze
+
+    DEFAULT_THRESHOLDS = {
+      total: 0,
+      srp: 0,
+      ocp: 0,
+      lsp: 0,
+      isp: 0,
+      dip: 0
+    }.freeze
+
+    # Issue #14: extended tuning knobs
+    DEFAULT_DIFF_THRESHOLDS = {
+      ignore_below_delta: 0.0,
+      flag_only_structural_below: 0.0
+    }.freeze
+
+    DEFAULT_SCORING_OPTIONS = {
+      isp_public_method_curve: :linear,
+      case_when_2way_lenient: true
+    }.freeze
+
+    attr_accessor :paths, :exclude, :format, :thresholds, :weights,
+                  :diff_ref, :max_decrease, :new_class_min,
+                  :dip_whitelist,
+                  :inspection_class_patterns, :symmetric_method_pairs,
+                  :diff_thresholds, :scoring_options
+
+    def initialize
+      @paths = ["."]
+      @exclude = []
+      @format = :text
+      @thresholds = DEFAULT_THRESHOLDS.dup
+      @weights = DEFAULT_WEIGHTS.dup
+      @diff_ref = nil
+      @max_decrease = nil
+      @new_class_min = nil
+      @dip_whitelist = []
+      @inspection_class_patterns = []
+      @symmetric_method_pairs = []
+      @diff_thresholds = DEFAULT_DIFF_THRESHOLDS.dup
+      @scoring_options = DEFAULT_SCORING_OPTIONS.dup
+    end
+
+    def self.default
+      new
+    end
+
+    def self.from_file(path)
+      config = new
+      return config unless File.exist?(path)
+
+      yaml = YAML.safe_load_file(path, symbolize_names: false) || {}
+      config.apply_yaml(yaml)
+      config
+    end
+
+    def apply_yaml(yaml)
+      apply_preset(yaml["preset"]) if yaml["preset"]
+
+      @paths = yaml["paths"] if yaml["paths"]
+      @exclude = yaml["exclude"] if yaml["exclude"]
+      @format = yaml["format"]&.to_sym if yaml["format"]
+
+      yaml["thresholds"]&.each { |k, v| @thresholds[k.to_sym] = v }
+
+      yaml["weights"]&.each { |k, v| @weights[k.to_sym] = v }
+
+      if yaml["dip"]
+        @dip_whitelist = yaml["dip"]["whitelist"] || []
+      end
+
+      apply_extended_keys(yaml)
+
+      return unless yaml["diff"]
+
+      @max_decrease = yaml["diff"]["max_decrease"]
+      @new_class_min = yaml["diff"]["new_class_min"]
+    end
+
+    def merge_cli_options(options)
+      @format = options[:format] if options[:format]
+      @diff_ref = options[:diff_ref] if options[:diff_ref]
+      @thresholds[:total] = options[:min_score] if options[:min_score]
+
+      %i[srp ocp lsp isp dip].each do |principle|
+        key = :"min_#{principle}"
+        @thresholds[principle] = options[key] if options[key]
+      end
+
+      @max_decrease = options[:max_decrease] if options[:max_decrease]
+      @exclude = options[:exclude].split(",") if options[:exclude]
+    end
+
+    private
+
+    def apply_preset(name)
+      preset = Presets.fetch(name)
+      @paths = preset[:paths] if preset[:paths]
+      @exclude = preset[:exclude] if preset[:exclude]
+      preset[:weights]&.each { |k, v| @weights[k] = v }
+      @dip_whitelist = preset[:dip_whitelist] if preset[:dip_whitelist]
+    end
+
+    # Issue #14: keys parsed by apply_extended_keys but not yet wired into
+    # the analyzers. Setting any of them is currently a no-op; the runtime
+    # emits a one-time warning so users know their config has no effect yet.
+    UNWIRED_EXTENDED_KEYS = %w[
+      inspection_classes
+      symmetric_method_pairs
+      diff_thresholds
+      scoring
+    ].freeze
+
+    def apply_extended_keys(yaml)
+      @inspection_class_patterns = Array(yaml["inspection_classes"]) if yaml["inspection_classes"]
+
+      custom_pairs = yaml["symmetric_method_pairs"].is_a?(Hash) &&
+                     yaml["symmetric_method_pairs"]["custom"]
+      @symmetric_method_pairs = custom_pairs if custom_pairs
+
+      diff_thresholds = yaml["diff_thresholds"]
+      diff_thresholds.each { |k, v| @diff_thresholds[k.to_sym] = v } if diff_thresholds.is_a?(Hash)
+
+      scoring = yaml["scoring"]
+      scoring.each { |k, v| @scoring_options[k.to_sym] = normalize_scoring_value(v) } if scoring.is_a?(Hash)
+
+      warn_unwired_keys(yaml)
+    end
+
+    def normalize_scoring_value(value)
+      return value.downcase.to_sym if value.is_a?(String)
+
+      value
+    end
+
+    def warn_unwired_keys(yaml)
+      present = UNWIRED_EXTENDED_KEYS.select { |k| yaml.key?(k) }
+      return if present.empty?
+
+      Kernel.warn(
+        "[solid_score] .solid-score.yml keys parsed but not yet wired " \
+          "into the analyzers: #{present.join(", ")} (tracked as a follow-up)."
+      )
+    end
+  end
+end

data/lib/solid_score/diff_analyzer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SolidScore
+  class DiffAnalyzer
+    attr_reader :base_ref
+
+    def initialize(base_ref)
+      @base_ref = base_ref
+    end
+
+    def changed_files
+      git_diff_names.split("\n").select { |f| f.end_with?(".rb") }
+    end
+
+    def changed_line_ranges
+      ranges = Hash.new { |h, k| h[k] = [] }
+      current_file = nil
+
+      git_diff_output.each_line do |line|
+        if line.start_with?("+++ b/")
+          current_file = line.sub("+++ b/", "").strip
+        elsif line.match?(/^@@ .+ @@/) || line.match?(/^\s+@@ .+ @@/)
+          match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/)
+          if match && current_file
+            start_line = match[1].to_i
+            count = (match[2] || "1").to_i
+            ranges[current_file] << (start_line..(start_line + count - 1))
+          end
+        end
+      end
+
+      ranges
+    end
+
+    def filter_classes(classes, file_ranges)
+      classes.select do |class_info|
+        file_ranges.key?(class_info.file_path) &&
+          file_ranges[class_info.file_path].any? do |range|
+            ranges_overlap?(range, class_info.line_start..class_info.line_end)
+          end
+      end
+    end
+
+    private
+
+    def ranges_overlap?(a, b)
+      a.begin <= b.end && b.begin <= a.end
+    end
+
+    def git_diff_names
+      `git diff --name-only #{base_ref}`.strip
+    end
+
+    def git_diff_output
+      `git diff #{base_ref}`
+    end
+  end
+end

data/lib/solid_score/diff_classifier.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidScore
+  # Splits a between-revision delta into structural and mechanical
+  # components so reviewers can tell genuine OCP/DIP/LSP regressions
+  # apart from mass-only SRP/ISP movements.
+  #
+  # - +delta_structural+ = OCP + LSP + DIP (architectural decay signals)
+  # - +delta_mechanical+ = SRP + ISP       (mass-driven movement)
+  # - +delta_total+      = +ScoreResult#total+ delta (weighted)
+  #
+  # The classification is performed at the principle-score level rather
+  # than the subscore level for now. The original IMPROVEMENT_PLAN.md
+  # discusses subscore-level classification (e.g. attributing the SRP
+  # +wmc_penalty+ to mechanical and the LCOM4 movement to structural);
+  # extending this requires breakdowns from every analyzer and is
+  # tracked as a follow-up.
+  #
+  # IMPORTANT: +delta_structural+ and +delta_mechanical+ are unweighted
+  # sums while +delta_total+ applies +ScoreResult+ weights. They are NOT
+  # required to add up to +delta_total+. Consumers that need the weighted
+  # split should multiply the unweighted contributions by the relevant
+  # weights themselves.
+  #
+  # Compare with +DiffAnalyzer+, which detects which classes/files
+  # changed between two revisions but does not interpret score deltas.
+  class DiffClassifier
+    STRUCTURAL_PRINCIPLES = %i[ocp lsp dip].freeze
+    MECHANICAL_PRINCIPLES = %i[srp isp].freeze
+
+    def classify(before_result, after_result)
+      {
+        delta_total: round1(after_result.total - before_result.total),
+        delta_structural: round1(principle_delta(before_result, after_result, STRUCTURAL_PRINCIPLES)),
+        delta_mechanical: round1(principle_delta(before_result, after_result, MECHANICAL_PRINCIPLES))
+      }
+    end
+
+    private
+
+    def principle_delta(before_result, after_result, principles)
+      principles.sum { |p| after_result.public_send(p) - before_result.public_send(p) }
+    end
+
+    def round1(value)
+      value.round(1)
+    end
+  end
+end

data/lib/solid_score/formatters/base_formatter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Formatters
+    class BaseFormatter
+      def format(results)
+        raise NotImplementedError
+      end
+    end
+  end
+end