railsforge 1.0.0

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,66 @@
+# Query object template v2
+# Enhanced query with chainable interface
+class <%= class_name %>
+  attr_reader :relation
+
+  def initialize(relation = nil)
+    @relation = relation || default_relation
+  end
+
+  # Chainable scope methods
+  def filter_by(**conditions)
+    conditions.each do |attribute, value|
+      @relation = @relation.where(attribute => value)
+    end
+    self
+  end
+
+  def order_by(attribute, direction = :asc)
+    @relation = @relation.order(attribute => direction)
+    self
+  end
+
+  def limit(count)
+    @relation = @relation.limit(count)
+    self
+  end
+
+  def offset(count)
+    @relation = @relation.offset(count)
+    self
+  end
+
+  # Execute the query
+  def call
+    @relation
+  end
+
+  # Convenience methods
+  def first
+    @relation.first
+  end
+
+  def last
+    @relation.last
+  end
+
+  def all
+    @relation.to_a
+  end
+
+  def count
+    @relation.count
+  end
+
+  def exists?
+    @relation.exists?
+  end
+
+  private
+
+  def default_relation
+    # TODO: Replace with actual model
+    # Example: Model.where(active: true)
+    raise NotImplementedError, "Override #default_relation in subclass"
+  end
+end

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

@@ -0,0 +1,33 @@
+# RSpec tests for <%= class_name %>
+# Enhanced v2 testing with better patterns
+RSpec.describe <%= class_name %> do
+  let(:params) { {} }
+  let(:service) { described_class.new(params) }
+
+  describe "#call" do
+    context "with valid params" do
+      it "returns a successful result" do
+        result = service.call
+        expect(result.success?).to be true
+        expect(result.data).to be_a(Hash)
+      end
+    end
+
+    context "with invalid params" do
+      let(:params) { { invalid: true } }
+
+      it "returns a failure result" do
+        result = service.call
+        expect(result.failure?).to be true
+        expect(result.errors).to be_an(Array)
+      end
+    end
+  end
+
+  describe ".call" do
+    it "creates and calls the service" do
+      result = described_class.call({})
+      expect(result).to be_a(Result)
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# Service class template v2
+# Enhanced service with better practices
+class <%= class_name %>
+  # Initialize with dependencies
+  # @param [Hash] params - Parameters for the service
+  def initialize(params = {})
+    @params = params
+    @errors = []
+  end
+
+  # Execute the service logic
+  # @return [Result] Result object with success/failure
+  def call
+    return failure(["Validation failed"]) unless validate?
+
+    success(execute_operation)
+  rescue StandardError => e
+    failure([e.message])
+  end
+
+  # Class-level call for convenience
+  # @param [Hash] params - Parameters for the service
+  # @return [Result] Result object
+  def self.call(params = {})
+    new(params).call
+  end
+
+  private
+
+  # Validate inputs
+  # @return [Boolean] True if valid
+  def validate?
+    true
+  end
+
+  # Execute the main operation
+  # @return [Object] Operation result
+  def execute_operation
+    # TODO: Implement service logic
+    {}
+  end
+
+  # Helper method for success result
+  # @param [Object] data - Result data
+  # @return [Result]
+  def success(data)
+    Result.new(success: true, data: data, errors: [])
+  end
+
+  # Helper method for failure result
+  # @param [Array<String>] errors - Error messages
+  # @return [Result]
+  def failure(errors)
+    Result.new(success: false, data: nil, errors: errors)
+  end
+end
+
+# Result class for service responses
+class Result
+  attr_reader :success, :data, :errors
+
+  def initialize(success:, data:, errors:)
+    @success = success
+    @data = data
+    @errors = errors
+  end
+
+  def failure?
+    !success
+  end
+end

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

@@ -0,0 +1,72 @@
+# Job template v3
+# Advanced job with retries, priority, and callbacks
+class <%= class_name %>Job < ApplicationJob
+  # Queue configuration
+  queue_with_priority PRIORITIES[:default]
+
+  # Retry configuration
+  retry_on StandardError, wait: :exponential_backoff, attempts: 5
+
+  # Discard configuration for permanent failures
+  discard_on PermanentJobError do |job, error|
+    Rails.logger.error("Job #{job.job_id} permanently failed: #{error.message}")
+  end
+
+  # Callback hooks
+  around_perform :instrument_job
+  before_perform :log_start
+  after_perform :log_complete
+
+  # Perform the job
+  # @param [Hash] args - Job arguments
+  def perform(*args)
+    # TODO: Implement job logic
+    # Example:
+    # user = User.find(args[:user_id])
+    # user.send_welcome_email
+    Rails.logger.info("Executing #{self.class.name}")
+  end
+
+  # Schedule for later
+  # @param [Integer] delay - Delay in seconds
+  def self.perform_in(delay, *args)
+    set(wait: delay seconds).perform_later(*args)
+  end
+
+  # Schedule at specific time
+  # @param [DateTime] time - Scheduled time
+  def self.perform_at(time, *args)
+    set(wait_until: time).perform_later(*args)
+  end
+
+  # Unique job - prevent duplicates
+  def self.unique_by(*attributes)
+    sidekiq_options unique: true,
+                    unique_args: ->(args) { args }
+  end
+
+  private
+
+  # Instrument the job for monitoring
+  def instrument_job
+    start_time = Time.now
+    Rails.logger.info("Starting #{self.class.name} at #{start_time}")
+    
+    begin
+      yield
+    ensure
+      duration = Time.now - start_time
+      Rails.logger.info("Completed #{self.class.name} in #{duration.round(2)}s")
+    end
+  end
+
+  # Log job start
+  def log_start
+    Rails.logger.debug("Job #{job_id} starting")
+  end
+
+  # Log job completion
+  def log_complete
+    Rails.logger.debug("Job #{job_id} completed")
+  end
+end

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

