rails_code_health 0.1.0 → 0.3.0

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/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.1.0"
+  VERSION = "0.3.0"
 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.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - George Kosmopoulos
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-17 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: []