rails_code_health 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaafc84bb8cf4bad9931fb39ef97d3a1bf76a61bc4e2289191df870f10a33e1e
-  data.tar.gz: ad77a703a06b6eee946756f7645ef76de9c943fcadd192c27a425bd37f3027fd
+  metadata.gz: 806988266c00efaa8181b4379e6baa5f5ff9e5913fa4a0801fd993ededf3a580
+  data.tar.gz: 61e1909e93309e22265b961038f87da7c0367f38cf6cf9a763449e144e39c73f
 SHA512:
-  metadata.gz: 832e4d0437e9e92e121da7a890f3451ee5f37047a586db713edfb07265ab55e5f8c0f221b21f9c4eccb974b7e4b4429ae28cedcd0c7ec5c060f633733996cea8
-  data.tar.gz: f00785bb224064d66c01486a4929fd74ba7102559f9280c3c95f619fb67034a41babcb7e2e93ffe74cb37a08848d7d19d9f0cc25a8aaab460ad5f667e695b926
+  metadata.gz: 37d498b553e834f76811b405f6be6b967fec45512170098b70b818bc952de8321cf7790dce0f7b93b1353fc373b12614ba9f7be98466e871d26f25b22ad75938
+  data.tar.gz: 1ca51781fa1cccfdabd3ef5e138d2cd2aea2e0a64432ea7e26802464c4e5c732185c09a8622ca4a558f8ccef7762653a168982dcc1db9f6fe29633ded8feb673

data/CHANGELOG.md

@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-05-18
+
+### Fixed
+- `ReportGenerator` no longer includes migration files in the "Top Performing Files" showcase. Migrations are almost always trivially simple by construction, so they routinely crowded out genuinely well-written healthy files in the top-5 list. Migrations are still analyzed and still appear in the "Files Needing Most Attention" list when problematic.
+
+### Added
+- `docs/index.html` static landing page for GitHub Pages, explaining the why and how of the gem.
+
+## [0.3.0] - 2026-05-12
+
+### Added
+- `RailsCodeHealth::ASTHelpers` module: shared AST traversal with scoped variants and visibility-aware def collection.
+- Fixture-based RSpec test suite under `spec/fixtures/code_samples/`.
+- New configuration group `smell_thresholds` for previously hard-coded values.
+
+### Fixed
+- `RubyAnalyzer#count_public_methods_in_class` now actually distinguishes public from private methods (including inline `private def foo`).
+- `RubyAnalyzer#count_parameters` now counts only true parameter nodes.
+- `RubyAnalyzer` nesting depth calculation no longer counts `:begin` and `:block` as nesting levels.
+- `RailsAnalyzer#count_controller_actions` no longer inverts public/private; the seven canonical RESTful actions are correctly counted, and private helpers are excluded.
+- `RailsAnalyzer#has_direct_model_access?` only fires when model calls appear inside public controller actions.
+- `RailsAnalyzer#has_business_logic?` uses stricter signals (business-verb calls on model receivers, transactions, loops with conditionals) instead of matching any compound `if` or any `.each do`.
+- Model `count_associations`, `count_validations`, `count_callbacks`, `count_scopes` count only top-level class body macros — no comments, strings, or nested-class matches.
+- `has_fat_model_smell?` uses class-scoped code-line count and class-scoped method count.
+- View `count_view_logic_lines` parses ERB fragments and no longer flags plain HTML that happens to contain `if`, `unless`, etc., in text.
+- Migration `has_data_changes?` recognizes `find_each`, `update`, `update_columns`, `update_column`, `update!`, `update_all`, `delete_all`, `save`, `save!`, raw `connection.execute`, and `execute`.
+- Service `detect_service_dependencies` uses word boundaries — `Profile.` no longer matches the `File.` check.
+- God class, high complexity, parameter, and nesting smell thresholds are now read from configuration instead of inlined.
+- Service `detect_service_smells` now flags `:fat_service` at complexity ≥ 13 (was > 15, which left some genuinely-fat services unflagged).
+- Interactor `detect_fail_usage` no longer double-counts `context.fail!` as both `context_fail` and `fail_bang`.
+- Serializer `count_serializer_attributes` / `count_serializer_associations` now count each symbol (`attributes :a, :b, :c` = 3) instead of just one per declaration line.
+- `FileAnalyzer#find_view_files` dedupes overlapping glob matches so files under `app/views/` are no longer counted twice when matched by both `app/views/**/*.erb` and `app/**/views/**/*.erb`.
+- `HealthCalculator` service/interactor/serializer penalties now use flat (un-weighted) multipliers for the most severe issues (missing call method, fat service, complex organizer, fat serializer) — the global `rails_conventions` weight (0.15) was too small to make these matter.
+
+### Changed (may affect scores)
+- Score changes are expected on any project where the above false positives or false negatives applied. Re-baseline before comparing to v0.2.0 reports.
+- Services missing a `call` method now score noticeably lower (penalty went from ~0.45 to 3.0); same for interactors. Fat serializers and complex organizers are also penalized more strongly.
+
 ## [0.2.0] - 2025-06-19
 
 ### Added
