railsforge 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01eaa16a2df2e84f2ce395692e0b09bd8691d96762548c6d8524ebf0f7870466
-  data.tar.gz: 8c80982d2fe51c9cc13acc5b580f43a9cabe162f2a09ccf5bcd9d5fe8ffe518b
+  metadata.gz: 1ca67789d645855334565249db474d63bfde8607e031642c52a287924c55b9cf
+  data.tar.gz: 9517139f8e3224a17ebd875c6606a2ea244e183e289acc1599181eed13522f07
 SHA512:
-  metadata.gz: 3dd1707c9e98f715d55206aaa06872deb0764f6bf678618447a42a60485c3e089fe9ea7cd424cc35a6f2b1d8fbb83c23368147686daf09d9057b9e4187c29d7b
-  data.tar.gz: beef673a82ca8a20306e6193b10a176d8433d42350a533c30271d22b9a8f111da2cb4793f0f3f2927d51dc799bacf4daba62da48e9dc62a558ff27bddc8897a6
+  metadata.gz: db1e954e6df040c1856be4cee40357e781201d29a550f31c1dc8924d4c3e93678daecefa42c8e651d02ddef5dc04d4ebd702cb37cac2a0731111ddf0a6e03d13
+  data.tar.gz: d7f692d25425099a0ea48499655272a70cf77f517cbfdadbe54826c517aa9e989833774feca6fb7742d36e5aa8bdc47c5c9d9760b8a0130009716ea74298e6c6

data/lib/railsforge/cli.rb

@@ -236,15 +236,29 @@ module RailsForge
     def self.generate_single(type, name, template_version)
       case type
       when :service
-        "Generating service: #{name}" + "\n" + RailsForge::Generators::ServiceGenerator.generate(name, with_spec: true, template_version: template_version)
+        "Generating service: #{name}\n" + RailsForge::Generators::ServiceGenerator.generate(name, with_spec: true, template_version: template_version)
       when :query
-        "Generating query: #{name}"
+        "Generating query: #{name}\n" + RailsForge::Generators::QueryGenerator.generate(name, with_spec: true, template_version: template_version)
       when :job
-        "Generating job: #{name}"
+        "Generating job: #{name}\n" + RailsForge::Generators::JobGenerator.generate(name, with_spec: true, template_version: template_version)
+      when :form
+        "Generating form: #{name}\n" + RailsForge::Generators::FormGenerator.generate(name, with_spec: true, template_version: template_version)
+      when :presenter
+        "Generating presenter: #{name}\n" + RailsForge::Generators::PresenterGenerator.generate(name, with_spec: true, template_version: template_version)
+      when :policy
+        "Generating policy: #{name}\n" + RailsForge::Generators::PolicyGenerator.generate(name, with_spec: true, template_version: template_version)
+      when :serializer
+        "Generating serializer: #{name}\n" + RailsForge::Generators::SerializerGenerator.generate(name, with_spec: true, template_version: template_version)
       when :component
-        "Generating component: #{name}" + "\n" + RailsForge::Generators::ViewComponentGenerator.new(name, template_version: template_version).generate
+        "Generating component: #{name}\n" + RailsForge::Generators::ViewComponentGenerator.new(name, template_version: template_version).generate
       when :stimulus
-        "Generating stimulus: #{name}" + "\n" + RailsForge::Generators::StimulusControllerGenerator.new(name, template_version: template_version).generate
+        "Generating stimulus: #{name}\n" + RailsForge::Generators::StimulusControllerGenerator.new(name, template_version: template_version).generate
+      when :mailer
+        "Generating mailer: #{name}\n" + RailsForge::MailerGenerator.generate(name, with_spec: true)
+      when :feature
+        "Generating feature: #{name}\n" + RailsForge::FeatureGenerator.generate(name, with_spec: true)
+      when :api
+        "Generating API: #{name}\n" + RailsForge::Generators::ApiGenerator.generate(name, with_spec: true)
       else
         "Generator for #{type} not fully implemented"
       end

data/lib/railsforge/generators/api_generator.rb

