solid_score 0.2.0

data/lib/rubocop/cop/solid_score/principle_base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SolidScore
+      # Abstract base for per-principle cops.
+      # Subclasses must define `principle_key` (e.g. :srp) and `principle_name` (e.g. "SRP").
+      class PrincipleBase < Base
+        include Helpers
+
+        def on_class(node)
+          check_principle(node)
+        end
+
+        def on_module(node)
+          check_principle(node)
+        end
+
+        private
+
+        def check_principle(node)
+          score_results_for.each do |result|
+            target_node = find_class_node_for(result) || node
+            next unless same_node?(target_node, node)
+
+            score = result.send(principle_key)
+            threshold = score_threshold
+            next unless score < threshold
+
+            add_offense(node, message: format(
+              self.class::MSG,
+              score, threshold
+            ))
+          end
+        end
+
+        def principle_key
+          raise NotImplementedError
+        end
+
+        def principle_name
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/solid_score/single_responsibility.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SolidScore
+      # Checks that each class/module meets a minimum SRP (Single Responsibility Principle) score.
+      #
+      # @example MinScore: 60 (default)
+      #   SolidScore/SingleResponsibility:
+      #     Enabled: true
+      #     MinScore: 60
+      class SingleResponsibility < PrincipleBase
+        MSG = "SRP score %.1f is below minimum %g"
+
+        private
+
+        def principle_key = :srp
+        def principle_name = "SRP"
+      end
+    end
+  end
+end

data/lib/rubocop/cop/solid_score/total_score.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module SolidScore
+      # Checks that each class/module meets a minimum SOLID total score.
+      #
+      # @example EnforcedMinScore: 70 (default)
+      #   # bad - total score below threshold
+      #   class GodObject
+      #     # ... many responsibilities, concrete deps, etc.
+      #   end
+      #
+      #   # good - total score above threshold
+      #   class FocusedService
+      #     # ... single responsibility, injected deps
+      #   end
+      #
+      # @example Configuration in .rubocop.yml
+      #   SolidScore/TotalScore:
+      #     Enabled: true
+      #     MinScore: 70
+      class TotalScore < Base
+        include Helpers
+
+        MSG = "SOLID total score %.1f is below minimum %g (SRP=%.1f OCP=%.1f LSP=%.1f ISP=%.1f DIP=%.1f)"
+
+        def on_class(node)
+          check_scores(node)
+        end
+
+        def on_module(node)
+          check_scores(node)
+        end
+
+        private
+
+        def check_scores(node)
+          score_results_for.each do |result|
+            target_node = find_class_node_for(result) || node
+            next unless same_node?(target_node, node)
+            next unless result.total < score_threshold
+
+            add_offense(node, message: format(
+              MSG,
+              result.total, score_threshold,
+              result.srp, result.ocp, result.lsp, result.isp, result.dip
+            ))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/solid_score/inject.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module SolidScore
+    # Injects default configuration from config/default.yml
+    module Inject
+      def self.defaults!
+        path = File.expand_path("../../../config/default.yml", __dir__)
+        hash = ::RuboCop::ConfigLoader.load_yaml_configuration(path)
+        config = ::RuboCop::Config.new(hash, path)
+        puts "configuration from #{path}" if ::RuboCop::ConfigLoader.debug?
+        config = ::RuboCop::ConfigLoader.merge_with_default(config, path)
+        ::RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop-solid_score.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "solid_score"
+require_relative "rubocop/solid_score/inject"
+
+require_relative "rubocop/cop/solid_score/helpers"
+require_relative "rubocop/cop/solid_score/total_score"
+require_relative "rubocop/cop/solid_score/principle_base"
+require_relative "rubocop/cop/solid_score/single_responsibility"
+require_relative "rubocop/cop/solid_score/open_closed"
+require_relative "rubocop/cop/solid_score/liskov_substitution"
+require_relative "rubocop/cop/solid_score/interface_segregation"
+require_relative "rubocop/cop/solid_score/dependency_inversion"
+
+RuboCop::SolidScore::Inject.defaults!

