rider-kick 0.0.12 → 0.0.14

data/lib/generators/rider_kick/scaffold_generator_contracts_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'tmpdir'
+require 'active_support/inflector'
+
+require 'fileutils'
+require 'generators/rider_kick/scaffold_generator'
+
+RSpec.describe 'rider_kick:scaffold contracts' do
+  let(:klass) { RiderKick::ScaffoldGenerator }
+
+  it 'menulis kontrak schema yang tepat di use_cases (list/fetch_by_id/create/update/destroy)' do
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        # Set domain scope to core for this test
+        RiderKick.configuration.domain_scope = 'core/'
+
+        FileUtils.mkdir_p([
+                            RiderKick.configuration.domains_path + '/core/use_cases',
+                            RiderKick.configuration.domains_path + '/core/repositories',
+                            RiderKick.configuration.domains_path + '/core/builders',
+                            RiderKick.configuration.domains_path + '/core/entities',
+                            'app/models/models',
+                            'db/structures'
+                          ])
+
+        # Stub model & kolom
+        Object.send(:remove_const, :Models) if Object.const_defined?(:Models)
+        Object.send(:remove_const, :Column) if Object.const_defined?(:Column)
+        module Models; end
+
+        Column = Struct.new(:name, :type, :sql_type, :null, :default, :precision, :scale, :limit)
+        class Models::User
+          def self.columns
+            [
+              Column.new('id', :uuid),
+              Column.new('created_at', :datetime),
+              Column.new('updated_at', :datetime)
+            ]
+          end
+
+          def self.columns_hash
+            columns.to_h { |c| [c.name.to_s, Struct.new(:type).new(c.type)] }
+          end
+
+          def self.column_names
+            columns.map { |c| c.name.to_s }
+          end
+        end
+
+        File.write('app/models/models/user.rb', "class Models::User < ApplicationRecord; end\n")
+
+        # YAML struktur minimal
+        File.write('db/structures/users_structure.yaml', <<~YAML)
+          model: Models::User
+          resource_name: users
+          actor: owner
+          resource_owner_id: account_id
+          resource_owner: account
+          uploaders: []
+          search_able: []
+          domains:
+            action_list:        { use_case: { contract: [] } }
+            action_fetch_by_id: { use_case: { contract: [] } }
+            action_create:      { use_case: { contract: [] } }
+            action_update:      { use_case: { contract: [] } }
+            action_destroy:     { use_case: { contract: [] } }
+          entity: { db_attributes: [id, created_at, updated_at] }
+        YAML
+
+        # Generate
+        klass.new(['users']).generate_use_case
+
+        # Cek isi kontrak
+        readf = ->(path) { File.read(File.join(path)) }
+        base  = RiderKick.configuration.domains_path + '/use_cases/users'
+
+        expect(readf["#{base}/owner_list_user.rb"])
+          .to include('Core::UseCases::Contract::Default', 'Contract::Pagination')
+
+        expect(readf["#{base}/owner_fetch_user_by_id.rb"])
+          .to include('required(:id).filled(:string)')
+
+        expect(readf["#{base}/owner_create_user.rb"])
+          .to include('Core::Repositories::Users::CreateUser')
+
+        expect(readf["#{base}/owner_update_user.rb"])
+          .to include('required(:id).filled(:string)')
+
+        expect(readf["#{base}/owner_destroy_user.rb"])
+          .to include('required(:id).filled(:string)')
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/scaffold_generator_contracts_with_scope_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'tmpdir'
+require 'active_support/inflector'
+
+require 'fileutils'
+require 'generators/rider_kick/scaffold_generator'
+
+RSpec.describe 'rider_kick:scaffold contracts (with scope)' do
+  let(:klass) { RiderKick::ScaffoldGenerator }
+
+  it 'menaruh use_cases di folder scope yang benar & menulis kontrak sesuai' do
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        # Set domain scope to core for this test
+        RiderKick.configuration.domain_scope = 'core/'
+
+        FileUtils.mkdir_p([
+                            RiderKick.configuration.domains_path + '/core/use_cases',
+                            RiderKick.configuration.domains_path + '/core/repositories',
+                            RiderKick.configuration.domains_path + '/core/builders',
+                            RiderKick.configuration.domains_path + '/core/entities',
+                            'app/models/models',
+                            'db/structures'
+                          ])
+
+        # Stub model & kolom
+        Object.send(:remove_const, :Models) if Object.const_defined?(:Models)
+        Object.send(:remove_const, :Column) if Object.const_defined?(:Column)
+        module Models; end
+
+        Column = Struct.new(:name, :type, :sql_type, :null, :default, :precision, :scale, :limit)
+        class Models::User
+          def self.columns
+            [
+              Column.new('id', :uuid),
+              Column.new('created_at', :datetime),
+              Column.new('updated_at', :datetime)
+            ]
+          end
+
+          def self.columns_hash
+            columns.to_h { |c| [c.name.to_s, Struct.new(:type).new(c.type)] }
+          end
+
+          def self.column_names
+            columns.map { |c| c.name.to_s }
+          end
+        end
+
+        File.write('app/models/models/user.rb', "class Models::User < ApplicationRecord; end\n")
+
+        File.write('db/structures/users_structure.yaml', <<~YAML)
+          model: Models::User
+          resource_name: users
+          actor: owner
+          resource_owner_id: account_id
+          resource_owner: account
+          uploaders: []
+          search_able: []
+          domains:
+            action_list:        { use_case: { contract: [] } }
+            action_fetch_by_id: { use_case: { contract: [] } }
+            action_create:      { use_case: { contract: [] } }
+            action_update:      { use_case: { contract: [] } }
+            action_destroy:     { use_case: { contract: [] } }
+          entity: { db_attributes: [id, created_at, updated_at] }
+        YAML
+
+        klass.new(['users', 'scope:dashboard']).generate_use_case
+
+        base = RiderKick.configuration.domains_path + '/use_cases/dashboard/users'
+        ['owner_list_user', 'owner_fetch_user_by_id', 'owner_create_user', 'owner_update_user', 'owner_destroy_user'].each do |uc|
+          expect(File).to exist("#{base}/#{uc}.rb")
+        end
+
+        expect(File.read("#{base}/owner_list_user.rb"))
+          .to include('Core::UseCases::Dashboard::Users::OwnerListUser')
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/scaffold_generator_engine_spec.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'tmpdir'
+require 'fileutils'
+require 'generators/rider_kick/scaffold_generator'
+
+RSpec.describe 'rider_kick:scaffold generator with engine option' do
+  let(:klass) { RiderKick::ScaffoldGenerator }
+
+  context 'without --engine option (main app)' do
+    it 'uses main app models path (app/models/models)' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          FileUtils.mkdir_p([
+                              RiderKick.configuration.domains_path + '/core/use_cases',
+                              RiderKick.configuration.domains_path + '/core/repositories',
+                              RiderKick.configuration.domains_path + '/core/builders',
+                              RiderKick.configuration.domains_path + '/core/entities',
+                              'app/models/models',
+                              'db/structures'
+                            ])
+
+          # Stub model & kolom
+          Object.send(:remove_const, :Models) if Object.const_defined?(:Models)
+          Object.send(:remove_const, :Column) if Object.const_defined?(:Column)
+          module Models; end
+
+          Column = Struct.new(:name, :type, :sql_type, :null, :default, :precision, :scale, :limit)
+          class Models::User
+            def self.columns
+              [
+                Column.new('id', :uuid),
+                Column.new('created_at', :datetime),
+                Column.new('updated_at', :datetime)
+              ]
+            end
+
+            def self.columns_hash
+              columns.to_h { |c| [c.name.to_s, Struct.new(:type).new(c.type)] }
+            end
+
+            def self.column_names
+              columns.map { |c| c.name.to_s }
+            end
+          end
+
+          File.write('app/models/models/user.rb', "class Models::User < ApplicationRecord; end\n")
+          File.write('db/structures/users_structure.yaml', <<~YAML)
+            model: Models::User
+            resource_name: users
+            actor: owner
+            resource_owner_id: account_id
+            resource_owner: account
+            uploaders: []
+            search_able: []
+            domains:
+              action_list:        { use_case: { contract: [] } }
+              action_fetch_by_id: { use_case: { contract: [] } }
+              action_create:      { use_case: { contract: [] } }
+              action_update:      { use_case: { contract: [] } }
+              action_destroy:     { use_case: { contract: [] } }
+            entity: { db_attributes: [id, created_at, updated_at] }
+          YAML
+
+          # Reset configuration untuk test
+          RiderKick.configuration.engine_name = nil
+
+          instance = klass.new(['users'])
+          allow(instance).to receive(:options).and_return({ engine: nil })
+          instance.generate_use_case
+
+          # 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 (engines/<engine_name>/app/models/<engine_name>/models)' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Set configuration for test first
+          RiderKick.configuration.engine_name = 'Core'
+          RiderKick.configuration.domain_scope = 'core/'
+
+          FileUtils.mkdir_p([
+                              RiderKick.configuration.domains_path,
+                              RiderKick.configuration.models_path,
+                              'engines/core/app/models/core',
+                              'engines/core/db/structures'
+                            ])
+
+          # Stub model classes
+          Object.send(:remove_const, :Models) if Object.const_defined?(:Models)
+          Object.send(:remove_const, :Column) if Object.const_defined?(:Column)
+          module Models; end
+
+          module Models::Core; end
+
+          Column = Struct.new(:name, :type, :sql_type, :null, :default, :precision, :scale, :limit)
+          class Models::Core::User
+            def self.columns
+              [
+                Column.new('id', :uuid),
+                Column.new('created_at', :datetime),
+                Column.new('updated_at', :datetime)
+              ]
+            end
+
+            def self.columns_hash
+              columns.to_h { |c| [c.name.to_s, Struct.new(:type).new(c.type)] }
+            end
+
+            def self.column_names
+              columns.map { |c| c.name.to_s }
+            end
+          end
+
+          File.write('engines/core/app/models/core/models/user.rb', "class Models::Core::User < ApplicationRecord; end\n")
+          File.write('engines/core/db/structures/users_structure.yaml', <<~YAML)
+            model: Models::Core::User
+            resource_name: users
+            actor: owner
+            resource_owner_id: account_id
+            resource_owner: account
+            uploaders: []
+            search_able: []
+            domains:
+              action_list:        { use_case: { contract: [] } }
+              action_fetch_by_id: { use_case: { contract: [] } }
+              action_create:      { use_case: { contract: [] } }
+              action_update:      { use_case: { contract: [] } }
+              action_destroy:     { use_case: { contract: [] } }
+            entity: { db_attributes: [id, created_at, updated_at] }
+          YAML
+
+          instance = klass.new(['users'])
+          instance.generate_use_case
+
+          # 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')
+        end
+      end
+    end
+
+    it 'generates files with correct engine configuration' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          # Set configuration for test first
+          RiderKick.configuration.engine_name = 'Admin'
+          RiderKick.configuration.domain_scope = 'admin/core/' # Engine-prefixed
+
+          FileUtils.mkdir_p([
+                              RiderKick.configuration.domains_path,
+                              'app/models/admin',
+                              'engines/admin/db/structures'
+                            ])
+
+          # Stub model classes
+          Object.send(:remove_const, :Models) if Object.const_defined?(:Models)
+          Object.send(:remove_const, :Column) if Object.const_defined?(:Column)
+          module Models; end
+
+          module Models::Admin; end
+
+          Column = Struct.new(:name, :type, :sql_type, :null, :default, :precision, :scale, :limit)
+          class Models::Admin::Product
+            def self.columns
+              [
+                Column.new('id', :uuid),
+                Column.new('created_at', :datetime),
+                Column.new('updated_at', :datetime)
+              ]
+            end
+
+            def self.columns_hash
+              columns.to_h { |c| [c.name.to_s, Struct.new(:type).new(c.type)] }
+            end
+
+            def self.column_names
+              columns.map { |c| c.name.to_s }
+            end
+          end
+
+          File.write('app/models/admin/product.rb', "class Models::Admin::Product < ApplicationRecord; end\n")
+          File.write('engines/admin/db/structures/products_structure.yaml', <<~YAML)
+            model: Models::Admin::Product
+            resource_name: products
+            actor: admin
+            resource_owner_id: account_id
+            resource_owner: account
+            uploaders: []
+            search_able: []
+            domains:
+              action_list:        { use_case: { contract: [] } }
+              action_fetch_by_id: { use_case: { contract: [] } }
+              action_create:      { use_case: { contract: [] } }
+              action_update:      { use_case: { contract: [] } }
+              action_destroy:     { use_case: { contract: [] } }
+            entity: { db_attributes: [id, created_at, updated_at] }
+          YAML
+
+          instance = klass.new(['products'])
+          instance.generate_use_case
+
+          # Verifikasi engine name sudah di-set
+          expect(RiderKick.configuration.engine_name).to eq('Admin')
+          expect(RiderKick.configuration.models_path).to eq('engines/admin/app/models/admin/models')
+
+          # Verifikasi files ter-generate
+          expect(File).to exist(RiderKick.configuration.domains_path + '/builders/product.rb')
+          expect(File).to exist(RiderKick.configuration.domains_path + '/entities/product.rb')
+        end
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/scaffold_generator_idempotent_spec.rb

