solid_score 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 465bf41b4b60ca3d4f6c9eecc7de89bb6bcf6dae598a0fa8052bca0e34a16dbf
-  data.tar.gz: 235fd46777ef84ab2fd31620a0171f269c1f56ff9347bdac4e98731f7a76c5c0
+  metadata.gz: 7ee2dc0b2b384805ab33e1feb4278ff65f196763453e98747536d3dad3cebbb4
+  data.tar.gz: 9dd4b65bad2542e7255f681c152eccf6e8005ed6af18b2a6e25884da2e1c3cce
 SHA512:
-  metadata.gz: 5522bbc639d6d4b88a89973f10dda2f58d59266d378361441c0bec332b355a0134255297e8d9a4888b486d1566c78b3791ab35aab8e3ef303dd88a6016d718c8
-  data.tar.gz: a81c10321ab5f6e75ca1d134caa1b8111112c98e9a0d3108b9f1313a338491be83c1fbad17f4b1fc55d6eaefc143692e0054fb9d39c47557837ce78903c3040a
+  metadata.gz: 86f7674c77418367188bcf18b695c7c46116d4efe87db725e583b19b0df8626b7431dfe543b1060781953350b1ac9757165d291db298fcac7043fc48046a0db6
+  data.tar.gz: ec1b3636db05fa9f5f3c47d5a535ebc4fe18d6fdcf7f64ac545c921f773a6ccd01fef4a7fe46766c016d0dd07fc9cec9bde66847f6df1064c7913b29e11d97fc

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

@@ -21,7 +21,7 @@ module RuboCop
 
           class_infos = parser.parse_file(file_path)
           scorer.score_all(class_infos)
-        rescue ::Parser::SyntaxError
+        rescue ::SolidScore::Parser::SyntaxError
           []
         end
 

data/lib/solid_score/parser/class_body_scanner.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module SolidScore
+  module Parser
+    # Builds a Models::ClassInfo from a single Prism ClassNode/ModuleNode by
+    # scanning its direct body statements: method definitions, visibility
+    # modifiers, mixins, attr_* declarations and Rails DSL calls.
+    class ClassBodyScanner
+      # Rails/ActiveSupport DSL methods treated as declarations rather than
+      # ordinary method calls.
+      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
+
+      VISIBILITY_MODIFIERS = %i[private protected public].freeze
+
+      # Direct statements of a class/module body. The body is a
+      # StatementsNode normally, but a BeginNode when the class itself has
+      # a rescue/ensure clause, in which case the statements sit inside it.
+      def self.body_statements(node)
+        body = node.body
+        body = body.statements if body.is_a?(::Prism::BeginNode)
+        body&.body || []
+      end
+
+      def initialize(node, file_path, namespace)
+        @node = node
+        @file_path = file_path
+        @namespace = namespace
+        @methods = []
+        @includes = []
+        @extends = []
+        @attr_readers = []
+        @attr_writers = []
+        @dsl_calls = []
+        @visibility = :public
+      end
+
+      def class_info
+        statements.each { |statement| scan(statement) }
+
+        Models::ClassInfo.new(
+          name: qualified_name,
+          file_path: @file_path,
+          line_start: @node.location.start_line,
+          line_end: @node.location.end_line,
+          methods: @methods,
+          superclass: superclass_name,
+          includes: @includes,
+          extends: @extends,
+          instance_variables: @methods.flat_map(&:instance_variables).uniq,
+          attr_readers: @attr_readers,
+          attr_writers: @attr_writers,
+          kind: @node.is_a?(::Prism::ModuleNode) ? :module : :class,
+          dsl_calls: @dsl_calls
+        )
+      end
+
+      private
+
+      def statements
+        self.class.body_statements(@node)
+      end
+
+      def qualified_name
+        raw = ConstantName.of(@node.constant_path)
+        @namespace ? "#{@namespace}::#{raw}" : raw
+      end
+
+      def superclass_name
+        return nil unless @node.is_a?(::Prism::ClassNode)
+
+        ConstantName.of(@node.superclass)
+      end
+
+      def scan(statement)
+        case statement
+        when ::Prism::DefNode then scan_def(statement)
+        when ::Prism::CallNode then scan_call(statement)
+        end
+      end
+
+      def scan_def(node)
+        @methods << if node.receiver
+                      MethodAnalyzer.new(node, visibility: :public, kind: :class).method_info
+                    else
+                      MethodAnalyzer.new(node, visibility: @visibility, kind: :instance).method_info
+                    end
+      end
+
+      def scan_call(node)
+        name = node.name
+        args = node.arguments&.arguments || []
+
+        case name
+        when *VISIBILITY_MODIFIERS then @visibility = name
+        when :include then @includes << ConstantName.of(args.first) if args.first
+        when :extend then @extends << ConstantName.of(args.first) if args.first
+        when :attr_reader then @attr_readers.concat(symbol_args(args))
+        when :attr_writer then @attr_writers.concat(symbol_args(args))
+        when :attr_accessor
+          names = symbol_args(args)
+          @attr_readers.concat(names)
+          @attr_writers.concat(names)
+        else
+          @dsl_calls << name if RAILS_DSL_METHODS.include?(name)
+        end
+      end
+
+      def symbol_args(args)
+        args.grep(::Prism::SymbolNode).map { |arg| arg.unescaped.to_sym }
+      end
+    end
+  end
+end

