rails_code_health 0.1.0

data/lib/rails_code_health/report_generator.rb

@@ -0,0 +1,335 @@
+module RailsCodeHealth
+  class ReportGenerator
+    def initialize(scored_results)
+      @results = scored_results
+    end
+
+    def generate
+      puts generate_summary_report
+      puts "\n" + "="*80 + "\n"
+      puts generate_detailed_report
+      puts "\n" + "="*80 + "\n"
+      puts generate_recommendations_report
+    end
+
+    def generate_json_report
+      {
+        summary: generate_summary_data,
+        files: @results.map { |result| format_file_result(result) },
+        recommendations: collect_all_recommendations,
+        generated_at: Time.now.iso8601
+      }.to_json
+    end
+
+    private
+
+    def generate_summary_report
+      summary = []
+      summary << "Rails Code Health Report"
+      summary << "=" * 50
+      summary << ""
+      
+      total_files = @results.count
+      healthy_files = @results.count { |r| r[:health_category] == :healthy }
+      warning_files = @results.count { |r| r[:health_category] == :warning }
+      alert_files = @results.count { |r| r[:health_category] == :alert }
+      critical_files = @results.count { |r| r[:health_category] == :critical }
+      
+      summary << "📊 Overall Health Summary:"
+      summary << "  Total files analyzed: #{total_files}"
+      summary << "  🟢 Healthy files (8.0-10.0): #{healthy_files} (#{percentage(healthy_files, total_files)}%)"
+      summary << "  🟡 Warning files (4.0-7.9): #{warning_files} (#{percentage(warning_files, total_files)}%)"
+      summary << "  🔴 Alert files (1.0-3.9): #{alert_files} (#{percentage(alert_files, total_files)}%)"
+      summary << "  ⚫ Critical files (<1.0): #{critical_files} (#{percentage(critical_files, total_files)}%)" if critical_files > 0
+      summary << ""
+      
+      average_score = (@results.sum { |r| r[:health_score] || 0 } / total_files.to_f).round(1)
+      summary << "📈 Average Health Score: #{average_score}/10.0"
+      
+      summary << ""
+      summary << generate_file_type_breakdown
+      
+      summary.join("\n")
+    end
+
+    def generate_file_type_breakdown
+      breakdown = []
+      breakdown << "📂 Breakdown by File Type:"
+      
+      file_types = @results.group_by { |r| r[:file_type] }
+      
+      file_types.each do |type, files|
+        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"
+      end
+      
+      breakdown.join("\n")
+    end
+
+    def generate_detailed_report
+      detailed = []
+      detailed << "📋 Detailed File Analysis"
+      detailed << "=" * 50
+      detailed << ""
+      
+      # Sort by health score (worst first)
+      sorted_results = @results.sort_by { |r| r[:health_score] || 0 }
+      
+      # Show worst 10 files
+      worst_files = sorted_results.first(10)
+      
+      detailed << "🚨 Files Needing Most Attention (Bottom 10):"
+      detailed << ""
+      
+      worst_files.each_with_index do |result, index|
+        detailed << format_file_summary(result, index + 1)
+        detailed << ""
+      end
+      
+      # Show best files if we have healthy ones
+      healthy_files = @results.select { |r| r[:health_category] == :healthy }
+      if healthy_files.any?
+        detailed << "✅ Top Performing Files:"
+        detailed << ""
+        
+        best_files = healthy_files.sort_by { |r| -(r[:health_score] || 0) }.first(5)
+        best_files.each_with_index do |result, index|
+          detailed << format_file_summary(result, index + 1, prefix: "👍")
+          detailed << ""
+        end
+      end
+      
+      detailed.join("\n")
+    end
+
+    def generate_recommendations_report
+      recommendations = []
+      recommendations << "💡 Key Recommendations"
+      recommendations << "=" * 50
+      recommendations << ""
+      
+      # Collect and categorize all recommendations
+      all_recommendations = collect_all_recommendations
+      
+      if all_recommendations.empty?
+        recommendations << "🎉 Great job! No major issues found."
+        return recommendations.join("\n")
+      end
+      
+      # Group recommendations by frequency
+      recommendation_counts = Hash.new(0)
+      all_recommendations.each { |rec| recommendation_counts[rec] += 1 }
+      
+      # Sort by frequency (most common first)
+      sorted_recommendations = recommendation_counts.sort_by { |_, count| -count }
+      
+      recommendations << "📈 Most Common Issues (by frequency):"
+      recommendations << ""
+      
+      sorted_recommendations.first(10).each_with_index do |(rec, count), index|
+        recommendations << "#{index + 1}. #{rec} (#{count} occurrence#{'s' if count > 1})"
+      end
+      
+      recommendations << ""
+      recommendations << "🎯 Priority Actions:"
+      recommendations << ""
+      
+      # Find files with lowest scores and their recommendations
+      critical_files = @results.select { |r| r[:health_score] && r[:health_score] < 4.0 }
+      if critical_files.any?
+        recommendations << "1. 🚨 Address critical files immediately:"
+        critical_files.first(3).each do |file|
+          recommendations << "   - #{file[:relative_path]} (score: #{file[:health_score]})"
+          if file[:recommendations] && file[:recommendations].any?
+            file[:recommendations].first(2).each do |rec|
+              recommendations << "     • #{rec}"
+            end
+          end
+        end
+        recommendations << ""
+      end
+      
+      recommendations << "2. 🔧 Focus on these improvement areas:"
+      recommendations << "   - Reduce method and class lengths"
+      recommendations << "   - Lower cyclomatic complexity"
+      recommendations << "   - Follow Rails conventions"
+      recommendations << "   - Extract business logic from controllers and views"
+      
+      recommendations.join("\n")
+    end
+
+    def format_file_summary(result, rank, prefix: "🔍")
+      summary = []
+      
+      health_emoji = case result[:health_category]
+                    when :healthy then "🟢"
+                    when :warning then "🟡"
+                    when :alert then "🔴"
+                    when :critical then "⚫"
+                    else "❓"
+                    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])}"
+      
+      # Add key metrics if available
+      if result[:ruby_analysis]
+        metrics = []
+        if result[:ruby_analysis][:method_metrics]
+          method_count = result[:ruby_analysis][:method_metrics].count
+          avg_complexity = result[:ruby_analysis][:method_metrics].map { |m| m[:cyclomatic_complexity] }.sum.to_f / method_count
+          metrics << "#{method_count} methods"
+          metrics << "avg complexity: #{avg_complexity.round(1)}"
+        end
+        
+        if result[:ruby_analysis][:class_metrics]
+          class_count = result[:ruby_analysis][:class_metrics].count
+          metrics << "#{class_count} class#{'es' if class_count != 1}"
+        end
+        
+        summary << "   Metrics: #{metrics.join(', ')}" if metrics.any?
+      end
+      
+      # Add Rails-specific info
+      if result[:rails_analysis]
+        rails_info = []
+        case result[:rails_analysis][:rails_type]
+        when :controller
+          rails_info << "#{result[:rails_analysis][:action_count]} actions"
+        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]
+        end
+        
+        summary << "   Rails: #{rails_info.join(', ')}" if rails_info.any?
+      end
+      
+      # Add top recommendations
+      if result[:recommendations] && result[:recommendations].any?
+        summary << "   Top issues:"
+        result[:recommendations].first(2).each do |rec|
+          summary << "     • #{rec}"
+        end
+      end
+      
+      summary.join("\n")
+    end
+
+    def collect_all_recommendations
+      @results.flat_map { |r| r[:recommendations] || [] }.uniq
+    end
+
+    def generate_summary_data
+      total_files = @results.count
+      {
+        total_files: total_files,
+        healthy_files: @results.count { |r| r[:health_category] == :healthy },
+        warning_files: @results.count { |r| r[:health_category] == :warning },
+        alert_files: @results.count { |r| r[:health_category] == :alert },
+        critical_files: @results.count { |r| r[:health_category] == :critical },
+        average_score: (@results.sum { |r| r[:health_score] || 0 } / total_files.to_f).round(1),
+        file_types: generate_file_type_summary
+      }
+    end
+
+    def generate_file_type_summary
+      file_types = @results.group_by { |r| r[:file_type] }
+      
+      file_types.transform_values do |files|
+        {
+          count: files.count,
+          average_score: (files.sum { |f| f[:health_score] || 0 } / files.count.to_f).round(1),
+          healthy_count: files.count { |f| f[:health_category] == :healthy }
+        }
+      end
+    end
+
+    def format_file_result(result)
+      {
+        file_path: result[:relative_path],
+        file_type: result[:file_type],
+        health_score: result[:health_score],
+        health_category: result[:health_category],
+        file_size: result[:file_size],
+        last_modified: result[:last_modified],
+        recommendations: result[:recommendations] || [],
+        metrics: extract_key_metrics(result)
+      }
+    end
+
+    def extract_key_metrics(result)
+      metrics = {}
+      
+      if result[:ruby_analysis]
+        ruby_metrics = result[:ruby_analysis]
+        
+        if ruby_metrics[:file_metrics]
+          metrics[:lines_of_code] = ruby_metrics[:file_metrics][:code_lines]
+          metrics[:total_lines] = ruby_metrics[:file_metrics][:total_lines]
+        end
+        
+        if ruby_metrics[:method_metrics]
+          methods = ruby_metrics[:method_metrics]
+          metrics[:method_count] = methods.count
+          metrics[:average_method_length] = methods.map { |m| m[:line_count] }.sum.to_f / methods.count if methods.any?
+          metrics[:average_complexity] = methods.map { |m| m[:cyclomatic_complexity] }.sum.to_f / methods.count if methods.any?
+          metrics[:max_complexity] = methods.map { |m| m[:cyclomatic_complexity] }.max
+        end
+        
+        if ruby_metrics[:class_metrics]
+          classes = ruby_metrics[:class_metrics]
+          metrics[:class_count] = classes.count
+          metrics[:average_class_length] = classes.map { |c| c[:line_count] }.sum.to_f / classes.count if classes.any?
+        end
+      end
+      
+      if result[:rails_analysis]
+        rails_metrics = result[:rails_analysis]
+        
+        case rails_metrics[:rails_type]
+        when :controller
+          metrics[:controller_actions] = rails_metrics[:action_count]
+          metrics[:uses_strong_parameters] = rails_metrics[:uses_strong_parameters]
+        when :model
+          metrics[:associations] = rails_metrics[:association_count]
+          metrics[:validations] = rails_metrics[:validation_count]
+          metrics[:callbacks] = rails_metrics[:callback_count]
+        when :view
+          metrics[:view_logic_lines] = rails_metrics[:logic_lines]
+          metrics[:has_inline_styles] = rails_metrics[:has_inline_styles]
+        end
+      end
+      
+      # Round float values
+      metrics.transform_values do |value|
+        value.is_a?(Float) ? value.round(2) : value
+      end
+    end
+
+    def percentage(part, total)
+      return 0 if total.zero?
+      ((part.to_f / total) * 100).round(1)
+    end
+
+    def format_file_size(size_in_bytes)
+      return "0 B" if size_in_bytes.nil? || size_in_bytes.zero?
+      
+      units = %w[B KB MB GB]
+      size = size_in_bytes.to_f
+      unit_index = 0
+      
+      while size >= 1024 && unit_index < units.length - 1
+        size /= 1024
+        unit_index += 1
+      end
+      
+      "#{size.round(1)} #{units[unit_index]}"
+    end
+  end
+end

