rails_code_health 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fcf270392e52c8b6ab9783a9ed2ffaa133825210ff18c0c4ec124ce8b8d2b7f
-  data.tar.gz: 6ddc72d1451b604e7df94e655e22b225647842dcbd0a00baec0618d4e3b1c823
+  metadata.gz: cde06b2eaad01a08ed9a618103f62aff853e4adcb4f3e6a2b93807e2e00d2dfa
+  data.tar.gz: 829b9eaa19feb6cbef043fa73822c48a204c25afc552ccf557193ff3498f6e09
 SHA512:
-  metadata.gz: 416a30e4fd42da4f2f8fe100e349c611c009d5468710974c59d945036145ce1c0df543ca1a8f51f3bf53868cd6ce9472e4be3457dcdaca3d5de12258ef16ed77
-  data.tar.gz: 44e261b45a963e81c5d3ace4be6b360ff8c052ba39dd4b0e3fa56789c145673e3b51d5359ebed08a2f7eb50214044031f0f6185760e3ac06072531be25659769
+  metadata.gz: 8e40c5161b69aaf9f98318f7204cf7c68b9a376464179cd3169aad3c60137c629feee9870f68ed6fe3578aa13d129aa426c12211f348d5d18b3bc06d74e5e6eb
+  data.tar.gz: 36c0b8ec173f03bf41008b14674a07bb5b5748bbd3c8e73bed0c0ac03cf19d9203578ca65bf4b650570a0626caa98a2847dd59ef59022b0afe9bbef0aefb59de

data/CHANGELOG.md

@@ -7,6 +7,53 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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
+- Comprehensive test suite with RSpec covering all major components
+- Test coverage for Configuration, FileAnalyzer, HealthCalculator, ProjectDetector, RailsAnalyzer, and ReportGenerator
+
+### Changed
+- Enhanced Configuration class with improved validation and error handling
+- Improved FileAnalyzer with better file processing capabilities
+- Updated HealthCalculator with more robust scoring algorithms
+- Enhanced ProjectDetector with better Rails project detection
+- Improved RailsAnalyzer with more comprehensive Rails pattern analysis
+- Enhanced ReportGenerator with better formatting and output options
+
+### Fixed
+- Various bug fixes and improvements based on user feedback
+
 ## [0.1.0] - 2025-06-17
 
 ### Added
