railsforge 1.0.2 → 2.1.0

data/lib/railsforge/analyzers/controller_analyzer.rb

@@ -1,19 +1,14 @@
 # Controller analyzer for RailsForge
 # Scans controllers for code quality issues
 
-require_relative 'base_analyzer'
+require_relative "base_analyzer"
 
 module RailsForge
   module Analyzers
-    # ControllerAnalyzer scans controllers for issues
     class ControllerAnalyzer < BaseAnalyzer
-      # Configuration thresholds
-      MAX_LINES = 150
+      MAX_LINES   = 150
       MAX_METHODS = 10
 
-      # Analyze controllers
-      # @param base_path [String] Rails app root
-      # @return [Array<Hash>] Analysis results
       def self.analyze(base_path = nil)
         base_path ||= find_rails_app_path
         return [] unless base_path
@@ -21,62 +16,41 @@ module RailsForge
         controllers_dir = File.join(base_path, "app", "controllers")
         return [] unless Dir.exist?(controllers_dir)
 
-        results = []
+        issues = []
         Dir.glob(File.join(controllers_dir, "**", "*_controller.rb")).each do |file|
-          next if file.end_with?("_application_controller.rb")
+          next if File.basename(file) == "application_controller.rb"
 
           content = File.read(file)
-          lines = content.lines.count
+          lines   = content.lines.count
           methods = content.scan(/def \w+/).count
-
-          issues = []
-          issues << "Exceeds #{MAX_LINES} lines" if lines > MAX_LINES
-          issues << "Has #{methods} methods (max: #{MAX_METHODS})" if methods > MAX_METHODS
-
-          if issues.any?
-            results << {
-              file: File.basename(file),
-              path: file,
-              lines: lines,
-              methods: methods,
-              issues: issues
-            }
+          rel     = file.delete_prefix("#{base_path}/")
+
+          if lines > MAX_LINES
+            issues << RailsForge::Issue.new(
+              analyzer:   :controller,
+              type:       :fat_controller,
+              severity:   "medium",
+              file:       rel,
+              line:       nil,
+              message:    "#{File.basename(file)} has #{lines} lines (max #{MAX_LINES})",
+              suggestion: "Extract business logic to Service objects"
+            )
           end
-        end
 
-        results
-      end
-
-      # Print results
-      def self.print_results(results)
-        puts "\nController Analysis"
-        puts "-" * 40
-
-        if results.empty?
-          puts "✓ No issues found"
-          return
-        end
-
-        results.each do |result|
-          puts "⚠ #{result[:file]}"
-          puts "  Lines: #{result[:lines]}, Methods: #{result[:methods]}"
-          result[:issues].each { |issue| puts "  - #{issue}" }
-        end
-      end
-
-      # Find Rails app path
-      def self.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
+          if methods > MAX_METHODS
+            issues << RailsForge::Issue.new(
+              analyzer:   :controller,
+              type:       :too_many_methods,
+              severity:   "low",
+              file:       rel,
+              line:       nil,
+              message:    "#{File.basename(file)} has #{methods} methods (max #{MAX_METHODS})",
+              suggestion: "Consider splitting into focused controllers"
+            )
+          end
         end
 
-        nil
+        issues
       end
     end
   end

data/lib/railsforge/analyzers/database_analyzer.rb

@@ -1,54 +1,40 @@
 # Database analyzer for RailsForge
 # Scans database schema for issues
 
-require_relative 'base_analyzer'
+require_relative "base_analyzer"
 
 module RailsForge
   module Analyzers
-    # DatabaseAnalyzer scans database/schema for issues
     class DatabaseAnalyzer < BaseAnalyzer
       class DatabaseError < StandardError; end
 
-      # Analyze database
       def self.analyze(base_path = nil)
         base_path ||= find_rails_app_path
         raise DatabaseError, "Not in a Rails application" unless base_path
 
-        results = []
         schema_file = File.join(base_path, "db", "schema.rb")
-
-        return results unless File.exist?(schema_file)
+        return [] unless File.exist?(schema_file)
 
         content = File.read(schema_file)