@@ -0,0 +1,84 @@
+# lib/generators/rider_kick/scaffold_generator_idempotent_spec.rb
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'tmpdir'
+require 'fileutils'
+
+require 'generators/rider_kick/scaffold_generator'
+
+RSpec.describe 'rider_kick:scaffold generator (idempotent)' do
+  let(:klass) { RiderKick::ScaffoldGenerator }
+
+  it 'tidak menduplikasi konten ketika dijalankan ulang' do
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        # 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'
+        ]
+
+        # Stub model classes
+        Object.send(:remove_const, :Models) if Object.const_defined?(:Models)
+        Object.send(:remove_const, :Column) if Object.const_defined?(:Column)
+        module Models; end
+
+        Column = Struct.new(:name, :type, :sql_type, :null, :default, :precision, :scale, :limit)
+        class Models::User
+          def self.columns
+            [
+              Column.new('id', :uuid),
+              Column.new('created_at', :datetime),
+              Column.new('updated_at', :datetime)
+            ]
+          end
+
+          def self.columns_hash
+            columns.to_h { |c| [c.name.to_s, Struct.new(:type).new(c.type)] }
+          end
+
+          def self.column_names
+            columns.map { |c| c.name.to_s }
+          end
+        end
+
+        # model fisik & YAML minimal
+        File.write('app/models/models/user.rb', "class Models::User < ApplicationRecord; end\n")
+        File.write('db/structures/users_structure.yaml', <<~YAML)
+          model: Models::User
+          resource_name: users
+          actor: owner
+          uploaders: []
+          search_able: []
+          domains:
+            action_list:        { use_case: { contract: [] } }
+            action_fetch_by_id: { use_case: { contract: [] } }
+            action_create:      { use_case: { contract: [] } }
+            action_update:      { use_case: { contract: [] } }
+            action_destroy:     { use_case: { contract: [] } }
+          entity: { db_attributes: [id, created_at, updated_at] }
+        YAML
+
+        # run pertama
+        klass.new(['users']).generate_use_case
+        builder_v1 = File.read(RiderKick.configuration.domains_path + '/builders/user.rb')
+
+        # run kedua (seharusnya idempotent)
+        klass.new(['users']).generate_use_case
+        builder_v2 = File.read(RiderKick.configuration.domains_path + '/builders/user.rb')
+
+        # konten tidak berubah
+        expect(builder_v2).to eq(builder_v1)
+
+        # entity & repositori tetap 1 file masing-masing
+        expect(Dir[RiderKick.configuration.domains_path + '/entities/user.rb'].size).to eq(1)
+        expect(Dir[RiderKick.configuration.domains_path + '/repositories/users/*.rb'].size).to be >= 5
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/scaffold_generator_list_spec_format_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'tmpdir'
+require 'generators/rider_kick/scaffold_generator'
+
+RSpec.describe 'rider_kick:scaffold list spec generation' do
+  let(:klass) { RiderKick::ScaffoldGenerator }
+
+  it 'generates list spec with resource_owner_id' do
+    stub_const('Models', Module.new)
+    stub_const('Models::Article', Class.new do
+      def self.columns
+        [
+          Struct.new(:name, :type).new('id', :integer),
+          Struct.new(:name, :type).new('title', :string),
+          Struct.new(:name, :type).new('content', :text),
+          Struct.new(:name, :type).new('account_id', :string),
+          Struct.new(:name, :type).new('user_id', :integer),
+          Struct.new(:name, :type).new('created_at', :datetime),
+          Struct.new(:name, :type).new('updated_at', :datetime)
+        ]
+      end
+
+      def self.column_names
+        ['id', 'title', 'content', 'account_id', 'user_id', 'created_at', 'updated_at']
+      end
+
+      def self.columns_hash
+        {
+          'title'      => Struct.new(:type).new(:string),
+          'content'    => Struct.new(:type).new(:text),
+          'account_id' => Struct.new(:type).new(:string),
+          'user_id'    => Struct.new(:type).new(:integer)
+        }
+      end
+    end)
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        FileUtils.mkdir_p('app/domains')
+        FileUtils.mkdir_p('db/structures')
+
+        # Create structure YAML
+        structure_yaml = <<~YAML
+          model: Models::Article
+          resource_name: article
+          actor: owner
+          resource_owner_id: account_id
+          domains:
+            action_list:
+              use_case:
+                contract: []
+              repository:
+                filters:
+                  - "{ field: 'title', type: 'search' }"
+        YAML
+
+        File.write('db/structures/articles_structure.yaml', structure_yaml)
+
+        instance = klass.new(['articles', { 'scope' => 'dashboard' }])
+
+        # Mock methods
+        allow(instance).to receive(:say)
+        allow(instance).to receive(:empty_directory)
+        allow(RiderKick.configuration).to receive(:domains_path).and_return('app/domains')
+
+        instance.generate_use_case
+
+        list_spec_file = 'app/domains/repositories/articles/list_article_spec.rb'
+        expect(File.exist?(list_spec_file)).to be true
+
+        content = File.read(list_spec_file)
+
+        # Verify format matches user's requirements
+        expect(content).to include('let(:repository) { described_class }')
+        expect(content).to include('repository.new(params: params).call')
+        expect(content).to include('account_id: SecureRandom.uuid')
+        expect(content).to include('create_list(:article, 3, account_id: params[:account_id])')
+        expect(content).to include('context \'with search filters\'')
+        expect(content).to include('context \'with resource owner filter\'')
+        expect(content).to include('context \'with sorting\'')
+      end
+    end
+  end
+
+  it 'generates list spec without resource_owner_id' do
+    stub_const('Models', Module.new)
+    stub_const('Models::Product', Class.new do
+      def self.columns
+        [
+          Struct.new(:name, :type).new('id', :integer),
+          Struct.new(:name, :type).new('name', :string),
+          Struct.new(:name, :type).new('price', :decimal),
+          Struct.new(:name, :type).new('created_at', :datetime),
+          Struct.new(:name, :type).new('updated_at', :datetime)
+        ]
+      end
+
+      def self.column_names
+        ['id', 'name', 'price', 'created_at', 'updated_at']
+      end
+
+      def self.columns_hash
+        {
+          'name'  => double(type: :string),
+          'price' => double(type: :decimal)
+        }
+      end
+    end)
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        FileUtils.mkdir_p('app/domains')
+        FileUtils.mkdir_p('db/structures')
+
+        structure_yaml = <<~YAML
+          model: Models::Product
+          resource_name: product
+          actor: admin
+          domains:
+            action_list:
+              use_case:
+                contract: []
+              repository:
+                filters: []
+        YAML
+
+        File.write('db/structures/products_structure.yaml', structure_yaml)
+
+        instance = klass.new(['products', { 'scope' => 'admin' }])
+
+        allow(instance).to receive(:say)
+        allow(instance).to receive(:empty_directory)
+        allow(RiderKick.configuration).to receive(:domains_path).and_return('app/domains')
+
+        instance.generate_use_case
+
+        list_spec_file = 'app/domains/repositories/products/list_product_spec.rb'
+        expect(File.exist?(list_spec_file)).to be true
+
+        content = File.read(list_spec_file)
+
+        # Verify format without resource_owner_id
+        expect(content).to include('let(:repository) { described_class }')
+        expect(content).to include('repository.new(params: params).call')
+        expect(content).to include('create_list(:product, 3)')
+        expect(content).not_to include('account_id')
+        expect(content).not_to include('user_id')
+      end
+    end
+  end
+end