railsforge 1.0.0 → 1.0.2

data/lib/railsforge/generators/presenter_generator.rb

@@ -0,0 +1,173 @@
+# Presenter generator for RailsForge
+# Generates presenter object files
+
+require_relative 'base_generator'
+
+module RailsForge
+  module Generators
+    # PresenterGenerator creates presenter files
+    class PresenterGenerator < BaseGenerator
+      # Error class for invalid presenter names
+      class InvalidPresenterNameError < StandardError; end
+
+      # Template version
+      TEMPLATE_VERSION = "v1"
+
+      # Initialize the generator
+      # @param name [String] Presenter name
+      # @param options [Hash] Generator options
+      def initialize(name, options = {})
+        super(name, options)
+        @template_version = options[:template_version] || TEMPLATE_VERSION
+        @with_spec = options.fetch(:with_spec, true)
+      end
+
+      # Generate presenter files
+      # @return [String] Success message
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        validate_name!(@name)
+
+        results = []
+        results << generate_presenter
+
+        if @with_spec
+          results << generate_spec
+        end
+
+        "Presenter '#{@name}' generated successfully!\n" + results.join("\n")
+      end
+
+      # Class method for CLI
+      def self.generate(presenter_name, with_spec: true, template_version: "v1")
+        new(presenter_name, with_spec: with_spec, template_version: template_version).generate
+      end
+
+      private
+
+      # Validate presenter name
+      def validate_name!(name)
+        raise InvalidPresenterNameError, "Presenter name cannot be empty" if name.nil? || name.strip.empty?
+        raise InvalidPresenterNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+      end
+
+      # Generate presenter file
+      def generate_presenter
+        presenter_dir = File.join(@base_path, "app", "presenters")
+        FileUtils.mkdir_p(presenter_dir)
+
+        file_name = "#{underscore}_presenter.rb"
+        file_path = File.join(presenter_dir, file_name)
+
+        return "  Skipping presenter (already exists)" if File.exist?(file_path)
+
+        content = load_template
+        content = apply_template(content)
+
+        File.write(file_path, content)
+        "  Created app/presenters/#{file_name}"
+      end
+
+      # Generate spec file
+      def generate_spec
+        spec_dir = File.join(@base_path, "spec", "presenters")
+        FileUtils.mkdir_p(spec_dir)
+
+        file_name = "#{underscore}_presenter_spec.rb"
+        file_path = File.join(spec_dir, file_name)
+
+        return "  Skipping spec (already exists)" if File.exist?(file_path)
+
+        content = load_spec_template
+        content = apply_template(content)
+
+        File.write(file_path, content)
+        "  Created spec/presenters/#{file_name}"
+      end
+
+      # Load template content
+      def load_template
+        template_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          @template_version,
+          "presenter",
+          "template.rb"
+        )
+
+        if File.exist?(template_path)
+          File.read(template_path)
+        else
+          default_template
+        end
+      end
+
+      # Load spec template
+      def load_spec_template
+        spec_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          @template_version,
+          "presenter",
+          "spec_template.rb"
+        )
+
+        if File.exist?(spec_path)
+          File.read(spec_path)
+        else
+          default_spec_template
+        end
+      end
+
+      # Default template
+      def default_template
+        <<~RUBY
+          # Presenter class for #{underscore}
+          # Encapsulates view logic
+          class #{camelize}Presenter
+            def initialize(object)
+              @object = object
+            end
+
+            def title
+              @object.name.titleize
+            end
+
+            def details
+              # TODO: Add presenter logic
+            end
+          end
+        RUBY
+      end
+
+      # Default spec template
+      def default_spec_template
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{camelize}Presenter do
+            let(:object) { double(name: 'Test Object') }
+            subject { described_class.new(object) }
+
+            describe '#title' do
+              it 'returns titleized name' do
+                expect(subject.title).to eq('Test Object')
+              end
+            end
+          end
+        RUBY
+      end
+
+      # Apply template variables
+      def apply_template(content)
+        content
+          .gsub("<%= name %>", @name)
+          .gsub("<%= name.camelize %>", camelize)
+          .gsub("<%= name.underscore %>", underscore)
+      end
+    end
+  end
+end

data/lib/railsforge/generators/query_generator.rb

