railsforge 1.0.0

data/lib/railsforge/analyzers/database_analyzer.rb

@@ -0,0 +1,55 @@
+# Database analyzer for RailsForge
+# Scans database schema for issues
+
+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)
+
+        content = File.read(schema_file)
+        tables = content.scan(/create_table\s+"(\w+)"/).flatten
+
+        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
+        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
+      end
+    end
+  end
+end

data/lib/railsforge/analyzers/metrics_analyzer.rb

@@ -0,0 +1,55 @@
+# Metrics analyzer for RailsForge
+# Provides comprehensive metrics analysis
+
+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")
+        }
+      end
+
+      def self.count_files(base_path)
+        counts = {}
+        GENERATOR_TYPES.each do |type|
+          folder = "app/#{type.chop}"
+          folder = "app/jobs" if type == "jobs"
+          counts[type] = count_in_folder(base_path, folder)
+        end
+        counts
+      end
+
+      def self.count_in_folder(base_path, folder)
+        path = File.join(base_path, folder)
+        Dir.exist?(path) ? Dir.glob(File.join(path, "**", "*.rb")).count : 0
+      end
+
+      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

@@ -0,0 +1,74 @@
+# Model analyzer for RailsForge
+# Scans models for code quality issues
+
+require_relative 'base_analyzer'
+
+module RailsForge
+  module Analyzers
+    # ModelAnalyzer scans models for issues
+    class ModelAnalyzer < BaseAnalyzer
+      MAX_METHODS = 15
+      MAX_LINES = 200
+
+      # Analyze models
+      def self.analyze(base_path = nil)
+        base_path ||= find_rails_app_path
+        return [] unless base_path
+
+        models_dir = File.join(base_path, "app", "models")
+        return [] unless Dir.exist?(models_dir)
+
+        results = []
+        Dir.glob(File.join(models_dir, "**", "*.rb")).each do |file|
+          next if file.end_with?("_application.rb")
+
+          content = File.read(file)
+          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
+            }
+          end
+        end
+
+        results
+      end
+
+      def self.print_results(results)
+        puts "\nModel Analysis"
+        puts "-" * 40
+
+        if results.empty?
+          puts "✓ No issues found"
+          return
+        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
+      end
+    end
+  end
+end

data/lib/railsforge/analyzers/performance_analyzer.rb

@@ -0,0 +1,161 @@
+# Performance analyzer for RailsForge
+# Checks for common performance issues
+
+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",
+        inefficient_query: "Inefficient Query",
+        cache_miss: "Cache Miss",
+        eager_loading: "Unnecessary Eager Loading"
+      }.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
+
+        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/
+        ]
+
+        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/
+        ]
+
+        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\(.*\)/
+        ]
+
+        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\//
+        ]
+
+        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.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
+            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"
+        end
+      end
+    end
+  end
+end

data/lib/railsforge/analyzers/refactor_analyzer.rb

