rails_code_health 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fcf270392e52c8b6ab9783a9ed2ffaa133825210ff18c0c4ec124ce8b8d2b7f
-  data.tar.gz: 6ddc72d1451b604e7df94e655e22b225647842dcbd0a00baec0618d4e3b1c823
+  metadata.gz: aaafc84bb8cf4bad9931fb39ef97d3a1bf76a61bc4e2289191df870f10a33e1e
+  data.tar.gz: ad77a703a06b6eee946756f7645ef76de9c943fcadd192c27a425bd37f3027fd
 SHA512:
-  metadata.gz: 416a30e4fd42da4f2f8fe100e349c611c009d5468710974c59d945036145ce1c0df543ca1a8f51f3bf53868cd6ce9472e4be3457dcdaca3d5de12258ef16ed77
-  data.tar.gz: 44e261b45a963e81c5d3ace4be6b360ff8c052ba39dd4b0e3fa56789c145673e3b51d5359ebed08a2f7eb50214044031f0f6185760e3ac06072531be25659769
+  metadata.gz: 832e4d0437e9e92e121da7a890f3451ee5f37047a586db713edfb07265ab55e5f8c0f221b21f9c4eccb974b7e4b4429ae28cedcd0c7ec5c060f633733996cea8
+  data.tar.gz: f00785bb224064d66c01486a4929fd74ba7102559f9280c3c95f619fb67034a41babcb7e2e93ffe74cb37a08848d7d19d9f0cc25a8aaab460ad5f667e695b926

data/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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 +43,6 @@ 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.2.0...HEAD
+[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,7 @@
 # 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.
+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
 

data/lib/rails_code_health/configuration.rb

@@ -64,6 +64,10 @@ 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 }
+        },
         'file_type_multipliers' => {
           'controllers' => 1.2,
           'models' => 1.0,
@@ -71,7 +75,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 = []

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,102 @@ module RailsCodeHealth
       penalties
     end
 
+    def calculate_service_penalties(service_data)
+      penalties = []
+      
+      # Missing call method - critical for services
+      unless service_data[:has_call_method]
+        penalties << 3.0 * @weights['rails_conventions']
+      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']
+      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']
+      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
+      unless interactor_data[:has_call_method]
+        penalties << 3.0 * @weights['rails_conventions']
+      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']
+        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']
+        end
+      end
+      
+      penalties
+    end
+
+    def calculate_serializer_penalties(serializer_data)
+      penalties = []
+      
+      # Too many attributes/associations (fat serializer)
+      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']
+      elsif total_fields > 15
+        penalties << 1.0 * @weights['rails_conventions']
+      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']
+      elsif custom_method_count > 5
+        penalties << 0.5 * @weights['rails_conventions']
+      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 +467,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

data/lib/rails_code_health/rails_analyzer.rb

@@ -21,6 +21,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 +43,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
       }
@@ -137,6 +144,18 @@ module RailsCodeHealth
       formats
     end
 
+    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) }
+    end
+
     def detect_controller_smells
       smells = []
       
@@ -163,6 +182,13 @@ module RailsCodeHealth
         }
       end
 
+      if has_business_logic?
+        smells << {
+          type: :business_logic_in_controller,
+          severity: :high
+        }
+      end
+
       smells
     end
 
@@ -372,6 +398,301 @@ module RailsCodeHealth
       smells
     end
 