data/lib/solid_score/parser/constant_name.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module SolidScore
+  module Parser
+    # Renders a Prism constant node as its qualified name ("Foo::Bar").
+    # Non-constant expressions (e.g. `Struct.new(:a)` as a superclass)
+    # fall back to their source text so callers still get a stable string.
+    module ConstantName
+      module_function
+
+      def of(node)
+        case node
+        when nil then nil
+        when ::Prism::ConstantReadNode then node.name.to_s
+        when ::Prism::ConstantPathNode then "#{of(node.parent)}::#{node.name}"
+        else node.slice
+        end
+      end
+    end
+  end
+end

data/lib/solid_score/parser/definition_collector.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module SolidScore
+  module Parser
+    # Walks a Prism syntax tree and collects every class/module definition
+    # as Models::ClassInfo, qualifying nested names with their namespace.
+    #
+    # Top-level definitions are found anywhere in the tree (e.g. inside an
+    # `if defined?(...)` guard). Inside a class/module body only direct
+    # child definitions are collected, matching the previous parser.
+    class DefinitionCollector < ::Prism::Visitor
+      attr_reader :classes
+
+      def initialize(file_path)
+        super()
+        @file_path = file_path
+        @namespace = nil
+        @classes = []
+      end
+
+      def visit_class_node(node)
+        collect_definition(node)
+      end
+
+      def visit_module_node(node)
+        collect_definition(node)
+      end
+
+      private
+
+      def collect_definition(node)
+        info = ClassBodyScanner.new(node, @file_path, @namespace).class_info
+        @classes << info
+        collect_nested(node, info.name)
+      end
+
+      def collect_nested(node, namespace)
+        with_namespace(namespace) do
+          ClassBodyScanner.body_statements(node)
+                          .select { |child| child.is_a?(::Prism::ClassNode) || child.is_a?(::Prism::ModuleNode) }
+                          .each { |child| visit(child) }
+        end
+      end
+
+      def with_namespace(namespace)
+        previous = @namespace
+        @namespace = namespace
+        yield
+      ensure
+        @namespace = previous
+      end
+    end
+  end
+end

