railsforge 1.0.2 → 2.0.0

data/lib/railsforge/refactors/refactor_controller.rb

@@ -1,117 +0,0 @@
-# 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

@@ -1,105 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-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

@@ -1,28 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-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

@@ -1,13 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-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

@@ -1,57 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-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

@@ -1,13 +0,0 @@
-# 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

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

@@ -1,12 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe <%= name.camelize %>Query do
-  let(:scope) { <%= name.camelize %>.all }
-  subject { described_class.new(scope: scope) }
-
-  describe '#call' do
-    it 'returns scope' do
-      expect(subject.call).to eq(scope)
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# Query class for <%= name %>
-# Encapsulates database queries
-#
-# Usage:
-#   result = <%= name.camelize %>Query.call
-#   result = <%= name.camelize %>Query.call(scope: User.active)
-class <%= name.camelize %>Query
-  def initialize(scope: nil)
-    @scope = scope || <%= name.camelize %>.all
-  end
-
-  def call
-    # TODO: Implement query logic
-    @scope
-  end
-end

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

@@ -1,13 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe <%= name.camelize %>Serializer do
-  let(:<%= name.underscore %>) { <%= name.camelize %>.new<% attributes.each do |attr| %>
-  <%= name.underscore %>.<%= attr %> = 'test'<% end %> }
-  subject { described_class.new(<%= name.underscore %>) }
-
-  describe 'serialization' do
-    it 'includes id' do
-      expect(subject.as_json[:id]).to eq(<%= name.underscore %>.id)
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-# Serializer class for <%= name %>
-# Handles JSON serialization
-#
-# Usage:
-#   render json: <%= name.camelize %>Serializer.new(<%= name.underscore %>)
-class <%= name.camelize %>Serializer < ApplicationSerializer
-  attributes :id<% attributes.each do |attr| %>
-  :<%= attr %><% end %>
-
-  # TODO: Add custom methods
-end

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

@@ -1,12 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe <%= name.camelize %>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

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

@@ -1,25 +0,0 @@
-# Service class for <%= name %>
-# Encapsulates business logic
-#
-# Usage:
-#   result = <%= name.camelize %>Service.call(params)
-#
-# @example Basic service
-#   class CreateUserService
-#     def initialize(user_params)
-#       @user_params = user_params
-#     end
-#
-#     def call
-#       User.create!(@user_params)
-#     end
-#   end
-class <%= name.camelize %>Service
-  def initialize(<%= name.underscore %>_params = {})
-    @params = <%= name.underscore %>_params
-  end
-
-  def call
-    # TODO: Implement service logic
-  end
-end

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

@@ -1,35 +0,0 @@
-// Stimulus controller: <%= class_name %>
-import { Controller } from "@hotwired/stimulus"
-
-export default class <%= class_name %> extends Controller {
-  // Define static targets
-  static targets = ["output", "input"]
-
-  // Connect lifecycle
-  connect() {
-    console.log("<%= class_name %> connected")
-  }
-
-  // Disconnect lifecycle
-  disconnect() {
-    console.log("<%= class_name %> disconnected")
-  }
-
-  // Example action
-  // Usage: data-action="<%= underscore_name %>#greet"
-  greet() {
-    console.log("Hello from <%= class_name %>!")
-  }
-
-  // Example: Handle input changes
-  // Usage: data-action="input-><%= underscore_name %>#handleInput"
-  handleInput(event) {
-    const value = event.target.value
-    console.log("Input value:", value)
-  }
-
-  // Example: Toggle visibility
-  toggle() {
-    this.outputTarget.classList.toggle("hidden")
-  }
-}

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

@@ -1,24 +0,0 @@
-# ViewComponent template for <%= class_name %>
-class <%= class_name %> < ViewComponent::Base
-  # Define component properties
-  # renders_maybe :some_child
-
-  # Initialize with data
-  # @param title [String] Component title
-  def initialize(title: "", classes: "")
-    @title = title
-    @classes = classes
-  end
-
-  # Check if title is present
-  # @return [Boolean]
-  def title?
-    @title.present?
-  end
-
-  # CSS classes for the component
-  # @return [String]
-  def classes
-    "component #{@classes}"
-  end
-end

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

@@ -1,49 +0,0 @@
-# Job template v2
-# Enhanced job with error handling and callbacks
-class <%= class_name %> < ApplicationJob
-  # Configure queue
-  queue_as :default
-
-  # Retry configuration
-  retry_on StandardError, wait: :exponentially_longer, attempts: 5
-
-  # Discard configuration
-  discard_on ActiveJob::DeserializationError
-
-  # Perform the job
-  # @param args [Array] Job arguments
-  def perform(*args)
-    # TODO: Implement job logic
-    Rails.logger.info "Executing #{self.class.name}"
-
-    # Example:
-    # SomeService.call(*args)
-  end
-
-  # Called before job execution
-  # @return [void]
-  def before_perform
-    Rails.logger.info "Starting #{self.class.name}"
-  end
-
-  # Called after job execution
-  # @return [void]
-  def after_perform
-    Rails.logger.info "Completed #{self.class.name}"
-  end
-
-  # Called on job failure
-  # @param exception [StandardError] The exception that was raised
-  # @return [void]
-  def on_failure(exception)
-    Rails.logger.error "#{self.class.name} failed: #{exception.message}"
-    # Notify error tracking service (e.g., Sentry, Bugsnag)
-  end
-
-  # Called when job is retried
-  # @param exception [StandardError] The exception that caused the retry
-  # @return [void]
-  def on_retry(exception)
-    Rails.logger.warn "#{self.class.name} retrying: #{exception.message}"
-  end
-end