data/lib/solid_score/analyzers/base_analyzer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Analyzers
+    class BaseAnalyzer
+      def analyze(class_info)
+        raise NotImplementedError, "#{self.class}#analyze must be implemented"
+      end
+
+      private
+
+      def clamp_score(score)
+        [[score, 0].max, 100].min.round(1)
+      end
+    end
+  end
+end

data/lib/solid_score/analyzers/dip_analyzer.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Analyzers
+    # Analyzes Dependency Inversion Principle compliance.
+    #
+    # Phase 1 改善: 標準ライブラリのホワイトリスト導入
+    # Phase 2b 改善: ファクトリメソッド検出、ユーザー定義ホワイトリスト
+    class DipAnalyzer < BaseAnalyzer
+      DI_BONUS = 15
+
+      # 具象依存1件あたりのペナルティと、その上限。
+      #
+      # 旧実装は concrete / (concrete + injected) の「比率」でスコアを決めて
+      # いたため、注入依存が0件のクラスは比率が必ず 1.0 になり、具象依存が
+      # 1件でも10件でも一律0点に潰れていた（著名OSSの13%が0点・中間スコア
+      # ほぼ消滅という二極化が実測された）。
+      #
+      # DIPで本来効くのは「いくつの具象クラスに直接結合しているか」という
+      # 絶対数なので、依存件数に比例した逓減ペナルティへ変更する。
+      # 1件=12pt … 5件以上で上限60ptに到達し、件数が増えるほど低スコアに
+      # なるが、1〜2件程度の素朴な `Foo.new` は中〜高スコアに留まる。
+      CONCRETE_DEP_PENALTY_PER = 12
+      MAX_CONCRETE_DEP_PENALTY = 60
+
+      # Issue #12: memoized factory bonus
+      MEMOIZED_FACTORY_BONUS_PER = 5
+      MEMOIZED_FACTORY_BONUS_MAX = 15
+
+      # Phase 2b: .new 以外のファクトリメソッドも具象依存として検出
+      FACTORY_METHODS = %i[new create build call open].freeze
+
+      # Ruby標準ライブラリおよびコアクラスのホワイトリスト
+      # これらのクラスの .new 呼び出しは具象依存としてカウントしない
+      STANDARD_LIBRARY_WHITELIST = %w[
+        Array Hash Set SortedSet
+        Thread Mutex Monitor ConditionVariable Queue SizedQueue
+        Time Date DateTime
+        BigDecimal Rational Complex
+        String StringIO Regexp
+        File Dir IO Tempfile
+        Struct OpenStruct
+        StandardError RuntimeError ArgumentError TypeError
+        Range Enumerator Proc Method
+        Logger
+        URI
+        JSON
+        CSV
+        Socket
+        Net::HTTP
+      ].freeze
+
+      def initialize(user_whitelist: [])
+        @user_whitelist = user_whitelist
+      end
+
+      # 具象依存が1件でも残るクラスは、DIボーナス等を加点しても満点には
+      # 到達させない上限。100点は「具象依存ゼロの真にクリーンなクラス」に
+      # 限定し、DI採用は加点しつつも「具象結合が残る＝DIPは完璧ではない」
+      # を表現する（具象1件 + 注入1件のような構成が100点に潰れるのを防ぐ）。
+      MAX_SCORE_WITH_CONCRETE_DEP = 95
+
+      # Phase 2c: レイヤー別のDIPペナルティ重み
+      # Controller/Model ではDIP違反の影響度を軽減
+      # (Railsの標準パターンである Service.new.call, OtherModel.create を許容)
+      LAYER_DIP_WEIGHT = {
+        controller: 0.4,  # Service.new.call は標準パターン
+        model: 0.5,       # OtherModel.create は標準パターン
+        service: 1.0,     # DIが推奨される層
+        job: 0.6,         # Service呼び出しは許容
+        mailer: 0.5,      # Model参照は許容
+        lib: 1.0,         # DIが推奨される層
+        unknown: 1.0
+      }.freeze
+
+      def analyze(class_info)
+        concrete_deps = count_concrete_instantiations(class_info)
+        injected_deps = count_injected_dependencies(class_info)
+        total_deps = concrete_deps + injected_deps
+        bonus = memoized_factory_bonus(class_info)
+
+        if total_deps.zero?
+          return clamp_score(100 + bonus)
+        end
+
+        # Phase 2c: レイヤー別にペナルティの重みを調整
+        weight = layer_weight(class_info)
+
+        # 具象依存の「絶対数」に応じた逓減ペナルティ（比率ベースを廃止）。
+        # これにより具象1件のクラスが0点に潰れず、多依存クラスとの差が出る。
+        score = 100 - (concrete_dep_penalty(concrete_deps) * weight)
+
+        score += DI_BONUS if injected_deps.positive?
+        score += bonus
+
+        # 具象依存が残る限り、加点しても満点には届かせない。
+        score = [score, MAX_SCORE_WITH_CONCRETE_DEP].min if concrete_deps.positive?
+
+        clamp_score(score)
+      end
+
+      private
+
+      # Phase 1 改善: 標準ライブラリを除外した具象依存カウント
+      #
+      # method_calls (MethodCallInfo) を使用してレシーバ情報を取得し、
+      # 標準ライブラリのインスタンス化を除外します。
+      #
+      # @param class_info [ClassInfo] クラス情報
+      # @return [Integer] 具象依存の数
+      def count_concrete_instantiations(class_info)
+        class_info.methods.sum do |method|
+          count_concrete_deps_in_method(method)
+        end
+      end
+
+      # Phase 2b: ファクトリメソッドも含めて具象依存をカウント
+      def count_concrete_deps_in_method(method)
+        method.method_calls.count do |call|
+          next false unless FACTORY_METHODS.include?(call.method_name)
+          next false unless call.receiver_type == :const
+
+          !whitelisted_class?(call.receiver)
+        end
+      end
+
+      # 標準ライブラリまたはユーザー定義ホワイトリストに含まれるかを判定
+      def whitelisted_class?(class_name)
+        return false if class_name.nil?
+
+        all_whitelist = STANDARD_LIBRARY_WHITELIST + @user_whitelist
+        all_whitelist.any? do |lib_class|
+          class_name == lib_class || class_name.end_with?("::#{lib_class}")
+        end
+      end
+
+      def count_injected_dependencies(class_info)
+        init = class_info.methods.find { |m| m.name == :initialize }
+        return 0 unless init
+
+        # Parser gem returns:
+        # :kwarg = required keyword argument (def foo(bar:))
+        # :kwoptarg = optional keyword argument (def foo(bar: default))
+        # :kwrestarg = keyword rest argument (def foo(**kwargs))
+        # Also check :key and :keyreq for backward compatibility
+        init.parameters.count { |type, _| %i[key keyreq kwarg kwoptarg kwrestarg].include?(type) }
+      end
+
+      # Issue #12: Reward `@svc ||= ServiceClass.new(...)` style memoised
+      # factories, but skip standard-library / user-whitelisted classes so
+      # `@queue ||= Queue.new` doesn't earn a DI-style bonus.
+      def memoized_factory_bonus(class_info)
+        count = class_info.methods.count do |m|
+          next false unless m.memoized_factory? && m.cyclomatic_complexity == 1
+          next false if m.memoized_factory_receiver.nil?
+
+          !whitelisted_class?(m.memoized_factory_receiver)
+        end
+        [count * MEMOIZED_FACTORY_BONUS_PER, MEMOIZED_FACTORY_BONUS_MAX].min
+      end
+
+      # 具象依存の件数に比例した逓減ペナルティ（上限あり）。
+      # 0件=0, 1件=12, 2件=24 ... 5件以上は60で頭打ち。
+      def concrete_dep_penalty(concrete_deps)
+        [concrete_deps * CONCRETE_DEP_PENALTY_PER, MAX_CONCRETE_DEP_PENALTY].min
+      end
+
+      def layer_weight(class_info)
+        LAYER_DIP_WEIGHT.fetch(class_info.layer, 1.0)
+      end
+    end
+  end
+end

