rider-kick 0.0.13 → 0.0.14

data/lib/generators/rider_kick/clean_arch_generator_engine_spec.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'tmpdir'
+require 'fileutils'
+require 'generators/rider_kick/clean_arch_generator'
+
+RSpec.describe 'rider_kick:clean_arch generator with engine option' do
+  let(:klass) { RiderKick::CleanArchGenerator }
+
+  context 'without --engine option (main app)' do
+    it 'uses main app models path when no engine specified' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          FileUtils.mkdir_p('config')
+          File.write('Gemfile', "source 'https://rubygems.org'\n")
+
+          # Reset configuration untuk test
+          RiderKick.configuration.engine_name = nil
+
+          instance = klass.new([])
+          opts = double('options', setup: true)
+          allow(opts).to receive(:[]).and_return(nil)
+          allow(opts).to receive(:[]).with(:engine).and_return(nil)
+          allow(opts).to receive(:[]).with(:quiet).and_return(false)
+          allow(instance).to receive(:options).and_return(opts)
+
+          # Hanya test setup_domain_structure yang relevan dengan engine configuration
+          allow(instance).to receive(:copy_domain_file) # Skip template yang memerlukan Rails
+          allow(instance).to receive(:setup_initializers) # Skip initializers yang memerlukan Rails
+          allow(instance).to receive(:setup_dotenv)
+          allow(instance).to receive(:setup_gitignore)
+          allow(instance).to receive(:setup_rubocop)
+          allow(instance).to receive(:setup_init_migration)
+          allow(instance).to receive(:setup_active_storage)
+          allow(instance).to receive(:setup_rspec)
+          allow(instance).to receive(:setup_readme)
+          allow(instance).to receive(:create_gem_dependencies)
+          allow(instance).to receive(:run)
+
+          instance.setup_configuration
+
+          # Verifikasi models_path menggunakan main app
+          expect(RiderKick.configuration.models_path).to eq('app/models/models')
+          expect(RiderKick.configuration.engine_name).to be_nil
+        end
+      end
+    end
+  end
+
+  context 'with --engine option' do
+    it 'uses engine models path when engine specified' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          FileUtils.mkdir_p('config')
+          File.write('Gemfile', "source 'https://rubygems.org'\n")
+
+          # Reset configuration untuk test
+          RiderKick.configuration.engine_name = nil
+
+          instance = klass.new([])
+          opts = double('options', setup: true)
+          allow(opts).to receive(:[]).and_return(nil)
+          allow(opts).to receive(:[]).with(:engine).and_return('Core')
+          allow(opts).to receive(:[]).with(:quiet).and_return(false)
+          allow(instance).to receive(:options).and_return(opts)
+
+          # Hanya test setup_domain_structure yang relevan dengan engine configuration
+          allow(instance).to receive(:copy_domain_file) # Skip template yang memerlukan Rails
+          allow(instance).to receive(:setup_initializers) # Skip initializers yang memerlukan Rails
+          allow(instance).to receive(:setup_dotenv)
+          allow(instance).to receive(:setup_gitignore)
+          allow(instance).to receive(:setup_rubocop)
+          allow(instance).to receive(:setup_init_migration)
+          allow(instance).to receive(:setup_active_storage)
+          allow(instance).to receive(:setup_rspec)
+          allow(instance).to receive(:setup_readme)
+          allow(instance).to receive(:create_gem_dependencies)
+          allow(instance).to receive(:run)
+
+          instance.setup_configuration
+
+          # Verifikasi models_path menggunakan engine
+          expect(RiderKick.configuration.models_path).to eq('engines/core/app/models/core/models')
+          expect(RiderKick.configuration.engine_name).to eq('Core')
+          expect(RiderKick.configuration.domain_scope).to eq('core/')
+        end
+      end
+    end
+
+    it 'creates models directory with correct engine path' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          FileUtils.mkdir_p('config')
+          File.write('Gemfile', "source 'https://rubygems.org'\n")
+
+          # Reset configuration untuk test
+          RiderKick.configuration.engine_name = nil
+
+          instance = klass.new([])
+          opts = double('options', setup: true)
+          allow(opts).to receive(:[]).and_return(nil)
+          allow(opts).to receive(:[]).with(:engine).and_return('Admin')
+          allow(opts).to receive(:[]).with(:quiet).and_return(false)
+          allow(instance).to receive(:options).and_return(opts)
+
+          # Hanya test setup_domain_structure yang relevan dengan engine configuration
+          allow(instance).to receive(:copy_domain_file) # Skip template yang memerlukan Rails
+          allow(instance).to receive(:setup_initializers) # Skip initializers yang memerlukan Rails
+          allow(instance).to receive(:setup_dotenv)
+          allow(instance).to receive(:setup_gitignore)
+          allow(instance).to receive(:setup_rubocop)
+          allow(instance).to receive(:setup_init_migration)
+          allow(instance).to receive(:setup_active_storage)
+          allow(instance).to receive(:setup_rspec)
+          allow(instance).to receive(:setup_readme)
+          allow(instance).to receive(:create_gem_dependencies)
+          allow(instance).to receive(:run)
+
+          instance.setup_configuration
+
+          # Verifikasi directory models dibuat dengan path engine
+          expect(Dir.exist?('engines/admin/app/models/admin')).to be true
+          expect(RiderKick.configuration.models_path).to eq('engines/admin/app/models/admin/models')
+          expect(RiderKick.configuration.domain_scope).to eq('admin/')
+        end
+      end
+    end
+  end
+
+  context 'domain scope default behavior' do
+    it 'uses empty domain scope as default' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Reset configuration to defaults
+          RiderKick.configuration.engine_name = nil
+          RiderKick.configuration.domain_scope = ''
+
+          # Mock the domain_class_name method to return predictable result
+          generator = klass.new([])
+          allow(generator).to receive(:domain_class_name).and_return('MyApp')
+
+          expect(RiderKick.configuration.domain_scope).to eq('')
+          expect(RiderKick.configuration.domains_path).to eq('app/domains/')
+        end
+      end
+    end
+
+    it 'generates class names with app name for empty domain scope in main app' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Create minimal Rails app structure for testing
+          FileUtils.mkdir_p('app/domains')
+
+          # Reset configuration
+          RiderKick.configuration.engine_name = nil
+          RiderKick.configuration.domain_scope = ''
+
+          instance = klass.new([])
+          opts = double('options', setup: true)
+          allow(opts).to receive(:[]).and_return(nil)
+          allow(opts).to receive(:[]).with(:engine).and_return(nil)
+          allow(opts).to receive(:[]).with(:quiet).and_return(false)
+          allow(instance).to receive(:options).and_return(opts)
+
+          # Mock methods to avoid actual file generation
+          allow(instance).to receive(:setup_domain_structure)
+          allow(instance).to receive(:setup_initializers)
+          allow(instance).to receive(:setup_dotenv)
+          allow(instance).to receive(:setup_gitignore)
+          allow(instance).to receive(:setup_rubocop)
+          allow(instance).to receive(:setup_active_storage)
+          allow(instance).to receive(:setup_rspec)
+          allow(instance).to receive(:setup_readme)
+          allow(instance).to receive(:create_gem_dependencies)
+          allow(instance).to receive(:setup_init_migration)
+          allow(instance).to receive(:setup_models)
+          allow(instance).to receive(:say)
+
+          # Test domain_class_name method
+          expect(instance.send(:domain_class_name)).to eq('MyApp')
+
+          # Test configuration paths
+          expect(RiderKick.configuration.domains_path).to eq('app/domains/')
+          expect(RiderKick.configuration.models_path).to eq('app/models/models')
+        end
+      end
+    end
+
+    it 'generates class names with engine name for engine with default domain scope' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Create minimal engine structure for testing
+          FileUtils.mkdir_p('engines/admin/lib/admin/engine.rb')
+
+          # Reset configuration
+          RiderKick.configuration.engine_name = 'Admin'
+          RiderKick.configuration.domain_scope = 'admin/' # Engine-prefixed domain scope
+
+          instance = klass.new([])
+          opts = double('options', setup: true)
+          allow(opts).to receive(:[]).and_return(nil)
+          allow(opts).to receive(:[]).with(:engine).and_return('Admin')
+          allow(opts).to receive(:[]).with(:quiet).and_return(false)
+          allow(instance).to receive(:options).and_return(opts)
+
+          # Mock methods to avoid actual file generation
+          allow(instance).to receive(:setup_domain_structure)
+          allow(instance).to receive(:setup_initializers)
+          allow(instance).to receive(:setup_dotenv)
+          allow(instance).to receive(:setup_gitignore)
+          allow(instance).to receive(:setup_rubocop)
+          allow(instance).to receive(:setup_active_storage)
+          allow(instance).to receive(:setup_rspec)
+          allow(instance).to receive(:setup_readme)
+          allow(instance).to receive(:create_gem_dependencies)
+          allow(instance).to receive(:setup_init_migration)
+          allow(instance).to receive(:setup_models)
+          allow(instance).to receive(:say)
+
+          # Test domain_class_name method for engine with empty domain scope
+          expect(instance.send(:domain_class_name)).to eq('Admin')
+
+          # Test configuration paths
+          expect(RiderKick.configuration.domains_path).to eq('engines/admin/app/domains/admin/')
+          expect(RiderKick.configuration.models_path).to eq('engines/admin/app/models/admin/models')
+        end
+      end
+    end
+
+    it 'generates class names with engine and domain for scoped domain in engine' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Create minimal engine structure for testing
+          FileUtils.mkdir_p('engines/admin/lib/admin/engine.rb')
+
+          # Reset configuration
+          RiderKick.configuration.engine_name = 'Admin'
+          RiderKick.configuration.domain_scope = 'admin/core/' # Engine-prefixed
+
+          instance = klass.new([])
+          opts = double('options', setup: true)
+          allow(opts).to receive(:[]).and_return(nil)
+          allow(opts).to receive(:[]).with(:engine).and_return('Admin')
+          allow(opts).to receive(:[]).with(:domain).and_return('core/')
+          allow(opts).to receive(:[]).with(:quiet).and_return(false)
+          allow(instance).to receive(:options).and_return(opts)
+
+          # Mock methods to avoid actual file generation
+          allow(instance).to receive(:setup_domain_structure)
+          allow(instance).to receive(:setup_initializers)
+          allow(instance).to receive(:setup_dotenv)
+          allow(instance).to receive(:setup_gitignore)
+          allow(instance).to receive(:setup_rubocop)
+          allow(instance).to receive(:setup_active_storage)
+          allow(instance).to receive(:setup_rspec)
+          allow(instance).to receive(:setup_readme)
+          allow(instance).to receive(:create_gem_dependencies)
+          allow(instance).to receive(:setup_init_migration)
+          allow(instance).to receive(:setup_models)
+          allow(instance).to receive(:say)
+
+          # Test domain_class_name method for engine with domain
+          expect(instance.send(:domain_class_name)).to eq('Admin::Core')
+
+          # Test domain_class_name_for_application_record method
+          expect(instance.send(:domain_class_name_for_application_record)).to eq('Admin')
+
+          # Test configuration paths - when both engine and domain specified, structure goes to engine domains
+          expect(RiderKick.configuration.domains_path).to eq('engines/admin/app/domains/admin/core/')
+          expect(RiderKick.configuration.models_path).to eq('engines/admin/app/models/admin/models')
+        end
+      end
+    end
+
+    it 'creates domains structure in engine when both engine and domain are specified during setup' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Create minimal Rails app structure for testing
+          FileUtils.mkdir_p('app/domains')
+
+          # Reset configuration
+          RiderKick.configuration.engine_name = 'MyEngine'
+          RiderKick.configuration.domain_scope = 'admin/'
+
+          instance = klass.new([])
+          opts = double('options', setup: true)
+          allow(opts).to receive(:[]).and_return(nil)
+          allow(opts).to receive(:[]).with(:engine).and_return('MyEngine')
+          allow(opts).to receive(:[]).with(:domain).and_return('admin/')
+          allow(opts).to receive(:[]).with(:quiet).and_return(false)
+          allow(instance).to receive(:options).and_return(opts)
+
+          # Mock methods to avoid actual file generation
+          allow(instance).to receive(:setup_domain_structure)
+          allow(instance).to receive(:setup_initializers)
+          allow(instance).to receive(:setup_dotenv)
+          allow(instance).to receive(:setup_gitignore)
+          allow(instance).to receive(:setup_rubocop)
+          allow(instance).to receive(:setup_active_storage)
+          allow(instance).to receive(:setup_rspec)
+          allow(instance).to receive(:setup_readme)
+          allow(instance).to receive(:create_gem_dependencies)
+          allow(instance).to receive(:setup_init_migration)
+          allow(instance).to receive(:setup_models)
+          allow(instance).to receive(:say)
+
+          # Test domain_class_name method for engine with domain
+          expect(instance.send(:domain_class_name)).to eq('MyEngine::Admin')
+
+          # Test configuration paths - should create structure in engine domains
+          expect(RiderKick.configuration.domains_path).to eq('engines/my_engine/app/domains/admin/')
+          expect(RiderKick.configuration.models_path).to eq('engines/my_engine/app/models/my_engine/models')
+        end
+      end
+    end
+
+    it 'generates ApplicationRecord class name for main app' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Create minimal Rails app structure for testing
+          FileUtils.mkdir_p('app/domains')
+
+          # Reset configuration
+          RiderKick.configuration.engine_name = nil
+          RiderKick.configuration.domain_scope = ''
+
+          instance = klass.new([])
+          opts = double('options', setup: true)
+          allow(opts).to receive(:[]).and_return(nil)
+          allow(opts).to receive(:[]).with(:engine).and_return(nil)
+          allow(opts).to receive(:[]).with(:quiet).and_return(false)
+          allow(instance).to receive(:options).and_return(opts)
+
+          # Mock methods to avoid actual file generation
+          allow(instance).to receive(:setup_domain_structure)
+          allow(instance).to receive(:setup_initializers)
+          allow(instance).to receive(:setup_dotenv)
+          allow(instance).to receive(:setup_gitignore)
+          allow(instance).to receive(:setup_rubocop)
+          allow(instance).to receive(:setup_active_storage)
+          allow(instance).to receive(:setup_rspec)
+          allow(instance).to receive(:setup_readme)
+          allow(instance).to receive(:create_gem_dependencies)
+          allow(instance).to receive(:setup_init_migration)
+          allow(instance).to receive(:setup_models)
+          allow(instance).to receive(:say)
+
+          # Test domain_class_name_for_application_record method for main app
+          expect(instance.send(:domain_class_name_for_application_record)).to eq('')
+
+          # Test configuration paths
+          expect(RiderKick.configuration.domains_path).to eq('app/domains/')
+          expect(RiderKick.configuration.models_path).to eq('app/models/models')
+        end
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/clean_arch_generator_factory_bot_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'tmpdir'
+require 'fileutils'
+require 'generators/rider_kick/clean_arch_generator'
+
+RSpec.describe 'rider_kick:clean_arch generator (FactoryBot & Faker setup)' do
+  let(:klass) { RiderKick::CleanArchGenerator }
+
+  it 'sets up FactoryBot and Faker with proper directory structure and configuration' do
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        # Setup minimal Rails structure
+        FileUtils.mkdir_p('config')
+        FileUtils.mkdir_p('spec')
+        File.write('Gemfile', "source 'https://rubygems.org'\n")
+
+        instance = klass.new([])
+        opts = double('options', setup: true)
+        allow(opts).to receive(:[]).and_return(nil)
+        allow(opts).to receive(:[]).with(:setup).and_return(true)
+        allow(opts).to receive(:[]).with(:engine).and_return(nil)
+        allow(opts).to receive(:[]).with(:quiet).and_return(false)
+        allow(instance).to receive(:options).and_return(opts)
+
+        # Skip other setup methods
+        allow(instance).to receive(:copy_domain_file)
+        allow(instance).to receive(:setup_initializers)
+        allow(instance).to receive(:setup_dotenv)
+        allow(instance).to receive(:setup_gitignore)
+        allow(instance).to receive(:setup_rubocop)
+        allow(instance).to receive(:setup_init_migration)
+        allow(instance).to receive(:setup_models)
+        allow(instance).to receive(:setup_active_storage)
+        allow(instance).to receive(:setup_readme)
+        allow(instance).to receive(:run)
+
+        # Call setup methods
+        instance.send(:setup_domain_structure)
+        instance.send(:setup_rspec)
+
+        # Verify FactoryBot directory structure
+        expect(Dir.exist?('spec/factories')).to be true
+
+        # Verify FactoryBot support file
+        factory_bot_support = 'spec/support/factory_bot.rb'
+        expect(File.exist?(factory_bot_support)).to be true
+
+        factory_bot_content = File.read(factory_bot_support)
+        expect(factory_bot_content).to include('FactoryBot::Syntax::Methods')
+        expect(factory_bot_content).to include('config.include FactoryBot::Syntax::Methods')
+        expect(factory_bot_content).to include('sequence :email')
+        expect(factory_bot_content).to include('sequence :uuid')
+
+        # Verify Faker support file
+        faker_support = 'spec/support/faker.rb'
+        expect(File.exist?(faker_support)).to be true
+
+        faker_content = File.read(faker_support)
+        expect(faker_content).to include('Faker::Config')
+        expect(faker_content).to include('module FakerHelpers')
+        expect(faker_content).to include('def self.random_phone')
+        expect(faker_content).to include('def self.random_address')
+        expect(faker_content).to include('def self.random_url')
+        expect(faker_content).to include('config.include FakerHelpers')
+
+        # Verify .gitkeep file
+        gitkeep = 'spec/factories/.gitkeep'
+        expect(File.exist?(gitkeep)).to be true
+
+        gitkeep_content = File.read(gitkeep)
+        expect(gitkeep_content).to include('FactoryBot.define')
+        expect(gitkeep_content).to include('Example:')
+
+        # Verify rails_helper includes
+        rails_helper = 'spec/rails_helper.rb'
+        expect(File.exist?(rails_helper)).to be true
+
+        rails_helper_content = File.read(rails_helper)
+        expect(rails_helper_content).to include("Dir[Rails.root.join('spec', 'support', '**', '*.rb')].sort.each { |f| require f }")
+        expect(rails_helper_content).to include('config.include FactoryBot::Syntax::Methods')
+        expect(rails_helper_content).to include('config.include FakerHelpers')
+      end
+    end
+  end
+
+  it 'generates Gemfile with correct dependencies' do
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        FileUtils.mkdir_p('config')
+        File.write('Gemfile', <<~GEMFILE)
+          source 'https://rubygems.org'
+
+          group :development, :test do
+          end
+        GEMFILE
+
+        instance = klass.new([])
+        opts = double('options', setup: true)
+        allow(opts).to receive(:[]).and_return(nil)
+        allow(opts).to receive(:[]).with(:setup).and_return(true)
+        allow(opts).to receive(:[]).with(:engine).and_return(nil)
+        allow(opts).to receive(:[]).with(:quiet).and_return(false)
+        allow(instance).to receive(:options).and_return(opts)
+
+        # Skip validation and other setup methods
+        allow(instance).to receive(:validate_setup_option)
+        allow(instance).to receive(:setup_configuration)
+        allow(instance).to receive(:run)
+
+        # Only run create_gem_dependencies
+        instance.create_gem_dependencies
+
+        gemfile_content = File.read('Gemfile')
+
+        # Verify gems are added in correct group
+        expect(gemfile_content).to include('group :development, :test do')
+        expect(gemfile_content).to include('gem "rspec-rails"')
+        expect(gemfile_content).to include('gem "factory_bot_rails"')
+        expect(gemfile_content).to include('gem "faker"')
+        expect(gemfile_content).to include('gem "shoulda-matchers"')
+
+        # Verify other gems
+        expect(gemfile_content).to include("gem 'dotenv-rails'")
+        expect(gemfile_content).to include("gem 'hashie'")
+        expect(gemfile_content).to include("gem 'pagy'")
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/entity_type_mapping_spec.rb