@@ -26,5 +73,7 @@ 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/yourusername/rails_code_health/compare/v0.1.0...HEAD
-[0.1.0]: https://github.com/yourusername/rails_code_health/releases/tag/v0.1.0
+[Unreleased]: https://github.com/gkosmo/rails_code_health/compare/v0.3.0...HEAD
+[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,6 +1,9 @@
 # Rails Code Health
 
-A Ruby gem that evaluates the code health of Ruby on Rails applications, inspired by CodeScene's research on technical debt and maintainability.
+[![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
+).
 
 ## Overview
 
@@ -126,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

@@ -64,6 +64,17 @@ module RailsCodeHealth
           'view_length' => { 'green' => 30, 'yellow' => 50, 'red' => 100 },
           'migration_complexity' => { 'green' => 10, 'yellow' => 20, 'red' => 40 }
         },
+        'service_thresholds' => {
+          '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,
@@ -71,7 +82,16 @@ module RailsCodeHealth
           'helpers' => 0.9,
           'lib' => 1.1,
           'specs' => 0.7,
-          'migrations' => 0.6
+          'migrations' => 0.6,
+          'service' => 1.3,
+          'interactor' => 1.2,
+          'serializer' => 0.9,
+          'form' => 1.1,
+          'decorator' => 0.9,
+          'presenter' => 0.9,
+          'policy' => 1.2,
+          'job' => 1.0,
+          'worker' => 1.0
         },
         'scoring_weights' => {
           'method_length' => 0.15,

data/lib/rails_code_health/file_analyzer.rb

@@ -80,7 +80,10 @@ module RailsCodeHealth
       view_patterns = [
         @project_path + 'app/views/**/*.erb',
         @project_path + 'app/views/**/*.haml',
-        @project_path + 'app/views/**/*.slim'
+        @project_path + 'app/views/**/*.slim',
+        @project_path + 'app/**/views/**/*.erb',
+        @project_path + 'app/**/views/**/*.haml',
+        @project_path + 'app/**/views/**/*.slim'
       ]
 
       files = []
@@ -88,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

@@ -107,6 +107,12 @@ module RailsCodeHealth
         penalties.concat(calculate_helper_penalties(rails_data))
       when :migration
         penalties.concat(calculate_migration_penalties(rails_data))
+      when :service
+        penalties.concat(calculate_service_penalties(rails_data))
+      when :interactor
+        penalties.concat(calculate_interactor_penalties(rails_data))
+      when :serializer
+        penalties.concat(calculate_serializer_penalties(rails_data))
       end
       
       penalties
@@ -132,6 +138,11 @@ module RailsCodeHealth
         penalties << 1.5 * @weights['rails_conventions']
       end
       
+      # Business logic in controller
+      if controller_data[:has_business_logic]
+        penalties << 2.0 * @weights['rails_conventions']
+      end
+      
       penalties
     end
 
@@ -212,6 +223,106 @@ module RailsCodeHealth
       penalties
     end
 
+    def calculate_service_penalties(service_data)
+      penalties = []
+
+      # 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
+      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'] ? 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
+      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 (flat penalty; see
+      # service equivalent for rationale).
+      unless interactor_data[:has_call_method]
+        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
+        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
+        end
+      end
+
+      penalties
+    end
+
+    def calculate_serializer_penalties(serializer_data)
+      penalties = []
+
+      # 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 << 1.5
+      elsif total_fields > 15
+        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 << 0.8
+      elsif custom_method_count > 5
+        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
+
     def calculate_code_smell_penalties(file_result)
       penalties = []
       
@@ -360,6 +471,24 @@ module RailsCodeHealth
             recommendations << "Reduce model callbacks (#{smell[:count]} found) - consider service objects"
           when :data_changes_in_migration
             recommendations << "Avoid data changes in migrations - use rake tasks instead"
+          when :business_logic_in_controller
+            recommendations << "Extract business logic from controller to service objects"
+          when :missing_call_method
+            recommendations << "Add a call method to follow service/interactor conventions"
+          when :fat_service
+            recommendations << "Break down service into smaller, focused services (complexity: #{smell[:complexity]})"
+          when :missing_error_handling
+            recommendations << "Add proper error handling with rescue blocks"
+          when :complex_organizer
+            recommendations << "Simplify organizer - it should only orchestrate other interactors (complexity: #{smell[:complexity]})"
+          when :missing_failure_handling
+            recommendations << "Add failure handling using context.fail or fail! methods"
+          when :fat_serializer
+            recommendations << "Split serializer - it has #{smell[:field_count]} fields"
+          when :complex_serializer
+            recommendations << "Move complex logic out of serializer (#{smell[:method_count]} custom methods)"
+          when :empty_serializer
+            recommendations << "Add attributes or associations to provide value"
           end
         end
       end

data/lib/rails_code_health/project_detector.rb

@@ -24,7 +24,7 @@ module RailsCodeHealth
         relative_path = file_path.relative_path_from(project_root).to_s
 
         case relative_path
-        when %r{^app/controllers/.*_controller\.rb$}
+        when %r{^app/.*/controllers/.*_controller\.rb$}, %r{^app/controllers/.*_controller\.rb$}
           :controller
         when %r{^app/models/.*\.rb$}
           :model
@@ -32,6 +32,28 @@ module RailsCodeHealth
           :view
         when %r{^app/helpers/.*_helper\.rb$}
           :helper
+        when %r{^app/.*/services/.*\.rb$}, %r{^app/services/.*\.rb$}
+          :service
+        when %r{^app/.*/interactors/.*\.rb$}, %r{^app/interactors/.*\.rb$}
+          :interactor
+        when %r{^app/.*/serializers/.*\.rb$}, %r{^app/serializers/.*\.rb$}
+          :serializer
+        when %r{^app/.*/forms/.*\.rb$}, %r{^app/forms/.*\.rb$}
+          :form
+        when %r{^app/.*/decorators/.*\.rb$}, %r{^app/decorators/.*\.rb$}
+          :decorator
+        when %r{^app/.*/presenters/.*\.rb$}, %r{^app/presenters/.*\.rb$}
+          :presenter
+        when %r{^app/.*/policies/.*\.rb$}, %r{^app/policies/.*\.rb$}
+          :policy
+        when %r{^app/.*/jobs/.*\.rb$}, %r{^app/jobs/.*\.rb$}
+          :job
+        when %r{^app/.*/workers/.*\.rb$}, %r{^app/workers/.*\.rb$}
+          :worker
+        when %r{^app/.*/mailers/.*\.rb$}, %r{^app/mailers/.*\.rb$}
+          :mailer
+        when %r{^app/.*/channels/.*\.rb$}, %r{^app/channels/.*\.rb$}
+          :channel
         when %r{^lib/.*\.rb$}
           :lib
         when %r{^db/migrate/.*\.rb$}
@@ -45,8 +67,61 @@ module RailsCodeHealth
         end
       end
 
+      def detect_detailed_file_type(file_path, project_root)
+        relative_path = file_path.relative_path_from(project_root).to_s
+        file_type = detect_file_type(file_path, project_root)
+        
+        context = {
+          organization: detect_organization_pattern(relative_path),
+          domain: extract_domain(relative_path),
+          area: extract_area(relative_path),
+          api_version: extract_api_version(relative_path)
+        }.compact
+
+        { type: file_type, context: context }
+      end
+
       private
 
+      def detect_organization_pattern(relative_path)
+        case relative_path
+        when %r{^app/topics/}
+          :topic_based
+        when %r{^app/domains/}
+          :domain_based
+        when %r{^app/modules/}
+          :module_based
+        else
+          :traditional
+        end
+      end
+
+      def extract_domain(relative_path)
+        case relative_path
+        when %r{^app/topics/([^/]+)/}
+          $1
+        when %r{^app/domains/([^/]+)/}
+          $1
+        when %r{^app/modules/([^/]+)/}
+          $1
+        else
+          nil
+        end
+      end
+
+      def extract_area(relative_path)
+        areas = %w[admin backoffice api]
+        areas.each do |area|
+          return area if relative_path.include?("/#{area}/")
+        end
+        nil
+      end
+
+      def extract_api_version(relative_path)
+        match = relative_path.match(%r{/v(\d+)/})
+        match ? "v#{match[1]}" : nil
+      end
+
       def has_rails_files?(path)
         RAILS_INDICATORS.any? { |file| (path + file).exist? }
       end