data/lib/solid_score/analyzers/isp_analyzer.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Analyzers
+    class IspAnalyzer < BaseAnalyzer
+      include Mitigations
+
+      # Issue #7: Linear interpolation between 5 and 25 public methods.
+      # 5 methods → 100, 25 methods → 20, slope -4pt per method.
+      PUBLIC_METHOD_SCORE_CEILING = 100
+      PUBLIC_METHOD_SCORE_FLOOR = 20
+      PUBLIC_METHOD_FREE_COUNT = 5
+      PUBLIC_METHOD_FLOOR_COUNT = 25
+      PUBLIC_METHOD_SLOPE = 4
+
+      # Issue #8: Symmetric prefix pairs.
+      # Methods like `enable_X` / `disable_X` describe one capability and should
+      # not double-count toward the public surface. Each prefix pair contributes
+      # at most one discount per matching suffix.
+      SYMMETRIC_PREFIXES = [
+        %w[enable disable], %w[start stop], %w[open close],
+        %w[add remove], %w[create delete], %w[show hide],
+        %w[lock unlock], %w[mount unmount], %w[register unregister],
+        %w[encrypt decrypt], %w[compress decompress],
+        %w[serialize deserialize], %w[connect disconnect],
+        %w[attach detach], %w[subscribe unsubscribe]
+      ].freeze
+
+      # Phase 2a: フレームワークConcern/標準ライブラリモジュール
+      # これらのincludeはペナルティを緩和する
+      FRAMEWORK_MODULES = %w[
+        ActiveModel::Validations ActiveModel::Callbacks
+        ActiveModel::Dirty ActiveModel::Serialization
+        ActiveModel::Model ActiveModel::Attributes
+        ActiveSupport::Concern ActiveSupport::Callbacks
+        Comparable Enumerable Singleton
+      ].freeze
+
+      def analyze(class_info)
+        public_methods = class_info.public_methods_list
+        return 100 if public_methods.empty?
+
+        score = public_method_score(effective_public_method_count(class_info))
+        score -= include_penalty(class_info)
+        score -= cohesion_penalty(class_info)
+        score = mitigate_inspection(score, class_info)
+
+        clamp_score(score)
+      end
+
+      private
+
+      def effective_public_method_count(class_info)
+        names = class_info.public_methods_list.map { |m| m.name.to_s }
+        names.size - symmetric_pair_count(names)
+      end
+
+      def symmetric_pair_count(names)
+        SYMMETRIC_PREFIXES.sum do |a, b|
+          # Regexp.escape so that future user-supplied prefixes (via
+          # .solid-score.yml) cannot inject unintended regex syntax.
+          a_re = /\A#{Regexp.escape(a)}_/
+          b_re = /\A#{Regexp.escape(b)}_/
+          a_suffixes = names.grep(a_re).map { |n| n.sub(a_re, "") }
+          b_suffixes = names.grep(b_re).map { |n| n.sub(b_re, "") }
+          (a_suffixes & b_suffixes).size
+        end
+      end
+
+      def public_method_score(count)
+        return PUBLIC_METHOD_SCORE_CEILING if count <= PUBLIC_METHOD_FREE_COUNT
+        return PUBLIC_METHOD_SCORE_FLOOR if count >= PUBLIC_METHOD_FLOOR_COUNT
+
+        PUBLIC_METHOD_SCORE_CEILING - ((count - PUBLIC_METHOD_FREE_COUNT) * PUBLIC_METHOD_SLOPE)
+      end
+
+      # Phase 2a: フレームワークConcernを区別してペナルティを計算
+      def include_penalty(class_info)
+        all_includes = class_info.includes + class_info.extends
+        custom_count = all_includes.count { |mod| !framework_module?(mod) }
+        framework_count = all_includes.size - custom_count
+
+        # カスタムモジュールはフルペナルティ、フレームワークモジュールは半減
+        penalty = custom_penalty(custom_count) + framework_penalty(framework_count)
+        [penalty, 20].min
+      end
+
+      def custom_penalty(count)
+        if count >= 7
+          20
+        elsif count >= 4
+          10
+        else
+          0
+        end
+      end
+
+      def framework_penalty(count)
+        if count >= 7
+          10
+        elsif count >= 4
+          5
+        else
+          0
+        end
+      end
+
+      def framework_module?(module_name)
+        return false if module_name.nil?
+
+        FRAMEWORK_MODULES.any? do |fm|
+          module_name == fm || module_name.end_with?("::#{fm}")
+        end
+      end
+
+      def cohesion_penalty(class_info)
+        public_methods = class_info.public_methods_list
+        return 0 if public_methods.size <= 2
+
+        srp = SrpAnalyzer.new
+        public_only_class = Models::ClassInfo.new(
+          name: class_info.name,
+          methods: public_methods
+        )
+        lcom4 = srp.calculate_lcom4(public_only_class)
+
+        lcom4 > 2 ? 15 : 0
+      end
+    end
+  end
+end

