railsforge 1.0.0

data/lib/railsforge/config.rb

@@ -0,0 +1,181 @@
+# Config module for RailsForge
+# Manages .railsforgerc configuration
+
+require 'yaml'
+require 'fileutils'
+
+module RailsForge
+  # Config class handles RailsForge configuration
+  class Config
+    # Default config file name
+    CONFIG_FILE = ".railsforgerc".freeze
+
+    # Default configuration
+    DEFAULT_CONFIG = {
+      "version" => "1.0",
+      "profile" => "standard",
+      "generators" => {
+        "default_template_version" => "v1",
+        "include_specs" => true
+      },
+      "analyzers" => {
+        "controller_max_lines" => 150,
+        "controller_max_methods" => 10,
+        "model_max_lines" => 200,
+        "model_max_method_lines" => 15
+      },
+      "refactor" => {
+        "min_method_lines" => 15,
+        "auto_extract" => false
+      }
+    }.freeze
+
+    # Load configuration from file
+    # @param base_path [String] Rails app root path
+    # @return [Hash] Configuration
+    def self.load(base_path = nil)
+      base_path ||= find_rails_app_path || Dir.pwd
+
+      config_file = File.join(base_path, CONFIG_FILE)
+
+      if File.exist?(config_file)
+        YAML.safe_load(File.read(config_file), permitted_classes: [], permitted_symbols: [], aliases: true) || DEFAULT_CONFIG
+      else
+        DEFAULT_CONFIG.dup
+      end
+    end
+
+    # Save configuration to file
+    # @param config [Hash] Configuration to save
+    # @param base_path [String] Rails app root path
+    def self.save(config, base_path = nil)
+      base_path ||= find_rails_app_path || Dir.pwd
+
+      config_file = File.join(base_path, CONFIG_FILE)
+
+      File.write(config_file, YAML.dump(config))
+      puts "Configuration saved to #{config_file}"
+    end
+
+    # Get a specific config value
+    # @param key [String] Configuration key (dot-notation supported)
+    # @param base_path [String] Rails app root path
+    # @return [Object] Configuration value
+    def self.get(key, base_path = nil)
+      config = load(base_path)
+
+      keys = key.split(".")
+      value = config
+
+      keys.each do |k|
+        value = value[k] if value.is_a?(Hash)
+      end
+
+      value
+    end
+
+    # Set a specific config value
+    # @param key [String] Configuration key
+    # @param value [Object] Value to set
+    # @param base_path [String] Rails app root path
+    def self.set(key, value, base_path = nil)
+      config = load(base_path)
+
+      keys = key.split(".")
+      current = config
+
+      keys[0...-1].each do |k|
+        current[k] ||= {}
+        current = current[k]
+      end
+
+      current[keys.last] = value
+      save(config, base_path)
+    end
+
+    # Initialize default config file
+    # @param base_path [String] Rails app root path
+    def self.init(base_path = nil)
+      base_path ||= find_rails_app_path || Dir.pwd
+
+      config_file = File.join(base_path, CONFIG_FILE)
+
+      if File.exist?(config_file)
+        puts "Config file already exists"
+        return false
+      end
+
+      save(DEFAULT_CONFIG.dup, base_path)
+      true
+    end
+
+    # Show current configuration
+    # @param base_path [String] Rails app root path
+    def self.show(base_path = nil)
+      config = load(base_path)
+
+      puts "RailsForge Configuration:"
+      puts ""
+
+      # Version
+      puts "  Version: #{config['version']}"
+      puts "  Profile: #{config['profile']}"
+      puts ""
+
+      # Generators
+      puts "  Generators:"
+      gens = config["generators"] || {}
+      gens.each do |key, value|
+        puts "    #{key}: #{value}"
+      end
+      puts ""
+
+      # Analyzers
+      puts "  Analyzers:"
+      analyzers = config["analyzers"] || {}
+      analyzers.each do |key, value|
+        puts "    #{key}: #{value}"
+      end
+      puts ""
+
+      # Refactor
+      puts "  Refactor:"
+      refactor = config["refactor"] || {}
+      refactor.each do |key, value|
+        puts "    #{key}: #{value}"
+      end
+    end
+
+    # Reset configuration to defaults
+    # @param base_path [String] Rails app root path
+    def self.reset(base_path = nil)
+      base_path ||= find_rails_app_path || Dir.pwd
+
+      config_file = File.join(base_path, CONFIG_FILE)
+
+      if File.exist?(config_file)
+        File.delete(config_file)
+        puts "Configuration reset to defaults"
+      else
+        puts "No configuration file to reset"
+      end
+    end
+
+    private
+
+    # 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
+      end
+
+      nil
+    end
+  end
+end