@@ -43,6 +81,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Reporting**: Detailed console output with health categories and JSON export
 - **CLI**: `rails-health` command with options for format, output file, and custom configuration
 
-[Unreleased]: https://github.com/gkosmo/rails_code_health/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/gkosmo/rails_code_health/compare/v0.3.1...HEAD
+[0.3.1]: https://github.com/gkosmo/rails_code_health/compare/v0.3.0...v0.3.1
+[0.3.0]: https://github.com/gkosmo/rails_code_health/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/gkosmo/rails_code_health/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/gkosmo/rails_code_health/releases/tag/v0.1.0

data/README.md

@@ -1,5 +1,7 @@
 # Rails Code Health
 
+[![CI](https://github.com/gkosmo/rails_code_health/actions/workflows/ci.yml/badge.svg)](https://github.com/gkosmo/rails_code_health/actions/workflows/ci.yml)
+
 A Ruby gem that evaluates the code health of Ruby on Rails applications, [inspired by CodeScene's research on technical debt and maintainability](https://arxiv.org/pdf/2203.04374
 ).
 
@@ -127,6 +129,8 @@ Health scores range from 1.0 (critical) to 10.0 (excellent) based on:
 - **🔴 Alert (1.0-3.9)**: Significant problems requiring attention
 - **⚫ Critical (<1.0)**: Severe issues, immediate action needed
 
+> **Note on v0.3.0 scores:** v0.3.0 fixes several false positives and false negatives in the Rails-specific checks. Scores on the same codebase will move compared to v0.2.0. See the CHANGELOG for the list of changed checks.
+
 ## Configuration
 
 Create a custom `thresholds.json` file:

data/lib/rails_code_health/ast_helpers.rb

@@ -0,0 +1,126 @@
+module RailsCodeHealth
+  module ASTHelpers
+    SCOPE_BOUNDARY_TYPES = %i[class module def defs sclass].freeze
+    VISIBILITY_MODIFIERS = %i[public private protected].freeze
+
+    # Yields every descendant (and the node itself) of the given type.
+    # Descends into all children.
+    def find_nodes(node, type, &block)
+      return unless node.is_a?(Parser::AST::Node)
+
+      yield(node) if node.type == type
+      node.children.each { |child| find_nodes(child, type, &block) }
+    end
+
+    # Returns a hash { public: [def_nodes], private: [def_nodes], protected: [def_nodes] }
+    # for the given class node. Handles bare modifier blocks and inline `private def foo`.
+    # Defs inside `class << self` are excluded (the :sclass node is not descended into).
+    #
+    # NOTE: `private :symbol_name` / `private :a, :b` forms are NOT handled —
+    # methods so marked stay classified as :public. Only bare modifier blocks
+    # (`private` on its own line) and inline `private def foo` are recognized.
+    def defs_by_visibility(class_node)
+      result = { public: [], private: [], protected: [] }
+      return result unless class_node.is_a?(Parser::AST::Node)
+      return result unless %i[class module].include?(class_node.type)
+
+      current = :public
+      body = class_body_children(class_node)
+
+      body.each do |child|
+        next unless child.is_a?(Parser::AST::Node)
+
+        if child.type == :send && child.children[0].nil? &&
+           VISIBILITY_MODIFIERS.include?(child.children[1])
+          modifier = child.children[1]
+          if child.children.length == 2
+            # bare modifier — changes default for subsequent defs
+            current = modifier
+          else
+            # inline form: `private def foo` or `private :foo`
+            inline_target = child.children[2]
+            if inline_target.is_a?(Parser::AST::Node) && inline_target.type == :def
+              result[modifier] << inline_target
+            end
+          end
+        elsif child.type == :def
+          result[current] << child
+        end
+      end
+
+      result
+    end
+
+    # Returns direct `:send` nodes in the class body matching the given method name.
+    # Does not descend into nested classes, modules, or method bodies.
+    #
+    # NOTE: calls wrapped in a block (e.g., `included do ... end` in concerns)
+    # are NOT matched — the wrapping :block node is not a :send. Use
+    # class_body_children directly and inspect :block nodes if you need to find
+    # macro calls inside such wrappers.
+    def class_body_sends(class_node, method_name)
+      matches = []
+      return matches unless class_node.is_a?(Parser::AST::Node)
+      return matches unless %i[class module].include?(class_node.type)
+
+      class_body_children(class_node).each do |child|
+        next unless child.is_a?(Parser::AST::Node)
+        next unless child.type == :send
+        # Receiver-less send only (e.g., `has_many :foo`, not `MyMod.has_many :foo`)
+        next unless child.children[0].nil?
+        matches << child if child.children[1] == method_name
+      end
+
+      matches
+    end
+
+    # Yields each Ruby code fragment inside <% %> / <%= %> / <%- %> tags.
+    # Multi-line tags are handled. ERB comment tags (<%# ... %>) are skipped.
+    # Returns an Enumerator if no block given.
+    def erb_ruby_fragments(source)
+      return enum_for(:erb_ruby_fragments, source) unless block_given?
+
+      source.scan(/<%(?!#)=?-?(.*?)-?%>/m) do |match|
+        yield match[0]
+      end
+    end
+
+    # Like find_nodes, but does not descend into nested class/module/def/defs/sclass
+    # nodes. The starting node itself is inspected; all children are inspected, but
+    # nested scope-introducing constructs are not recursed into.
+    def find_nodes_in_scope(node, type, &block)
+      return unless node.is_a?(Parser::AST::Node)
+
+      yield(node) if node.type == type
+
+      node.children.each do |child|
+        next unless child.is_a?(Parser::AST::Node)
+
+        # Scope-boundary children get yielded if they match the target type,
+        # but we do not recurse into them.
+        if SCOPE_BOUNDARY_TYPES.include?(child.type)
+          yield(child) if child.type == type
+          next
+        end
+
+        find_nodes_in_scope(child, type, &block)
+      end
+    end
+
+    private
+
+    # The body of a `class` node is its third child; for `module`, the second.
+    # The body may be a single node or a `:begin` containing a sequence of nodes.
+    def class_body_children(class_or_module_node)
+      body =
+        case class_or_module_node.type
+        when :class then class_or_module_node.children[2]
+        when :module then class_or_module_node.children[1]
+        end
+
+      return [] if body.nil?
+      return body.children if body.is_a?(Parser::AST::Node) && body.type == :begin
+      [body]
+    end
+  end
+end

data/lib/rails_code_health/configuration.rb

@@ -68,6 +68,13 @@ module RailsCodeHealth
           'dependency_count' => { 'green' => 3, 'yellow' => 5, 'red' => 8 },
           'complexity_score' => { 'green' => 10, 'yellow' => 15, 'red' => 25 }
         },
+        'smell_thresholds' => {
+          'god_class_lines' => 400,
+          'god_class_methods' => 20,
+          'high_complexity_method' => 15,
+          'too_many_parameters' => 5,
+          'nested_conditionals' => 4
+        },
         'file_type_multipliers' => {
           'controllers' => 1.2,
           'models' => 1.0,

data/lib/rails_code_health/file_analyzer.rb

@@ -91,7 +91,9 @@ module RailsCodeHealth
         files.concat(Dir.glob(pattern))
       end
 
-      files.map { |f| Pathname.new(f) }
+      # Patterns overlap (`app/views/**/*.erb` and `app/**/views/**/*.erb` both
+      # match files under `app/views/...`); dedupe by absolute path.
+      files.uniq.map { |f| Pathname.new(f) }
     end
 
     def should_skip_file?(relative_path)

data/lib/rails_code_health/health_calculator.rb

@@ -225,97 +225,101 @@ module RailsCodeHealth
 
     def calculate_service_penalties(service_data)
       penalties = []
-      
-      # Missing call method - critical for services
+
+      # Missing call method - critical for services. Use a flat (un-attenuated)
+      # penalty here because the `rails_conventions` weight (0.15) is sized for
+      # softer conventions; missing the core service contract is severe.
       unless service_data[:has_call_method]
-        penalties << 3.0 * @weights['rails_conventions']
+        penalties << 3.0
       end
-      
+
       # Too many dependencies
       dependency_count = service_data[:dependencies]&.count || 0
       service_thresholds = @thresholds['service_thresholds']['dependency_count']
       if dependency_count > service_thresholds['yellow']
-        severity = dependency_count > service_thresholds['red'] ? 2.0 : 1.0
-        penalties << severity * @weights['rails_conventions']
+        severity = dependency_count > service_thresholds['red'] ? 1.5 : 0.75
+        penalties << severity
       end
-      
+
       # High complexity
       complexity = service_data[:complexity_score] || 0
       complexity_thresholds = @thresholds['service_thresholds']['complexity_score']
       if complexity > complexity_thresholds['yellow']
         severity = complexity > complexity_thresholds['red'] ? 2.0 : 1.0
-        penalties << severity * @weights['rails_conventions']
+        penalties << severity
       end
-      
+
       # Missing error handling
       error_handling = service_data[:error_handling] || {}
       unless error_handling[:has_error_handling]
         penalties << 1.0 * @weights['rails_conventions']
       end
-      
+
       penalties
     end
 
     def calculate_interactor_penalties(interactor_data)
       penalties = []
-      
-      # Missing call method - critical for interactors
+
+      # Missing call method - critical for interactors (flat penalty; see
+      # service equivalent for rationale).
       unless interactor_data[:has_call_method]
-        penalties << 3.0 * @weights['rails_conventions']
+        penalties << 3.0
       end
-      
+
       # Complex organizers
       if interactor_data[:is_organizer]
         complexity = interactor_data[:complexity_score] || 0
         if complexity > 20  # Organizers should be simple orchestrators
-          penalties << 2.0 * @weights['rails_conventions']
+          penalties << 2.0
         end
       end
-      
+
       # Missing failure handling
       fail_usage = interactor_data[:fail_usage] || {}
       if (fail_usage[:context_fail] || 0) == 0 && (fail_usage[:fail_bang] || 0) == 0
         penalties << 1.5 * @weights['rails_conventions']
       end
-      
+
       # High complexity for regular interactors
       unless interactor_data[:is_organizer]
         complexity = interactor_data[:complexity_score] || 0
         if complexity > 15
-          penalties << 1.5 * @weights['rails_conventions']
+          penalties << 1.5
         end
       end
-      
+
       penalties
     end
 
     def calculate_serializer_penalties(serializer_data)
       penalties = []
-      
-      # Too many attributes/associations (fat serializer)
+
+      # Too many attributes/associations (fat serializer). Flat penalties because
+      # `rails_conventions` weight (0.15) drowned out the fat signal.
       attribute_count = serializer_data[:attribute_count] || 0
       association_count = serializer_data[:association_count] || 0
       total_fields = attribute_count + association_count
-      
+
       if total_fields > 20
-        penalties << 2.0 * @weights['rails_conventions']
+        penalties << 1.5
       elsif total_fields > 15
-        penalties << 1.0 * @weights['rails_conventions']
+        penalties << 0.5
       end
-      
+
       # Too many custom methods (complex logic)
       custom_method_count = serializer_data[:custom_method_count] || 0
       if custom_method_count > 10
-        penalties << 1.5 * @weights['rails_conventions']
+        penalties << 0.8
       elsif custom_method_count > 5
-        penalties << 0.5 * @weights['rails_conventions']
+        penalties << 0.4
       end
-      
+
       # Empty serializer (no value)
       if total_fields == 0 && custom_method_count == 0
         penalties << 1.0 * @weights['rails_conventions']
       end
-      
+
       penalties
     end
 

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
@@ -104,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
@@ -122,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
@@ -144,16 +153,22 @@ 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?
-      business_logic_patterns = [
-        /if.*&&.*/, # Complex conditionals
-        /\.each\s*do/, # Iteration
-        /\b(calculate|compute|process)\b/, # Business operations
-        /\.(sum|count|average)\b/, # Aggregations
-        /transaction\s*do/ # Database transactions
-      ]
-      
-      business_logic_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|
+          found = true if action_has_business_logic?(def_node)
+        end
+      end
+      found
     end
 
     def detect_controller_smells
@@ -192,52 +207,115 @@ module RailsCodeHealth
       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
@@ -270,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?
@@ -350,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?
@@ -432,34 +522,29 @@ module RailsCodeHealth
     end
 
     def detect_service_dependencies
-      dependencies = []
-      
-      # ActiveRecord usage
-      if @source.match?(/\w+\.find\(/) || @source.match?(/\w+\.where\(/) || @source.match?(/\w+\.create\(/)
-        dependencies << :active_record
+      deps = []
+
+      if @source.match?(/\b(?:[A-Z]\w*)\.(?:find|find_by|where|create|create!|update|update!|all|first|last)\b/)
+        deps << :active_record
       end
-      
-      # External APIs
-      if @source.include?('Net::HTTP') || @source.include?('HTTParty') || @source.include?('Faraday')
-        dependencies << :external_api
+
+      if @source.match?(/\b(?:Net::HTTP|HTTParty|Faraday|RestClient|Typhoeus)\b/)
+        deps << :external_api
       end
-      
-      # File system
-      if @source.include?('File.') || @source.include?('Dir.') || @source.include?('FileUtils')
-        dependencies << :file_system
+
+      if @source.match?(/\b(?:File|Dir|FileUtils|Pathname)\.\w+/)
+        deps << :file_system
       end
-      
-      # Email
-      if @source.include?('Mailer') || @source.include?('deliver') || @source.include?('ActionMailer')
-        dependencies << :email
+
+      if @source.match?(/\b(?:Mailer|ActionMailer)\b/) || @source.match?(/\.deliver(?:_now|_later)?\b/)
+        deps << :email
       end
-      
-      # Cache
-      if @source.include?('Rails.cache') || @source.include?('cache_store') || @source.include?('Redis')
-        dependencies << :cache
+
+      if @source.match?(/\bRails\.cache\b/) || @source.match?(/\bRedis\b/) || @source.match?(/\bcache_store\b/)
+        deps << :cache
       end
-      
-      dependencies.uniq
+
+      deps.uniq
     end
 
     def detect_error_handling
@@ -502,7 +587,7 @@ module RailsCodeHealth
       end
       
       complexity = calculate_service_complexity
-      if complexity > 15
+      if complexity >= 13
         smells << {
           type: :fat_service,
           complexity: complexity,
@@ -546,7 +631,8 @@ module RailsCodeHealth
     def detect_fail_usage
       {
         context_fail: @source.scan(/context\.fail/).count,
-        fail_bang: @source.scan(/fail!/).count
+        # `fail!` only — NOT `context.fail!` (that's counted as context_fail).
+        fail_bang: @source.scan(/(?<!\.)\bfail!/).count
       }
     end
 
@@ -624,19 +710,23 @@ module RailsCodeHealth
     end
 
     def count_serializer_attributes
-      # Count attributes declarations (lines starting with attributes/attribute)
-      @source.scan(/^\s*attributes?\s+/).count + @source.scan(/^\s*attribute\s+/).count
+      # 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 count_serializer_associations
-      associations = 0
-      association_methods = %w[has_one has_many belongs_to]
-      
-      association_methods.each do |method|
-        associations += @source.scan(/^\s*#{method}\s+/).count
+      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
-      
-      associations
+      count
     end
 
     def count_custom_serializer_methods
@@ -693,20 +783,5 @@ module RailsCodeHealth
       smells
     end
 
-    # Helper methods
-    def find_nodes(node, type, &block)
-      return unless node.is_a?(Parser::AST::Node)
-
-      yield(node) if node.type == type
-
-      node.children.each do |child|
-        find_nodes(child, type, &block)
-      end
-    end
-
-    def private_controller_method?(method_name)
-      %w[show new edit create update destroy].include?(method_name) ||
-        method_name.end_with?('_params')
-    end
   end
 end

data/lib/rails_code_health/report_generator.rb

@@ -183,7 +183,7 @@ module RailsCodeHealth
       end
       
       # Show best files if we have healthy ones
-      healthy_files = @results.select { |r| r[:health_category] == :healthy }
+      healthy_files = @results.select { |r| r[:health_category] == :healthy && r[:file_type] != :migration }
       if healthy_files.any?
         detailed << "✅ Top Performing Files:"
         detailed << ""

data/lib/rails_code_health/ruby_analyzer.rb

@@ -1,5 +1,6 @@
 module RailsCodeHealth
   class RubyAnalyzer
+    include RailsCodeHealth::ASTHelpers
     def initialize(file_path)
       @file_path = file_path
       @source = File.read(file_path)
@@ -89,17 +90,6 @@ module RailsCodeHealth
       smells
     end
 
-    # AST traversal helper
-    def find_nodes(node, type, &block)
-      return unless node.is_a?(Parser::AST::Node)
-
-      yield(node) if node.type == type
-
-      node.children.each do |child|
-        find_nodes(child, type, &block)
-      end
-    end
-
     # Complexity calculations
     def calculate_cyclomatic_complexity(node)
       complexity = 1 # Base complexity
@@ -166,11 +156,12 @@ module RailsCodeHealth
 
     def detect_god_classes
       classes = []
+      t = RailsCodeHealth.configuration.thresholds['smell_thresholds']
       find_nodes(@ast, :class) do |node|
         line_count = count_lines_in_node(node)
         method_count = count_methods_in_class(node)
-        
-        if line_count > 400 && method_count > 20
+
+        if line_count > t['god_class_lines'] && method_count > t['god_class_methods']
           classes << {
             type: :god_class,
             class_name: extract_class_name(node),
@@ -185,9 +176,10 @@ module RailsCodeHealth
 
     def detect_high_complexity_methods
       methods = []
+      threshold = RailsCodeHealth.configuration.thresholds['smell_thresholds']['high_complexity_method']
       find_nodes(@ast, :def) do |node|
         complexity = calculate_cyclomatic_complexity(node)
-        if complexity > 15
+        if complexity > threshold
           methods << {
             type: :high_complexity,
             method_name: node.children[0],
@@ -201,9 +193,10 @@ module RailsCodeHealth
 
     def detect_too_many_parameters
       methods = []
+      threshold = RailsCodeHealth.configuration.thresholds['smell_thresholds']['too_many_parameters']
       find_nodes(@ast, :def) do |node|
         param_count = count_parameters(node)
-        if param_count > 5
+        if param_count > threshold
           methods << {
             type: :too_many_parameters,
             method_name: node.children[0],
@@ -217,9 +210,10 @@ module RailsCodeHealth
 
     def detect_nested_conditionals
       methods = []
+      threshold = RailsCodeHealth.configuration.thresholds['smell_thresholds']['nested_conditionals']
       find_nodes(@ast, :def) do |node|
         max_depth = calculate_max_nesting_depth(node)
-        if max_depth > 4
+        if max_depth > threshold
           methods << {
             type: :nested_conditionals,
             method_name: node.children[0],
@@ -245,15 +239,16 @@ module RailsCodeHealth
     end
 
     def count_public_methods_in_class(class_node)
-      # This is a simplified version - in reality, you'd need to track visibility modifiers
-      count_methods_in_class(class_node)
+      defs_by_visibility(class_node)[:public].size
     end
 
+    PARAM_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg].freeze
+
     def count_parameters(method_node)
       args_node = method_node.children[1]
-      return 0 unless args_node
-      
-      args_node.children.count
+      return 0 unless args_node.is_a?(Parser::AST::Node)
+
+      args_node.children.count { |c| c.is_a?(Parser::AST::Node) && PARAM_TYPES.include?(c.type) }
     end
 
     def extract_class_name(class_node)
@@ -306,8 +301,10 @@ module RailsCodeHealth
       count
     end
 
+    NESTING_TYPES = %i[if case while until for].freeze
+
     def nesting_node?(node)
-      [:if, :case, :while, :until, :for, :begin, :block].include?(node.type)
+      NESTING_TYPES.include?(node.type)
     end
 
     def has_rescue_block?(node)

data/lib/rails_code_health/version.rb

@@ -1,3 +1,3 @@
 module RailsCodeHealth
-  VERSION = "0.2.0"
+  VERSION = "0.3.1"
 end

data/lib/rails_code_health.rb

@@ -6,6 +6,7 @@ require 'json'
 require 'pathname'
 
 require_relative 'rails_code_health/version'
+require_relative 'rails_code_health/ast_helpers'
 require_relative 'rails_code_health/configuration'
 require_relative 'rails_code_health/project_detector'
 require_relative 'rails_code_health/file_analyzer'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rails_code_health
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - George Kosmopoulos
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -151,6 +150,7 @@ files:
 - bin/rails-health
 - config/tresholds.json
 - lib/rails_code_health.rb
+- lib/rails_code_health/ast_helpers.rb
 - lib/rails_code_health/cli.rb
 - lib/rails_code_health/configuration.rb
 - lib/rails_code_health/file_analyzer.rb
@@ -164,7 +164,6 @@ homepage: https://github.com/gkosmo/rails_code_health
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -179,8 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Code health analyzer for Ruby on Rails applications
 test_files: []