data/lib/solid_score/parser/method_analyzer.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module SolidScore
+  module Parser
+    # Builds a Models::MethodInfo from a Prism DefNode by walking the method
+    # body once and collecting every metric the analyzers need.
+    class MethodAnalyzer
+      # Factory-style method names that count as instantiation for the
+      # `@ivar ||= Const.new` memoisation pattern (Issue #12).
+      # Mirrors DipAnalyzer::FACTORY_METHODS.
+      FACTORY_METHODS = %i[new create build call open].freeze
+
+      # Instance variable nodes: reads, every assignment form, and
+      # multiple-assignment targets (`@a, @b = ...`).
+      INSTANCE_VARIABLE_NODES = [
+        ::Prism::InstanceVariableReadNode,
+        ::Prism::InstanceVariableWriteNode,
+        ::Prism::InstanceVariableOrWriteNode,
+        ::Prism::InstanceVariableAndWriteNode,
+        ::Prism::InstanceVariableOperatorWriteNode,
+        ::Prism::InstanceVariableTargetNode
+      ].freeze
+
+      # Statement-like nodes that count toward the effective body size
+      # (Issue #10). Calls, conditionals, assignments, loops, jumps and
+      # blocks each count once; `||=`-style operator assignments count as
+      # both the assignment and the operator (see OPERATOR_ASSIGNMENT_NODES).
+      #
+      # Deliberately not counted: `case/in` pattern matching, `begin`,
+      # `rescue`/`ensure` wrappers, `when` clauses (the enclosing `case`
+      # already counts) and variable reads.
+      EFFECTIVE_STATEMENT_NODES = [
+        ::Prism::CallNode,
+        ::Prism::IfNode, ::Prism::UnlessNode, ::Prism::CaseNode, ::Prism::ReturnNode,
+        ::Prism::InstanceVariableWriteNode, ::Prism::LocalVariableWriteNode,
+        ::Prism::GlobalVariableWriteNode, ::Prism::ClassVariableWriteNode,
+        ::Prism::MultiWriteNode,
+        ::Prism::InstanceVariableTargetNode, ::Prism::LocalVariableTargetNode,
+        ::Prism::GlobalVariableTargetNode, ::Prism::ClassVariableTargetNode,
+        ::Prism::CallTargetNode, ::Prism::IndexTargetNode,
+        ::Prism::ConstantOrWriteNode, ::Prism::ConstantAndWriteNode, ::Prism::ConstantOperatorWriteNode,
+        ::Prism::ConstantPathOrWriteNode, ::Prism::ConstantPathAndWriteNode, ::Prism::ConstantPathOperatorWriteNode,
+        ::Prism::YieldNode, ::Prism::BlockNode, ::Prism::LambdaNode,
+        ::Prism::WhileNode, ::Prism::UntilNode, ::Prism::ForNode,
+        ::Prism::NextNode, ::Prism::BreakNode, ::Prism::RetryNode, ::Prism::RedoNode,
+        ::Prism::SuperNode, ::Prism::ForwardingSuperNode
+      ].freeze
+
+      # `x ||= v`, `x &&= v`, `x += v` on variables and attributes. Counted
+      # twice so the effective statement count matches the previous parser,
+      # which saw these as an assignment node wrapping an operator node.
+      # The attribute and index forms also read the target (`self.a ||= v`
+      # calls `a`), so they are recorded as method calls too.
+      OPERATOR_ASSIGNMENT_NODES = [
+        ::Prism::LocalVariableOrWriteNode, ::Prism::LocalVariableAndWriteNode,
+        ::Prism::LocalVariableOperatorWriteNode,
+        ::Prism::InstanceVariableOrWriteNode, ::Prism::InstanceVariableAndWriteNode,
+        ::Prism::InstanceVariableOperatorWriteNode,
+        ::Prism::GlobalVariableOrWriteNode, ::Prism::GlobalVariableAndWriteNode,
+        ::Prism::GlobalVariableOperatorWriteNode,
+        ::Prism::ClassVariableOrWriteNode, ::Prism::ClassVariableAndWriteNode,
+        ::Prism::ClassVariableOperatorWriteNode,
+        ::Prism::CallOrWriteNode, ::Prism::CallAndWriteNode, ::Prism::CallOperatorWriteNode,
+        ::Prism::IndexOrWriteNode, ::Prism::IndexAndWriteNode, ::Prism::IndexOperatorWriteNode
+      ].freeze
+
+      ATTRIBUTE_ASSIGNMENT_NODES = [
+        ::Prism::CallOrWriteNode, ::Prism::CallAndWriteNode, ::Prism::CallOperatorWriteNode
+      ].freeze
+
+      INDEX_ASSIGNMENT_NODES = [
+        ::Prism::IndexOrWriteNode, ::Prism::IndexAndWriteNode, ::Prism::IndexOperatorWriteNode
+      ].freeze
+
+      # Branching nodes that add one to cyclomatic complexity. Rescue is
+      # handled separately in visit_begin_node so that a multi-clause rescue
+      # counts once, as the previous parser did.
+      BRANCH_NODES = [
+        ::Prism::IfNode, ::Prism::UnlessNode, ::Prism::WhileNode, ::Prism::UntilNode,
+        ::Prism::ForNode, ::Prism::WhenNode, ::Prism::AndNode, ::Prism::OrNode,
+        ::Prism::RescueModifierNode
+      ].freeze
+
+      def initialize(node, visibility:, kind:)
+        @node = node
+        @visibility = visibility
+        @kind = kind
+        @instance_variables = []
+        @called_methods = []
+        @method_calls = []
+        @raises = []
+        @calls_super = false
+        @case_when_count = 0
+        @cyclomatic_complexity = 1
+        @effective_statement_count = 0
+        @memoized_factory_receiver = nil
+        @nested_definition_depth = 0
+      end
+
+      def method_info
+        walk(@node.body)
+
+        Models::MethodInfo.new(
+          name: @node.name,
+          visibility: @visibility,
+          line_start: @node.location.start_line,
+          line_end: @node.location.end_line,
+          instance_variables: @instance_variables.uniq,
+          called_methods: @called_methods.uniq,
+          parameters: parameters,
+          cyclomatic_complexity: @cyclomatic_complexity,
+          raises: @raises,
+          calls_super: @calls_super,
+          method_calls: @method_calls,
+          case_when_count: @case_when_count,
+          kind: @kind,
+          effective_statement_count: @effective_statement_count,
+          memoized_factory_receiver: @memoized_factory_receiver
+        )
+      end
+
+      private
+
+      # Pre-order walk. Generic bookkeeping first, then node-specific hooks,
+      # then recurse into children. A plain recursion is used instead of
+      # Prism::Visitor because every visit_* there iterates children itself,
+      # leaving no single place to hook all nodes.
+      def walk(node)
+        return unless node
+
+        record_instance_variable(node)
+        record_effective_statement(node)
+        @cyclomatic_complexity += 1 if BRANCH_NODES.any? { |type| node.is_a?(type) }
+        inspect_node(node)
+
+        nested = node.is_a?(::Prism::DefNode)
+        @nested_definition_depth += 1 if nested
+        node.compact_child_nodes.each { |child| walk(child) }
+        @nested_definition_depth -= 1 if nested
+      end
+
+      def inspect_node(node)
+        case node
+        when ::Prism::CallNode then inspect_call(node)
+        when *ATTRIBUTE_ASSIGNMENT_NODES then record_call(node.read_name, node.receiver)
+        when *INDEX_ASSIGNMENT_NODES then record_call(:[], node.receiver)
+        when ::Prism::CallTargetNode then record_call(node.name, node.receiver)
+        when ::Prism::IndexTargetNode then record_call(:[]=, node.receiver)
+        when ::Prism::InstanceVariableOrWriteNode
+          @memoized_factory_receiver ||= memoized_factory_receiver_for(node)
+        when ::Prism::SuperNode, ::Prism::ForwardingSuperNode then @calls_super = true
+        when ::Prism::CaseNode
+          @case_when_count += node.conditions.count { |condition| condition.is_a?(::Prism::WhenNode) }
+        when ::Prism::BeginNode then @cyclomatic_complexity += 1 if node.rescue_clause
+        end
+      end
+
+      def inspect_call(node)
+        record_call(node.name, node.receiver)
+        record_raise(node)
+      end
+
+      def record_call(name, receiver_node)
+        receiver, receiver_type = receiver_info(receiver_node)
+        @called_methods << name
+        @method_calls << Models::MethodCallInfo.new(method_name: name, receiver: receiver, receiver_type: receiver_type)
+      end
+
+      def record_instance_variable(node)
+        @instance_variables << node.name if INSTANCE_VARIABLE_NODES.any? { |type| node.is_a?(type) }
+      end
+
+      def record_effective_statement(node)
+        return if @nested_definition_depth.positive?
+
+        @effective_statement_count += 1 if EFFECTIVE_STATEMENT_NODES.any? { |type| node.is_a?(type) }
+        @effective_statement_count += 2 if OPERATOR_ASSIGNMENT_NODES.any? { |type| node.is_a?(type) }
+      end
+
+      def record_raise(node)
+        return unless %i[raise fail].include?(node.name)
+
+        raised = node.arguments&.arguments&.first
+        return unless raised.is_a?(::Prism::ConstantReadNode) || raised.is_a?(::Prism::ConstantPathNode)
+
+        @raises << ConstantName.of(raised)
+      end
+
+      def receiver_info(node)
+        case node
+        when nil, ::Prism::SelfNode then [nil, :self]
+        when ::Prism::ConstantReadNode, ::Prism::ConstantPathNode then [ConstantName.of(node), :const]
+        when ::Prism::InstanceVariableReadNode then [node.name.to_s, :ivar]
+        when ::Prism::LocalVariableReadNode then [node.name.to_s, :lvar]
+        when ::Prism::CallNode then [nil, :send]
+        else [nil, :unknown]
+        end
+      end
+
+      def memoized_factory_receiver_for(node)
+        call = node.value
+        return nil unless call.is_a?(::Prism::CallNode) && FACTORY_METHODS.include?(call.name)
+
+        receiver = call.receiver
+        return nil unless receiver.is_a?(::Prism::ConstantReadNode) || receiver.is_a?(::Prism::ConstantPathNode)
+
+        ConstantName.of(receiver)
+      end
+
+      def parameters
+        params = @node.parameters
+        return [] unless params
+
+        [
+          *params.requireds.map { |p| positional(p) },
+          *params.optionals.map { |p| [:optarg, p.name] },
+          *Array(params.rest).map { |p| rest(p) },
+          *params.posts.map { |p| positional(p) },
+          *params.keywords.map { |p| keyword(p) },
+          *Array(params.keyword_rest).map { |p| keyword_rest(p) },
+          *Array(params.block).map { |p| [:blockarg, p.name] }
+        ]
+      end
+
+      def positional(node)
+        node.is_a?(::Prism::MultiTargetNode) ? [:mlhs, nil] : [:arg, node.name]
+      end
+
+      def rest(node)
+        node.is_a?(::Prism::ImplicitRestNode) ? [:restarg, nil] : [:restarg, node.name]
+      end
+
+      def keyword(node)
+        node.is_a?(::Prism::RequiredKeywordParameterNode) ? [:kwarg, node.name] : [:kwoptarg, node.name]
+      end
+
+      def keyword_rest(node)
+        case node
+        when ::Prism::ForwardingParameterNode then [:forward_arg, nil]
+        when ::Prism::NoKeywordsParameterNode then [:kwnilarg, nil]
+        else [:kwrestarg, node.name]
+        end
+      end
+    end
+  end
+end