data/lib/rails_code_health/ruby_analyzer.rb

@@ -0,0 +1,319 @@
+module RailsCodeHealth
+  class RubyAnalyzer
+    def initialize(file_path)
+      @file_path = file_path
+      @source = File.read(file_path)
+      @ast = Parser::CurrentRuby.parse(@source)
+    rescue Parser::SyntaxError => e
+      @parse_error = e
+      @ast = nil
+    end
+
+    def analyze
+      return { parse_error: @parse_error.message } if @parse_error
+
+      {
+        file_metrics: analyze_file,
+        class_metrics: analyze_classes,
+        method_metrics: analyze_methods,
+        complexity_metrics: analyze_complexity,
+        code_smells: detect_code_smells
+      }
+    end
+
+    private
+
+    def analyze_file
+      lines = @source.lines
+      {
+        total_lines: lines.count,
+        code_lines: lines.reject { |line| line.strip.empty? || line.strip.start_with?('#') }.count,
+        comment_lines: lines.count { |line| line.strip.start_with?('#') },
+        blank_lines: lines.count { |line| line.strip.empty? }
+      }
+    end
+
+    def analyze_classes
+      return [] unless @ast
+
+      classes = []
+      find_nodes(@ast, :class) do |node|
+        classes << {
+          name: extract_class_name(node),
+          line_count: count_lines_in_node(node),
+          method_count: count_methods_in_class(node),
+          public_method_count: count_public_methods_in_class(node),
+          inheritance: extract_inheritance(node),
+          complexity_score: calculate_class_complexity(node)
+        }
+      end
+      classes
+    end
+
+    def analyze_methods
+      return [] unless @ast
+
+      methods = []
+      find_nodes(@ast, :def) do |node|
+        methods << {
+          name: node.children[0],
+          line_count: count_lines_in_node(node),
+          parameter_count: count_parameters(node),
+          cyclomatic_complexity: calculate_cyclomatic_complexity(node),
+          nesting_depth: calculate_max_nesting_depth(node),
+          abc_score: calculate_abc_score(node),
+          has_rescue: has_rescue_block?(node)
+        }
+      end
+      methods
+    end
+
+    def analyze_complexity
+      return {} unless @ast
+
+      {
+        overall_complexity: calculate_overall_complexity,
+        max_nesting_depth: find_max_nesting_depth(@ast),
+        conditional_complexity: count_conditionals(@ast),
+        loop_complexity: count_loops(@ast)
+      }
+    end
+
+    def detect_code_smells
+      smells = []
+      smells.concat(detect_long_methods)
+      smells.concat(detect_god_classes)
+      smells.concat(detect_high_complexity_methods)
+      smells.concat(detect_too_many_parameters)
+      smells.concat(detect_nested_conditionals)
+      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
+      
+      find_nodes(node, :if) { complexity += 1 }
+      find_nodes(node, :case) { complexity += 1 }
+      find_nodes(node, :while) { complexity += 1 }
+      find_nodes(node, :until) { complexity += 1 }
+      find_nodes(node, :for) { complexity += 1 }
+      find_nodes(node, :rescue) { complexity += 1 }
+      find_nodes(node, :when) { complexity += 1 }
+      
+      complexity
+    end
+
+    def calculate_max_nesting_depth(node, depth = 0)
+      return depth unless node.is_a?(Parser::AST::Node)
+
+      max_depth = depth
+      
+      if nesting_node?(node)
+        depth += 1
+        max_depth = depth
+      end
+
+      node.children.each do |child|
+        child_depth = calculate_max_nesting_depth(child, depth)
+        max_depth = [max_depth, child_depth].max
+      end
+
+      max_depth
+    end
+
+    def calculate_abc_score(node)
+      assignments = 0
+      branches = 0
+      conditions = 0
+
+      find_nodes(node, :lvasgn) { assignments += 1 }
+      find_nodes(node, :ivasgn) { assignments += 1 }
+      find_nodes(node, :send) { branches += 1 }
+      find_nodes(node, :if) { conditions += 1 }
+      find_nodes(node, :case) { conditions += 1 }
+
+      Math.sqrt(assignments**2 + branches**2 + conditions**2).round(2)
+    end
+
+    # Code smell detection
+    def detect_long_methods
+      methods = []
+      find_nodes(@ast, :def) do |node|
+        line_count = count_lines_in_node(node)
+        if line_count > RailsCodeHealth.configuration.thresholds['ruby_thresholds']['method_length']['red']
+          methods << {
+            type: :long_method,
+            method_name: node.children[0],
+            line_count: line_count,
+            severity: :high
+          }
+        end
+      end
+      methods
+    end
+
+    def detect_god_classes
+      classes = []
+      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
+          classes << {
+            type: :god_class,
+            class_name: extract_class_name(node),
+            line_count: line_count,
+            method_count: method_count,
+            severity: :high
+          }
+        end
+      end
+      classes
+    end
+
+    def detect_high_complexity_methods
+      methods = []
+      find_nodes(@ast, :def) do |node|
+        complexity = calculate_cyclomatic_complexity(node)
+        if complexity > 15
+          methods << {
+            type: :high_complexity,
+            method_name: node.children[0],
+            complexity: complexity,
+            severity: :high
+          }
+        end
+      end
+      methods
+    end
+
+    def detect_too_many_parameters
+      methods = []
+      find_nodes(@ast, :def) do |node|
+        param_count = count_parameters(node)
+        if param_count > 5
+          methods << {
+            type: :too_many_parameters,
+            method_name: node.children[0],
+            parameter_count: param_count,
+            severity: :medium
+          }
+        end
+      end
+      methods
+    end
+
+    def detect_nested_conditionals
+      methods = []
+      find_nodes(@ast, :def) do |node|
+        max_depth = calculate_max_nesting_depth(node)
+        if max_depth > 4
+          methods << {
+            type: :nested_conditionals,
+            method_name: node.children[0],
+            nesting_depth: max_depth,
+            severity: :medium
+          }
+        end
+      end
+      methods
+    end
+
+    # Helper methods
+    def count_lines_in_node(node)
+      return 0 unless node.respond_to?(:loc) && node.loc.respond_to?(:last_line)
+      
+      node.loc.last_line - node.loc.first_line + 1
+    end
+
+    def count_methods_in_class(class_node)
+      method_count = 0
+      find_nodes(class_node, :def) { method_count += 1 }
+      method_count
+    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)
+    end
+
+    def count_parameters(method_node)
+      args_node = method_node.children[1]
+      return 0 unless args_node
+      
+      args_node.children.count
+    end
+
+    def extract_class_name(class_node)
+      class_node.children[0]&.children&.last || 'Unknown'
+    end
+
+    def extract_inheritance(class_node)
+      superclass_node = class_node.children[1]
+      return nil unless superclass_node
+      
+      if superclass_node.type == :const
+        superclass_node.children.last
+      else
+        'Unknown'
+      end
+    end
+
+    def calculate_class_complexity(class_node)
+      total_complexity = 0
+      find_nodes(class_node, :def) do |method_node|
+        total_complexity += calculate_cyclomatic_complexity(method_node)
+      end
+      total_complexity
+    end
+
+    def calculate_overall_complexity
+      total = 0
+      find_nodes(@ast, :def) do |node|
+        total += calculate_cyclomatic_complexity(node)
+      end
+      total
+    end
+
+    def find_max_nesting_depth(node)
+      calculate_max_nesting_depth(node)
+    end
+
+    def count_conditionals(node)
+      count = 0
+      find_nodes(node, :if) { count += 1 }
+      find_nodes(node, :case) { count += 1 }
+      count
+    end
+
+    def count_loops(node)
+      count = 0
+      find_nodes(node, :while) { count += 1 }
+      find_nodes(node, :until) { count += 1 }
+      find_nodes(node, :for) { count += 1 }
+      count
+    end
+
+    def nesting_node?(node)
+      [:if, :case, :while, :until, :for, :begin, :block].include?(node.type)
+    end
+
+    def has_rescue_block?(node)
+      has_rescue = false
+      find_nodes(node, :rescue) { has_rescue = true }
+      has_rescue
+    end
+  end
+end

