railsforge 1.0.0

data/lib/railsforge/profiles/blog.yml

@@ -0,0 +1,47 @@
+# Blog Profile Configuration
+# Use with: railsforge new my_blog --profile=blog
+
+name: blog
+description: A standard blog application with articles, comments, and user authentication
+
+# Default folders to create
+folders:
+  - app/controllers
+  - app/models
+  - app/views
+  - app/helpers
+  - app/mailers
+  - app/jobs
+  - app/services
+  - app/queries
+  - app/presenters
+  - app/policies
+  - app/serializers
+  - app/forms
+  - config/initializers
+  - db/migrate
+  - spec/models
+  - spec/controllers
+  - spec/views
+  - spec/requests
+  - spec/services
+  - spec/policies
+  - spec/serializers
+
+# Default generators to run after app creation
+generators:
+  - model
+  - scaffold
+  - resource
+
+# Features to enable by default
+features:
+  - authentication
+  - authorization
+  - mailers
+
+# Template variables
+defaults:
+  css_framework: tailwind
+  testing: rspec
+  database: postgresql

data/lib/railsforge/profiles/standard.yml

@@ -0,0 +1,44 @@
+# Standard Profile Configuration
+# Use with: railsforge new my_app --profile=standard (default)
+
+name: standard
+description: A standard Rails application with common defaults
+
+# Default folders to create
+folders:
+  - app/controllers
+  - app/models
+  - app/views
+  - app/helpers
+  - app/mailers
+  - app/jobs
+  - app/services
+  - app/queries
+  - app/presenters
+  - app/policies
+  - app/serializers
+  - app/forms
+  - config/initializers
+  - db/migrate
+  - spec/models
+  - spec/controllers
+  - spec/requests
+  - spec/services
+  - spec/policies
+
+# Default generators to run after app creation
+generators:
+  - model
+  - scaffold
+  - resource
+
+# Features to enable by default
+features:
+  - authentication
+  - mailers
+
+# Template variables
+defaults:
+  css_framework: tailwind
+  testing: rspec
+  database: postgresql

data/lib/railsforge/profiles.rb

@@ -0,0 +1,99 @@
+# ProfileLoader module handles loading RailsForge profiles
+require 'yaml'
+
+module RailsForge
+  # Profile module for managing application profiles
+  module Profile
+    # Error class for profile loading issues
+    class ProfileError < StandardError; end
+
+    # Profile directory path
+    PROFILES_DIR = File.expand_path('../profiles', __FILE__)
+
+    # Load a profile by name
+    # @param profile_name [String] The name of the profile to load
+    # @return [Hash] The profile configuration
+    # @raises [ProfileError] If profile not found or invalid
+    def self.load(profile_name)
+      profile_path = File.join(PROFILES_DIR, "#{profile_name}.yml")
+      
+      unless File.exist?(profile_path)
+        raise ProfileError, "Profile '#{profile_name}' not found. Available profiles: #{available_profiles.join(', ')}"
+      end
+
+      begin
+        YAML.safe_load(File.read(profile_path), permitted_classes: [], permitted_symbols: [], aliases: true)
+      rescue => e
+        raise ProfileError, "Failed to load profile '#{profile_name}': #{e.message}"
+      end
+    end
+
+    # Get list of available profiles
+    # @return [Array<String>] Array of profile names
+    def self.available_profiles
+      return [] unless Dir.exist?(PROFILES_DIR)
+      
+      Dir.glob(File.join(PROFILES_DIR, '*.yml')).map do |file|
+        File.basename(file, '.yml')
+      end.sort
+    end
+
+    # Validate a profile configuration
+    # @param profile [Hash] The profile configuration to validate
+    # @return [Boolean] True if valid
+    def self.validate?(profile)
+      return false unless profile.is_a?(Hash)
+      
+      required_keys = %w[name description folders]
+      required_keys.all? { |key| profile.key?(key) }
+    end
+
+    # Create folders defined in profile
+    # @param base_path [String] The Rails app root path
+    # @param profile [Hash] The profile configuration
+    def self.create_folders(base_path, profile)
+      folders = profile['folders'] || []
+      
+      folders.each do |folder|
+        full_path = File.join(base_path, folder)
+        unless Dir.exist?(full_path)
+          FileUtils.mkdir_p(full_path)
+          puts "  Created #{folder}"
+        end
+      end
+    end
+
+    # Get default features from profile
+    # @param profile [Hash] The profile configuration
+    # @return [Array<String>] Array of feature names
+    def self.default_features(profile)
+      profile['features'] || []
+    end
+
+    # Get default template variables from profile
+    # @param profile [Hash] The profile configuration
+    # @return [Hash] Default template variables
+    def self.defaults(profile)
+      profile['defaults'] || {}
+    end
+
+    # Show available profiles with descriptions
+    # @return [String] Formatted list of profiles
+    def self.show_available
+      profiles = available_profiles
+      
+      if profiles.empty?
+        return "No profiles available."
+      end
+
+      output = "Available profiles:\n\n"
+      
+      profiles.each do |name|
+        profile = load(name)
+        output += "  #{name.ljust(15)} - #{profile['description']}\n"
+      end
+      
+      output
+    end
+  end
+end

data/lib/railsforge/refactor_analyzer.rb

@@ -0,0 +1,401 @@
+module RailsForge
+  # RefactorAnalyzer module handles refactoring suggestions and code extraction
+  module RefactorAnalyzer
+    # Error class for refactoring issues
+    class RefactorError < StandardError; end
+
+    # Configuration thresholds
+    CONTROLLER_MAX_LINES = 150
+    CONTROLLER_MAX_METHODS = 10
+    MODEL_MAX_LINES = 200
+    MODEL_MAX_METHOD_LINES = 15
+
+    # Analyzes controllers for refactoring opportunities
+    # @param base_path [String] Rails app root path
+    # @return [Array<Hash>] Array of refactoring suggestions
+    def self.analyze_controllers(base_path = nil)
+      base_path ||= find_rails_app_path
+      raise RefactorError, "Not in a Rails application directory" 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_controller_file(file)
+        results << result if result[:needs_refactoring]
+      end
+      results
+    end
+
+    # Analyzes models for refactoring opportunities
+    # @param base_path [String] Rails app root path
+    # @return [Array<Hash>] Array of refactoring suggestions
+    def self.analyze_models(base_path = nil)
+      base_path ||= find_rails_app_path
+      raise RefactorError, "Not in a Rails application directory" 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_model_file(file)
+        results << result if result[:needs_refactoring]
+      end
+      results
+    end
+
+    # Analyzes a controller file
+    # @param file_path [String] Path to controller file
+    # @return [Hash] Analysis results
+    def self.analyze_controller_file(file_path)
+      content = File.read(file_path)
+      lines = content.lines.count
+      methods = extract_methods(content)
+
+      issues = []
+      suggestions = []
+
+      if lines > CONTROLLER_MAX_LINES
+        issues << "Controller exceeds #{CONTROLLER_MAX_LINES} lines (currently #{lines})"
+        suggestions << "Consider moving business logic into a Service object"
+      end
+
+      if methods.count > CONTROLLER_MAX_METHODS
+        issues << "Controller has #{methods.count} methods (recommended: #{CONTROLLER_MAX_METHODS} or less)"
+        suggestions << "Consider extracting some actions into separate controllers or using a Service"
+      end
+
+      # Find long methods that could be extracted
+      methods.each do |method|
+        if method[:lines] > MODEL_MAX_METHOD_LINES
+          suggestions << "Method `#{method[:name]}` has #{method[:lines]} lines - consider extracting to Service"
+        end
+      end
+
+      {
+        type: :controller,
+        file: File.basename(file_path),
+        path: file_path,
+        lines: lines,
+        methods: methods,
+        issues: issues,
+        suggestions: suggestions,
+        needs_refactoring: issues.any? || suggestions.any?
+      }
+    end
+
+    # Analyzes a model file
+    # @param file_path [String] Path to model file
+    # @return [Hash] Analysis results
+    def self.analyze_model_file(file_path)
+      content = File.read(file_path)
+      lines = content.lines.count
+      methods = extract_methods(content)
+
+      issues = []
+      suggestions = []
+
+      if lines > MODEL_MAX_LINES
+        issues << "Model exceeds #{MODEL_MAX_LINES} lines (currently #{lines})"
+        suggestions << "Consider extracting scopes into Query objects or validations to a Form"
+      end
+
+      # Find long methods
+      methods.each do |method|
+        if method[:lines] > MODEL_MAX_METHOD_LINES
+          suggestions << "Method `#{method[:name]}` has #{method[:lines]} lines - consider extracting to a Service"
+        end
+      end
+
+      {
+        type: :model,
+        file: File.basename(file_path),
+        path: file_path,
+        lines: lines,
+        methods: methods,
+        issues: issues,
+        suggestions: suggestions,
+        needs_refactoring: issues.any? || suggestions.any?
+      }
+    end
+
+    # Extracts method names and line counts from content
+    # @param content [String] Ruby code content
+    # @return [Array<Hash>] Array of method info
+    def self.extract_methods(content)
+      methods = []
+
+      # Match def method_name or def self.method_name
+      content.scan(/def\s+(self\.)?([a-z_][a-zA-Z_]*)/) do |prefix, name|
+        methods << {
+          name: name,
+          is_class_method: prefix == "self.",
+          lines: 1  # Simplified - just mark as present
+        }
+      end
+
+      methods
+    end
+
+    # Counts lines in a method
+    # @param content [String] Ruby code content
+    # @param method_name [String] Method name
+    # @param start_line [Integer] Starting line number
+    # @return [Integer] Number of lines
+    def self.count_method_lines(content, method_name, start_line)
+      # Find the end of the method
+      lines = content.lines
+      end_pos = content.length
+
+      # Look for next def or class or end
+      rest = content.lines[start_line..-1].join
+      if rest =~ /\n\s*def\s+(self\.)?[a-z_]/i
+        end_pos = $~.begin(0)
+      elsif rest =~ /\n\s*(class|module)\s+/
+        end_pos = $~.begin(0)
+      elsif rest =~ /\n\s*end\s*$/
+        end_pos = $~.begin(0)
+      end
+
+      content[start_line..end_pos].lines.count
+    end
+
+    # Generates a service file for extracted logic
+    # @param name [String] Service name
+    # @param logic [String] Logic to extract
+    # @param base_path [String] Rails app root
+    # @return [String] Path to created file
+    def self.generate_service(name, logic, base_path = nil)
+      base_path ||= find_rails_app_path
+      raise RefactorError, "Not in a Rails application directory" unless base_path
+
+      service_dir = File.join(base_path, "app", "services")
+      FileUtils.mkdir_p(service_dir)
+
+      file_name = "#{name.underscore}_service.rb"
+      file_path = File.join(service_dir, file_name)
+
+      if File.exist?(file_path)
+        puts "  Skipping service (already exists)"
+        return file_path
+      end
+
+      content = <<~RUBY
+        # Service class for #{name}
+        # Extracted from controller/model logic
+        #
+        # Usage:
+        #   #{name}Service.call(params)
+        class #{name}Service
+          def initialize(**args)
+            @args = args
+          end
+
+          def call
+            # Extracted logic:
+            # #{logic.gsub("\n", "\n            # ")}
+          end
+        end
+      RUBY
+
+      File.write(file_path, content)
+      puts "  Created app/services/#{file_name}"
+      file_path
+    end
+
+    # Generates a query file for extracted logic
+    # @param name [String] Query name
+    # @param scope [String] Scope logic
+    # @param base_path [String] Rails app root
+    # @return [String] Path to created file
+    def self.generate_query(name, scope, base_path = nil)
+      base_path ||= find_rails_app_path
+      raise RefactorError, "Not in a Rails application directory" unless base_path
+
+      query_dir = File.join(base_path, "app", "queries")
+      FileUtils.mkdir_p(query_dir)
+
+      file_name = "find_#{name.underscore}.rb"
+      file_path = File.join(query_dir, file_name)
+
+      if File.exist?(file_path)
+        puts "  Skipping query (already exists)"
+        return file_path
+      end
+
+      content = <<~RUBY
+        # Query class for #{name}
+        # Extracted scope/query logic
+        #
+        # Usage:
+        #   Find#{name}.call
+        class Find#{name}
+          def initialize(scope: nil)
+            @scope = scope || #{name}.all
+          end
+
+          def call
+            # Extracted scope:
+            # #{scope.gsub("\n", "\n            # ")}
+            @scope
+          end
+        end
+      RUBY
+
+      File.write(file_path, content)
+      puts "  Created app/queries/#{file_name}"
+      file_path
+    end
+
+    # Generates an RSpec test for a service
+    # @param name [String] Service name
+    # @param base_path [String] Rails app root
+    # @return [String] Path to created file
+    def self.generate_service_spec(name, base_path = nil)
+      base_path ||= find_rails_app_path
+      raise RefactorError, "Not in a Rails application directory" unless base_path
+
+      spec_dir = File.join(base_path, "spec", "services")
+      FileUtils.mkdir_p(spec_dir)
+
+      file_name = "#{name.underscore}_service_spec.rb"
+      file_path = File.join(spec_dir, file_name)
+
+      if File.exist?(file_path)
+        puts "  Skipping spec (already exists)"
+        return file_path
+      end
+
+      content = <<~RUBY
+        require 'rails_helper'
+
+        RSpec.describe #{name}Service do
+          let(:params) { {} }
+          subject { described_class.new(params) }
+
+          describe '#call' do
+            it 'returns successful result' do
+              expect(subject.call).to be_truthy
+            end
+          end
+        end
+      RUBY
+
+      File.write(file_path, content)
+      puts "  Created spec/services/#{file_name}"
+      file_path
+    end
+
+    # Generates an RSpec test for a query
+    # @param name [String] Query name
+    # @param base_path [String] Rails app root
+    # @return [String] Path to created file
+    def self.generate_query_spec(name, base_path = nil)
+      base_path ||= find_rails_app_path
+      raise RefactorError, "Not in a Rails application directory" unless base_path
+
+      spec_dir = File.join(base_path, "spec", "queries")
+      FileUtils.mkdir_p(spec_dir)
+
+      file_name = "find_#{name.underscore}_spec.rb"
+      file_path = File.join(spec_dir, file_name)
+
+      if File.exist?(file_path)
+        puts "  Skipping spec (already exists)"
+        return file_path
+      end
+
+      content = <<~RUBY
+        require 'rails_helper'
+
+        RSpec.describe Find#{name} do
+          let(:scope) { #{name}.all }
+          subject { described_class.new(scope: scope) }
+
+          describe '#call' do
+            it 'returns scope' do
+              expect(subject.call).to eq(scope)
+            end
+          end
+        end
+      RUBY
+
+      File.write(file_path, content)
+      puts "  Created spec/queries/#{file_name}"
+      file_path
+    end
+
+    # Extracts code from a controller/model and creates a service
+    # @param file_path [String] Source file path
+    # @param method_names [Array<String>] Methods to extract
+    # @param service_name [String] Name for new service
+    # @return [Hash] Results
+    def self.extract_to_service(file_path, method_names, service_name)
+      content = File.read(file_path)
+
+      extracted_logic = []
+      method_names.each do |method_name|
+        # Find method in content
+        if content.include?("def #{method_name}")
+          # Extract method and its body
+          method_match = content.match(/def #{method_name}.*?(\n\s*end\n)/m)
+          extracted_logic << method_match[0] if method_match
+        end
+      end
+
+      base_path = find_rails_app_path
+      generate_service(service_name, extracted_logic.join("\n"), base_path)
+      generate_service_spec(service_name, base_path)
+
+      {
+        service: "app/services/#{service_name.underscore}_service.rb",
+        spec: "spec/services/#{service_name.underscore}_service_spec.rb"
+      }
+    end
+
+    # Prints refactoring report
+    # @param results [Array<Hash>] Analysis results
+    def self.print_report(results)
+      return puts "\n✓ No refactoring needed!" if results.empty?
+
+      puts "\n" + "=" * 60
+      puts "REFACTORING REPORT"
+      puts "=" * 60
+
+      results.each do |result|
+        puts "\n📁 #{result[:file]} (#{result[:type]})"
+        puts "   Lines: #{result[:lines]}"
+
+        if result[:issues].any?
+          puts "\n   ⚠️  Issues:"
+          result[:issues].each { |issue| puts "      • #{issue}" }
+        end
+
+        if result[:suggestions].any?
+          puts "\n   💡 Suggestions:"
+          result[:suggestions].each { |sug| puts "      • #{sug}" }
+        end
+      end
+
+      puts "\n" + "=" * 60
+      puts "Total files needing refactoring: #{results.count}"
+      puts "=" * 60
+    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