railsforge 1.0.0 → 1.0.2

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

data/lib/railsforge/generators/job_generator.rb

@@ -0,0 +1,176 @@
+# Job generator for RailsForge
+# Generates background job files
+
+require_relative 'base_generator'
+
+module RailsForge
+  module Generators
+    # JobGenerator creates job files
+    class JobGenerator < BaseGenerator
+      # Error class for invalid job names
+      class InvalidJobNameError < StandardError; end
+
+      # Template version
+      TEMPLATE_VERSION = "v1"
+
+      # Initialize the generator
+      # @param name [String] Job 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 job files
+      # @return [String] Success message
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        validate_name!(@name)
+
+        results = []
+        results << generate_job
+
+        if @with_spec
+          results << generate_spec
+        end
+
+        "Job '#{@name}' generated successfully!\n" + results.join("\n")
+      end
+
+      # Class method for CLI
+      def self.generate(job_name, with_spec: true, template_version: "v1")
+        new(job_name, with_spec: with_spec, template_version: template_version).generate
+      end
+
+      private
+
+      # Validate job name
+      def validate_name!(name)
+        raise InvalidJobNameError, "Job name cannot be empty" if name.nil? || name.strip.empty?
+        raise InvalidJobNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+      end
+
+      # Generate job file
+      def generate_job
+        job_dir = File.join(@base_path, "app", "jobs")
+        FileUtils.mkdir_p(job_dir)
+
+        file_name = "#{underscore}_job.rb"
+        file_path = File.join(job_dir, file_name)
+
+        return "  Skipping job (already exists)" if File.exist?(file_path)
+
+        content = load_template
+        content = apply_template(content)
+
+        File.write(file_path, content)
+        "  Created app/jobs/#{file_name}"
+      end
+
+      # Generate spec file
+      def generate_spec
+        spec_dir = File.join(@base_path, "spec", "jobs")
+        FileUtils.mkdir_p(spec_dir)
+
+        file_name = "#{underscore}_job_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/jobs/#{file_name}"
+      end
+
+      # Load template content
+      def load_template
+        template_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          @template_version,
+          "job",
+          "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,
+          "job",
+          "spec_template.rb"
+        )
+
+        if File.exist?(spec_path)
+          File.read(spec_path)
+        else
+          default_spec_template
+        end
+      end
+
+      # Default template
+      def default_template
+        <<~RUBY
+          # Background job for #{underscore}
+          # Handles async processing
+          #
+          # Usage:
+          #   #{camelize}Job.perform_later(record)
+          #   #{camelize}Job.perform_now(record)
+          class #{camelize}Job < ApplicationJob
+            queue_as :default
+
+            def perform(*args)
+              # TODO: Implement job logic
+            end
+          end
+        RUBY
+      end
+
+      # Default spec template
+      def default_spec_template
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{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
+        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/policy_generator.rb

@@ -0,0 +1,220 @@
+# Policy generator for RailsForge
+# Generates policy object files (for Pundit)
+
+require_relative 'base_generator'
+
+module RailsForge
+  module Generators
+    # PolicyGenerator creates policy files
+    class PolicyGenerator < BaseGenerator
+      # Error class for invalid policy names
+      class InvalidPolicyNameError < StandardError; end
+
+      # Template version
+      TEMPLATE_VERSION = "v1"
+
+      # Initialize the generator
+      # @param name [String] Policy 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 policy files
+      # @return [String] Success message
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        validate_name!(@name)
+
+        results = []
+        results << generate_policy
+
+        if @with_spec
+          results << generate_spec
+        end
+
+        "Policy '#{@name}' generated successfully!\n" + results.join("\n")
+      end
+
+      # Class method for CLI
+      def self.generate(policy_name, with_spec: true, template_version: "v1")
+        new(policy_name, with_spec: with_spec, template_version: template_version).generate
+      end
+
+      private
+
+      # Validate policy name
+      def validate_name!(name)
+        raise InvalidPolicyNameError, "Policy name cannot be empty" if name.nil? || name.strip.empty?
+        raise InvalidPolicyNameError, "Name must match pattern: /\\A[A-Z][a-zA-Z0-9]*\\z/" unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+      end
+
+      # Generate policy file
+      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 = load_template
+        content = apply_template(content)
+
+        File.write(file_path, content)
+        "  Created app/policies/#{file_name}"
+      end
+
+      # Generate spec file
+      def generate_spec
+        spec_dir = File.join(@base_path, "spec", "policies")
+        FileUtils.mkdir_p(spec_dir)
+
+        file_name = "#{underscore}_policy_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/policies/#{file_name}"
+      end
+
+      # Load template content
+      def load_template
+        template_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          @template_version,
+          "policy",
+          "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,
+          "policy",
+          "spec_template.rb"
+        )
+
+        if File.exist?(spec_path)
+          File.read(spec_path)
+        else
+          default_spec_template
+        end
+      end
+
+      # Default template
+      def default_template
+        <<~RUBY
+          # Policy class for #{underscore}
+          # Defines authorization rules using Pundit
+          class #{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? && record.user == user
+            end
+
+            def edit?
+              update?
+            end
+
+            def destroy?
+              user.present? && record.user == user
+            end
+
+            class Scope
+              def initialize(user, scope)
+                @user = user
+                @scope = scope
+              end
+
+              def resolve
+                scope.all
+              end
+            end
+          end
+        RUBY
+      end
+
+      # Default spec template
+      def default_spec_template
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{camelize}Policy do
+            let(:user) { User.new }
+            let(:record) { #{camelize}.new }
+
+            subject { described_class.new(user, record) }
+
+            it { should permit(:index) }
+            it { should permit(:show) }
+            it { should permit(:new) }
+            it { should permit(:create) }
+
+            context 'when user is the owner' do
+              let(:user) { record.user }
+
+              it { should permit(:update) }
+              it { should permit(:destroy) }
+            end
+
+            context 'when user is not the owner' do
+              it { should_not permit(:update) }
+              it { should_not permit(:destroy) }
+            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