data/lib/solid_score/analyzers/lsp_analyzer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Analyzers
+    # Analyzes Liskov Substitution Principle compliance.
+    #
+    # LSP違反の静的に検出可能な真のシグナルは「サブクラスが親の契約を破る
+    # 例外を投げる（NotImplementedError 以外の raise）」こと。
+    #
+    # 旧実装は「super を呼ばないメソッドごとに減点（no_super_penalty）」も
+    # していたが、静的解析では「親をオーバーライドしたメソッド」と「子で
+    # 新規追加しただけのメソッド」を区別できないため、Visitor/Adapter
+    # パターンの完全オーバーライドや、単に独自メソッドを多く持つだけの
+    # 継承クラスまで一律に減点していた（実測: LSP<100 の継承クラスの84%が
+    # この誤検出由来）。super を呼ばないこと自体は LSP 違反ではないため、
+    # このペナルティは廃止した。
+    #
+    # 既知の限界:
+    # 現在の判定軸は extra_raise（契約破りの例外）1軸のみで、契約破りの
+    # raise を含まない継承クラスは一律 100 点になる。これは「誤検出ゼロを
+    # 優先した意図的な縮退」であり、LSP の重み(0.10)が低いことと併せて
+    # 許容している。AST だけでは「親メソッドの存在」「事前/事後条件」
+    # 「戻り値の共変/反変」を確認できないため、これらの検出軸を追加するには
+    # クロスファイル/実行時の型情報が必要になる。将来の拡張候補（共変戻り値・
+    # 事前条件強化・シグネチャ変更の検出など）は Issue #24 を参照。
+    class LspAnalyzer < BaseAnalyzer
+      SIGNATURE_CHANGE_PENALTY = 20
+      EXTRA_RAISE_PENALTY = 15
+
+      def analyze(class_info)
+        return 100 unless class_info.has_superclass?
+
+        score = 100.0
+
+        class_info.methods.each do |method|
+          next if method.name == :initialize
+
+          score -= extra_raise_penalty(method)
+        end
+
+        clamp_score(score)
+      end
+
+      private
+
+      def extra_raise_penalty(method)
+        standard_raises = ["NotImplementedError"]
+        extra_raises = method.raises.reject { |r| standard_raises.include?(r) }
+
+        extra_raises.any? ? EXTRA_RAISE_PENALTY : 0
+      end
+    end
+  end
+end

