rails_code_health 0.1.0 → 0.3.0

data/lib/rails_code_health/rails_analyzer.rb

@@ -1,5 +1,7 @@
 module RailsCodeHealth
   class RailsAnalyzer
+    include RailsCodeHealth::ASTHelpers
+
     def initialize(file_path, file_type)
       @file_path = file_path
       @file_type = file_type
@@ -21,6 +23,12 @@ module RailsCodeHealth
         analyze_helper
       when :migration
         analyze_migration
+      when :service
+        analyze_service
+      when :interactor
+        analyze_interactor
+      when :serializer
+        analyze_serializer
       else
         {}
       end
@@ -37,6 +45,7 @@ module RailsCodeHealth
         has_before_actions: has_before_actions?,
         uses_strong_parameters: uses_strong_parameters?,
         has_direct_model_access: has_direct_model_access?,
+        has_business_logic: has_business_logic?,
         response_formats: detect_response_formats,
         rails_smells: detect_controller_smells
       }
@@ -97,11 +106,10 @@ module RailsCodeHealth
       return 0 unless @ast
 
       action_count = 0
-      find_nodes(@ast, :def) do |node|
-        method_name = node.children[0].to_s
-        # Skip private methods and Rails internal methods
-        unless method_name.start_with?('_') || private_controller_method?(method_name)
-          action_count += 1
+      find_nodes(@ast, :class) do |class_node|
+        defs_by_visibility(class_node)[:public].each do |def_node|
+          name = def_node.children[0].to_s
+          action_count += 1 unless name.start_with?('_')
         end
       end
       action_count
@@ -115,17 +123,25 @@ module RailsCodeHealth
       @source.include?('params.require') || @source.include?('params.permit')
     end
 
+    DIRECT_MODEL_METHODS = %i[find find_by where create create! update update! all first last destroy_all].freeze
+
     def has_direct_model_access?