@@ -0,0 +1,54 @@
+# Query spec template v3
+require 'rails_helper'
+
+RSpec.describe <%= class_name %> do
+  let(:query) { described_class.new(relation) }
+  let(:relation) { double('Relation') }
+
+  describe '#where' do
+    it 'adds conditions' do
+      expect(query.where(status: 'active')).to be_a(described_class)
+    end
+  end
+
+  describe '#includes' do
+    it 'adds includes' do
+      expect(query.includes(:user)).to be_a(described_class)
+    end
+  end
+
+  describe '#order' do
+    it 'adds order' do
+      expect(query.order(created_at: :desc)).to be_a(described_class)
+    end
+  end
+
+  describe '#paginate' do
+    it 'sets limit and offset' do
+      paginated = query.paginate(page: 2, per_page: 10)
+      expect(paginated).to be_a(described_class)
+    end
+  end
+
+  describe '#call' do
+    it 'executes the query' do
+      allow(relation).to receive_message_chain(:where, :includes, :order, :to_a).and_return([])
+      expect(query.call).to eq([])
+    end
+  end
+
+  describe '#count' do
+    it 'returns total count' do
+      allow(relation).to receive_message_chain(:where, :includes, :order, :count).and_return(10)
+      expect(query.count).to eq(10)
+    end
+  end
+
+  describe '#pagination_info' do
+    it 'returns pagination metadata' do
+      allow(relation).to receive_message_chain(:where, :includes, :order, :count).and_return(25)
+      info = query.pagination_info(page: 1, per_page: 10)
+      expect(info[:total_pages]).to eq(3)
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# Query object template v3
+# Advanced query with pagination and caching
+class <%= class_name %>
+  # @return [ActiveRecord::Relation] relation
+  attr_reader :relation
+
+  def initialize(relation = default_relation)
+    @relation = relation
+    @conditions = []
+    @includes = []
+    @order = []
+    @limit_value = nil
+    @offset_value = nil
+  end
+
+  # Add conditions
+  # @param [Hash] conditions - Query conditions
+  def where(conditions)
+    @conditions << conditions
+    self
+  end
+
+  # Eager load associations
+  # @param [Array<Symbol>] associations - Associations to include
+  def includes(*associations)
+    @includes << associations
+    self
+  end
+
+  # Order results
+  # @param [Hash] order_spec - Order specification
+  def order(order_spec)
+    @order << order_spec
+    self
+  end
+
+  # Paginate results
+  # @param [Integer] page - Page number (1-indexed)
+  # @param [Integer] per_page - Items per page
+  def paginate(page: 1, per_page: 25)
+    @limit_value = per_page
+    @offset_value = (page - 1) * per_page
+    self
+  end
+
+  # Cache results
+  # @param [Integer] duration - Cache duration in seconds
+  def cached(duration: 5.minutes)
+    cache_key = generate_cache_key
+    Rails.cache.fetch(cache_key, expires_in: duration) do
+      to_a
+    end
+  end
+
+  # Execute query and return results
+  def call
+    build_relation.to_a
+  end
+
+  # Get total count
+  def count
+    build_relation.count
+  end
+
+  # Pagination metadata
+  def pagination_info(page: 1, per_page: 25)
+    total = count
+    {
+      current_page: page,
+      per_page: per_page,
+      total_count: total,
+      total_pages: (total.to_f / per_page).ceil,
+      has_next_page: (page * per_page) < total,
+      has_previous_page: page > 1
+    }
+  end
+
+  # Reset to default
+  def reset
+    @conditions = []
+    @includes = []
+    @order = []
+    @limit_value = nil
+    @offset_value = nil
+    self
+  end
+
+  private
+
+  def default_relation
+    raise NotImplementedError, "Override default_relation in subclass"
+  end
+
+  def build_relation
+    result = @relation
+
+    @conditions.each { |cond| result = result.where(cond) }
+    @includes.flatten.each { |inc| result = result.includes(inc) }
+    @order.each { |ord| result = result.order(ord) }
+    result = result.limit(@limit_value) if @limit_value
+    result = result.offset(@offset_value) if @offset_value
+
+    result
+  end
+
+  def generate_cache_key
+    {
+      conditions: @conditions,
+      includes: @includes,
+      order: @order,
+      limit: @limit_value,
+      offset: @offset_value
+    }
+  end
+end

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

@@ -0,0 +1,51 @@
+# Service spec template v3
+require 'rails_helper'
+
+RSpec.describe <%= class_name %> do
+  let(:service) { described_class.new(params) }
+  let(:params) { { name: 'Test' } }
+
+  describe '#call' do
+    context 'with valid params' do
+      it 'returns success' do
+        result = service.call
+        expect(result).to be_success
+      end
+
+      it 'contains data in result' do
+        result = service.call
+        expect(result.value!).to have_key(:data)
+      end
+
+      it 'includes metadata' do
+        result = service.call
+        expect(result.value!).to have_key(:metadata)
+      end
+    end
+
+    context 'with invalid params' do
+      let(:params) { {} }
+
+      it 'returns failure' do
+        result = service.call
+        expect(result).to be_failure
+      end
+    end
+  end
+
+  describe '.call' do
+    it 'works as class method' do
+      result = described_class.call(name: 'Test')
+      expect(result).to be_success
+    end
+  end
+
+  describe '#then' do
+    let(:next_service) { double('NextService', new: double(call: Success({}))) }
+
+    it 'chains to another service' do
+      result = service.then(next_service, extra: 'param')
+      expect(result).to be_a(Dry::Monads::Result)
+    end
+  end
+end