railsforge 1.0.2 → 2.0.0

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

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

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

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

@@ -1,72 +0,0 @@
-# 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])
-    # UserMailer.welcome(user).deliver_now
-    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

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

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

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

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

@@ -1,93 +0,0 @@
-# Service class template v3
-# Advanced service with result monad and chaining
-class <%= class_name %>
-  include Dry::Monads[:result, :do]
-
-  # Initialize with dependencies
-  # @param [Hash] params - Parameters for the service
-  def initialize(params = {})
-    @params = params
-    @dependencies = {}
-  end
-
-  # Register a dependency
-  # @param [Symbol] key - Dependency key
-  # @param [Object] value - Dependency value
-  def register(key, value)
-    @dependencies[key] = value
-    self
-  end
-
-  # Execute the service - returns a Dry::Monads Result
-  def call
-    yield validate!
-    yield process!
-    Success(result_data)
-  rescue StandardError => e
-    Failure(error: e.message, code: :unexpected_error)
-  end
-
-  # Chain another service
-  # @param [Class] service_class - Next service to call
-  # @param [Hash] params - Parameters for next service
-  def then(service_class, params = {})
-    result = call
-    return result unless result.success?
-
-    service = service_class.new(@params.merge(params)).call
-    service
-  end
-
-  # Class-level call
-  def self.call(params = {})
-    new(params).call
-  end
-
-  private
-
-  # Validate inputs - returns Result
-  # Override this method to add custom validation
-  # @example
-  #   def validate!
-  #     return Failure(errors: ['Name required']) if @params[:name].blank?
-  #     Success(true)
-  #   end
-  def validate!
-    Success(true)
-  end
-
-  # Process the main logic - returns Result
-  # Override this method to implement your service logic
-  # @example
-  #   def process!
-  #     user = User.create!(@params)
-  #     @result = { user: user }
-  #     Success(true)
-  #   end
-  def process!
-    @result = {}
-    Success(true)
-  end
-
-  # Build result data
-  def result_data
-    {
-      data: @result,
-      metadata: {
-        service: self.class.name,
-        timestamp: Time.now.utc.iso8601
-      }
-    }
-  end
-end
-
-# Result wrapper for success/failure
-module Result
-  def self.success(data)
-    { success: true, data: data }
-  end
-
-  def self.failure(errors)
-    { success: false, errors: errors }
-  end
-end