@@ -0,0 +1,392 @@
+# API Generator for RailsForge
+# Generates API resources with controllers, serializers, policies, services, and queries
+
+require_relative 'base_generator'
+
+module RailsForge
+  module Generators
+    # ApiGenerator creates API resources
+    class ApiGenerator < BaseGenerator
+      # Error class for invalid resource names
+      class InvalidResourceNameError < StandardError; end
+
+      # Initialize the generator
+      # @param name [String] Resource name
+      # @param options [Hash] Generator options
+      def initialize(name, options = {})
+        super(name, options)
+        @namespace = options[:namespace] || "api"
+        @version = options[:version] || "v1"
+        @with_spec = options.fetch(:with_spec, true)
+      end
+
+      # Generate API resource files
+      # @return [String] Success message
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        validate_name!(@name)
+
+        results = []
+        results << generate_controller
+        results << generate_serializer
+        results << generate_policy
+        results << generate_service
+        results << generate_query
+        results << generate_request_spec if @with_spec
+
+        "API resource '#{@name}' generated successfully with #{results.count} files!\n" + results.join("\n")
+      end
+
+      # Class method for CLI
+      def self.generate(resource_name, with_spec: true, version: "v1", namespace: "api")
+        new(resource_name, with_spec: with_spec, version: version, namespace: namespace).generate
+      end
+
+      private
+
+      # Validate resource name
+      def validate_name!(name)
+        raise InvalidResourceNameError, "Resource name cannot be empty" if name.nil? || name.strip.empty?
+        raise InvalidResourceNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+      end
+
+      # Pluralize helper
+      def pluralize(word)
+        return word + 's' unless word.end_with?('s')
+        return word + 'es' if word.end_with?('sh') || word.end_with?('ch')
+        word + 's'
+      end
+
+      # Generate controller
+      def generate_controller
+        controller_dir = File.join(@base_path, "app", "controllers", @namespace, @version)
+        FileUtils.mkdir_p(controller_dir)
+
+        resource_plural = pluralize(@name)
+        resource_underscore = underscore
+        resource_underscore_plural = pluralize(resource_underscore)
+
+        file_name = "#{resource_underscore}_controller.rb"
+        file_path = File.join(controller_dir, file_name)
+
+        return "  Skipping controller (already exists)" if File.exist?(file_path)
+
+        content = <<~RUBY
+          # API Controller for #{@name}
+          # Version: #{@version}
+          # Namespace: #{@namespace}
+          #
+          # Generates standard CRUD actions for REST API
+          class #{resource_plural}Controller < ApplicationController
+            before_action :set_#{resource_underscore}, only: [:show, :update, :destroy]
+            before_action :authenticate_user!, unless: :devise_controller?
+
+            # GET /#{resource_underscore_plural}
+            def index
+              @#{resource_underscore_plural} = #{@name}Query.call
+              render json: #{@name}Serializer.new(@#{resource_underscore_plural}).serializable_hash
+            end
+
+            # GET /#{resource_underscore_plural}/:id
+            def show
+              render json: #{@name}Serializer.new(@#{resource_underscore}).serializable_hash
+            end
+
+            # POST /#{resource_underscore_plural}
+            def create
+              @result = Create#{@name}Service.call(#{resource_underscore}_params)
+
+              if @result.success?
+                render json: #{@name}Serializer.new(@result.#{resource_underscore}).serializable_hash, status: :created
+              else
+                render json: { errors: @result.errors }, status: :unprocessable_entity
+              end
+            end
+
+            # PATCH/PUT /#{resource_underscore_plural}/:id
+            def update
+              @result = Update#{@name}Service.call(@#{resource_underscore}, #{resource_underscore}_params)
+
+              if @result.success?
+                render json: #{@name}Serializer.new(@result.#{resource_underscore}).serializable_hash
+              else
+                render json: { errors: @result.errors }, status: :unprocessable_entity
+              end
+            end
+
+            # DELETE /#{resource_underscore_plural}/:id
+            def destroy
+              @#{resource_underscore}.destroy
+              head :no_content
+            end
+
+            private
+
+            def set_#{resource_underscore}
+              @#{resource_underscore} = #{@name}.find(params[:id])
+            end
+
+            def #{resource_underscore}_params
+              params.require(:#{resource_underscore}).permit(:name)
+            end
+          end
+        RUBY
+
+        File.write(file_path, content)
+        "  Created app/controllers/#{@namespace}/#{@version}/#{file_name}"
+      end
+
+      # Generate serializer
+      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 = <<~RUBY
+          # Serializer for #{@name}
+          class #{@name}Serializer < ApplicationSerializer
+            attributes :id, :name, :created_at, :updated_at
+          end
+        RUBY
+
+        File.write(file_path, content)
+        "  Created app/serializers/#{file_name}"
+      end
+
+      # Generate policy
+      def generate_policy
+        policy_dir = File.join(@base_path, "app", "policies")
+        FileUtils.mkdir_p(policy_dir)
+
+        file_name = "#{underscore}_policy.rb"
+        file_path = File.join(policy_dir, file_name)
+
+        return "  Skipping policy (already exists)" if File.exist?(file_path)
+
+        content = <<~RUBY
+          # Policy for #{@name}
+          class #{@name}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 update?
+              user.present?
+            end
+
+            def destroy?
+              user.present?
+            end
+
+            class Scope
+              def initialize(user, scope)
+                @user = user
+                @scope = scope
+              end
+
+              def resolve
+                scope.all
+              end
+            end
+          end
+        RUBY
+
+        File.write(file_path, content)
+        "  Created app/policies/#{file_name}"
+      end
+
+      # Generate service
+      def generate_service
+        service_dir = File.join(@base_path, "app", "services")
+        FileUtils.mkdir_p(service_dir)
+        res_underscore = underscore
+
+        # Create service
+        file_name = "create_#{res_underscore}_service.rb"
+        file_path = File.join(service_dir, file_name)
+
+        unless File.exist?(file_path)
+          content = <<~RUBY
+            # Service for creating #{@name}
+            class Create#{@name}Service
+              def initialize(params)
+                @params = params
+              end
+
+              def call
+                @#{res_underscore} = #{@name}.create!(@params)
+                Result.new(success: true, #{res_underscore}: @#{res_underscore})
+              rescue => e
+                Result.new(success: false, errors: e.message)
+              end
+
+              class Result
+                attr_reader :#{res_underscore}, :errors
+                def initialize(success:, #{res_underscore}: nil, errors: nil)
+                  @success = success
+                  @#{res_underscore} = #{res_underscore}
+                  @errors = errors
+                end
+
+                def success?
+                  @success
+                end
+              end
+            end
+          RUBY
+
+          File.write(file_path, content)
+        end
+
+        # Update service
+        file_name = "update_#{res_underscore}_service.rb"
+        file_path = File.join(service_dir, file_name)
+
+        unless File.exist?(file_path)
+          content = <<~RUBY
+            # Service for updating #{@name}
+            class Update#{@name}Service
+              def initialize(#{res_underscore}, params)
+                @#{res_underscore} = #{res_underscore}
+                @params = params
+              end
+
+              def call
+                if @#{res_underscore}.update(@params)
+                  Result.new(success: true, #{res_underscore}: @#{res_underscore})
+                else
+                  Result.new(success: false, errors: @#{res_underscore}.errors.full_messages)
+                end
+              end
+
+              class Result
+                attr_reader :#{res_underscore}, :errors
+                def initialize(success:, #{res_underscore}: nil, errors: nil)
+                  @success = success
+                  @#{res_underscore} = #{res_underscore}
+                  @errors = errors
+                end
+
+                def success?
+                  @success
+                end
+              end
+            end
+          RUBY
+
+          File.write(file_path, content)
+        end
+
+        "  Created app/services/create_#{res_underscore}_service.rb and update_#{res_underscore}_service.rb"
+      end
+
+      # Generate query
+      def generate_query
+        query_dir = File.join(@base_path, "app", "queries")
+        FileUtils.mkdir_p(query_dir)
+
+        file_name = "find_#{underscore}.rb"
+        file_path = File.join(query_dir, file_name)
+
+        return "  Skipping query (already exists)" if File.exist?(file_path)
+
+        content = <<~RUBY
+          # Query for finding #{@name}
+          class Find#{@name}
+            def initialize(scope: nil)
+              @scope = scope || #{@name}.all
+            end
+
+            def call
+              @scope
+            end
+          end
+        RUBY
+
+        File.write(file_path, content)
+        "  Created app/queries/#{file_name}"
+      end
+
+      # Generate request spec
+      def generate_request_spec
+        spec_dir = File.join(@base_path, "spec", "requests", @namespace, @version)
+        FileUtils.mkdir_p(spec_dir)
+
+        resource_plural = pluralize(@name)
+        resource_underscore = underscore
+
+        file_name = "#{resource_underscore}_spec.rb"
+        file_path = File.join(spec_dir, file_name)
+
+        return "  Skipping spec (already exists)" if File.exist?(file_path)
+
+        content = <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe "#{@namespace.capitalize}::#{@version.capitalize}::#{resource_plural}Controller" do
+            let(:user) { User.create!(name: "Test", email: "test@example.com") }
+            let(:#{resource_underscore}) { #{@name}.create!(name: "Test #{@name}") }
+
+            before do
+              sign_in user
+            end
+
+            describe "GET /index" do
+              it "returns a success response" do
+                get :index
+                expect(response).to be_successful
+              end
+            end
+
+            describe "GET /show" do
+              it "returns a success response" do
+                get :show, params: { id: #{resource_underscore}.id }
+                expect(response).to be_successful
+              end
+            end
+
+            describe "POST /create" do
+              it "creates a new #{resource_underscore}" do
+                expect {
+                  post :create, params: { #{resource_underscore}: { name: "New #{@name}" } }
+                }.to change(#{@name}, :count).by(1)
+              end
+            end
+
+            describe "DELETE /destroy" do
+              it "deletes the #{resource_underscore}" do
+                #{resource_underscore}
+                expect {
+                  delete :destroy, params: { id: #{resource_underscore}.id }
+                }.to change(#{@name}, :count).by(-1)
+              end
+            end
+          end
+        RUBY
+
+        File.write(file_path, content)
+        "  Created spec/requests/#{@namespace}/#{@version}/#{file_name}"
+      end
+    end
+  end
+end

data/lib/railsforge/generators/base_generator.rb

@@ -58,7 +58,12 @@ module RailsForge
       # Convert to camelize
       # @return [String] Camelized name
       def camelize
-        @name.to_s.split('_').map(&:capitalize).join
+        result = @name.to_s.gsub(/::/, '/')
+        result.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .split('_')
+              .map(&:capitalize)
+              .join
       end
 
       # Generate the file

data/lib/railsforge/generators/form_generator.rb

@@ -0,0 +1,180 @@
+# Form generator for RailsForge
+# Generates form object files
+
+require_relative 'base_generator'
+
+module RailsForge
+  module Generators
+    # FormGenerator creates form files
+    class FormGenerator < BaseGenerator
+      # Error class for invalid form names
+      class InvalidFormNameError < StandardError; end
+
+      # Template version
+      TEMPLATE_VERSION = "v1"
+
+      # Initialize the generator
+      # @param name [String] Form 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 form files
+      # @return [String] Success message
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        validate_name!(@name)
+
+        results = []
+        results << generate_form
+
+        if @with_spec
+          results << generate_spec
+        end
+
+        "Form '#{@name}' generated successfully!\n" + results.join("\n")
+      end
+
+      # Class method for CLI
+      def self.generate(form_name, with_spec: true, template_version: "v1")
+        new(form_name, with_spec: with_spec, template_version: template_version).generate
+      end
+
+      private
+
+      # Validate form name
+      def validate_name!(name)
+        raise InvalidFormNameError, "Form name cannot be empty" if name.nil? || name.strip.empty?
+        raise InvalidFormNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+      end
+
+      # Generate form file
+      def generate_form
+        form_dir = File.join(@base_path, "app", "forms")
+        FileUtils.mkdir_p(form_dir)
+
+        file_name = "#{underscore}_form.rb"
+        file_path = File.join(form_dir, file_name)
+
+        return "  Skipping form (already exists)" if File.exist?(file_path)
+
+        content = load_template
+        content = apply_template(content)
+
+        File.write(file_path, content)
+        "  Created app/forms/#{file_name}"
+      end
+
+      # Generate spec file
+      def generate_spec
+        spec_dir = File.join(@base_path, "spec", "forms")
+        FileUtils.mkdir_p(spec_dir)
+
+        file_name = "#{underscore}_form_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/forms/#{file_name}"
+      end
+
+      # Load template content
+      def load_template
+        template_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          @template_version,
+          "form",
+          "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,
+          "form",
+          "spec_template.rb"
+        )
+
+        if File.exist?(spec_path)
+          File.read(spec_path)
+        else
+          default_spec_template
+        end
+      end
+
+      # Default template
+      def default_template
+        <<~RUBY
+          # Form class for #{underscore}
+          # Encapsulates form validation and processing
+          class #{camelize}Form
+            include ActiveModel::Model
+
+            attr_accessor :name, :email
+
+            validates :name, presence: true
+            validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
+
+            def save
+              return false unless valid?
+
+              # TODO: Implement save logic
+              true
+            end
+          end
+        RUBY
+      end
+
+      # Default spec template
+      def default_spec_template
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{camelize}Form do
+            describe 'validations' do
+              it 'validates presence of name' do
+                form = described_class.new(name: nil, email: 'test@example.com')
+                expect(form).not_to be_valid
+                expect(form.errors[:name]).to be_present
+              end
+
+              it 'validates email format' do
+                form = described_class.new(name: 'Test', email: 'invalid')
+                expect(form).not_to be_valid
+                expect(form.errors[:email]).to be_present
+              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