@@ -4,22 +4,26 @@
 require 'rails/generators'
 require 'tmpdir'
 require 'fileutils'
-require 'ostruct'
 require 'generators/rider_kick/scaffold_generator'
 
 RSpec.describe 'entity type mapping' do
   let(:klass) { RiderKick::ScaffoldGenerator }
 
   it 'memetakan kolom ke Types::Strict yang benar' do
+    # Store original configuration
+    original_engine = RiderKick.configuration.engine_name
+    original_domain = RiderKick.configuration.domain_scope
+
     Dir.mktmpdir do |dir|
       Dir.chdir(dir) do
-        FileUtils.mkdir_p %w[
-          app/domains/core/use_cases
-          app/domains/core/repositories
-          app/domains/core/builders
-          app/domains/core/entities
-          app/models/models
-          db/structures
+        # Reset configuration for this test
+        RiderKick.configuration.engine_name = nil
+        RiderKick.configuration.domain_scope = 'core/'
+
+        FileUtils.mkdir_p [
+          RiderKick.configuration.domains_path,
+          'app/models/models',
+          'db/structures'
         ]
 
         # pakai stub shared Models::User dari spec/support (sudah auto-require)
@@ -28,7 +32,9 @@ RSpec.describe 'entity type mapping' do
           model: Models::User
           resource_name: users
           actor: owner
-          uploaders: []
+          resource_owner_id: account_id
+          resource_owner: account
+          uploaders: [{ name: 'avatar', type: 'single' }]
           search_able: []
           domains:
             action_list:        { use_case: { contract: [] } }
@@ -36,17 +42,20 @@ RSpec.describe 'entity type mapping' do
             action_create:      { use_case: { contract: [] } }
             action_update:      { use_case: { contract: [] } }
             action_destroy:     { use_case: { contract: [] } }
-          entity: { skipped_fields: [id, created_at, updated_at] }
+            entity: { db_attributes: ['id', 'name', 'price', 'created_at', 'updated_at'] }
         YAML
 
         klass.new(['users']).generate_use_case
 
-        entity = File.read('app/domains/core/entities/user.rb')
-        # harapannya: string, decimal, datetime dipetakan ke Strict
+        entity = File.read(RiderKick.configuration.domains_path + '/entities/user.rb')
+        # harapannya: string, datetime dipetakan ke Strict
         expect(entity).to match(/Types::Strict::String/)
-        expect(entity).to match(/Types::Strict::Decimal|Types::Coercible::Decimal/)
         expect(entity).to match(/Types::Strict::Time|Types::Strict::Date|Types::Strict::DateTime/)
       end
+    ensure
+      # Restore original configuration
+      RiderKick.configuration.engine_name = original_engine
+      RiderKick.configuration.domain_scope = original_domain
     end
   end
 end

data/lib/generators/rider_kick/errors.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RiderKick
+  # Base error class for all generator errors
+  class GeneratorError < StandardError
+    attr_reader :context
+
+    def initialize(message, context = {})
+      super(message)
+      @context = context
+    end
+
+    def to_s
+      if @context.any?
+        context_str = @context.map { |k, v| "#{k}: #{v}" }.join(', ')
+        "#{super} (#{context_str})"
+      else
+        super
+      end
+    end
+  end
+
+  # Error raised when validation fails
+  class ValidationError < GeneratorError
+  end
+
+  # Error raised when configuration is invalid
+  class ConfigurationError < GeneratorError
+  end
+
+  # Error raised when a model is not found
+  class ModelNotFoundError < GeneratorError
+  end
+
+  # Error raised when a file is not found
+  class FileNotFoundError < GeneratorError
+  end
+
+  # Error raised when YAML format is invalid
+  class YamlFormatError < GeneratorError
+  end
+end