data/lib/solid_score/parser/ruby_parser.rb

@@ -1,450 +1,30 @@
 # frozen_string_literal: true
 
-require "parser/current"
+require "prism"
 
 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
+    # Raised when a source file cannot be parsed. Prism itself never raises
+    # on syntax errors (it returns a partial tree plus diagnostics), so the
+    # first error is surfaced here for callers that want to skip the file.
+    class SyntaxError < StandardError; end
 
+    # Parses Ruby source with Prism's native node API and extracts
+    # class/module definitions as Models::ClassInfo.
+    class RubyParser
       def parse_file(file_path)
-        source = File.read(file_path)
-        ast = ::Parser::CurrentRuby.parse(source)
-        return [] unless ast
+        result = ::Prism.parse_file(file_path)
+        raise SyntaxError, format_error(file_path, result.errors.first) if result.failure?
 
-        extract_definitions(ast, file_path)
+        collector = DefinitionCollector.new(file_path)
+        result.value.accept(collector)
+        collector.classes
       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
+      def format_error(file_path, error)
+        "#{file_path}:#{error.location.start_line}:#{error.location.start_column}: #{error.message}"
       end
     end
   end

data/lib/solid_score/runner.rb

@@ -56,7 +56,7 @@ module SolidScore
 
     def parse_file(file)
       @parser.parse_file(file)
