railsforge 1.0.0

data/lib/railsforge/feature_generator.rb

@@ -0,0 +1,560 @@
+module RailsForge
+  # FeatureGenerator module handles generating multiple related files for a feature
+  module FeatureGenerator
+    # Error class for invalid feature names
+    class InvalidFeatureNameError < StandardError; end
+
+    # Validates the feature name to ensure it's valid Ruby class name
+    def self.validate_feature_name(name)
+      if name.nil? || name.strip.empty?
+        raise InvalidFeatureNameError, "Feature name cannot be empty"
+      end
+
+      # Don't validate names starting with dashes (they're likely flags)
+      return if name.start_with?("-")
+
+      unless name =~ /\A[A-Z][a-zA-Z0-9]*\z/
+        raise InvalidFeatureNameError, "Feature name must be in PascalCase (e.g., User)"
+      end
+    end
+
+    # Generates multiple related files for a feature
+    def self.generate(feature_name, with_spec: true)
+      validate_feature_name(feature_name)
+
+      base_path = find_rails_app_path
+      unless base_path
+        raise "Not in a Rails application directory"
+      end
+
+      results = []
+
+      # Generate Service
+      results << generate_service(base_path, feature_name)
+
+      # Generate Query
+      results << generate_query(base_path, feature_name)
+
+      # Generate Form
+      results << generate_form(base_path, feature_name)
+
+      # Generate Presenter
+      results << generate_presenter(base_path, feature_name)
+
+      # Generate Policy
+      results << generate_policy(base_path, feature_name)
+
+      # Generate Serializer
+      results << generate_serializer(base_path, feature_name)
+
+      if with_spec
+        results << generate_service_spec(base_path, feature_name)
+        results << generate_query_spec(base_path, feature_name)
+        results << generate_form_spec(base_path, feature_name)
+        results << generate_presenter_spec(base_path, feature_name)
+        results << generate_policy_spec(base_path, feature_name)
+        results << generate_serializer_spec(base_path, feature_name)
+      end
+
+      "Feature '#{feature_name}' generated successfully with #{results.count} files!"
+    end
+
+    def self.generate_service(base_path, feature_name)
+      service_dir = File.join(base_path, "app", "services")
+      FileUtils.mkdir_p(service_dir)
+
+      file_name = "#{feature_name.underscore}_service.rb"
+      file_path = File.join(service_dir, file_name)
+
+      return "  Skipping service (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, service_template(feature_name))
+      puts "  Created app/services/#{file_name}"
+      file_path
+    end
+
+    def self.generate_query(base_path, feature_name)
+      query_dir = File.join(base_path, "app", "queries")
+      FileUtils.mkdir_p(query_dir)
+
+      file_name = "find_#{feature_name.underscore}.rb"
+      file_path = File.join(query_dir, file_name)
+
+      return "  Skipping query (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, query_template(feature_name))
+      puts "  Created app/queries/#{file_name}"
+      file_path
+    end
+
+    def self.generate_form(base_path, feature_name)
+      form_dir = File.join(base_path, "app", "forms")
+      FileUtils.mkdir_p(form_dir)
+
+      file_name = "#{feature_name.underscore}_form.rb"
+      file_path = File.join(form_dir, file_name)
+
+      return "  Skipping form (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, form_template(feature_name))
+      puts "  Created app/forms/#{file_name}"
+      file_path
+    end
+
+    def self.generate_presenter(base_path, feature_name)
+      presenter_dir = File.join(base_path, "app", "presenters")
+      FileUtils.mkdir_p(presenter_dir)
+
+      file_name = "#{feature_name.underscore}_presenter.rb"
+      file_path = File.join(presenter_dir, file_name)
+
+      return "  Skipping presenter (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, presenter_template(feature_name))
+      puts "  Created app/presenters/#{file_name}"
+      file_path
+    end
+
+    def self.generate_policy(base_path, feature_name)
+      policy_dir = File.join(base_path, "app", "policies")
+      FileUtils.mkdir_p(policy_dir)
+
+      file_name = "#{feature_name.underscore}_policy.rb"
+      file_path = File.join(policy_dir, file_name)
+
+      return "  Skipping policy (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, policy_template(feature_name))
+      puts "  Created app/policies/#{file_name}"
+      file_path
+    end
+
+    def self.generate_serializer(base_path, feature_name)
+      serializer_dir = File.join(base_path, "app", "serializers")
+      FileUtils.mkdir_p(serializer_dir)
+
+      file_name = "#{feature_name.underscore}_serializer.rb"
+      file_path = File.join(serializer_dir, file_name)
+
+      return "  Skipping serializer (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, serializer_template(feature_name))
+      puts "  Created app/serializers/#{file_name}"
+      file_path
+    end
+
+    # Spec file generators
+    def self.generate_service_spec(base_path, feature_name)
+      spec_dir = File.join(base_path, "spec", "services")
+      FileUtils.mkdir_p(spec_dir)
+
+      file_name = "#{feature_name.underscore}_service_spec.rb"
+      file_path = File.join(spec_dir, file_name)
+
+      return "  Skipping service spec (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, service_spec_template(feature_name))
+      puts "  Created spec/services/#{file_name}"
+      file_path
+    end
+
+    def self.generate_query_spec(base_path, feature_name)
+      spec_dir = File.join(base_path, "spec", "queries")
+      FileUtils.mkdir_p(spec_dir)
+
+      file_name = "find_#{feature_name.underscore}_spec.rb"
+      file_path = File.join(spec_dir, file_name)
+
+      return "  Skipping query spec (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, query_spec_template(feature_name))
+      puts "  Created spec/queries/#{file_name}"
+      file_path
+    end
+
+    def self.generate_form_spec(base_path, feature_name)
+      spec_dir = File.join(base_path, "spec", "forms")
+      FileUtils.mkdir_p(spec_dir)
+
+      file_name = "#{feature_name.underscore}_form_spec.rb"
+      file_path = File.join(spec_dir, file_name)
+
+      return "  Skipping form spec (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, form_spec_template(feature_name))
+      puts "  Created spec/forms/#{file_name}"
+      file_path
+    end
+
+    def self.generate_presenter_spec(base_path, feature_name)
+      spec_dir = File.join(base_path, "spec", "presenters")
+      FileUtils.mkdir_p(spec_dir)
+
+      file_name = "#{feature_name.underscore}_presenter_spec.rb"
+      file_path = File.join(spec_dir, file_name)
+
+      return "  Skipping presenter spec (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, presenter_spec_template(feature_name))
+      puts "  Created spec/presenters/#{file_name}"
+      file_path
+    end
+
+    def self.generate_policy_spec(base_path, feature_name)
+      spec_dir = File.join(base_path, "spec", "policies")
+      FileUtils.mkdir_p(spec_dir)
+
+      file_name = "#{feature_name.underscore}_policy_spec.rb"
+      file_path = File.join(spec_dir, file_name)
+
+      return "  Skipping policy spec (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, policy_spec_template(feature_name))
+      puts "  Created spec/policies/#{file_name}"
+      file_path
+    end
+
+    def self.generate_serializer_spec(base_path, feature_name)
+      spec_dir = File.join(base_path, "spec", "serializers")
+      FileUtils.mkdir_p(spec_dir)
+
+      file_name = "#{feature_name.underscore}_serializer_spec.rb"
+      file_path = File.join(spec_dir, file_name)
+
+      return "  Skipping serializer spec (already exists)" if File.exist?(file_path)
+
+      File.write(file_path, serializer_spec_template(feature_name))
+      puts "  Created spec/serializers/#{file_name}"
+      file_path
+    end
+
+    def self.find_rails_app_path
+      path = Dir.pwd
+      10.times do
+        return path if File.exist?(File.join(path, "config", "application.rb"))
+        parent = File.dirname(path)
+        break if parent == path
+        path = parent
+      end
+      nil
+    end
+
+    # Templates
+    def self.service_template(feature_name)
+      <<~RUBY
+        # Service class for #{feature_name}
+        # Encapsulates business logic
+        #
+        # Usage:
+        #   result = #{feature_name}Service.call(params)
+        #
+        # @example Basic service
+        #   class Create#{feature_name}Service
+        #     def initialize(#{feature_name.underscore}_params)
+        #       @#{feature_name.underscore}_params = #{feature_name.underscore}_params
+        #     end
+        #
+        #     def call
+        #       #{feature_name}.create!(@#{feature_name.underscore}_params)
+        #     end
+        #   end
+        class #{feature_name}Service
+          def initialize(#{feature_name.underscore}_params = {})
+            @params = #{feature_name.underscore}_params
+          end
+
+          def call
+            # TODO: Implement service logic
+          end
+        end
+      RUBY
+    end
+
+    def self.query_template(feature_name)
+      <<~RUBY
+        # Query class for #{feature_name}
+        # Encapsulates database queries
+        #
+        # Usage:
+        #   result = #{feature_name}Query.call
+        #   result = #{feature_name}Query.call(scope: #{feature_name}.active)
+        class Find#{feature_name}
+          def initialize(scope: nil)
+            @scope = scope || #{feature_name}.all
+          end
+
+          def call
+            # TODO: Implement query logic
+            @scope
+          end
+        end
+      RUBY
+    end
+
+    def self.form_template(feature_name)
+      <<~RUBY
+        # Form class for #{feature_name}
+        # Encapsulates form validation logic
+        #
+        # Usage:
+        #   form = #{feature_name}Form.new(params)
+        #   if form.valid?
+        #     form.save
+        #   end
+        class #{feature_name}Form
+          include ActiveModel::Model
+
+          attr_accessor :#{feature_name.underscore}_attributes
+
+          validate :validate_#{feature_name.underscore}
+
+          def save
+            return false unless valid?
+
+            # TODO: Implement save logic
+            true
+          end
+
+          private
+
+          def validate_#{feature_name.underscore}
+            # TODO: Add validations
+          end
+        end
+      RUBY
+    end
+
+    def self.presenter_template(feature_name)
+      <<~RUBY
+        # Presenter class for #{feature_name}
+        # Handles view presentation logic
+        #
+        # Usage:
+        #   presenter = #{feature_name}Presenter.new(@#{feature_name.underscore})
+        #   presenter.display_name
+        class #{feature_name}Presenter
+          def initialize(#{feature_name.underscore})
+            @#{feature_name.underscore} = #{feature_name.underscore}
+          end
+
+          # TODO: Add presenter methods
+        end
+      RUBY
+    end
+
+    def self.policy_template(feature_name)
+      <<~RUBY
+        # Policy class for #{feature_name}
+        # Handles authorization logic
+        #
+        # Usage:
+        #   authorize #{feature_name.underscore}
+        #   policy_scope(#{feature_name.underscore})
+        class #{feature_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 new?
+            create?
+          end
+
+          def update?
+            user.present?
+          end
+
+          def edit?
+            update?
+          end
+
+          def destroy?
+            user.present?
+          end
+
+          class Scope
+            def initialize(user, scope)
+              @user = user
+              @scope = scope
+            end
+
+            def resolve
+              scope.all
+            end
+
+            private
+
+            attr_reader :user, :scope
+          end
+        end
+      RUBY
+    end
+
+    def self.serializer_template(feature_name)
+      <<~RUBY
+        # Serializer class for #{feature_name}
+        # Handles JSON serialization
+        #
+        # Usage:
+        #   render json: #{feature_name}Serializer.new(#{feature_name.underscore})
+        class #{feature_name}Serializer < ApplicationSerializer
+          attributes :id
+
+          # TODO: Add custom methods
+        end
+      RUBY
+    end
+
+    # Spec templates
+    def self.service_spec_template(feature_name)
+      <<~RUBY
+        require 'rails_helper'
+
+        RSpec.describe #{feature_name}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
+      RUBY
+    end
+
+    def self.query_spec_template(feature_name)
+      <<~RUBY
+        require 'rails_helper'
+
+        RSpec.describe Find#{feature_name} do
+          let(:scope) { #{feature_name}.all }
+          subject { described_class.new(scope: scope) }
+
+          describe '#call' do
+            it 'returns scope' do
+              expect(subject.call).to eq(scope)
+            end
+          end
+        end
+      RUBY
+    end
+
+    def self.form_spec_template(feature_name)
+      <<~RUBY
+        require 'rails_helper'
+
+        RSpec.describe #{feature_name}Form do
+          let(:params) { {} }
+          subject { described_class.new(#{feature_name.underscore}_params: params) }
+
+          describe '#valid?' do
+            it 'is valid with valid params' do
+              expect(subject.valid?).to be_truthy
+            end
+          end
+
+          describe '#save' do
+            it 'saves successfully' do
+              expect(subject.save).to be_truthy
+            end
+          end
+        end
+      RUBY
+    end
+
+    def self.presenter_spec_template(feature_name)
+      <<~RUBY
+        require 'rails_helper'
+
+        RSpec.describe #{feature_name}Presenter do
+          let(:#{feature_name.underscore}) { #{feature_name}.new }
+          subject { described_class.new(#{feature_name.underscore}) }
+
+          describe 'initialization' do
+            it 'initializes successfully' do
+              expect(subject).to be_a(described_class)
+            end
+          end
+        end
+      RUBY
+    end
+
+    def self.policy_spec_template(feature_name)
+      <<~RUBY
+        require 'rails_helper'
+
+        RSpec.describe #{feature_name}Policy do
+          let(:user) { nil }
+          let(:record) { #{feature_name}.new }
+          subject { described_class.new(user, record) }
+
+          describe '#index?' do
+            it 'allows everyone' do
+              expect(subject.index?).to be_truthy
+            end
+          end
+
+          describe '#show?' do
+            it 'allows everyone' do
+              expect(subject.show?).to be_truthy
+            end
+          end
+
+          describe '#create?' do
+            it 'requires user' do
+              expect(subject.create?).to be_falsey
+            end
+
+            it 'allows authenticated user' do
+              user = User.new
+              expect(described_class.new(user, record).create?).to be_truthy
+            end
+          end
+
+          describe 'Scope' do
+            let(:scope) { #{feature_name}.all }
+            subject { described_class::Scope.new(user, scope) }
+
+            describe '#resolve' do
+              it 'returns all records' do
+                expect(subject.resolve).to eq(scope.all)
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    def self.serializer_spec_template(feature_name)
+      <<~RUBY
+        require 'rails_helper'
+
+        RSpec.describe #{feature_name}Serializer do
+          let(:#{feature_name.underscore}) { #{feature_name}.new }
+          subject { described_class.new(#{feature_name.underscore}) }
+
+          describe 'serialization' do
+            it 'includes id' do
+              expect(subject.as_json[:id]).to eq(#{feature_name.underscore}.id)
+            end
+          end
+        end
+      RUBY
+    end
+  end
+end