data/lib/rails_code_health/version.rb

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

data/lib/rails_code_health.rb

@@ -0,0 +1,46 @@
+require 'parser/current'
+require 'ast'
+require 'rubocop/ast'
+require 'active_support'
+require 'json'
+require 'pathname'
+
+require_relative 'rails_code_health/version'
+require_relative 'rails_code_health/configuration'
+require_relative 'rails_code_health/project_detector'
+require_relative 'rails_code_health/file_analyzer'
+require_relative 'rails_code_health/ruby_analyzer'
+require_relative 'rails_code_health/rails_analyzer'
+require_relative 'rails_code_health/health_calculator'
+require_relative 'rails_code_health/report_generator'
+require_relative 'rails_code_health/cli'
+
+module RailsCodeHealth
+  class Error < StandardError; end
+
+  class << self
+    def analyze(path = '.')
+      project_path = Pathname.new(path).expand_path
+      
+      unless ProjectDetector.rails_project?(project_path)
+        raise Error, "Not a Rails project directory: #{project_path}"
+      end
+
+      analyzer = FileAnalyzer.new(project_path)
+      results = analyzer.analyze_all
+
+      health_calculator = HealthCalculator.new
+      scored_results = health_calculator.calculate_scores(results)
+
+      ReportGenerator.new(scored_results).generate
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+    end
+  end
+end