-        tables = content.scan(/create_table\s+"(\w+)"/).flatten
+        tables  = content.scan(/create_table\s+"(\w+)"/).flatten
+        issues  = []
 
         tables.each do |table|
           table_section = content[/create_table\s+"#{table}".*?(?=create_table|\z)/m]
-          if table_section && table_section.include?("t.datetime")
-            results << {
-              type: :index,
-              table: table,
-              issue: "Consider adding index on datetime columns",
-              suggestion: "add_index :#{table}, :created_at"
-            }
-          end
+          next unless table_section&.include?("t.datetime")
+
+          issues << RailsForge::Issue.new(
+            analyzer:   :database,
+            type:       :missing_index,
+            severity:   "medium",
+            file:       "db/schema.rb",
+            line:       nil,
+            message:    "Table `#{table}` has datetime columns without an index",
+            suggestion: "add_index :#{table}, :created_at"
+          )
         end
 
-        results
-      end
-
-      def self.print_report(results)
-        puts "\nDatabase Analysis"
-        puts "-" * 40
-
-        if results.empty?
-          puts "✓ No issues found"
-          return
-        end
-
-        results.each do |result|
-          puts "⚠ #{result[:table]}: #{result[:issue]}"
-        end
+        issues
       end
     end
   end

data/lib/railsforge/analyzers/metrics_analyzer.rb

@@ -1,36 +1,31 @@
 # Metrics analyzer for RailsForge
-# Provides comprehensive metrics analysis
+# Provides project-level metrics summary (not issues)
 
-require_relative 'base_analyzer'
+require_relative "base_analyzer"
 
 module RailsForge
   module Analyzers
-    # MetricsAnalyzer provides code metrics
     class MetricsAnalyzer < BaseAnalyzer
       GENERATOR_TYPES = %w[services queries forms presenters policies serializers jobs].freeze
 
-      # Analyze metrics
       def self.analyze(base_path = nil)
         base_path ||= find_rails_app_path
         return {} unless base_path
 
         {
           generator_counts: count_files(base_path),
-          total_files: count_all_files(base_path),
-          services_count: count_in_folder(base_path, "app/services"),
-          queries_count: count_in_folder(base_path, "app/queries"),
-          jobs_count: count_in_folder(base_path, "app/jobs")
+          total_files:      count_all_files(base_path),
+          services_count:   count_in_folder(base_path, "app/services"),
+          queries_count:    count_in_folder(base_path, "app/queries"),
+          jobs_count:       count_in_folder(base_path, "app/jobs")
         }
       end
 
       def self.count_files(base_path)
-        counts = {}
-        GENERATOR_TYPES.each do |type|
-          folder = "app/#{type.chop}"
-          folder = "app/jobs" if type == "jobs"
+        GENERATOR_TYPES.each_with_object({}) do |type, counts|
+          folder = type == "jobs" ? "app/jobs" : "app/#{type.chop}"
           counts[type] = count_in_folder(base_path, folder)
         end
-        counts
       end
 
       def self.count_in_folder(base_path, folder)
@@ -41,15 +36,6 @@ module RailsForge
       def self.count_all_files(base_path)
         Dir.glob(File.join(base_path, "app", "**", "*.rb")).count
       end
-
-      def self.print_results(results)
-        puts "\nMetrics Analysis"
-        puts "-" * 40
-        puts "Total Files: #{results[:total_files]}"
-        puts "Services: #{results[:services_count]}"
-        puts "Queries: #{results[:queries_count]}"
-        puts "Jobs: #{results[:jobs_count]}"
-      end
     end
   end
 end

data/lib/railsforge/analyzers/model_analyzer.rb

@@ -1,16 +1,14 @@
 # Model analyzer for RailsForge
 # Scans models for code quality issues
 
-require_relative 'base_analyzer'
+require_relative "base_analyzer"
 
 module RailsForge
   module Analyzers
-    # ModelAnalyzer scans models for issues
     class ModelAnalyzer < BaseAnalyzer
+      MAX_LINES   = 200
       MAX_METHODS = 15
-      MAX_LINES = 200
 
-      # Analyze models
       def self.analyze(base_path = nil)
         base_path ||= find_rails_app_path
         return [] unless base_path
@@ -18,56 +16,41 @@ module RailsForge
         models_dir = File.join(base_path, "app", "models")
         return [] unless Dir.exist?(models_dir)
 
