railsforge 1.0.0

data/lib/railsforge/doctor.rb

@@ -0,0 +1,250 @@
+# Doctor module for RailsForge
+# Provides a comprehensive project health report
+
+module RailsForge
+  # Doctor class provides a full project health check
+  class Doctor
+    # Initialize the Doctor analyzer
+    def initialize(base_path = nil)
+      @base_path = base_path || find_rails_app_path
+      raise DoctorError, "Not in a Rails application directory" unless @base_path
+
+      @results = {
+        controllers: [],
+        models: [],
+        database: [],
+        specs: [],
+        refactors: [],
+        metrics: {}
+      }
+    end
+
+    # Run all analyzers and generate report
+    # @return [Hash] Complete health check results
+    def run
+      puts "Running RailsForge Doctor..."
+      puts ""
+
+      # Run all analyzers
+      run_analyzers
+
+      # Calculate score
+      @results[:score] = calculate_score
+
+      # Print report
+      print_report
+
+      @results
+    end
+
+    private
+
+    # Run all available analyzers
+    def run_analyzers
+      # Controller analysis
+      begin
+        @results[:controllers] = RailsForge::Analyzers::RefactorAnalyzer.analyze_controllers(@base_path)
+      rescue => e
+        @results[:controllers] = []
+      end
+
+      # Model analysis
+      begin
+        @results[:models] = RailsForge::Analyzers::RefactorAnalyzer.analyze_models(@base_path)
+      rescue => e
+        @results[:models] = []
+      end
+
+      # Database analysis
+      begin
+        @results[:database] = RailsForge::Analyzers::DatabaseAnalyzer.analyze(@base_path)
+      rescue => e
+        @results[:database] = []
+      end
+
+      # Spec analysis
+      begin
+        @results[:specs] = RailsForge::Analyzers::SpecAnalyzer.analyze(@base_path)
+      rescue => e
+        @results[:specs] = []
+      end
+
+      # Refactor suggestions (from RefactorAnalyzer)
+      begin
+        @results[:refactors] = []
+        @results[:controllers].each do |ctrl|
+          @results[:refactors].concat(ctrl[:suggestions] || [])
+        end
+        @results[:models].each do |model|
+          @results[:refactors].concat(model[:suggestions] || [])
+        end
+      rescue => e
+        @results[:refactors] = []
+      end
+
+      # Metrics
+      begin
+        @results[:metrics] = RailsForge::Analyzers::MetricsAnalyzer.analyze(@base_path)
+      rescue => e
+        @results[:metrics] = {}
+      end
+    end
+
+    # Calculate architecture score
+    # @return [Integer] Score out of 100
+    def calculate_score
+      score = 100
+
+      # Subtract 5 points per fat controller
+      fat_controllers = @results[:controllers].count { |c| c[:needs_refactoring] }
+      score -= fat_controllers * 5
+
+      # Subtract 5 points per fat model
+      fat_models = @results[:models].count { |m| m[:needs_refactoring] }
+      score -= fat_models * 5
+
+      # Subtract 3 points per missing spec
+      missing_specs = @results[:specs].count { |s| s[:has_spec] == false }
+      score -= missing_specs * 3
+
+      # Subtract 2 points per missing index (database issues)
+      missing_indexes = @results[:database].count { |d| d[:type] == :index }
+      score -= missing_indexes * 2
+
+      # Subtract 2 points per long method
+      long_methods = count_long_methods
+      score -= long_methods * 2
+
+      [score, 0].max
+    end
+
+    # Count long methods in controllers and models
+    # @return [Integer] Number of long methods
+    def count_long_methods
+      count = 0
+
+      @results[:controllers].each do |ctrl|
+        methods = ctrl[:methods] || []
+        count += methods.count { |m| m[:lines].to_i > 15 }
+      end
+
+      @results[:models].each do |model|
+        methods = model[:methods] || []
+        count += methods.count { |m| m[:lines].to_i > 15 }
+      end
+
+      count
+    end
+
+    # Print formatted report
+    def print_report
+      score = @results[:score]
+      score_color = score >= 80 ? :green : score >= 50 ? :yellow : :red
+
+      puts "RailsForge Doctor Report"
+      puts "────────────────────────"
+      puts ""
+      puts "Architecture Score: #{colorize(score, score_color)}/100"
+      puts ""
+
+      # Controllers
+      puts "Controllers:"
+      if @results[:controllers].empty?
+        puts "  ✓ No issues found"
+      else
+        @results[:controllers].each do |ctrl|
+          issues = ctrl[:issues] || []
+          if issues.any?
+            puts "  ⚠ #{ctrl[:file]}: #{issues.join(', ')}"
+          end
+        end
+      end
+      puts ""
+
+      # Models
+      puts "Models:"
+      if @results[:models].empty?
+        puts "  ✓ No issues found"
+      else
+        @results[:models].each do |model|
+          issues = model[:issues] || []
+          if issues.any?
+            puts "  ⚠ #{model[:file]}: #{issues.join(', ')}"
+          end
+        end
+      end
+      puts ""
+
+      # Database
+      puts "Database:"
+      if @results[:database].empty?
+        puts "  ✓ No issues found"
+      else
+        @results[:database].first(5).each do |db|
+          puts "  ⚠ #{db[:table]}: #{db[:issue]}"
+        end
+        puts "  ... and #{@results[:database].count - 5} more" if @results[:database].count > 5
+      end
+      puts ""
+
+      # Specs
+      missing_specs = @results[:specs].select { |s| s[:has_spec] == false }
+      puts "Specs:"
+      if missing_specs.empty?
+        puts "  ✓ All components have specs"
+      else
+        puts "  ⚠ #{missing_specs.count} missing specs:"
+        missing_specs.first(5).each do |spec|
+          puts "    - #{spec[:type]}: #{spec[:name]}"
+        end
+        puts "    ... and #{missing_specs.count - 5} more" if missing_specs.count > 5
+      end
+      puts ""
+
+      # Suggestions
+      puts "Suggestions:"
+      if @results[:refactors].empty?
+        puts "  ✓ No refactoring suggestions"
+      else
+        @results[:refactors].first(10).each do |suggestion|
+          puts "  • #{suggestion}"
+        end
+        puts "  ... and #{@results[:refactors].count - 10} more" if @results[:refactors].count > 10
+      end
+      puts ""
+    end
+
+    # Find Rails app path
+    # @return [String, nil] Rails app root path
+    def find_rails_app_path
+      path = Dir.pwd
+      max_depth = 10
+
+      max_depth.times do
+        return path if File.exist?(File.join(path, "config", "application.rb"))
+        parent = File.dirname(path)
+        break if parent == path
+        path = parent
+      end
+
+      nil
+    end
+
+    # Colorize output for terminal
+    # @param text [String] Text to colorize
+    # @param color [Symbol] Color name
+    # @return [String] Colorized text
+    def colorize(text, color)
+      colors = {
+        green: "\e[32m",
+        yellow: "\e[33m",
+        red: "\e[31m",
+        reset: "\e[0m"
+      }
+      "#{colors[color]}#{text}#{colors[:reset]}"
+    end
+
+    # Error class for doctor issues
+    class DoctorError < StandardError; end
+  end
+end