+    # 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
+      dependencies = []
+      
+      # ActiveRecord usage
+      if @source.match?(/\w+\.find\(/) || @source.match?(/\w+\.where\(/) || @source.match?(/\w+\.create\(/)
+        dependencies << :active_record
+      end
+      
+      # External APIs
+      if @source.include?('Net::HTTP') || @source.include?('HTTParty') || @source.include?('Faraday')
+        dependencies << :external_api
+      end
+      
+      # File system
+      if @source.include?('File.') || @source.include?('Dir.') || @source.include?('FileUtils')
+        dependencies << :file_system
+      end
+      
+      # Email
+      if @source.include?('Mailer') || @source.include?('deliver') || @source.include?('ActionMailer')
+        dependencies << :email
+      end
+      
+      # Cache
+      if @source.include?('Rails.cache') || @source.include?('cache_store') || @source.include?('Redis')
+        dependencies << :cache
+      end
+      
+      dependencies.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 > 15
+        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_bang: @source.scan(/fail!/).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
+
+      {
+        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
+
+    def count_serializer_attributes
+      # Count attributes declarations (lines starting with attributes/attribute)
+      @source.scan(/^\s*attributes?\s+/).count + @source.scan(/^\s*attribute\s+/).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
+      end
+      
+      associations
+    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
+
     # Helper methods
     def find_nodes(node, type, &block)
       return unless node.is_a?(Parser::AST::Node)

data/lib/rails_code_health/report_generator.rb

@@ -58,18 +58,110 @@ module RailsCodeHealth
       
       file_types = @results.group_by { |r| r[:file_type] }
       
-      file_types.each do |type, files|
+      # Define the order for file types
+      type_order = [
+        :controller, :model, :view, :helper, :migration,
+        :service, :interactor, :serializer, :form, :decorator,
+        :presenter, :policy, :job, :worker, :mailer, :channel,
+        :lib, :config, :test, :ruby
+      ]
+      
+      # Sort file types by the defined order, with unknown types at the end
+      sorted_types = file_types.keys.sort_by do |type|
+        index = type_order.index(type)
+        index || type_order.length
+      end
+      
+      sorted_types.each do |type, _|
+        files = file_types[type]
         next if files.empty?
         
         avg_score = (files.sum { |f| f[:health_score] || 0 } / files.count.to_f).round(1)
         healthy_count = files.count { |f| f[:health_category] == :healthy }
         
-        breakdown << "  #{type.to_s.capitalize}: #{files.count} files, avg score: #{avg_score}, #{healthy_count} healthy"
+        # Get file type emoji
+        emoji = get_file_type_emoji(type)
+        
+        # Show context breakdown for new file types
+        context_info = ""
+        if [:service, :interactor, :serializer, :form, :decorator, :presenter, :policy, :job, :worker].include?(type)
+          context_info = generate_context_breakdown(files)
+        end
+        
+        breakdown << "  #{emoji} #{type.to_s.capitalize}: #{files.count} files, avg score: #{avg_score}, #{healthy_count} healthy"
+        breakdown << context_info if !context_info.empty?
       end
       
       breakdown.join("\n")
     end
 
+    def get_file_type_emoji(type)
+      emoji_map = {
+        controller: "🎮",
+        model: "📊",
+        view: "🖼️",
+        helper: "🔧",
+        migration: "📈",
+        service: "⚙️",
+        interactor: "🔄",
+        serializer: "📦",
+        form: "📝",
+        decorator: "🎨",
+        presenter: "🎪",
+        policy: "🛡️",
+        job: "⚡",
+        worker: "👷",
+        mailer: "📧",
+        channel: "📡",
+        lib: "📚",
+        config: "⚙️",
+        test: "🧪",
+        ruby: "💎"
+      }
+      emoji_map[type] || "📄"
+    end
+
+    def generate_context_breakdown(files)
+      # Check if any files have context information
+      files_with_context = files.select { |f| f[:context] && !f[:context].empty? }
+      return "" if files_with_context.empty?
+      
+      breakdown_lines = []
+      
+      # Organization patterns
+      organizations = files_with_context.group_by { |f| f[:context][:organization] }
+      if organizations.keys.any? { |org| org != :traditional }
+        org_breakdown = organizations.map do |org, org_files|
+          next if org == :traditional
+          "#{org.to_s.gsub('_', ' ').capitalize}: #{org_files.count}"
+        end.compact
+        breakdown_lines << "    📁 Organization: #{org_breakdown.join(', ')}" if org_breakdown.any?
+      end
+      
+      # Domains
+      domains = files_with_context.group_by { |f| f[:context][:domain] }.reject { |domain, _| domain.nil? }
+      if domains.any?
+        domain_breakdown = domains.map { |domain, domain_files| "#{domain}: #{domain_files.count}" }
+        breakdown_lines << "    🏢 Domains: #{domain_breakdown.join(', ')}"
+      end
+      
+      # Areas
+      areas = files_with_context.group_by { |f| f[:context][:area] }.reject { |area, _| area.nil? }
+      if areas.any?
+        area_breakdown = areas.map { |area, area_files| "#{area}: #{area_files.count}" }
+        breakdown_lines << "    🏠 Areas: #{area_breakdown.join(', ')}"
+      end
+      
+      # API versions
+      api_versions = files_with_context.group_by { |f| f[:context][:api_version] }.reject { |version, _| version.nil? }
+      if api_versions.any?
+        version_breakdown = api_versions.map { |version, version_files| "#{version}: #{version_files.count}" }
+        breakdown_lines << "    🔢 API Versions: #{version_breakdown.join(', ')}"
+      end
+      
+      breakdown_lines.join("\n")
+    end
+
     def generate_detailed_report
       detailed = []
       detailed << "📋 Detailed File Analysis"
@@ -174,7 +266,21 @@ module RailsCodeHealth
                     end
       
       summary << "#{rank}. #{prefix} #{health_emoji} #{result[:relative_path]}"
-      summary << "   Score: #{result[:health_score]}/10.0 | Type: #{result[:file_type]} | Size: #{format_file_size(result[:file_size])}"
+      
+      # Build context string
+      context_parts = ["Type: #{result[:file_type]}", "Size: #{format_file_size(result[:file_size])}"]
+      
+      if result[:context] && !result[:context].empty?
+        context_info = []
+        context_info << "#{result[:context][:domain]}" if result[:context][:domain]
+        context_info << "#{result[:context][:area]}" if result[:context][:area]
+        context_info << "#{result[:context][:api_version]}" if result[:context][:api_version]
+        context_info << "#{result[:context][:organization].to_s.gsub('_', ' ')}" if result[:context][:organization] && result[:context][:organization] != :traditional
+        
+        context_parts << "Context: #{context_info.join(', ')}" if context_info.any?
+      end
+      
+      summary << "   Score: #{result[:health_score]}/10.0 | #{context_parts.join(' | ')}"
       
       # Add key metrics if available
       if result[:ruby_analysis]
@@ -200,11 +306,24 @@ module RailsCodeHealth
         case result[:rails_analysis][:rails_type]
         when :controller
           rails_info << "#{result[:rails_analysis][:action_count]} actions"
+          rails_info << "business logic" if result[:rails_analysis][:has_business_logic]
         when :model
           rails_info << "#{result[:rails_analysis][:association_count]} associations" if result[:rails_analysis][:association_count]
           rails_info << "#{result[:rails_analysis][:validation_count]} validations" if result[:rails_analysis][:validation_count]
         when :view
           rails_info << "#{result[:rails_analysis][:logic_lines]} logic lines" if result[:rails_analysis][:logic_lines]
+        when :service
+          rails_info << "call method" if result[:rails_analysis][:has_call_method]
+          rails_info << "deps: #{result[:rails_analysis][:dependencies].join(', ')}" if result[:rails_analysis][:dependencies]&.any?
+          rails_info << "complexity: #{result[:rails_analysis][:complexity_score]}" if result[:rails_analysis][:complexity_score]
+        when :interactor
+          rails_info << "call method" if result[:rails_analysis][:has_call_method]
+          rails_info << "organizer" if result[:rails_analysis][:is_organizer]
+          rails_info << "complexity: #{result[:rails_analysis][:complexity_score]}" if result[:rails_analysis][:complexity_score]
+        when :serializer
+          rails_info << "#{result[:rails_analysis][:attribute_count]} attributes" if result[:rails_analysis][:attribute_count]
+          rails_info << "#{result[:rails_analysis][:association_count]} associations" if result[:rails_analysis][:association_count]
+          rails_info << "#{result[:rails_analysis][:custom_method_count]} custom methods" if result[:rails_analysis][:custom_method_count]
         end
         
         summary << "   Rails: #{rails_info.join(', ')}" if rails_info.any?
@@ -296,6 +415,7 @@ module RailsCodeHealth
         when :controller
           metrics[:controller_actions] = rails_metrics[:action_count]
           metrics[:uses_strong_parameters] = rails_metrics[:uses_strong_parameters]
+          metrics[:has_business_logic] = rails_metrics[:has_business_logic]
         when :model
           metrics[:associations] = rails_metrics[:association_count]
           metrics[:validations] = rails_metrics[:validation_count]
@@ -303,6 +423,21 @@ module RailsCodeHealth
         when :view
           metrics[:view_logic_lines] = rails_metrics[:logic_lines]
           metrics[:has_inline_styles] = rails_metrics[:has_inline_styles]
+        when :service
+          metrics[:has_call_method] = rails_metrics[:has_call_method]
+          metrics[:dependencies] = rails_metrics[:dependencies]
+          metrics[:complexity_score] = rails_metrics[:complexity_score]
+          metrics[:error_handling] = rails_metrics[:error_handling]
+        when :interactor
+          metrics[:has_call_method] = rails_metrics[:has_call_method]
+          metrics[:is_organizer] = rails_metrics[:is_organizer]
+          metrics[:context_usage] = rails_metrics[:context_usage]
+          metrics[:complexity_score] = rails_metrics[:complexity_score]
+        when :serializer
+          metrics[:attribute_count] = rails_metrics[:attribute_count]
+          metrics[:association_count] = rails_metrics[:association_count]
+          metrics[:custom_method_count] = rails_metrics[:custom_method_count]
+          metrics[:has_conditional_attributes] = rails_metrics[:has_conditional_attributes]
         end
       end
       

data/lib/rails_code_health/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_code_health
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - George Kosmopoulos
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-17 00:00:00.000000000 Z
+date: 2025-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser