railsforge 1.0.0

data/lib/railsforge/refactor_controller.rb

@@ -0,0 +1,277 @@
+# RefactorController module for RailsForge
+# Automatically refactors fat controllers by extracting service objects
+
+require 'fileutils'
+
+module RailsForge
+  # RefactorController class extracts services from fat controller methods
+  class RefactorController
+    # Minimum lines to consider a method for extraction
+    MIN_METHOD_LINES = 15
+
+    # Initialize the refactor
+    def initialize(base_path = nil)
+      @base_path = base_path || find_rails_app_path
+      raise RefactorControllerError, "Not in a Rails application directory" unless @base_path
+    end
+
+    # Refactor a specific controller
+    # @param controller_name [String] Name of controller to refactor
+    # @return [Hash] Refactoring results
+    def refactor(controller_name)
+      controller_file = find_controller_file(controller_name)
+
+      unless controller_file
+        raise RefactorControllerError, "Controller '#{controller_name}' not found"
+      end
+
+      puts "Analyzing controller: #{controller_name}"
+      puts ""
+
+      # Read controller content
+      content = File.read(controller_file)
+
+      # Find methods that can be extracted
+      long_methods = find_long_methods(content)
+
+      if long_methods.empty?
+        puts "No methods found that need extraction (min #{MIN_METHOD_LINES} lines)"
+        return { extracted: [], controller: controller_name }
+      end
+
+      puts "Found #{long_methods.count} method(s) to extract:"
+      long_methods.each do |method|
+        puts "  - #{method[:name]} (#{method[:lines]} lines)"
+      end
+      puts ""
+
+      # Extract each method to a service
+      extracted = []
+      long_methods.each do |method|
+        service = extract_method_to_service(controller_name, method)
+        if service
+          update_controller_method(controller_file, method, service)
+          extracted << service
+        end
+      end
+
+      puts "Extraction complete!"
+      puts "  Created #{extracted.count} service(s)"
+      puts ""
+
+      { extracted: extracted, controller: controller_name, methods: long_methods }
+    end
+
+    # Preview what would be extracted without making changes
+    # @param controller_name [String] Name of controller to analyze
+    # @return [Array] Methods that would be extracted
+    def preview(controller_name)
+      controller_file = find_controller_file(controller_name)
+
+      unless controller_file
+        raise RefactorControllerError, "Controller '#{controller_name}' not found"
+      end
+
+      content = File.read(controller_file)
+      find_long_methods(content)
+    end
+
+    private
+
+    # Find the controller file 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
+
+    # Find controller file by name
+    def find_controller_file(controller_name)
+      controllers_dir = File.join(@base_path, "app", "controllers")
+
+      # Try different variations
+      [
+        "#{controller_name.underscore}_controller.rb",
+        "#{controller_name.underscore}_controller.rb"
+      ].each do |filename|
+        path = File.join(controllers_dir, filename)
+        return path if File.exist?(path)
+      end
+
+      # Search recursively
+      Dir.glob(File.join(controllers_dir, "**", "*_controller.rb")).each do |file|
+        return file if File.basename(file).include?(controller_name.underscore)
+      end
+
+      nil
+    end
+
+    # Find methods that exceed the line threshold
+    def find_long_methods(content)
+      methods = []
+      lines = content.lines
+
+      # Simple regex to find method definitions
+      in_method = false
+      method_start = 0
+      method_name = nil
+      method_lines = []
+
+      lines.each_with_index do |line, index|
+        # Match def method_name or def self.method_name
+        if line =~ /\bdef\s+(self\.)?(\w+)/
+          if in_method
+            # Close previous method
+            methods << {
+              name: method_name,
+              start: method_start,
+              lines: method_lines.count,
+              content: method_lines.join
+            }
+          end
+
+          in_method = true
+          method_start = index
+          method_name = $2
+          method_lines = [line]
+        elsif in_method
+          if line.strip.start_with?("end") && method_lines.last =~ /\b(end|else|elsif|when)\b/
+            # This might be the end of the method
+            method_lines << line
+
+            # Check if this is the closing end
+            depth = method_lines.join.scan(/\b(begin|class|module|def|do|if|case)\b/).count
+            end_depth = method_lines.join.scan(/\bend\b/).count
+
+            if depth == end_depth && depth > 0
+              methods << {
+                name: method_name,
+                start: method_start,
+                lines: method_lines.count,
+                content: method_lines.join
+              }
+              in_method = false
+              method_lines = []
+            end
+          else
+            method_lines << line
+          end
+        end
+      end
+
+      # Close last method if still open
+      if in_method && method_lines.any?
+        methods << {
+          name: method_name,
+          start: method_start,
+          lines: method_lines.count,
+          content: method_lines.join
+        }
+      end
+
+      # Filter to only long methods
+      methods.select { |m| m[:lines] >= MIN_METHOD_LINES }
+    end
+
+    # Extract a method to a service object
+    def extract_method_to_service(controller_name, method_info)
+      service_dir = File.join(@base_path, "app", "services", controller_name.underscore)
+      FileUtils.mkdir_p(service_dir)
+
+      service_name = "#{method_info[:name]}_service"
+      service_class_name = "#{controller_name}#{method_info[:name].camelize}Service"
+
+      service_path = File.join(service_dir, "#{service_name}.rb")
+
+      if File.exist?(service_path)
+        puts "  Skipping #{service_name} (already exists)"
+        return nil
+      end
+
+      # Generate service content
+      service_content = generate_service_content(service_class_name, method_info)
+
+      File.write(service_path, service_content)
+      puts "  Created app/services/#{controller_name.underscore}/#{service_name}.rb"
+
+      { name: service_name, class: service_class_name, path: service_path }
+    end
+
+    # Generate service object content
+    def generate_service_content(class_name, method_info)
+      <<~RUBY
+        # Service extracted from controller method: #{method_info[:name]}
+        # Original method had #{method_info[:lines]} lines
+        class #{class_name}
+          def initialize(params = {})
+            @params = params
+          end
+
+          def call
+            # TODO: Refactor extracted logic here
+            # Original method content:
+            # #{method_info[:content].lines.first(5).join('# ')}
+          end
+
+          def self.call(params = {})
+            new(params).call
+          end
+        end
+      RUBY
+    end
+
+    # Update the controller method to use the service
+    def update_controller_method(controller_file, method_info, service)
+      content = File.read(controller_file)
+
+      # Replace method body with service call
+      new_method = <<~RUBY
+        def #{method_info[:name]}
+          result = #{service[:class]}.call(params)
+        end
+      RUBY
+
+      # Simple replacement - in production would use proper parsing
+      lines = content.lines
+
+      # Find and replace the method
+      modified_lines = []
+      in_target_method = false
+      method_depth = 0
+
+      lines.each_with_index do |line, index|
+        if line =~ /\bdef\s+(self\.)?#{method_info[:name]}\b/
+          in_target_method = true
+          modified_lines << new_method
+          next
+        end
+
+        if in_target_method
+          method_depth += 1 if line =~ /\b(def|class|module|if|case|do)\b/
+          method_depth -= 1 if line =~ /\bend\b/ && method_depth > 0
+
+          if method_depth == 0
+            in_target_method = false
+          end
+          next # Skip original method lines
+        end
+
+        modified_lines << line
+      end
+
+      File.write(controller_file, modified_lines.join)
+      puts "  Updated controller method to use service"
+    end
+
+    # Error class
+    class RefactorControllerError < StandardError; end
+  end
+end

data/lib/railsforge/refactors/refactor_controller.rb

@@ -0,0 +1,117 @@
+# RefactorController module for RailsForge
+# Automatically refactors fat controllers by extracting service objects
+
+require 'fileutils'
+
+module RailsForge
+  module Refactors
+    # RefactorController class extracts services from fat controller methods
+    class RefactorController
+      MIN_METHOD_LINES = 15
+
+      def initialize(base_path = nil)
+        @base_path = base_path || find_rails_app_path
+        raise RefactorControllerError, "Not in a Rails application" unless @base_path
+      end
+
+      # Refactor a specific controller
+      def refactor(controller_name)
+        controller_file = find_controller_file(controller_name)
+        raise RefactorControllerError, "Controller not found" unless controller_file
+
+        content = File.read(controller_file)
+        long_methods = find_long_methods(content)
+
+        if long_methods.empty?
+          puts "No methods to extract"
+          return { extracted: [] }
+        end
+
+        puts "Found #{long_methods.count} method(s) to extract"
+
+        extracted = []
+        long_methods.each do |method|
+          service = extract_to_service(controller_name, method)
+          extracted << service if service
+        end
+
+        { extracted: extracted }
+      end
+
+      private
+
+      def 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
+
+      def find_controller_file(name)
+        dir = File.join(@base_path, "app", "controllers")
+        return nil unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, "**", "*_controller.rb")).find do |f|
+          File.basename(f).include?(name.underscore)
+        end
+      end
+
+      def find_long_methods(content)
+        methods = []
+        lines = content.lines
+        in_method = false
+        method_lines = []
+        method_name = nil
+
+        lines.each_with_index do |line, i|
+          if line =~ /\bdef\s+(\w+)/
+            methods << { name: method_name, lines: method_lines.count } if in_method
+            in_method = true
+            method_name = $1
+            method_lines = [line]
+          elsif in_method
+            method_lines << line
+            if line.strip == "end" && method_lines.count > 1
+              methods << { name: method_name, lines: method_lines.count, content: method_lines.join }
+              in_method = false
+            end
+          end
+        end
+
+        methods.select { |m| m[:lines] >= MIN_METHOD_LINES }
+      end
+
+      def extract_to_service(controller_name, method_info)
+        service_dir = File.join(@base_path, "app", "services", controller_name.underscore)
+        FileUtils.mkdir_p(service_dir)
+
+        service_name = "#{method_info[:name]}_service"
+        service_path = File.join(service_dir, "#{service_name}.rb")
+
+        return nil if File.exist?(service_path)
+
+        File.write(service_path, <<~RUBY)
+          # Extracted from controller: #{controller_name}
+          class #{controller_name}#{method_info[:name].capitalize}Service
+            def initialize(params = {})
+              @params = params
+            end
+
+            def call
+              # TODO: Implement extracted logic
+            end
+          end
+        RUBY
+
+        puts "  Created app/services/#{controller_name.underscore}/#{service_name}.rb"
+        { name: service_name }
+      end
+
+      class RefactorControllerError < StandardError; end
+    end
+  end
+end

data/lib/railsforge/template_loader.rb

@@ -0,0 +1,105 @@
+# TemplateLoader module handles loading template versions
+require 'fileutils'
+
+module RailsForge
+  # Template module for managing generator templates
+  module Template
+    # Error class for template loading issues
+    class TemplateError < StandardError; end
+
+    # Template directory path
+    TEMPLATES_DIR = File.expand_path('../templates', __FILE__)
+
+    # Default template version
+    DEFAULT_VERSION = "v1"
+
+    # Get available template versions
+    # @return [Array<String>] Array of version names
+    def self.available_versions
+      return [] unless Dir.exist?(TEMPLATES_DIR)
+      
+      Dir.glob(File.join(TEMPLATES_DIR, 'v*')).map do |dir|
+        File.basename(dir)
+      end.sort
+    end
+
+    # Load template for a specific generator and version
+    # @param generator_type [String] Type of generator (service, query, etc.)
+    # @param version [String] Template version (e.g., "v1")
+    # @return [Hash] Template configuration
+    def self.load_template(generator_type, version = DEFAULT_VERSION)
+      template_path = File.join(TEMPLATES_DIR, version, generator_type, "template.rb")
+      
+      unless File.exist?(template_path)
+        raise TemplateError, "Template not found for #{generator_type} version #{version}"
+      end
+
+      {
+        template_path: template_path,
+        version: version,
+        generator_type: generator_type
+      }
+    end
+
+    # Get template content
+    # @param generator_type [String] Type of generator
+    # @param version [String] Template version
+    # @return [String] Template content
+    def self.get_content(generator_type, version = DEFAULT_VERSION)
+      template_info = load_template(generator_type, version)
+      File.read(template_info[:template_path])
+    end
+
+    # Check if template exists
+    # @param generator_type [String] Type of generator
+    # @param version [String] Template version
+    # @return [Boolean] True if template exists
+    def self.exists?(generator_type, version = DEFAULT_VERSION)
+      template_path = File.join(TEMPLATES_DIR, version, generator_type, "template.rb")
+      File.exist?(template_path)
+    end
+
+    # List templates in a version
+    # @param version [String] Template version
+    # @return [Array<String>] List of generator types
+    def self.list_templates(version = DEFAULT_VERSION)
+      version_path = File.join(TEMPLATES_DIR, version)
+      return [] unless Dir.exist?(version_path)
+      
+      Dir.glob(File.join(version_path, '*')).select do |dir|
+        File.directory?(dir)
+      end.map do |dir|
+        File.basename(dir)
+      end
+    end
+
+    # Show available versions with their templates
+    # @return [String] Formatted list
+    def self.show_available
+      output = "Available template versions:\n\n"
+      
+      available_versions.each do |version|
+        output += "  #{version}:\n"
+        templates = list_templates(version)
+        templates.each do |template|
+          output += "    - #{template}\n"
+        end
+        output += "\n"
+      end
+      
+      output
+    end
+
+    # Get spec template content
+    # @param generator_type [String] Type of generator
+    # @param version [String] Template version
+    # @return [String] Spec template content
+    def self.get_spec_content(generator_type, version = DEFAULT_VERSION)
+      spec_path = File.join(TEMPLATES_DIR, version, generator_type, "spec_template.rb")
+      
+      return nil unless File.exist?(spec_path)
+      
+      File.read(spec_path)
+    end
+  end
+end

data/lib/railsforge/templates/v1/form/spec_template.rb

@@ -0,0 +1,18 @@
+require 'rails_helper'
+
+RSpec.describe <%= name.camelize %>Form do
+  let(:params) { {} }
+  subject { described_class.new(<%= name.underscore %>_params: params) }
+
+  describe '#valid?' do
+    it 'is valid with valid params' do
+      expect(subject.valid?).to be_truthy
+    end
+  end
+
+  describe '#save' do
+    it 'saves successfully' do
+      expect(subject.save).to be_truthy
+    end
+  end
+end

data/lib/railsforge/templates/v1/form/template.rb

@@ -0,0 +1,28 @@
+# Form class for <%= name %>
+# Encapsulates form validation logic
+#
+# Usage:
+#   form = <%= name.camelize %>Form.new(params)
+#   if form.valid?
+#     form.save
+#   end
+class <%= name.camelize %>Form
+  include ActiveModel::Model
+
+  attr_accessor <%= name.underscore %>_attributes
+
+  validate :validate_<%= name.underscore %>
+
+  def save
+    return false unless valid?
+
+    # TODO: Implement save logic
+    true
+  end
+
+  private
+
+  def validate_<%= name.underscore %>
+    # TODO: Add validations
+  end
+end

data/lib/railsforge/templates/v1/job/spec_template.rb

@@ -0,0 +1,17 @@
+require 'rails_helper'
+
+RSpec.describe <%= name.camelize %>Job do
+  let(:args) { [] }
+  
+  it 'enqueues the job' do
+    expect {
+      described_class.perform_later(*args)
+    }.to have_enqueued_job(described_class)
+  end
+
+  describe '#perform' do
+    it 'performs the job' do
+      expect { subject.perform(*args) }.not_to raise_error
+    end
+  end
+end

data/lib/railsforge/templates/v1/job/template.rb

@@ -0,0 +1,13 @@
+# Background job for <%= name %>
+# Handles async processing
+#
+# Usage:
+#   <%= name.camelize %>Job.perform_later(record)
+#   <%= name.camelize %>Job.perform_now(record)
+class <%= name.camelize %>Job < ApplicationJob
+  queue_as :default
+
+  def perform(*args)
+    # TODO: Implement job logic
+  end
+end

data/lib/railsforge/templates/v1/policy/spec_template.rb

@@ -0,0 +1,41 @@
+require 'rails_helper'
+
+RSpec.describe <%= name.camelize %>Policy do
+  let(:user) { nil }
+  let(:record) { <%= name.camelize %>.new }
+  subject { described_class.new(user, record) }
+
+  describe '#index?' do
+    it 'allows everyone' do
+      expect(subject.index?).to be_truthy
+    end
+  end
+
+  describe '#show?' do
+    it 'allows everyone' do
+      expect(subject.show?).to be_truthy
+    end
+  end
+
+  describe '#create?' do
+    it 'requires user' do
+      expect(subject.create?).to be_falsey
+    end
+
+    it 'allows authenticated user' do
+      user = User.new
+      expect(described_class.new(user, record).create?).to be_truthy
+    end
+  end
+
+  describe 'Scope' do
+    let(:scope) { <%= name.camelize %>.all }
+    subject { described_class::Scope.new(user, scope) }
+
+    describe '#resolve' do
+      it 'returns all records' do
+        expect(subject.resolve).to eq(scope.all)
+      end
+    end
+  end
+end

data/lib/railsforge/templates/v1/policy/template.rb

@@ -0,0 +1,57 @@
+# Policy class for <%= name %>
+# Handles authorization logic
+#
+# Usage:
+#   authorize <%= name.underscore %>
+#   policy_scope(<%= name.underscore %>)
+class <%= name.camelize %>Policy
+  attr_reader :user, :record
+
+  def initialize(user, record)
+    @user = user
+    @record = record
+  end
+
+  def index?
+    true
+  end
+
+  def show?
+    true
+  end
+
+  def create?
+    user.present?
+  end
+
+  def new?
+    create?
+  end
+
+  def update?
+    user.present?
+  end
+
+  def edit?
+    update?
+  end
+
+  def destroy?
+    user.present?
+  end
+
+  class Scope
+    def initialize(user, scope)
+      @user = user
+      @scope = scope
+    end
+
+    def resolve
+      scope.all
+    end
+
+    private
+
+    attr_reader :user, :scope
+  end
+end

data/lib/railsforge/templates/v1/presenter/spec_template.rb

@@ -0,0 +1,12 @@
+require 'rails_helper'
+
+RSpec.describe <%= name.camelize %>Presenter do
+  let(:<%= name.underscore %>) { <%= name.camelize %>.new }
+  subject { described_class.new(<%= name.underscore %>) }
+
+  describe 'initialization' do
+    it 'initializes successfully' do
+      expect(subject).to be_a(described_class)
+    end
+  end
+end

data/lib/railsforge/templates/v1/presenter/template.rb

@@ -0,0 +1,13 @@
+# Presenter class for <%= name %>
+# Handles view presentation logic
+#
+# Usage:
+#   presenter = <%= name.camelize %>Presenter.new(@<%= name.underscore %>)
+#   presenter.full_name
+class <%= name.camelize %>Presenter
+  def initialize(<%= name.underscore %>)
+    @<%= name.underscore %> = <%= name.underscore %>
+  end
+
+  # TODO: Add presenter methods
+end