-    rescue ::Parser::SyntaxError
+    rescue ::SolidScore::Parser::SyntaxError
       []
     end
 

data/lib/solid_score/version.rb

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

data/lib/solid_score.rb

@@ -4,6 +4,10 @@ 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/constant_name"
+require_relative "solid_score/parser/method_analyzer"
+require_relative "solid_score/parser/class_body_scanner"
+require_relative "solid_score/parser/definition_collector"
 require_relative "solid_score/parser/ruby_parser"
 require_relative "solid_score/analyzers/base_analyzer"
 require_relative "solid_score/analyzers/mitigations"

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: solid_score
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - harachan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ast
+  name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.4'
-- !ruby/object:Gem::Dependency
-  name: parser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '1.0'
 description: Static analysis tool that scores Ruby classes/modules against SOLID principles
   using AST analysis
 email:
@@ -80,6 +66,10 @@ files:
 - lib/solid_score/models/class_info.rb
 - lib/solid_score/models/method_info.rb
 - lib/solid_score/models/score_result.rb
+- lib/solid_score/parser/class_body_scanner.rb
+- lib/solid_score/parser/constant_name.rb
+- lib/solid_score/parser/definition_collector.rb
+- lib/solid_score/parser/method_analyzer.rb
 - lib/solid_score/parser/ruby_parser.rb
 - lib/solid_score/presets.rb
 - lib/solid_score/runner.rb