@@ -0,0 +1,174 @@
+# Query generator for RailsForge
+# Generates query object files
+
+require_relative 'base_generator'
+
+module RailsForge
+  module Generators
+    # QueryGenerator creates query files
+    class QueryGenerator < BaseGenerator
+      # Error class for invalid query names
+      class InvalidQueryNameError < StandardError; end
+
+      # Template version
+      TEMPLATE_VERSION = "v1"
+
+      # Initialize the generator
+      # @param name [String] Query name
+      # @param options [Hash] Generator options
+      def initialize(name, options = {})
+        super(name, options)
+        @template_version = options[:template_version] || TEMPLATE_VERSION
+        @with_spec = options.fetch(:with_spec, true)
+      end
+
+      # Generate query files
+      # @return [String] Success message
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        validate_name!(@name)
+
+        results = []
+        results << generate_query
+
+        if @with_spec
+          results << generate_spec
+        end
+
+        "Query '#{@name}' generated successfully!\n" + results.join("\n")
+      end
+
+      # Class method for CLI
+      def self.generate(query_name, with_spec: true, template_version: "v1")
+        new(query_name, with_spec: with_spec, template_version: template_version).generate
+      end
+
+      private
+
+      # Validate query name
+      def validate_name!(name)
+        raise InvalidQueryNameError, "Query name cannot be empty" if name.nil? || name.strip.empty?
+        raise InvalidQueryNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+      end
+
+      # Generate query file
+      def generate_query
+        query_dir = File.join(@base_path, "app", "queries")
+        FileUtils.mkdir_p(query_dir)
+
+        file_name = "#{underscore}.rb"
+        file_path = File.join(query_dir, file_name)
+
+        return "  Skipping query (already exists)" if File.exist?(file_path)
+
+        content = load_template
+        content = apply_template(content)
+
+        File.write(file_path, content)
+        "  Created app/queries/#{file_name}"
+      end
+
+      # Generate spec file
+      def generate_spec
+        spec_dir = File.join(@base_path, "spec", "queries")
+        FileUtils.mkdir_p(spec_dir)
+
+        file_name = "#{underscore}_spec.rb"
+        file_path = File.join(spec_dir, file_name)
+
+        return "  Skipping spec (already exists)" if File.exist?(file_path)
+
+        content = load_spec_template
+        content = apply_template(content)
+
+        File.write(file_path, content)
+        "  Created spec/queries/#{file_name}"
+      end
+
+      # Load template content
+      def load_template
+        template_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          @template_version,
+          "query",
+          "template.rb"
+        )
+
+        if File.exist?(template_path)
+          File.read(template_path)
+        else
+          default_template
+        end
+      end
+
+      # Load spec template
+      def load_spec_template
+        spec_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          @template_version,
+          "query",
+          "spec_template.rb"
+        )
+
+        if File.exist?(spec_path)
+          File.read(spec_path)
+        else
+          default_spec_template
+        end
+      end
+
+      # Default template
+      def default_template
+        <<~RUBY
+          # Query class for #{underscore}
+          # Encapsulates database queries
+          class #{camelize}
+            def initialize(scope: nil)
+              @scope = scope || default_scope
+            end
+
+            def call
+              @scope
+            end
+
+            private
+
+            def default_scope
+              # TODO: Replace with actual model scope
+              Model.all
+            end
+          end
+        RUBY
+      end
+
+      # Default spec template
+      def default_spec_template
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{camelize} do
+            describe '#call' do
+              it 'returns scope' do
+                result = described_class.call
+                expect(result).to be_a(ActiveRecord::Relation)
+              end
+            end
+          end
+        RUBY
+      end
+
+      # Apply template variables
+      def apply_template(content)
+        content
+          .gsub("<%= name %>", @name)
+          .gsub("<%= name.camelize %>", camelize)
+          .gsub("<%= name.underscore %>", underscore)
+      end
+    end
+  end
+end

data/lib/railsforge/generators/serializer_generator.rb