data/lib/solid_score/analyzers/mitigations.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Analyzers
+    # Shared score-mitigation helpers used by multiple analyzers.
+    module Mitigations
+      INSPECTION_MIN_SCORE = 80
+
+      private
+
+      # Issue #9: floor inspection / diagnostic helpers at INSPECTION_MIN_SCORE.
+      def mitigate_inspection(score, class_info)
+        return score unless class_info.inspection_class?
+
+        [score, INSPECTION_MIN_SCORE].max
+      end
+    end
+  end
+end

data/lib/solid_score/analyzers/ocp_analyzer.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Analyzers
+    # Analyzes Open/Closed Principle compliance.
+    #
+    # Phase 1 改善: case/when 分岐へのペナルティ追加
+    # Phase 2b 改善: respond_to? を弱い型チェックとして追加
+    class OcpAnalyzer < BaseAnalyzer
+      # 強い型チェック: 直接的な型判定 → 10点/回
+      STRONG_TYPE_CHECK_METHODS = %i[is_a? kind_of? instance_of?].freeze
+      # 弱い型チェック: ダックタイピング分岐 → 5点/回
+      WEAK_TYPE_CHECK_METHODS = %i[respond_to?].freeze
+
+      MAX_TYPE_CHECK_PENALTY = 40
+      MAX_EXTENSION_BONUS = 20
+
+      CASE_WHEN_PENALTY_PER_BRANCH = 5
+      MAX_CASE_WHEN_PENALTY = 30
+
+      def analyze(class_info)
+        return 100 if class_info.methods.empty?
+
+        score = 100.0
+
+        score -= conditional_density_penalty(class_info)
+        score -= type_check_penalty(class_info)
+        score -= case_when_penalty(class_info) # Phase 1 改善
+        score += extension_point_bonus(class_info)
+
+        clamp_score(score)
+      end
+
+      private
+
+      def conditional_density_penalty(class_info)
+        method_count = class_info.methods.size.to_f
+        return 0 if method_count.zero?
+
+        branch_count = class_info.methods.sum { |m| m.cyclomatic_complexity - 1 }
+        density = branch_count / method_count
+
+        if density > 1.0
+          40
+        elsif density > 0.5
+          20
+        else
+          0
+        end
+      end
+
+      # Phase 2b: 強い型チェックと弱い型チェックで差別化
+      def type_check_penalty(class_info)
+        strong_checks = count_type_checks(class_info, STRONG_TYPE_CHECK_METHODS)
+        weak_checks = count_type_checks(class_info, WEAK_TYPE_CHECK_METHODS)
+
+        [strong_checks * 10 + weak_checks * 5, MAX_TYPE_CHECK_PENALTY].min
+      end
+
+      def count_type_checks(class_info, check_methods)
+        class_info.methods.sum do |method|
+          method.called_methods.count { |m| check_methods.include?(m) }
+        end
+      end
+
+      # Issue #11: 2-way and 3-way case/when leniency.
+      # 1 when-clause   → 2pt   (2-way branch, often a minor domain conditional)
+      # 2 when-clauses  → 5pt   (3-way branch, still acceptable)
+      # 3+ when-clauses → n * 5pt (linear, real OCP smell)
+      #
+      # Note on the per-method shape: in earlier versions the score was driven
+      # by a class-wide pool of `when` clauses. With the per-method curve, a
+      # class containing many small 2-way conditionals will now score better
+      # than before, but the class-level cap (MAX_CASE_WHEN_PENALTY) still
+      # caps the contribution. This trade-off is intentional — wide n-way
+      # switches are still penalised heavily.
+      def case_when_penalty(class_info)
+        raw = class_info.methods.sum { |m| case_when_penalty_for_count(m.case_when_count) }
+        [raw, MAX_CASE_WHEN_PENALTY].min
+      end
+
+      def case_when_penalty_for_count(when_count)
+        case when_count
+        when 0 then 0
+        when 1 then 2
+        when 2 then 5
+        else when_count * CASE_WHEN_PENALTY_PER_BRANCH
+        end
+      end
+
+      def extension_point_bonus(class_info)
+        extension_points = class_info.methods.count do |method|
+          method.raises.include?("NotImplementedError")
+        end
+
+        has_block_params = class_info.methods.count do |method|
+          method.parameters.any? { |type, _| type == :block }
+        end
+
+        [(extension_points + has_block_params) * 10, MAX_EXTENSION_BONUS].min
+      end
+    end
+  end
+end