-        results = []
+        issues = []
         Dir.glob(File.join(models_dir, "**", "*.rb")).each do |file|
-          next if file.end_with?("_application.rb")
+          next if File.basename(file) == "application_record.rb"
 
           content = File.read(file)
-          lines = content.lines.count
+          lines   = content.lines.count
           methods = content.scan(/def \w+/).count
-
-          issues = []
-          issues << "Exceeds #{MAX_LINES} lines" if lines > MAX_LINES
-          issues << "Has #{methods} methods" if methods > MAX_METHODS
-
-          if issues.any?
-            results << {
-              file: File.basename(file),
-              path: file,
-              lines: lines,
-              methods: methods,
-              issues: issues
-            }
+          rel     = file.delete_prefix("#{base_path}/")
+
+          if lines > MAX_LINES
+            issues << RailsForge::Issue.new(
+              analyzer:   :model,
+              type:       :fat_model,
+              severity:   "medium",
+              file:       rel,
+              line:       nil,
+              message:    "#{File.basename(file)} has #{lines} lines (max #{MAX_LINES})",
+              suggestion: "Consider extracting concerns or service objects"
+            )
           end
-        end
-
-        results
-      end
-
-      def self.print_results(results)
-        puts "\nModel Analysis"
-        puts "-" * 40
 
-        if results.empty?
-          puts "✓ No issues found"
-          return
+          if methods > MAX_METHODS
+            issues << RailsForge::Issue.new(
+              analyzer:   :model,
+              type:       :too_many_methods,
+              severity:   "low",
+              file:       rel,
+              line:       nil,
+              message:    "#{File.basename(file)} has #{methods} methods (max #{MAX_METHODS})",
+              suggestion: "Consider extracting business logic to service or concern"
+            )
+          end
         end
 
-        results.each do |result|
-          puts "⚠ #{result[:file]}"
-          result[:issues].each { |issue| puts "  - #{issue}" }
-        end
-      end
-
-      def self.find_rails_app_path
-        path = Dir.pwd
-        10.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
+        issues
       end
     end
   end

data/lib/railsforge/analyzers/performance_analyzer.rb

@@ -1,25 +1,29 @@
 # Performance analyzer for RailsForge
 # Checks for common performance issues
 
-require 'fileutils'
+require "fileutils"
 
 module RailsForge
   module Analyzers
-    # PerformanceAnalyzer scans code for performance problems
     class PerformanceAnalyzer < BaseAnalyzer
-      # Performance issue types
       ISSUE_TYPES = {
-        n_plus_one: "N+1 Query",
-        missing_index: "Missing Database Index",
-        slow_method: "Slow Method",
+        n_plus_one:        "N+1 Query",
+        missing_index:     "Missing Database Index",
+        slow_method:       "Slow Method",
         inefficient_query: "Inefficient Query",
-        cache_miss: "Cache Miss",
-        eager_loading: "Unnecessary Eager Loading"
+        cache_miss:        "Cache Miss",
+        eager_loading:     "Unnecessary Eager Loading"
+      }.freeze
+
+      SUGGESTIONS = {
+        n_plus_one:        "Use eager loading: includes(:association) or preload(:association)",
+        missing_index:     "Add a database index to the foreign key column",
+        slow_method:       "Consider async processing or caching for slow operations",
+        inefficient_query: "Refactor query to avoid loading unnecessary records",
+        cache_miss:        "Consider caching with Rails.cache or HTTP caching",
+        eager_loading:     "Remove unnecessary includes() if association is not used"
       }.freeze
 
-      # Analyze Rails app for performance issues
-      # @param base_path [String] Rails app root path
-      # @return [Array<Hash>] Performance issues found
       def self.analyze(base_path = nil)
         base_path ||= find_rails_app_path
         return [] unless base_path
@@ -27,133 +31,69 @@ module RailsForge
         new(base_path).find_issues
       end
 
-      # Initialize analyzer
-      # @param base_path [String] Rails app root path
       def initialize(base_path)
         @base_path = base_path
         @issues = []
       end
 
-      # Find all performance issues
-      # @return [Array<Hash>] Issues found
       def find_issues
         check_n_plus_one
         check_missing_indexes
         check_slow_methods
         check_inefficient_queries