data/lib/railsforge/database_analyzer.rb

@@ -0,0 +1,300 @@
+module RailsForge
+  # DatabaseAnalyzer module scans models and database schema for issues
+  module DatabaseAnalyzer
+    # Error class for database analysis issues
+    class DatabaseError < StandardError; end
+
+    # Simple pluralize helper
+    def self.pluralize(word)
+      return word + 's' unless word.end_with?('s')
+      return word + 'es' if word.end_with?('sh') || word.end_with?('ch')
+      word + 's'
+    end
+
+    # Simple tableize helper
+    def self.tableize(word)
+      pluralize(word.downcase)
+    end
+
+    # Analyzes database and models for common issues
+    # @param base_path [String] Rails app root path
+    # @return [Array<Hash>] Analysis results
+    def self.analyze(base_path = nil)
+      base_path ||= find_rails_app_path
+      raise DatabaseError, "Not in a Rails application directory" unless base_path
+
+      results = []
+
+      # Analyze models
+      results += analyze_models(base_path)
+
+      # Analyze schema if available
+      results += analyze_schema(base_path)
+
+      results
+    end
+
+    # Analyzes models for missing indexes and constraints
+    # @param base_path [String] Rails app root path
+    # @return [Array<Hash>] Analysis results
+    def self.analyze_models(base_path)
+      results = []
+      models_dir = File.join(base_path, "app", "models")
+
+      return results unless Dir.exist?(models_dir)
+
+      Dir.glob(File.join(models_dir, "**", "*.rb")).each do |file|
+        next if file.end_with?("_application.rb")
+
+        model_name = File.basename(file, ".rb")
+        content = File.read(file)
+
+        # Skip abstract classes
+        next if content.include?("abstract_class = true")
+
+        # Check for missing indexes on foreign keys
+        results += check_foreign_keys(content, model_name)
+
+        # Check for uniqueness constraints
+        results += check_uniqueness(content, model_name)
+
+        # Check for missing database indexes
+        results += check_indexes(content, model_name)
+      end
+
+      results
+    end
+
+    # Analyzes schema.rb for missing foreign keys and indexes
+    # @param base_path [String] Rails app root path
+    # @return [Array<Hash>] Analysis results
+    def self.analyze_schema(base_path)
+      results = []
+      schema_file = File.join(base_path, "db", "schema.rb")
+
+      return results unless File.exist?(schema_file)
+
+      content = File.read(schema_file)
+
+      # Parse create_table statements
+      tables = content.scan(/create_table\s+"(\w+)"/).flatten
+
+      tables.each do |table|
+        # Check for tables without indexes
+        table_section = content[/create_table\s+"#{table}".*?(?=create_table|\z)/m]
+
+        if table_section
+          # Check for missing timestamps indexes
+          if table_section.include?("t.datetime")
+            results << {
+              type: :index,
+              table: table,
+              issue: "Table #{table} has datetime columns - consider adding indexes",
+              suggestion: "add_index :#{table}, :created_at",
+              severity: :low
+            } unless table_section.include?("index") && table.include?("created_at")
+          end
+        end
+      end
+
+      results
+    end
+
+    # Checks for missing foreign key indexes
+    # @param content [String] Model file content
+    # @param model_name [String] Model name
+    # @return [Array<Hash>] Analysis results
+    def self.check_foreign_keys(content, model_name)
+      results = []
+
+      # Find belongs_to associations
+      content.scan(/belongs_to\s+:(\w+)/).each do |assoc|
+        assoc_name = assoc[0]
+
+        # Check if foreign key is indexed
+        unless content.include?("index") && content.include?("#{assoc_name}_id")
+          results << {
+            type: :foreign_key,
+            model: model_name,
+            assoc: assoc_name,
+            issue: "Model #{model_name} has belongs_to :#{assoc_name} but may be missing an index",
+            suggestion: "add_index :#{tableize(model_name)}, :#{assoc_name}_id",
+            severity: :medium
+          }
+        end
+      end
+
+      results
+    end
+
+    # Checks for uniqueness validations without database constraints
+    # @param content [String] Model file content
+    # @param model_name [String] Model name
+    # @return [Array<Hash>] Analysis results
+    def self.check_uniqueness(content, model_name)
+      results = []
+
+      # Find uniqueness validations
+      content.scan(/validates\s+:(\w+),\s+uniqueness:/).each do |field|
+        field_name = field[0]
+
+        # Check if there's a unique index
+        unless content.include?("unique: true")
+          results << {
+            type: :uniqueness,
+            model: model_name,
+            field: field_name,
+            issue: "Model #{model_name} validates uniqueness of :#{field_name} but has no unique index",
+            suggestion: "add_index :#{tableize(model_name)}, :#{field_name}, unique: true",
+            severity: :high
+          }
+        end
+      end
+
+      results
+    end
+
+    # Checks for commonly indexed fields that may be missing indexes
+    # @param content [String] Model file content
+    # @param model_name [String] Model name
+    # @return [Array<Hash>] Analysis results
+    def self.check_indexes(content, model_name)
+      results = []
+
+      # Common fields that should be indexed
+      commonly_indexed = %w[email slug token uuid]
+
+      commonly_indexed.each do |field|
+        if content.include?(":#{field}") && !content.include?("add_index")
+          results << {
+            type: :index,
+            model: model_name,
+            issue: "Model #{model_name} has :#{field} field but may be missing an index",
+            suggestion: "add_index :#{tableize(model_name)}, :#{field}",
+            severity: :medium
+          }
+        end
+      end
+
+      # Check for has_many :through associations that need indexes
+      content.scan(/has_many\s+:(\w+),\s+through:/).each do |assoc|
+        results << {
+          type: :index,
+          model: model_name,
+          issue: "Model #{model_name} has has_many :through :#{assoc[0]} - ensure join table has indexes",
+          suggestion: "Ensure your join table has composite indexes on both foreign keys",
+          severity: :low
+        }
+      end
+
+      results
+    end
+
+    # Generates a migration file for a suggested fix
+    # @param suggestion [Hash] Suggestion details
+    # @param base_path [String] Rails app root
+    # @return [String] Path to created migration
+    def self.generate_migration(suggestion, base_path = nil)
+      base_path ||= find_rails_app_path
+      raise DatabaseError, "Not in a Rails application directory" unless base_path
+
+      migrate_dir = File.join(base_path, "db", "migrate")
+      FileUtils.mkdir_p(migrate_dir)
+
+      timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+      filename = "migration_#{timestamp}.rb"
+      filepath = File.join(migrate_dir, filename)
+
+      table_name = tableize(suggestion[:model])
+
+      migration_content = case suggestion[:type]
+      when :uniqueness
+        field = suggestion[:field] || "field"
+        <<~RUBY
+          class Add#{suggestion[:model]}#{field.capitalize}UniqueIndex < ActiveRecord::Migration[7.0]
+            def change
+              add_index :#{table_name}, :#{field}, unique: true
+            end
+          end
+        RUBY
+      when :foreign_key
+        assoc = suggestion[:assoc] || "association"
+        <<~RUBY
+          class Add#{suggestion[:model].capitalize}#{assoc.capitalize}Index < ActiveRecord::Migration[7.0]
+            def change
+              add_index :#{table_name}, :#{assoc}_id
+            end
+          end
+        RUBY
+      when :index
+        <<~RUBY
+          class Add#{suggestion[:model].capitalize}Index < ActiveRecord::Migration[7.0]
+            def change
+              #{suggestion[:suggestion]}
+            end
+          end
+        RUBY
+      else
+        "# No migration template available for #{suggestion[:type]}"
+      end
+
+      File.write(filepath, migration_content)
+      puts "  Created db/migrate/#{filename}"
+      filepath
+    end
+
+    # Prints analysis report
+    # @param results [Array<Hash>] Analysis results
+    def self.print_report(results)
+      return puts "\n✓ No database issues found!" if results.empty?
+
+      puts "\n" + "=" * 60
+      puts "DATABASE ANALYSIS REPORT"
+      puts "=" * 60
+
+      # Group by severity
+      high = results.select { |r| r[:severity] == :high }
+      medium = results.select { |r| r[:severity] == :medium }
+      low = results.select { |r| r[:severity] == :low }
+
+      if high.any?
+        puts "\n🔴 High Priority (#{high.count}):"
+        high.each { |r| print_issue(r) }
+      end
+
+      if medium.any?
+        puts "\n🟡 Medium Priority (#{medium.count}):"
+        medium.each { |r| print_issue(r) }
+      end
+
+      if low.any?
+        puts "\n🟢 Low Priority (#{low.count}):"
+        low.each { |r| print_issue(r) }
+      end
+
+      puts "\n" + "=" * 60
+      puts "Total issues found: #{results.count}"
+      puts "=" * 60
+    end
+
+    # Prints a single issue
+    # @param issue [Hash] Issue details
+    def self.print_issue(issue)
+      puts "\n  #{issue[:type].to_s.upcase}: #{issue[:issue]}"
+      puts "    → Suggested: #{issue[:suggestion]}"
+    end
+
+    # Finds Rails app root path
+    # @return [String, nil] Rails app path
+    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