railsforge 1.0.0

data/lib/railsforge/generators/test_generator.rb

@@ -0,0 +1,289 @@
+# Test generator for RailsForge
+# Generates comprehensive test files for any Rails component
+
+require 'fileutils'
+
+module RailsForge
+  module Generators
+    # Test generator
+    class TestGenerator < BaseGenerator
+      # Initialize the generator
+      def initialize(name = "test", options = {})
+        super(name, options)
+        @component_type = options[:type] || "model"
+        @spec_path = options[:spec_path] || "spec"
+      end
+
+      # Generate test files
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        results = []
+        results << generate_factory
+        results << generate_spec
+        results << generate_integration_spec if @component_type == "feature"
+
+        results.join("\n")
+      end
+
+      private
+
+      # Generate factory file
+      def generate_factory
+        factories_dir = File.join(@base_path, "spec", "factories")
+        FileUtils.mkdir_p(factories_dir)
+
+        factory_path = File.join(factories_dir, "#{@name.underscore.pluralize}.rb")
+        return "Factory already exists" if File.exist?(factory_path)
+
+        content = <<~RUBY
+          # Factory for #{@name.titleize}
+          FactoryBot.define do
+            factory :#{@name.underscore} do
+          #{factory_attributes}
+            end
+          end
+        RUBY
+
+        File.write(factory_path, content)
+        "Created spec/factories/#{@name.underscore.pluralize}.rb"
+      end
+
+      # Generate model spec
+      def generate_spec
+        spec_dir = File.join(@base_path, @spec_path, "models")
+        FileUtils.mkdir_p(spec_dir)
+
+        spec_path = File.join(spec_dir, "#{@name.underscore}_spec.rb")
+        return "Spec already exists" if File.exist?(spec_path)
+
+        content = case @component_type
+        when "model"
+          model_spec
+        when "controller"
+          controller_spec
+        when "service"
+          service_spec
+        when "job"
+          job_spec
+        else
+          generic_spec
+        end
+
+        File.write(spec_path, content)
+        "Created spec/models/#{@name.underscore}_spec.rb"
+      end
+
+      # Generate integration/feature spec
+      def generate_integration_spec
+        spec_dir = File.join(@base_path, @spec_path, "features")
+        FileUtils.mkdir_p(spec_dir)
+
+        spec_path = File.join(spec_dir, "#{@name.underscore}_spec.rb")
+        return "Feature spec already exists" if File.exist?(spec_path)
+
+        content = feature_spec
+        File.write(spec_path, content)
+        "Created spec/features/#{@name.underscore}_spec.rb"
+      end
+
+      # Model spec template
+      def model_spec
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{@name}, type: :model do
+            describe 'associations' do
+              it { should have_many(:related) }
+              it { should belong_to(:owner) }
+            end
+
+            describe 'validations' do
+              it { should validate_presence_of(:name) }
+              it { should validate_uniqueness_of(:slug).scoped_to(:tenant) }
+            end
+
+            describe 'scopes' do
+              describe '.active' do
+                it 'returns only active records' do
+                  active = create(:#{@name.underscore}, status: 'active')
+                  create(:#{@name.underscore}, status: 'inactive')
+                  expect(described_class.active).to include(active)
+                end
+              end
+            end
+
+            describe '#activate!' do
+              it 'sets status to active' do
+                record = create(:#{@name.underscore}, status: 'inactive')
+                record.activate!
+                expect(record.status).to eq('active')
+              end
+            end
+
+            describe '#to_s' do
+              it 'returns the name' do
+                record = build(:#{@name.underscore}, name: 'Test Name')
+                expect(record.to_s).to eq('Test Name')
+              end
+            end
+          end
+        RUBY
+      end
+
+      # Controller spec template
+      def controller_spec
+        controller_name = "#{@name.underscore.pluralize}_controller"
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{@name.pluralize}Controller, type: :controller do
+            let(:user) { create(:user) }
+            let(:#{@name.underscore}) { create(:#{@name.underscore}) }
+
+            before { sign_in user }
+
+            describe 'GET #index' do
+              it 'returns a success response' do
+                get :index
+                expect(response).to be_successful
+              end
+
+              it 'assigns all #{@name.underscore.pluralize}' do
+                get :index
+                expect(assigns(:#{@name.underscore.pluralize})).to include(#{@name.underscore})
+              end
+            end
+
+            describe 'GET #show' do
+              it 'returns a success response' do
+                get :show, params: { id: #{@name.underscore}.id }
+                expect(response).to be_successful
+              end
+            end
+
+            describe 'POST #create' do
+              context 'with valid params' do
+                let(:valid_attributes) { attributes_for(:#{@name.underscore}) }
+
+                it 'creates a new #{@name}' do
+                  expect {
+                    post :create, params: { #{@name.underscore}: valid_attributes }
+                  }.to change(described_class, :count).by(1)
+                end
+
+                it 'redirects to the created #{@name}' do
+                  post :create, params: { #{@name.underscore}: valid_attributes }
+                  expect(response).to redirect_to(#{@name.underscore}.id)
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      # Service spec template
+      def service_spec
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{@name}Service do
+            let(:service) { described_class.new(params) }
+            let(:params) { { id: 1 } }
+
+            describe '#call' do
+              context 'with valid params' do
+                it 'returns success' do
+                  result = service.call
+                  expect(result).to be_success
+                end
+              end
+
+              context 'with invalid params' do
+                let(:params) { {} }
+
+                it 'returns failure' do
+                  result = service.call
+                  expect(result).to be_failure
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      # Job spec template
+      def job_spec
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{@name}Job, type: :job do
+            let(:args) { { user_id: 1 } }
+
+            describe '#perform' do
+              it 'executes the job' do
+                expect {
+                  described_class.new.perform(args)
+                }.not_to raise_error
+              end
+            end
+
+            describe '.perform_later' do
+              it 'enqueues the job' do
+                ActiveJob::Base.queue_adapter = :test
+                expect {
+                  described_class.perform_later(args)
+                }.to have_enqueued_job(described_class)
+              end
+            end
+          end
+        RUBY
+      end
+
+      # Generic spec template
+      def generic_spec
+        <<~RUBY
+          require 'rails_helper'
+
+          RSpec.describe #{@name} do
+            it 'has valid factory' do
+              expect(build(:#{@name.underscore})).to be_valid
+            end
+          end
+        RUBY
+      end
+
+      # Feature spec template
+      def feature_spec
+        <<~RUBY
+          require 'rails_helper'
+
+          feature '#{@name.titleize} Management' do
+            scenario 'user creates a new #{@name.underscore}' do
+              user = create(:user)
+              sign_in user
+
+              visit new_#{@name.underscore}_path
+              fill_in 'Name', with: 'Test #{@name}'
+              click_button 'Create'
+
+              expect(page).to have_content('Test #{@name}')
+            end
+          end
+        RUBY
+      end
+
+      # Factory attributes
+      def factory_attributes
+        case @component_type
+        when "user"
+          "sequence(:email) { |n| \"user#{n}@example.com\" }\n      password { 'password123' }\n      name { 'Test User' }"
+        when "post"
+          "title { 'Test Post' }\n      body { 'Post content' }\n      author { create(:user) }"
+        else
+          "sequence(:name) { |n| \"#{@name} #{n}\" }"
+        end
+      end
+    end
+  end
+end

data/lib/railsforge/generators/view_component_generator.rb

@@ -0,0 +1,169 @@
+# ViewComponent generator for RailsForge
+# Generates ViewComponent files
+
+require 'fileutils'
+
+module RailsForge
+  module Generators
+    # ViewComponent generator
+    class ViewComponentGenerator < BaseGenerator
+      # Template version
+      TEMPLATE_VERSION = "v1"
+
+      # Initialize the generator
+      # @param name [String] Component name
+      # @param options [Hash] Generator options
+      def initialize(name, options = {})
+        super(name, options)
+        validate_name!
+      end
+
+      # Generate ViewComponent files
+      # @return [String] Success message
+      def generate
+        return "Not in a Rails application directory" unless @base_path
+
+        results = []
+        results << generate_component
+        results << generate_template if with_template?
+        results << generate_spec if with_spec?
+
+        results.join("\n")
+      end
+
+      private
+
+      # Validate component name
+      def validate_name!
+        validate_name!(@name, /\A[A-Z][a-zA-Z0-9]*\z/, InvalidNameError)
+      end
+
+      # Get template version
+      def template_version
+        @options[:template_version] || TEMPLATE_VERSION
+      end
+
+      # Check if should generate template
+      def with_template?
+        @options[:template] != false
+      end
+
+      # Check if should generate spec
+      def with_spec?
+        @options[:spec] != false
+      end
+
+      # Generate the component Ruby file
+      def generate_component
+        component_dir = File.join(@base_path, "app", "components")
+        FileUtils.mkdir_p(component_dir)
+
+        file_name = "#{underscore}.rb"
+        file_path = File.join(component_dir, file_name)
+
+        return "Skipping component (already exists)" if File.exist?(file_path)
+
+        # Try to load template
+        template_content = load_template
+        content = apply_template(template_content)
+
+        File.write(file_path, content)
+        "Created app/components/#{file_name}"
+      end
+
+      # Generate the component template ERB file
+      def generate_template
+        template_dir = File.join(@base_path, "app", "components", underscore)
+        FileUtils.mkdir_p(template_dir)
+
+        file_name = "#{underscore}.html.erb"
+        file_path = File.join(template_dir, file_name)
+
+        return "Skipping template (already exists)" if File.exist?(file_path)
+
+        content = <<~ERB
+          <div class="#{underscore}">
+            <%% if title? %>
+              <h2><%%= @title %></h2>
+            <%% end %>
+            <%%= content %>
+          </div>
+        ERB
+
+        File.write(file_path, content)
+        "Created app/components/#{underscore}/#{file_name}"
+      end
+
+      # Generate the component spec
+      def generate_spec
+        spec_dir = File.join(@base_path, "spec", "components")
+        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 = <<~RUBY
+          # frozen_string_literal: true
+
+          require "rails_helper"
+
+          RSpec.describe #{camelize}, type: :component do
+            let(:options) { { title: "Test" } }
+
+            it "renders successfully" do
+              render_inline(described_class.new(**options))
+
+              expect(page).to have_content("Test")
+            end
+          end
+        RUBY
+
+        File.write(file_path, content)
+        "Created spec/components/#{file_name}"
+      end
+
+      # Load template content
+      def load_template
+        template_path = File.join(
+          File.dirname(__FILE__),
+          "..",
+          "templates",
+          template_version,
+          "view_component",
+          "template.rb"
+        )
+
+        if File.exist?(template_path)
+          File.read(template_path)
+        else
+          default_template
+        end
+      end
+
+      # Default template content
+      def default_template
+        <<~RUBY
+          class <%= class_name %> < ViewComponent::Base
+            def initialize(title: "", classes: "")
+              @title = title
+              @classes = classes
+            end
+
+            def title?
+              @title.present?
+            end
+          end
+        RUBY
+      end
+
+      # Apply template variables
+      def apply_template(content)
+        content
+          .gsub("<%= class_name %>", camelize)
+          .gsub("<%= underscore_name %>", underscore)
+      end
+    end
+  end
+end