-
         @issues
       end
 
-      # Print performance report
-      # @param issues [Array<Hash>] Issues to print
-      def self.print_report(issues)
-        puts "Performance Analysis"
-        puts "=" * 50
-
-        if issues.empty?
-          puts "✓ No performance issues found"
-          return
-        end
-
-        puts "Found #{issues.count} performance issue(s):"
-        puts ""
-
-        issues.each do |issue|
-          puts "⚠ #{issue[:type]}"
-          puts "  File: #{issue[:file]}"
-          puts "  Line: #{issue[:line]}"
-          puts "  Issue: #{issue[:message]}"
-          puts ""
-        end
-      end
-
       private
 
-      # Check for N+1 query problems
       def check_n_plus_one
-        # Look for loops with database queries inside
-        patterns = [
-          /\.each\s+do.*\.find/,
-          /\.map.*\.where/,
-          /@.*\.all\.each/
-        ]
-
+        patterns = [/\.each\s+do.*\.find/, /\.map.*\.where/, /@.*\.all\.each/]
         scan_files("app/controllers/**/*.rb", patterns, :n_plus_one)
         scan_files("app/views/**/*.erb", patterns, :n_plus_one)
       end
 
-      # Check for missing database indexes
       def check_missing_indexes
-        # Look for foreign keys without indexes
-        patterns = [
-          /belongs_to\s+:\w+/,
-          /add_reference/
-        ]
-
+        patterns = [/belongs_to\s+:\w+/, /add_reference/]
         scan_files("db/migrate/**/*.rb", patterns, :missing_index)
       end
 
-      # Check for slow methods
       def check_slow_methods
-        # Look for potentially slow operations
-        patterns = [
-          /\.each\s+do\s*\n.*\.save/,
-          /Process\.spawn/,
-          /\.read/,
-          /\.open\(.*\)/
-        ]
-
+        patterns = [/\.each\s+do\s*\n.*\.save/, /Process\.spawn/, /\.read/, /\.open\(.*\)/]
         scan_files("app/**/*.rb", patterns, :slow_method)
       end
 
-      # Check for inefficient queries
       def check_inefficient_queries
-        # Look for inefficient query patterns
-        patterns = [
-          /\.order\(.*\)\.last/,
-          /\.where\(.*\)\.first\! /,
-          /\.all\.to_a/,
-          /\.select\(.+\)\.map\//
-        ]
-
+        patterns = [/\.order\(.*\)\.last/, /\.where\(.*\)\.first\! /, /\.all\.to_a/, /\.select\(.+\)\.map\//]
         scan_files("app/models/**/*.rb", patterns, :inefficient_query)
         scan_files("app/controllers/**/*.rb", patterns, :inefficient_query)
       end
 
-      # Scan files for patterns
       def scan_files(glob, patterns, issue_type)
         Dir.glob(File.join(@base_path, glob)).each do |file|
-          content = File.read(file)
-          lines = content.lines
-
+          lines = File.read(file).lines
           lines.each_with_index do |line, index|
             patterns.each do |pattern|
-              if line =~ pattern
-                @issues << {
-                  type: ISSUE_TYPES[issue_type],
-                  file: file.gsub(@base_path, ""),
-                  line: index + 1,
-                  message: line.strip,
-                  severity: severity_for(issue_type)
-                }
-              end
+              next unless line =~ pattern
+
+              @issues << RailsForge::Issue.new(
+                analyzer:   :performance,
+                type:       issue_type,
+                severity:   severity_for(issue_type),
+                file:       file.delete_prefix("#{@base_path}/"),
+                line:       index + 1,
+                message:    "#{ISSUE_TYPES[issue_type]}: #{line.strip}",
+                suggestion: SUGGESTIONS[issue_type]
+              )
             end
           end
         end
       end
 
-      # Get severity for issue type
       def severity_for(issue_type)
         case issue_type
-        when :n_plus_one
-          "high"
-        when :missing_index
-          "high"
-        when :inefficient_query
-          "medium"
-        else
-          "low"
+        when :n_plus_one, :missing_index then "high"
+        when :inefficient_query          then "medium"
+        else                                  "low"
         end
       end
     end