solid_score 0.2.0

data/lib/solid_score/parser/ruby_parser.rb

@@ -0,0 +1,451 @@
+# frozen_string_literal: true
+
+require "parser/current"
+
+module SolidScore
+  module Parser
+    # Parses Ruby source files and extracts class/method information.
+    #
+    # Phase 1 改善:
+    # - MethodCallInfo によるレシーバ情報の収集
+    # - case/when 分岐数のカウント
+    #
+    # Phase 2a 改善:
+    # - クラスメソッド (def self.xxx) の解析対応
+    # - モジュール (module) の解析対応
+    # - ネストしたクラス/モジュール対応
+    # - Rails DSL認識
+    class RubyParser
+      # Rails/ActiveSupport DSLメソッド
+      # これらはメソッド定義ではなくDSL宣言として扱う
+      RAILS_DSL_METHODS = %i[
+        has_many has_one belongs_to has_and_belongs_to_many
+        validates validate validates_presence_of validates_uniqueness_of
+        validates_format_of validates_length_of validates_numericality_of
+        validates_inclusion_of validates_exclusion_of validates_associated
+        before_action after_action around_action skip_before_action
+        before_filter after_filter around_filter
+        before_validation after_validation
+        before_create after_create before_update after_update
+        before_save after_save before_destroy after_destroy
+        after_commit after_rollback
+        scope enum delegate
+        serialize store
+        accepts_nested_attributes_for
+      ].freeze
+
+      def parse_file(file_path)
+        source = File.read(file_path)
+        ast = ::Parser::CurrentRuby.parse(source)
+        return [] unless ast
+
+        extract_definitions(ast, file_path)
+      end
+
+      private
+
+      # Phase 2a: クラスとモジュールの両方を抽出し、ネストにも対応
+      def extract_definitions(node, file_path, classes = [], namespace = nil)
+        return classes unless node.is_a?(::AST::Node)
+
+        case node.type
+        when :class
+          class_info = build_class_info(node, file_path, namespace)
+          classes << class_info
+          # ネストしたクラス/モジュールを探索
+          extract_nested_definitions(node.children[2], file_path, classes, class_info.name)
+        when :module
+          module_info = build_module_info(node, file_path, namespace)
+          classes << module_info
+          # モジュール内のネストしたクラス/モジュールを探索
+          extract_nested_definitions(node.children[1], file_path, classes, module_info.name)
+        else
+          node.children.each { |child| extract_definitions(child, file_path, classes, namespace) }
+        end
+
+        classes
+      end
+
+      # ネストしたクラス/モジュールを探索（親のbodyから）
+      def extract_nested_definitions(body, file_path, classes, parent_name)
+        return unless body.is_a?(::AST::Node)
+
+        nodes = body.type == :begin ? body.children : [body]
+        nodes.each do |child|
+          next unless child.is_a?(::AST::Node)
+
+          case child.type
+          when :class, :module
+            extract_definitions(child, file_path, classes, parent_name)
+          end
+        end
+      end
+
+      def build_class_info(node, file_path, namespace = nil)
+        raw_name = extract_class_name(node.children[0])
+        name = namespace ? "#{namespace}::#{raw_name}" : raw_name
+        superclass = node.children[1] ? extract_class_name(node.children[1]) : nil
+        body = node.children[2]
+
+        build_definition_info(name, file_path, node, body, superclass: superclass, kind: :class)
+      end
+
+      # Phase 2a: モジュール情報を構築
+      def build_module_info(node, file_path, namespace = nil)
+        raw_name = extract_class_name(node.children[0])
+        name = namespace ? "#{namespace}::#{raw_name}" : raw_name
+        body = node.children[1]
+
+        build_definition_info(name, file_path, node, body, kind: :module)
+      end
+
+      # クラス/モジュール共通の情報構築
+      def build_definition_info(name, file_path, node, body, superclass: nil, kind: :class)
+        methods = []
+        includes = []
+        extends = []
+        attr_readers = []
+        attr_writers = []
+        dsl_calls = []
+        current_visibility = :public
+
+        if body
+          traverse_body(body, methods, includes, extends, attr_readers, attr_writers,
+                        dsl_calls, current_visibility)
+        end
+
+        instance_variables = methods.flat_map(&:instance_variables).uniq
+
+        Models::ClassInfo.new(
+          name: name,
+          file_path: file_path,
+          line_start: node.loc.line,
+          line_end: node.loc.last_line,
+          methods: methods,
+          superclass: superclass,
+          includes: includes,
+          extends: extends,
+          instance_variables: instance_variables,
+          attr_readers: attr_readers,
+          attr_writers: attr_writers,
+          kind: kind,
+          dsl_calls: dsl_calls
+        )
+      end
+
+      def traverse_body(node, methods, includes, extends, attr_readers, attr_writers,
+                        dsl_calls, current_visibility)
+        return unless node.is_a?(::AST::Node)
+
+        case node.type
+        when :begin
+          node.children.each do |child|
+            current_visibility = traverse_body(child, methods, includes, extends,
+                                               attr_readers, attr_writers,
+                                               dsl_calls, current_visibility)
+          end
+        when :def
+          methods << build_method_info(node, current_visibility, kind: :instance)
+        when :defs
+          # Phase 2a: クラスメソッド (def self.xxx)
+          # :defs ノード構造: [receiver, name, args, body]
+          methods << build_method_info(node, :public, kind: :class)
+        when :send
+          current_visibility = handle_send_node(node, current_visibility, includes, extends,
+                                                attr_readers, attr_writers, dsl_calls)
+        when :class, :module
+          # ネストしたクラス/モジュールはtraverse_bodyではスキップ
+          # extract_nested_definitionsで別途処理する
+        end
+
+        current_visibility
+      end
+
+      def handle_send_node(node, current_visibility, includes, extends,
+                           attr_readers, attr_writers, dsl_calls)
+        method_name = node.children[1]
+
+        case method_name
+        when :private, :protected, :public
+          method_name
+        when :include
+          includes << extract_class_name(node.children[2]) if node.children[2]
+          current_visibility
+        when :extend
+          extends << extract_class_name(node.children[2]) if node.children[2]
+          current_visibility
+        when :attr_reader
+          node.children[2..].each { |arg| attr_readers << arg.children[0] if arg.type == :sym }
+          current_visibility
+        when :attr_accessor
+          node.children[2..].each do |arg|
+            next unless arg.type == :sym
+
+            attr_readers << arg.children[0]
+            attr_writers << arg.children[0]
+          end
+          current_visibility
+        when :attr_writer
+          node.children[2..].each { |arg| attr_writers << arg.children[0] if arg.type == :sym }
+          current_visibility
+        else
+          # Phase 2a: Rails DSL認識
+          if RAILS_DSL_METHODS.include?(method_name)
+            dsl_calls << method_name
+          end
+          current_visibility
+        end
+      end
+
+      # Issue #12: factory-style method names that count as instantiation.
+      # Mirrors DipAnalyzer::FACTORY_METHODS so the bonus tracks the same set
+      # of patterns that are penalised as concrete dependencies.
+      MEMOIZED_FACTORY_METHODS = %i[new create build call open].freeze
+
+      # Issue #10: Statement-like AST nodes that count toward the effective body size.
+      #
+      # Notes on what we *don't* count and why:
+      # - :begin / :rescue / :ensure are sequence wrappers (their handler bodies
+      #   are counted via their children).
+      # - :when is a child of :case and would double-count the dispatch.
+      # - :ivar / :lvar are lookups, not statements.
+      #
+      # Notes on what we *do* count:
+      # - :send and :csend (safe-navigation) treat method calls as a statement;
+      #   chained calls intentionally accumulate because each step is observable
+      #   behaviour.
+      # - :masgn (multiple assignment) joins the explicit assignment forms.
+      EFFECTIVE_STATEMENT_TYPES = %i[
+        send csend
+        if case return
+        ivasgn lvasgn gvasgn cvasgn masgn
+        and_asgn or_asgn op_asgn
+        yield block
+        while until for
+        next break retry redo super zsuper
+      ].freeze
+
+      # Nested method/lambda boundaries — count_effective_statements stops at
+      # these so that statements inside an inner lambda don't leak into the
+      # outer method's count.
+      NESTED_DEFINITION_TYPES = %i[def defs].freeze
+
+      # :def ノード構造: [name, args, body]
+      # :defs ノード構造: [receiver, name, args, body]
+      def build_method_info(node, visibility, kind: :instance)
+        name, args, body = extract_method_parts(node, kind)
+
+        instance_vars = []
+        called_methods = []
+        raises = []
+        method_calls = []
+        calls_super = false
+        case_when_count = 0
+        memoized_receiver = nil
+        effective_count = 0
+
+        if body
+          collect_method_details(body, instance_vars, called_methods, raises, method_calls)
+          calls_super = contains_super?(body)
+          case_when_count = count_case_when_branches(body)
+          memoized_receiver = detect_memoized_factory_receiver(body)
+          effective_count = count_effective_statements(body)
+        end
+
+        parameters = extract_parameters(args)
+        complexity = calculate_cyclomatic_complexity(body)
+
+        Models::MethodInfo.new(
+          name: name,
+          visibility: visibility,
+          line_start: node.loc.line,
+          line_end: node.loc.last_line,
+          instance_variables: instance_vars.uniq,
+          called_methods: called_methods.uniq,
+          parameters: parameters,
+          cyclomatic_complexity: complexity,
+          raises: raises,
+          calls_super: calls_super,
+          method_calls: method_calls,
+          case_when_count: case_when_count,
+          kind: kind,
+          effective_statement_count: effective_count,
+          memoized_factory_receiver: memoized_receiver
+        )
+      end
+
+      # Issue #12: Detects the `@ivar ||= ConstantClass.new(...)` memoised
+      # factory pattern (and the broader factory-method variants such as
+      # `.create`, `.build`, `.call`, `.open`). Returns the constant's
+      # qualified name (e.g. "ProvisioningService", "Foo::Bar") so the
+      # analyzer can apply the standard-library whitelist consistently
+      # with the concrete-dependency penalty path.
+      def detect_memoized_factory_receiver(node)
+        return nil unless node.is_a?(::AST::Node)
+
+        receiver = memoized_factory_receiver_for(node)
+        return receiver if receiver
+
+        node.children.each do |child|
+          found = detect_memoized_factory_receiver(child)
+          return found if found
+        end
+        nil
+      end
+
+      def memoized_factory_receiver_for(node)
+        return nil unless node.type == :or_asgn
+
+        lhs, rhs = node.children
+        return nil unless lhs.is_a?(::AST::Node) && lhs.type == :ivasgn
+        return nil unless rhs.is_a?(::AST::Node) && rhs.type == :send
+
+        receiver, method_name = rhs.children[0], rhs.children[1]
+        return nil unless receiver.is_a?(::AST::Node) && receiver.type == :const
+        return nil unless MEMOIZED_FACTORY_METHODS.include?(method_name)
+
+        extract_class_name(receiver)
+      end
+
+      def count_effective_statements(node, count = 0, root: true)
+        return count unless node.is_a?(::AST::Node)
+        # Don't recurse into nested method/lambda definitions when counting
+        # the parent body. The nested definition's own effective count is
+        # tracked separately by build_method_info.
+        return count if !root && NESTED_DEFINITION_TYPES.include?(node.type)
+
+        count += 1 if EFFECTIVE_STATEMENT_TYPES.include?(node.type)
+        node.children.each { |child| count = count_effective_statements(child, count, root: false) }
+        count
+      end
+
+      def extract_method_parts(node, kind)
+        case kind
+        when :class
+          [node.children[1], node.children[2], node.children[3]]
+        else
+          [node.children[0], node.children[1], node.children[2]]
+        end
+      end
+
+      # Phase 1 改善: レシーバ情報を含むメソッド呼び出し情報を収集
+      def collect_method_details(node, instance_vars, called_methods, raises, method_calls)
+        return unless node.is_a?(::AST::Node)
+
+        case node.type
+        when :ivar, :ivasgn
+          instance_vars << node.children[0]
+        when :send
+          receiver_node = node.children[0]
+          method_name = node.children[1]
+
+          called_methods << method_name
+
+          # Collect detailed method call info with receiver
+          method_calls << build_method_call_info(receiver_node, method_name)
+
+          if %i[raise fail].include?(method_name)
+            raise_class = node.children[2]
+            raises << extract_class_name(raise_class) if raise_class.is_a?(::AST::Node) && raise_class.type == :const
+          end
+        end
+
+        node.children.each do |child|
+          collect_method_details(child, instance_vars, called_methods, raises, method_calls)
+        end
+      end
+
+      # Phase 1 改善: メソッド呼び出し情報を構築
+      def build_method_call_info(receiver_node, method_name)
+        receiver, receiver_type = extract_receiver_info(receiver_node)
+
+        Models::MethodCallInfo.new(
+          method_name: method_name,
+          receiver: receiver,
+          receiver_type: receiver_type
+        )
+      end
+
+      # Phase 1 改善: レシーバ情報を抽出
+      def extract_receiver_info(node)
+        return [nil, :self] if node.nil?
+        return [nil, :unknown] unless node.is_a?(::AST::Node)
+
+        case node.type
+        when :const
+          [extract_class_name(node), :const]
+        when :ivar
+          [node.children[0].to_s, :ivar]
+        when :lvar
+          [node.children[0].to_s, :lvar]
+        when :self
+          [nil, :self]
+        when :send
+          # Chained method call (e.g., foo.bar.baz)
+          [nil, :send]
+        else
+          [nil, :unknown]
+        end
+      end
+
+      # Phase 1 改善: case/when 分岐数をカウント
+      def count_case_when_branches(node, count = 0)
+        return count unless node.is_a?(::AST::Node)
+
+        if node.type == :case
+          when_count = node.children.count { |child| child.is_a?(::AST::Node) && child.type == :when }
+          count += when_count
+        end
+
+        node.children.each do |child|
+          count = count_case_when_branches(child, count)
+        end
+
+        count
+      end
+
+      def contains_super?(node)
+        return false unless node.is_a?(::AST::Node)
+        return true if %i[super zsuper].include?(node.type)
+
+        node.children.any? { |child| contains_super?(child) }
+      end
+
+      def extract_parameters(args_node)
+        return [] unless args_node
+
+        args_node.children.map do |arg|
+          [arg.type, arg.children[0]]
+        end
+      end
+
+      def calculate_cyclomatic_complexity(node, complexity = 1)
+        return complexity unless node.is_a?(::AST::Node)
+
+        case node.type
+        when :if, :while, :until, :for, :when, :and, :or, :rescue
+          complexity += 1
+        end
+
+        node.children.each do |child|
+          complexity = calculate_cyclomatic_complexity(child, complexity)
+        end
+
+        complexity
+      end
+
+      def extract_class_name(node)
+        return nil unless node.is_a?(::AST::Node)
+
+        case node.type
+        when :const
+          parent = node.children[0]
+          name = node.children[1].to_s
+          parent ? "#{extract_class_name(parent)}::#{name}" : name
+        else
+          node.to_s
+        end
+      end
+    end
+  end
+end