@@ -0,0 +1,166 @@
+# Serializer generator for RailsForge
+# Generates serializer object files
+
+require_relative 'base_generator'
+
+module RailsForge
+  module Generators
+    # SerializerGenerator creates serializer files
+    class SerializerGenerator < BaseGenerator
+      # Error class for invalid serializer names
+      class InvalidSerializerNameError < StandardError; end
+
+      # Template version
+      TEMPLATE_VERSION = "v1"
+
+      # Initialize the generator
+      # @param name [String] Serializer name
+      # @param options [Hash] Generator options
+      def initialize(name, options = {})
+        super(name, options)
+        @template_version = options[:template_version] || TEMPLATE_VERSION
+        @with_spec = options.fetch(:with_spec, true)
+      end
+
+      # Generate serializer files
+      # @return [String] Success message
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        validate_name!(@name)
+
+        results = []
+        results << generate_serializer
+
+        if @with_spec
+          results << generate_spec
+        end
+
+        "Serializer '#{@name}' generated successfully!\n" + results.join("\n")
+      end
+
+      # Class method for CLI
+      def self.generate(serializer_name, with_spec: true, template_version: "v1")
+        new(serializer_name, with_spec: with_spec, template_version: template_version).generate
+      end
+
+      private
+
+      # Validate serializer name
+      def validate_name!(name)
+        raise InvalidSerializerNameError, "Serializer name cannot be empty" if name.nil? || name.strip.empty?
+        raise InvalidSerializerNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+      end
+
+      # Generate serializer file
+      def generate_serializer
+        serializer_dir = File.join(@base_path, "app", "serializers")
+        FileUtils.mkdir_p(serializer_dir)
+
+        file_name = "#{underscore}_serializer.rb"
+        file_path = File.join(serializer_dir, file_name)
+
+        return "  Skipping serializer (already exists)" if File.exist?(file_path)
+
+        content = load_template
+        content = apply_template(content)
+
+        File.write(file_path, content)
+        "  Created app/serializers/#{file_name}"
+      end
+
+      # Generate spec file
+      def generate_spec
+        spec_dir = File.join(@base_path, "spec", "serializers")
+        FileUtils.mkdir_p(spec_dir)
+
+        file_name = "#{underscore}_serializer_spec.rb"
+        file_path = File.join(spec_dir, file_name)
+
+        return "  Skipping spec (already exists)" if File.exist?(file_path)
+
+        content = load_spec_template
+        content = apply_template(content)
+
+        File.write(file_path, content)
+        "  Created spec/serializers/#{file_name}"
+      end
+
+      # Load template content
+      def load_template
+        template_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          @template_version,
+          "serializer",
+          "template.rb"
+        )
+
+        if File.exist?(template_path)
+          File.read(template_path)
+        else
+          default_template
+        end
+      end
+
+      # Load spec template
+      def load_spec_template
+        spec_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          @template_version,
+          "serializer",
+          "spec_template.rb"
+        )
+
+        if File.exist?(spec_path)
+          File.read(spec_path)
+        else
+          default_spec_template
+        end
+      end
+
+      # Default template
+      def default_template
+        <<~RUBY
+          # Serializer class for #{underscore}
+          # Defines JSON serialization
+          class #{camelize}Serializer < ApplicationSerializer
+            attributes :id, :name, :created_at, :updated_at
+
+            # TODO and: Add associations methods
+            # belongs_to :user
+            # has_many :items
+          end
+        RUBY
+      end
+
+      # Default spec template
+      def default_spec_template
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{camelize}Serializer do
+            let(:resource) { #{camelize}.create!(name: 'Test') }
+            let(:serializer) { described_class.new(resource) }
+            let(:serialization) { ActiveModel::SerializableResource.new(resource).as_json }
+
+            it 'includes expected attributes' do
+              expect(serialization[:#{camelize.underscore}] [:name]).to eq('Test')
+            end
+          end
+        RUBY
+      end
+
+      # Apply template variables
+      def apply_template(content)
+        content
+          .gsub("<%= name %>", @name)
+          .gsub("<%= name.camelize %>", camelize)
+          .gsub("<%= name.underscore %>", underscore)
+      end
+    end
+  end
+end

data/lib/railsforge/loader.rb

@@ -1,56 +1,87 @@
 # RailsForge modular loader
-# This file centralizes all require statements
+# This file centralizes all require statements with lazy loading
 
 require "fileutils"
 
 # Get the lib directory path
 LIB_DIR = File.dirname(__FILE__)
 
-# Core modules
+# Core modules - always needed
 require_relative "version"
-require_relative "profiles"
-require_relative "template_loader"
-
-# CLI
-require_relative "cli"
-
-# Generators (modular)
-require_relative "generators/base_generator"
-require_relative "generators/service_generator"
-require_relative "generators/view_component_generator"
-require_relative "generators/stimulus_controller_generator"
-require_relative "generators/demo_generator"
-require_relative "generators/devops_generator"
-require_relative "generators/monitoring_generator"
-require_relative "generators/test_generator"
-
-# Analyzers (modular)
-require_relative "analyzers/base_analyzer"
-require_relative "analyzers/controller_analyzer"
-require_relative "analyzers/model_analyzer"
-require_relative "analyzers/spec_analyzer"
-require_relative "analyzers/database_analyzer"
-require_relative "analyzers/metrics_analyzer"
-require_relative "analyzers/refactor_analyzer"
-require_relative "analyzers/security_analyzer"
-require_relative "analyzers/performance_analyzer"
-
-# Refactors
-require_relative "refactors/refactor_controller"
-
-# Plugins
-require_relative "plugins"
-
-# Additional features (legacy compatibility)
-require_relative "mailer_generator"
-require_relative "feature_generator"
-require_relative "api_generator"
-require_relative "audit"
-require_relative "doctor"
-require_relative "graph"
-require_relative "wizard"
-require_relative "wizard_tui"
-require_relative "config"
-
-# Generator module (app creation)
-require_relative "generator"
+
+# Minimal CLI loader for --help and --version (fast)
+require_relative "cli_minimal"
+
+# Lazy-load everything else
+module RailsForge
+  class << self
+    # Lazy-load generators
+    def require_generator(name)
+      require_relative "generators/#{name}"
+    end
+
+    # Lazy-load analyzers  
+    def require_analyzer(name)
+      require_relative "analyzers/#{name}"
+    end
+
+    # Lazy-load other modules
+    def require_module(name)
+      require_relative name
+    end
+
+    # Preload all (for commands that need everything)
+    def preload_all!
+      require_relative "profiles"
+      require_relative "template_loader"
+      
+      # Define Generators module first to ensure proper namespace
+      require_relative "generators/base_generator"
+      
+      # Generators
+      require_relative "generators/service_generator"
+      require_relative "generators/job_generator"
+      require_relative "generators/query_generator"
+      require_relative "generators/form_generator"
+      require_relative "generators/presenter_generator"
+      require_relative "generators/policy_generator"
+      require_relative "generators/serializer_generator"
+      require_relative "generators/api_generator"
+      require_relative "generators/view_component_generator"
+      require_relative "generators/stimulus_controller_generator"
+      require_relative "generators/demo_generator"
+      require_relative "generators/devops_generator"
+      require_relative "generators/monitoring_generator"
+      require_relative "generators/test_generator"
+      
+      # Analyzers
+      require_relative "analyzers/base_analyzer"
+      require_relative "analyzers/controller_analyzer"
+      require_relative "analyzers/model_analyzer"
+      require_relative "analyzers/spec_analyzer"
+      require_relative "analyzers/database_analyzer"
+      require_relative "analyzers/metrics_analyzer"
+      require_relative "analyzers/refactor_analyzer"
+      require_relative "analyzers/security_analyzer"
+      require_relative "analyzers/performance_analyzer"
+      
+      # Refactors & plugins
+      require_relative "refactors/refactor_controller"
+      require_relative "plugins"
+      
+      # Legacy (modules with class methods)
+      require_relative "mailer_generator"
+      require_relative "feature_generator"
+      require_relative "audit"
+      require_relative "doctor"
+      require_relative "graph"
+      require_relative "wizard"
+      require_relative "wizard_tui"
+      require_relative "config"
+      require_relative "generator"
+      
+      # CLI
+      require_relative "cli"
+    end
+  end
+end

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

@@ -23,7 +23,7 @@ class <%= class_name %>Job < ApplicationJob
     # TODO: Implement job logic
     # Example:
     # user = User.find(args[:user_id])
-    # user.send_welcome_email
+    # UserMailer.welcome(user).deliver_now
     Rails.logger.info("Executing #{self.class.name}")
   end
 

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

@@ -46,16 +46,25 @@ class <%= class_name %>
   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!
-    # TODO: Add validation logic
-    # Example:
-    # return Failure(errors: ['Name required']) if @params[:name].blank?
     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!
-    # TODO: Implement service logic
     @result = {}
     Success(true)
   end

data/lib/railsforge/version.rb

@@ -1,5 +1,5 @@
 # Version module for RailsForge gem
 # Defines the current version of the gem
 module RailsForge
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end