@@ -0,0 +1,118 @@
+# Refactor analyzer for RailsForge
+# Provides refactoring suggestions
+
+require_relative 'base_analyzer'
+
+module RailsForge
+  module Analyzers
+    # RefactorAnalyzer provides refactoring suggestions
+    class RefactorAnalyzer < BaseAnalyzer
+      class RefactorError < StandardError; end
+
+      CONTROLLER_MAX_LINES = 150
+      CONTROLLER_MAX_METHODS = 10
+      MODEL_MAX_LINES = 200
+      MODEL_MAX_METHOD_LINES = 15
+
+      # Analyze controllers
+      def self.analyze_controllers(base_path = nil)
+        base_path ||= find_rails_app_path
+        raise RefactorError, "Not in a Rails app" unless base_path
+
+        controllers_dir = File.join(base_path, "app", "controllers")
+        return [] unless Dir.exist?(controllers_dir)
+
+        results = []
+        Dir.glob(File.join(controllers_dir, "**", "*_controller.rb")).each do |file|
+          result = analyze_file(file, :controller)
+          results << result if result[:needs_refactoring]
+        end
+        results
+      end
+
+      # Analyze models
+      def self.analyze_models(base_path = nil)
+        base_path ||= find_rails_app_path
+        raise RefactorError, "Not in a Rails app" unless base_path
+
+        models_dir = File.join(base_path, "app", "models")
+        return [] unless Dir.exist?(models_dir)
+
+        results = []
+        Dir.glob(File.join(models_dir, "**", "*.rb")).each do |file|
+          next if file.end_with?("_application.rb")
+          result = analyze_file(file, :model)
+          results << result if result[:needs_refactoring]
+        end
+        results
+      end
+
+      def self.analyze_file(file_path, type)
+        content = File.read(file_path)
+        lines = content.lines.count
+        methods = extract_methods(content)
+
+        issues = []
+        suggestions = []
+
+        if type == :controller
+          issues << "Exceeds #{CONTROLLER_MAX_LINES} lines" if lines > CONTROLLER_MAX_LINES
+          issues << "Has #{methods.count} methods" if methods.count > CONTROLLER_MAX_METHODS
+          suggestions << "Consider moving business logic to Service object" if lines > CONTROLLER_MAX_LINES
+        else
+          issues << "Exceeds #{MODEL_MAX_LINES} lines" if lines > MODEL_MAX_LINES
+        end
+
+        methods.each do |method|
+          suggestions << "Method `#{method[:name]}` has #{method[:lines]} lines - consider extracting" if method[:lines] > MODEL_MAX_METHOD_LINES
+        end
+
+        {
+          type: type,
+          file: File.basename(file_path),
+          path: file_path,
+          lines: lines,
+          methods: methods,
+          issues: issues,
+          suggestions: suggestions,
+          needs_refactoring: issues.any? || suggestions.any?
+        }
+      end
+
+      def self.extract_methods(content)
+        methods = []
+        in_method = false
+        method_lines = []
+
+        content.lines.each do |line|
+          if line =~ /\bdef\s+(\w+)/
+            methods << { name: $1, lines: method_lines.count } if in_method
+            in_method = true
+            method_lines = [line]
+          elsif in_method
+            method_lines << line
+            methods << { name: methods.last[:name], lines: method_lines.count } if line.strip == "end" && method_lines.count > 1
+          end
+        end
+
+        methods
+      end
+
+      def self.print_report(results)
+        puts "\nRefactoring Suggestions"
+        puts "-" * 40
+
+        if results.empty?
+          puts "✓ No refactoring needed"
+          return
+        end
+
+        results.each do |result|
+          puts "⚠ #{result[:file]}"
+          result[:issues].each { |i| puts "  - #{i}" }
+          result[:suggestions].each { |s| puts "  → #{s}" }
+        end
+      end
+    end
+  end
+end

data/lib/railsforge/analyzers/security_analyzer.rb