data/lib/solid_score/presets.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module SolidScore
+  module Presets
+    RAILS = {
+      paths: %w[
+        app/models
+        app/controllers
+        app/services
+        app/jobs
+        app/mailers
+        app/forms
+        app/presenters
+        app/serializers
+        lib
+      ],
+      exclude: %w[
+        spec/**
+        test/**
+        vendor/**
+        db/**
+        tmp/**
+      ],
+      weights: {
+        srp: 0.25,
+        ocp: 0.15,
+        lsp: 0.10,
+        isp: 0.20,
+        dip: 0.30
+      },
+      dip_whitelist: %w[
+        Rails
+        Logger
+        FileUtils
+        Pathname
+        URI
+        JSON
+        CSV
+        Net::HTTP
+        OpenSSL
+        Digest
+        SecureRandom
+        ERB
+        ActionMailer
+        ActiveJob
+        ActiveStorage
+      ]
+    }.freeze
+
+    REGISTRY = {
+      "rails" => RAILS
+    }.freeze
+
+    def self.fetch(name)
+      REGISTRY.fetch(name.to_s) do
+        raise ArgumentError, "Unknown preset: #{name}. Available: #{REGISTRY.keys.join(', ')}"
+      end
+    end
+
+    def self.available
+      REGISTRY.keys
+    end
+  end
+end

data/lib/solid_score/runner.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module SolidScore
+  class Runner
+    attr_reader :results
+
+    def initialize(config)
+      @config = config
+      @parser = Parser::RubyParser.new
+      @scorer = Scorer.new(weights: config.weights, dip_whitelist: config.dip_whitelist)
+      @results = []
+    end
+
+    def run
+      files = collect_files
+      classes = files.flat_map { |f| parse_file(f) }
+      @results = @scorer.score_all(classes)
+    end
+
+    def passing?
+      return true if @results.empty?
+
+      @results.all? { |r| meets_thresholds?(r) }
+    end
+
+    def formatted_output
+      formatter = build_formatter
+      formatter.format(@results)
+    end
+
+    private
+
+    def collect_files
+      files = @config.paths.flat_map do |path|
+        if File.file?(path)
+          [path]
+        else
+          Dir.glob(File.join(path, "**", "*.rb"))
+        end
+      end
+
+      files.reject { |f| excluded?(f) }
+    end
+
+    def excluded?(file)
+      @config.exclude.any? do |pattern|
+        # **/dir/** パターンは部分一致で処理（File.fnmatch?は絶対パスで非対応）
+        if pattern.start_with?("**/") && pattern.end_with?("/**")
+          dir = pattern.delete_prefix("**/").delete_suffix("/**")
+          file.include?("/#{dir}/")
+        else
+          File.fnmatch?(pattern, file, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+        end
+      end
+    end
+
+    def parse_file(file)
+      @parser.parse_file(file)
+    rescue ::Parser::SyntaxError
+      []
+    end
+
+    def meets_thresholds?(result)
+      return false if result.total < @config.thresholds[:total]
+
+      %i[srp ocp lsp isp dip].all? do |principle|
+        result.send(principle) >= @config.thresholds[principle]
+      end
+    end
+
+    def build_formatter
+      case @config.format
+      when :json
+        Formatters::JsonFormatter.new
+      when :html
+        Formatters::HtmlFormatter.new
+      else
+        Formatters::TextFormatter.new
+      end
+    end
+  end
+end

data/lib/solid_score/scorer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SolidScore
+  class Scorer
+    def initialize(weights: Models::ScoreResult::DEFAULT_WEIGHTS, dip_whitelist: [])
+      @weights = weights
+      @srp_analyzer = Analyzers::SrpAnalyzer.new
+      @ocp_analyzer = Analyzers::OcpAnalyzer.new
+      @lsp_analyzer = Analyzers::LspAnalyzer.new
+      @isp_analyzer = Analyzers::IspAnalyzer.new
+      @dip_analyzer = Analyzers::DipAnalyzer.new(user_whitelist: dip_whitelist)
+    end
+
+    def score(class_info)
+      srp = @srp_analyzer.analyze_with_breakdown(class_info)
+
+      Models::ScoreResult.new(
+        class_name: class_info.name,
+        file_path: class_info.file_path,
+        srp: srp[:score],
+        ocp: @ocp_analyzer.analyze(class_info),
+        lsp: @lsp_analyzer.analyze(class_info),
+        isp: @isp_analyzer.analyze(class_info),
+        dip: @dip_analyzer.analyze(class_info),
+        weights: @weights,
+        class_info: class_info,
+        subscores: { srp: srp[:breakdown] }
+      )
+    end
+
+    def score_all(class_infos)
+      class_infos.map { |ci| score(ci) }
+    end
+  end
+end

data/lib/solid_score/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidScore
+  VERSION = "0.2.0"
+end

data/lib/solid_score.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "solid_score/version"
+require_relative "solid_score/models/method_info"
+require_relative "solid_score/models/class_info"
+require_relative "solid_score/models/score_result"
+require_relative "solid_score/parser/ruby_parser"
+require_relative "solid_score/analyzers/base_analyzer"
+require_relative "solid_score/analyzers/mitigations"
+require_relative "solid_score/analyzers/srp_analyzer"
+require_relative "solid_score/analyzers/ocp_analyzer"
+require_relative "solid_score/analyzers/lsp_analyzer"
+require_relative "solid_score/analyzers/isp_analyzer"
+require_relative "solid_score/analyzers/dip_analyzer"
+require_relative "solid_score/scorer"
+require_relative "solid_score/presets"
+require_relative "solid_score/configuration"
+require_relative "solid_score/formatters/base_formatter"
+require_relative "solid_score/formatters/text_formatter"
+require_relative "solid_score/formatters/json_formatter"
+require_relative "solid_score/formatters/html_formatter"
+require_relative "solid_score/diff_analyzer"
+require_relative "solid_score/diff_classifier"
+require_relative "solid_score/runner"
+require_relative "solid_score/cli"
+
+module SolidScore
+end