-      # Look for direct ActiveRecord calls in controller actions
-      model_patterns = [
-        /\w+\.find\(/,
-        /\w+\.where\(/,
-        /\w+\.create\(/,
-        /\w+\.update\(/,
-        /\w+\.all/
-      ]
-      
-      model_patterns.any? { |pattern| @source.match?(pattern) }
+      return false unless @ast
+
+      found = false
+      find_nodes(@ast, :class) do |class_node|
+        defs_by_visibility(class_node)[:public].each do |def_node|
+          find_nodes(def_node, :send) do |send_node|
+            receiver = send_node.children[0]
+            method_name = send_node.children[1]
+            # Receiver must be a constant (a likely model class) and the method must be an AR method.
+            next unless receiver.is_a?(Parser::AST::Node) && receiver.type == :const
+            next unless DIRECT_MODEL_METHODS.include?(method_name)
+            found = true
+          end
+        end
+      end
+      found
     end
 
     def detect_response_formats
@@ -137,6 +153,24 @@ module RailsCodeHealth
       formats
     end
 
+    BUSINESS_VERBS = %i[calculate compute process charge refund transition].freeze
+    # Methods with these prefixes likely indicate business logic.
+    # `process_` was previously included but removed because of false positives
+    # on common AR attributes like `process_id`.
+    BUSINESS_VERB_PREFIXES = %w[calculate_ compute_].freeze
+
+    def has_business_logic?
+      return false unless @ast
+
+      found = false
+      find_nodes(@ast, :class) do |class_node|
+        defs_by_visibility(class_node)[:public].each do |def_node|
+          found = true if action_has_business_logic?(def_node)
+        end
+      end
+      found
+    end
+
     def detect_controller_smells
       smells = []
       
@@ -163,55 +197,125 @@ module RailsCodeHealth
         }
       end
 
+      if has_business_logic?
+        smells << {
+          type: :business_logic_in_controller,
+          severity: :high
+        }
+      end
+
       smells
     end
 
+    def action_has_business_logic?(def_node)
+      # NOTE: arithmetic signal (plan A2 item 2) intentionally not implemented —
+      # accuracy of detecting "two non-literal operands" was deemed not worth
+      # the false positive risk in v0.3.0.
+      return true if business_verb_call?(def_node)
+      return true if transaction_block?(def_node)
+      return true if loop_with_conditional?(def_node)
+      false
+    end
+
+    def business_verb_call?(def_node)
+      found = false
+      find_nodes(def_node, :send) do |send_node|
+        method_name = send_node.children[1].to_s
+        if BUSINESS_VERBS.include?(method_name.to_sym) ||
+           BUSINESS_VERB_PREFIXES.any? { |p| method_name.start_with?(p) }
+          found = true
+        end
+      end
+      found
+    end
+
+    def transaction_block?(def_node)
+      found = false
+      find_nodes(def_node, :block) do |block_node|
+        send_node = block_node.children[0]
+        next unless send_node.is_a?(Parser::AST::Node) && send_node.type == :send
+        found = true if send_node.children[1] == :transaction
+      end
+      found
+    end
+
+    def loop_with_conditional?(def_node)
+      found = false
+      find_nodes(def_node, :block) do |block_node|
+        send_node = block_node.children[0]
+        next unless send_node.is_a?(Parser::AST::Node) && send_node.type == :send
+        next unless %i[each map select reject].include?(send_node.children[1])
+        # Look for conditionals inside the block body.
+        find_nodes(block_node.children[2], :if) { found = true }
+        find_nodes(block_node.children[2], :case) { found = true }
+      end
+      found
+    end
+
+    ASSOCIATION_MACROS = %i[belongs_to has_one has_many has_and_belongs_to_many].freeze
+    VALIDATION_MACROS = %i[validates validates_presence_of validates_uniqueness_of validates_format_of validates_length_of validates_numericality_of validates_inclusion_of validates_exclusion_of validates_acceptance_of validates_confirmation_of].freeze
+    CALLBACK_MACROS = %i[before_save after_save before_create after_create before_update after_update before_destroy after_destroy after_commit after_rollback before_validation after_validation].freeze
+
     # Model analysis methods
     def count_associations
-      associations = 0
-      association_methods = %w[belongs_to has_one has_many has_and_belongs_to_many]
-      
-      association_methods.each do |method|
-        associations += @source.scan(/#{method}\s+:/).count
+      total = 0
+      find_nodes(@ast, :class) do |class_node|
+        ASSOCIATION_MACROS.each do |macro|
+          total += class_body_sends(class_node, macro).size
+        end
       end
-      
-      associations
+      total
     end
 
     def count_validations
-      validations = 0
-      validation_methods = %w[validates validates_presence_of validates_uniqueness_of validates_format_of]
-      
-      validation_methods.each do |method|
-        validations += @source.scan(/#{method}\s+/).count
+      total = 0
+      find_nodes(@ast, :class) do |class_node|
+        VALIDATION_MACROS.each do |macro|
+          total += class_body_sends(class_node, macro).size
+        end
       end
-      
-      validations
+      total
     end
 
     def count_callbacks
-      callbacks = 0
-      callback_methods = %w[before_save after_save before_create after_create before_update after_update before_destroy after_destroy]
-      
-      callback_methods.each do |method|
-        callbacks += @source.scan(/#{method}\s+/).count
+      total = 0
+      find_nodes(@ast, :class) do |class_node|
+        CALLBACK_MACROS.each do |macro|
+          total += class_body_sends(class_node, macro).size
+        end
       end
-      
-      callbacks
+      total
     end
 
     def count_scopes
-      @source.scan(/scope\s+:/).count
+      total = 0
+      find_nodes(@ast, :class) do |class_node|
+        total += class_body_sends(class_node, :scope).size
+      end
+      total
     end
 
     def has_fat_model_smell?
       return false unless @ast
 
-      line_count = @source.lines.count
+      class_node = nil
+      find_nodes(@ast, :class) { |n| class_node ||= n }
+      return false unless class_node
+
+      code_lines = code_line_count(class_node)
       method_count = 0
-      find_nodes(@ast, :def) { method_count += 1 }
-      
-      line_count > 200 && method_count > 15
+      find_nodes_in_scope(class_node, :def) { method_count += 1 }
+
+      code_lines > 200 && method_count > 15
+    end
+
+    def code_line_count(node)
+      return 0 unless node.respond_to?(:loc) && node.loc.respond_to?(:expression)
+      expr = node.loc.expression
+      return 0 unless expr
+
+      lines = expr.source.lines
+      lines.count { |line| line.strip != '' && !line.strip.start_with?('#') }
     end
 
     def detect_model_smells
@@ -244,16 +348,16 @@ module RailsCodeHealth
       smells
     end
 
+    VIEW_CONTROL_FLOW_KEYWORDS = %w[if unless elsif else case for while end].freeze
+
     # View analysis methods
-    def count_view_logic_lines(lines)
-      logic_count = 0
-      
-      lines.each do |line|
-        # Count Ruby code blocks in ERB
-        logic_count += 1 if line.match?(/<%((?!%>).)*%>/) || line.match?(/<%((?!%>).)*if|unless|case|for|while/)
+    def count_view_logic_lines(_lines)
+      count = 0
+      erb_ruby_fragments(@source).each do |ruby|
+        tokens = ruby.scan(/\b\w+\b/)
+        count += 1 if (tokens & VIEW_CONTROL_FLOW_KEYWORDS).any?
       end
-      
-      logic_count
+      count
     end
 
     def has_inline_styles?
@@ -324,10 +428,22 @@ module RailsCodeHealth
       smells
     end
 
+    DATA_CHANGE_METHODS = %i[
+      execute update_all delete_all
+      find_each update update_columns update_column
+      update! save save!
+    ].freeze
+
     # Migration analysis methods
     def has_data_changes?
-      data_methods = %w[execute update_all delete_all]
-      data_methods.any? { |method| @source.include?(method) }
+      return false unless @ast
+
+      found = false
+      find_nodes(@ast, :send) do |send_node|
+        method_name = send_node.children[1]
+        found = true if DATA_CHANGE_METHODS.include?(method_name)
+      end
+      found
     end
 
     def has_index_changes?
@@ -372,20 +488,300 @@ module RailsCodeHealth
       smells
     end
 
-    # Helper methods
-    def find_nodes(node, type, &block)
-      return unless node.is_a?(Parser::AST::Node)
+    # Service analysis methods
+    def analyze_service
+      return {} unless @ast
+
+      {
+        rails_type: :service,
+        has_call_method: has_call_method?,
+        dependencies: detect_service_dependencies,
+        error_handling: detect_error_handling,
+        complexity_score: calculate_service_complexity,
+        rails_smells: detect_service_smells
+      }
+    end
+
+    def has_call_method?
+      return false unless @ast
+      
+      has_instance_call = false
+      has_class_call = false
+      
+      find_nodes(@ast, :def) do |node|
+        method_name = node.children[0].to_s
+        has_instance_call = true if method_name == 'call'
+      end
+      
+      find_nodes(@ast, :defs) do |node|
+        method_name = node.children[1].to_s
+        has_class_call = true if method_name == 'call'
+      end
+      
+      has_instance_call || has_class_call
+    end
+
+    def detect_service_dependencies
+      deps = []
+
+      if @source.match?(/\b(?:[A-Z]\w*)\.(?:find|find_by|where|create|create!|update|update!|all|first|last)\b/)
+        deps << :active_record
+      end
+
+      if @source.match?(/\b(?:Net::HTTP|HTTParty|Faraday|RestClient|Typhoeus)\b/)
+        deps << :external_api
+      end
+
+      if @source.match?(/\b(?:File|Dir|FileUtils|Pathname)\.\w+/)
+        deps << :file_system
+      end
+
+      if @source.match?(/\b(?:Mailer|ActionMailer)\b/) || @source.match?(/\.deliver(?:_now|_later)?\b/)
+        deps << :email
+      end
+
+      if @source.match?(/\bRails\.cache\b/) || @source.match?(/\bRedis\b/) || @source.match?(/\bcache_store\b/)
+        deps << :cache
+      end
+
+      deps.uniq
+    end
+
+    def detect_error_handling
+      error_handling = {
+        rescue_blocks: @source.scan(/rescue/).count,
+        raise_statements: @source.scan(/raise/).count
+      }
+      
+      error_handling[:has_error_handling] = error_handling[:rescue_blocks] > 0 || error_handling[:raise_statements] > 0
+      error_handling
+    end
+
+    def calculate_service_complexity
+      complexity = 0
+      
+      # Base complexity from dependencies
+      complexity += detect_service_dependencies.count * 2
+      
+      # Conditional complexity
+      complexity += @source.scan(/\bif\b/).count
+      complexity += @source.scan(/\bunless\b/).count
+      complexity += @source.scan(/\bcase\b/).count
+      
+      # Error handling complexity
+      error_handling = detect_error_handling
+      complexity += error_handling[:rescue_blocks] * 2
+      complexity += error_handling[:raise_statements]
+      
+      complexity
+    end
+
+    def detect_service_smells
+      smells = []
+      
+      unless has_call_method?
+        smells << {
+          type: :missing_call_method,
+          severity: :high
+        }
+      end
+      
+      complexity = calculate_service_complexity
+      if complexity >= 13
+        smells << {
+          type: :fat_service,
+          complexity: complexity,
+          severity: :high
+        }
+      end
+      
+      error_handling = detect_error_handling
+      unless error_handling[:has_error_handling]
+        smells << {
+          type: :missing_error_handling,
+          severity: :medium
+        }
+      end
+      
+      smells
+    end
+
+    # Interactor analysis methods
+    def analyze_interactor
+      return {} unless @ast
+
+      {
+        rails_type: :interactor,
+        has_call_method: has_call_method?,
+        context_usage: detect_context_usage,
+        fail_usage: detect_fail_usage,
+        is_organizer: is_organizer?,
+        complexity_score: calculate_interactor_complexity,
+        rails_smells: detect_interactor_smells
+      }
+    end
+
+    def detect_context_usage
+      {
+        context_references: @source.scan(/(?<!@)\bcontext\./).count,
+        instance_context_references: @source.scan(/@context/).count
+      }
+    end
+
+    def detect_fail_usage
+      {
+        context_fail: @source.scan(/context\.fail/).count,
+        # `fail!` only — NOT `context.fail!` (that's counted as context_fail).
+        fail_bang: @source.scan(/(?<!\.)\bfail!/).count
+      }
+    end
+
+    def is_organizer?
+      @source.include?('organize') || @source.include?('Interactor::Organizer')
+    end
+
+    def calculate_interactor_complexity
+      complexity = 0
+      
+      # Base complexity for organizers
+      complexity += 5 if is_organizer?
+      
+      # Context usage complexity
+      context_usage = detect_context_usage
+      complexity += context_usage[:context_references]
+      complexity += context_usage[:instance_context_references]
+      
+      # Conditional complexity
+      complexity += @source.scan(/\bif\b/).count
+      complexity += @source.scan(/\bunless\b/).count
+      
+      # Fail usage adds complexity
+      fail_usage = detect_fail_usage
+      complexity += fail_usage[:context_fail] * 2
+      complexity += fail_usage[:fail_bang] * 2
+      
+      complexity
+    end
+
+    def detect_interactor_smells
+      smells = []
+      
+      unless has_call_method?
+        smells << {
+          type: :missing_call_method,
+          severity: :high
+        }
+      end
+      
+      if is_organizer?
+        complexity = calculate_interactor_complexity
+        if complexity > 20
+          smells << {
+            type: :complex_organizer,
+            complexity: complexity,
+            severity: :high
+          }
+        end
+      end
+      
+      fail_usage = detect_fail_usage
+      if fail_usage[:context_fail] == 0 && fail_usage[:fail_bang] == 0
+        smells << {
+          type: :missing_failure_handling,
+          severity: :medium
+        }
+      end
+      
+      smells
+    end
+
+    # Serializer analysis methods
+    def analyze_serializer
+      return {} unless @ast
 
-      yield(node) if node.type == type
+      {
+        rails_type: :serializer,
+        attribute_count: count_serializer_attributes,
+        association_count: count_serializer_associations,
+        custom_method_count: count_custom_serializer_methods,
+        has_conditional_attributes: has_conditional_attributes?,
+        rails_smells: detect_serializer_smells
+      }
+    end
 
-      node.children.each do |child|
-        find_nodes(child, type, &block)
+    def count_serializer_attributes
+      # Count each symbol passed to attributes/attribute calls.
+      # `attributes :id, :name, :email` counts as 3; `attribute :full_name` as 1.
+      count = 0
+      @source.scan(/^\s*attributes?\s+(.+)$/).each do |(args)|
+        count += args.scan(/:\w+/).size
       end
+      count
     end
 
-    def private_controller_method?(method_name)
-      %w[show new edit create update destroy].include?(method_name) ||
-        method_name.end_with?('_params')
+    def count_serializer_associations
+      count = 0
+      %w[has_one has_many belongs_to].each do |method|
+        @source.scan(/^\s*#{method}\s+(.+)$/).each do |(args)|
+          count += args.scan(/:\w+/).size
+        end
+      end
+      count
     end
+
+    def count_custom_serializer_methods
+      return 0 unless @ast
+      
+      method_count = 0
+      standard_methods = %w[initialize attributes serialize serializable_hash]
+      
+      find_nodes(@ast, :def) do |node|
+        method_name = node.children[0].to_s
+        unless standard_methods.include?(method_name) || method_name.start_with?('_')
+          method_count += 1
+        end
+      end
+      
+      method_count
+    end
+
+    def has_conditional_attributes?
+      @source.include?('if:') || @source.include?('unless:') || @source.include?('condition:')
+    end
+
+    def detect_serializer_smells
+      smells = []
+      
+      attribute_count = count_serializer_attributes
+      association_count = count_serializer_associations
+      total_fields = attribute_count + association_count
+      
+      if total_fields > 20
+        smells << {
+          type: :fat_serializer,
+          field_count: total_fields,
+          severity: :high
+        }
+      end
+      
+      custom_method_count = count_custom_serializer_methods
+      if custom_method_count > 10
+        smells << {
+          type: :complex_serializer,
+          method_count: custom_method_count,
+          severity: :medium
+        }
+      end
+      
+      if attribute_count == 0 && association_count == 0
+        smells << {
+          type: :empty_serializer,
+          severity: :low
+        }
+      end
+      
+      smells
+    end
+
   end
 end