@@ -0,0 +1,169 @@
+# Security analyzer for RailsForge
+# Checks for common security vulnerabilities
+
+require 'fileutils'
+
+module RailsForge
+  module Analyzers
+    # SecurityAnalyzer scans code for security issues
+    class SecurityAnalyzer < BaseAnalyzer
+      # Security issue types
+      ISSUE_TYPES = {
+        sql_injection: "SQL Injection",
+        mass_assignment: "Unsafe Mass Assignment",
+        xss: "Cross-Site Scripting (XSS)",
+        sensitive_data: "Sensitive Data Exposure",
+        weak_crypto: "Weak Cryptography",
+        command_injection: "Command Injection"
+      }.freeze
+
+      # Analyze Rails app for security issues
+      # @param base_path [String] Rails app root path
+      # @return [Array<Hash>] Security issues found
+      def self.analyze(base_path = nil)
+        base_path ||= find_rails_app_path
+        return [] unless base_path
+
+        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 security issues
+      # @return [Array<Hash>] Issues found
+      def find_issues
+        check_sql_injection
+        check_mass_assignment
+        check_xss
+        check_sensitive_data
+        check_weak_crypto
+
+        @issues
+      end
+
+      # Print security report
+      # @param issues [Array<Hash>] Issues to print
+      def self.print_report(issues)
+        puts "Security Analysis"
+        puts "=" * 50
+
+        if issues.empty?
+          puts "✓ No security issues found"
+          return
+        end
+
+        puts "Found #{issues.count} security 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 SQL injection vulnerabilities
+      def check_sql_injection
+        patterns = [
+          /\.where\s*\(\s*params\./,
+          /find_by\(.*\#\{.*\}/,
+          /execute\s*\(.*\#\{.*\}/
+        ]
+
+        scan_files("app/models/**/*.rb", patterns, :sql_injection)
+        scan_files("app/controllers/**/*.rb", patterns, :sql_injection)
+      end
+
+      # Check for unsafe mass assignment
+      def check_mass_assignment
+        patterns = [
+          /attr_accessible/,
+          /attr_protected/
+        ]
+
+        scan_files("app/models/**/*.rb", patterns, :mass_assignment)
+      end
+
+      # Check for XSS vulnerabilities
+      def check_xss
+        patterns = [
+          /raw\s*\(/,
+          /html_safe\s*$/,
+          /\<\%=\s*[^>]+without/
+        ]
+
+        scan_files("app/views/**/*.erb", patterns, :xss)
+        scan_files("app/helpers/**/*.rb", patterns, :xss)
+      end
+
+      # Check for sensitive data exposure
+      def check_sensitive_data
+        patterns = [
+          /password/,
+          /secret/,
+          /token/,
+          /api_key/,
+          /private_key/
+        ]
+
+        scan_files("app/models/**/*.rb", patterns, :sensitive_data)
+        scan_files("config/**/*.rb", patterns, :sensitive_data)
+      end
+
+      # Check for weak cryptography
+      def check_weak_crypto
+        patterns = [
+          /MD5/,
+          /SHA1/,
+          /DES\.encrypt/,
+          /\.encrypt\s+[^:]+$/
+        ]
+
+        scan_files("app/**/*.rb", patterns, :weak_crypto)
+      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.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
+            end
+          end
+        end
+      end
+
+      # Get severity for issue type
+      def severity_for(issue_type)
+        case issue_type
+        when :sql_injection, :command_injection
+          "high"
+        when :mass_assignment, :xss
+          "medium"
+        else
+          "low"
+        end
+      end
+    end
+  end
+end

data/lib/railsforge/analyzers/spec_analyzer.rb

@@ -0,0 +1,58 @@
+# Spec analyzer for RailsForge
+# Checks for missing spec files
+
+require_relative 'base_analyzer'
+
+module RailsForge
+  module Analyzers
+    # SpecAnalyzer checks spec coverage
+    class SpecAnalyzer < BaseAnalyzer
+      GENERATOR_TYPES = %w[services queries jobs forms presenters policies serializers].freeze
+
+      # Analyze spec coverage
+      def self.analyze(base_path = nil)
+        base_path ||= find_rails_app_path
+        return [] unless base_path
+
+        results = []
+        GENERATOR_TYPES.each do |type|
+          app_folder = "app/#{type.chop}"
+          spec_folder = "spec/#{type}"
+
+          app_path = File.join(base_path, app_folder)
+          spec_path = File.join(base_path, spec_folder)
+
+          next unless Dir.exist?(app_path)
+
+          app_files = Dir.glob(File.join(app_path, "**", "*.rb")).map { |f| File.basename(f, ".rb") }
+          spec_files = Dir.exist?(spec_path) ? Dir.glob(File.join(spec_path, "**", "*_spec.rb")).map { |f| File.basename(f, "_spec.rb") } : []
+
+          (app_files - spec_files).each do |missing|
+            results << {
+              type: type.chop,
+              name: missing,
+              has_spec: false
+            }
+          end
+        end
+
+        results
+      end
+
+      def self.print_results(results)
+        puts "\nSpec Coverage Analysis"
+        puts "-" * 40
+
+        if results.empty?
+          puts "✓ All components have specs"
+          return
+        end
+
+        puts "⚠ #{results.count} missing specs:"
+        results.first(10).each do |result|
+          puts "  - #{result[:type]}: #{result[:name]}"
+        end
+      end
+    end
+  end
+end