rider-kick 0.0.13 → 0.0.14

data/lib/generators/rider_kick/factory_generator.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'active_support/inflector'
+require 'faker'
+require_relative 'base_generator'
+require_relative '../../rider-kick'
+
+module RiderKick
+  class FactoryGenerator < BaseGenerator
+    source_root File.expand_path('templates', __dir__)
+
+    argument :arg_model_name, type: :string, banner: 'Models::Article'
+    argument :arg_scope, type: :hash, default: {}, banner: 'scope:core'
+    class_option :engine, type: :string, default: nil, desc: 'Specify engine name (e.g., Core, Admin)'
+    class_option :static, type: :boolean, default: false, desc: 'Generate static values instead of Faker calls'
+
+    def generate_factory
+      configure_engine
+      setup_variables
+      generate_factory_file
+    end
+
+    private
+
+    def setup_variables
+      @model_name = arg_model_name
+      validate_model_exists!(@model_name)
+      @model_class = @model_name.constantize
+      @variable_subject = @model_name.split('::').last.underscore.downcase
+      @factory_name = @variable_subject
+      @scope_path = arg_scope.fetch('scope', '').to_s.downcase
+
+      # Get all columns excluding those we want to skip
+      @attributes = @model_class.columns.reject do |column|
+        skip_column?(column.name)
+      end
+    rescue ModelNotFoundError => e
+      say "Error: #{e.message}", :red
+      raise
+    end
+
+    def skip_column?(column_name)
+      # Skip id, timestamps, and all foreign key columns (ending with _id)
+      ['id', 'created_at', 'updated_at', 'type'].include?(column_name) ||
+        column_name.end_with?('_id')
+    end
+
+    def generate_factory_file
+      factory_dir = if @scope_path.present?
+        File.join('spec', 'factories', @scope_path)
+      else
+        File.join('spec', 'factories')
+      end
+
+      empty_directory factory_dir unless Dir.exist?(factory_dir)
+
+      factory_file_path = File.join(factory_dir, "#{@factory_name}.rb")
+      template 'spec/factories/factory.rb.tt', factory_file_path
+
+      say "Factory created: #{factory_file_path}", :green
+    end
+
+    def generate_faker_value(column)
+      faker_expression = get_faker_expression(column)
+
+      # Time-based columns always use Time.zone.now, even with --static
+      if is_time_column?(column)
+        faker_expression
+      elsif options[:static]
+        evaluate_faker_expression(faker_expression)
+      else
+        faker_expression
+      end
+    end
+
+    def is_time_column?(column)
+      ['datetime', 'timestamp', 'time'].include?(column.type.to_s)
+    end
+
+    def get_faker_expression(column)
+      case column.type.to_s
+      when 'string'
+        if column.name.include?('email')
+          'Faker::Internet.email'
+        elsif column.name.include?('name')
+          'Faker::Name.name'
+        elsif column.name.include?('phone')
+          'Faker::PhoneNumber.phone_number'
+        elsif column.name.include?('address')
+          'Faker::Address.full_address'
+        elsif column.name.include?('city')
+          'Faker::Address.city'
+        elsif column.name.include?('country')
+          'Faker::Address.country'
+        elsif column.name.include?('url') || column.name.include?('website')
+          'Faker::Internet.url'
+        elsif column.name.include?('title')
+          'Faker::Lorem.sentence(word_count: 3)'
+        elsif column.name.include?('code')
+          'Faker::Alphanumeric.alphanumeric(number: 10)'
+        else
+          'Faker::Lorem.word'
+        end
+      when 'text'
+        if column.name.include?('description') || column.name.include?('content') || column.name.include?('body')
+          'Faker::Lorem.paragraph(sentence_count: 3)'
+        else
+          'Faker::Lorem.sentence'
+        end
+      when 'integer'
+        if column.name.include?('count') || column.name.include?('quantity')
+          'Faker::Number.between(from: 1, to: 100)'
+        elsif column.name.include?('age')
+          'Faker::Number.between(from: 18, to: 80)'
+        elsif column.name.include?('price') || column.name.include?('amount')
+          'Faker::Number.between(from: 1000, to: 1000000)'
+        else
+          'Faker::Number.number(digits: 5)'
+        end
+      when 'bigint'
+        'Faker::Number.number(digits: 10)'
+      when 'float'
+        'Faker::Number.decimal(l_digits: 2, r_digits: 2)'
+      when 'decimal'
+        if column.name.include?('price') || column.name.include?('amount')
+          'Faker::Commerce.price'
+        else
+          'Faker::Number.decimal(l_digits: 4, r_digits: 2)'
+        end
+      when 'boolean'
+        '[true, false].sample'
+      when 'date'
+        'Faker::Date.between(from: 1.year.ago, to: Date.today)'
+      when 'datetime', 'timestamp', 'time'
+        'Time.zone.now'
+      when 'uuid'
+        'SecureRandom.uuid'
+      when 'json', 'jsonb'
+        '{ key: Faker::Lorem.word, value: Faker::Lorem.sentence }'
+      when 'inet'
+        'Faker::Internet.ip_v4_address'
+      when 'cidr'
+        'Faker::Internet.ip_v4_cidr'
+      when 'macaddr'
+        'Faker::Internet.mac_address'
+      else
+        # Default fallback
+        'Faker::Lorem.word'
+      end
+    end
+
+    def evaluate_faker_expression(expression)
+      # Safely evaluate the Faker expression using whitelist mapping
+      result = safe_evaluate_faker_expression(expression)
+      format_static_value(result)
+    rescue => e
+      say "Warning: Could not evaluate '#{expression}': #{e.message}", :yellow
+      expression # Fallback to original expression if evaluation fails
+    end
+
+    def safe_evaluate_faker_expression(expression)
+      # Check custom FakerMapping registry first
+      custom_mapping = RiderKick::FakerMapping.get(expression)
+      return custom_mapping.call if custom_mapping
+
+      # Whitelist mapping for safe Faker expression evaluation
+      faker_methods = {
+        'Faker::Internet.email'                                    => -> { Faker::Internet.email },
+        'Faker::Name.name'                                         => -> { Faker::Name.name },
+        'Faker::PhoneNumber.phone_number'                          => -> { Faker::PhoneNumber.phone_number },
+        'Faker::Address.full_address'                              => -> { Faker::Address.full_address },
+        'Faker::Address.city'                                      => -> { Faker::Address.city },
+        'Faker::Address.country'                                   => -> { Faker::Address.country },
+        'Faker::Internet.url'                                      => -> { Faker::Internet.url },
+        'Faker::Lorem.sentence(word_count: 3)'                     => -> { Faker::Lorem.sentence(word_count: 3) },
+        'Faker::Alphanumeric.alphanumeric(number: 10)'             => -> { Faker::Alphanumeric.alphanumeric(number: 10) },
+        'Faker::Lorem.word'                                        => -> { Faker::Lorem.word },
+        'Faker::Lorem.paragraph(sentence_count: 3)'                => -> { Faker::Lorem.paragraph(sentence_count: 3) },
+        'Faker::Lorem.sentence'                                    => -> { Faker::Lorem.sentence },
+        'Faker::Number.between(from: 1, to: 100)'                  => -> { Faker::Number.between(from: 1, to: 100) },
+        'Faker::Number.between(from: 18, to: 80)'                  => -> { Faker::Number.between(from: 18, to: 80) },
+        'Faker::Number.between(from: 1000, to: 1000000)'           => -> { Faker::Number.between(from: 1000, to: 1_000_000) },
+        'Faker::Number.number(digits: 5)'                          => -> { Faker::Number.number(digits: 5) },
+        'Faker::Number.number(digits: 10)'                         => -> { Faker::Number.number(digits: 10) },
+        'Faker::Number.decimal(l_digits: 2, r_digits: 2)'          => -> { Faker::Number.decimal(l_digits: 2, r_digits: 2) },
+        'Faker::Commerce.price'                                    => -> { Faker::Commerce.price },
+        'Faker::Number.decimal(l_digits: 4, r_digits: 2)'          => -> { Faker::Number.decimal(l_digits: 4, r_digits: 2) },
+        '[true, false].sample'                                     => -> { [true, false].sample },
+        'Faker::Date.between(from: 1.year.ago, to: Date.today)'    => -> { Faker::Date.between(from: 1.year.ago, to: Date.today) },
+        'Time.zone.now'                                            => -> { Time.zone.now },
+        'SecureRandom.uuid'                                        => -> { SecureRandom.uuid },
+        '{ key: Faker::Lorem.word, value: Faker::Lorem.sentence }' => -> { { key: Faker::Lorem.word, value: Faker::Lorem.sentence } },
+        'Faker::Internet.ip_v4_address'                            => -> { Faker::Internet.ip_v4_address },
+        'Faker::Internet.ip_v4_cidr'                               => -> { Faker::Internet.ip_v4_cidr },
+        'Faker::Internet.mac_address'                              => -> { Faker::Internet.mac_address }
+      }
+
+      # Check if expression is in whitelist
+      if faker_methods.key?(expression)
+        faker_methods[expression].call
+      else
+        # Fallback: try to parse simple expressions
+        # Handle expressions with parameters (basic parsing)
+        case expression
+        when /^Faker::(\w+)\.(\w+)$/
+          # Simple Faker::Module.method format
+          module_name = Regexp.last_match(1)
+          method_name = Regexp.last_match(2)
+          faker_module = Faker.const_get(module_name)
+          faker_module.public_send(method_name)
+        else
+          # If not in whitelist and can't parse, raise error
+          raise ArgumentError, "Expression '#{expression}' is not in the safe whitelist"
+        end
+      end
+    end
+
+    def format_static_value(value)
+      case value
+      when String
+        "'#{value.gsub("'", "\\\\'")}'"
+      when Numeric
+        value.to_s
+      when TrueClass, FalseClass
+        value.to_s
+      when Date
+        "'#{value}'"
+      when Time, DateTime
+        "'#{value.strftime('%Y-%m-%d %H:%M:%S')}'"
+      when Hash
+        value.inspect
+      else
+        value.inspect
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/factory_generator_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'tmpdir'
+require 'generators/rider_kick/factory_generator'
+
+RSpec.describe 'rider_kick:factory generator' do
+  let(:klass) { RiderKick::FactoryGenerator }
+
+  it 'generates factory with proper format' do
+    # Stub the model class
+    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('user_id', :integer),
+          Struct.new(:name, :type).new('published', :boolean),
+          Struct.new(:name, :type).new('created_at', :datetime),
+          Struct.new(:name, :type).new('updated_at', :datetime)
+        ]
+      end
+    end)
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        FileUtils.mkdir_p('spec/factories/core')
+
+        instance = klass.new(['Models::Article', { 'scope' => 'core' }])
+        instance.generate_factory
+
+        factory_file = File.join('spec/factories/core/article.rb')
+        expect(File.exist?(factory_file)).to be true
+
+        content = File.read(factory_file)
+        expect(content).to include('factory :article')
+        expect(content).to include("class: 'Models::Article'")
+        expect(content).to include('title')
+        expect(content).to include('content')
+        expect(content).to include('published')
+        expect(content).not_to include('user_id')
+        expect(content).not_to include('created_at')
+        expect(content).not_to include('updated_at')
+      end
+    end
+  end
+
+  it 'skips all foreign key columns ending with _id' do
+    stub_const('Models', Module.new)
+    stub_const('Models::Comment', Class.new do
+      def self.columns
+        [
+          Struct.new(:name, :type).new('id', :integer),
+          Struct.new(:name, :type).new('body', :text),
+          Struct.new(:name, :type).new('user_id', :integer),
+          Struct.new(:name, :type).new('post_id', :integer),
+          Struct.new(:name, :type).new('author_id', :integer),
+          Struct.new(:name, :type).new('created_at', :datetime),
+          Struct.new(:name, :type).new('updated_at', :datetime)
+        ]
+      end
+    end)
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        FileUtils.mkdir_p('spec/factories')
+
+        instance = klass.new(['Models::Comment'])
+        instance.generate_factory
+
+        factory_file = File.join('spec/factories/comment.rb')
+        content = File.read(factory_file)
+
+        expect(content).to include('body')
+        expect(content).not_to include('user_id')
+        expect(content).not_to include('post_id')
+        expect(content).not_to include('author_id')
+      end
+    end
+  end
+
+  it 'raises error when model not found' do
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        instance = klass.new(['Models::NonExistent'])
+        expect { instance.generate_factory }
+          .to raise_error(RiderKick::ModelNotFoundError)
+      end
+    end
+  end
+
+  it 'generates factory with static values when --static option is used' do
+    stub_const('Models', Module.new)
+    stub_const('Models::User', Class.new do
+      def self.columns
+        [
+          Struct.new(:name, :type).new('id', :integer),
+          Struct.new(:name, :type).new('full_name', :string),
+          Struct.new(:name, :type).new('email', :string),
+          Struct.new(:name, :type).new('age', :integer),
+          Struct.new(:name, :type).new('active', :boolean),
+          Struct.new(:name, :type).new('created_at', :datetime),
+          Struct.new(:name, :type).new('updated_at', :datetime)
+        ]
+      end
+    end)
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        FileUtils.mkdir_p('spec/factories')
+
+        instance = klass.new(['Models::User'], {}, {})
+        instance.options = { static: true }
+        instance.generate_factory
+
+        factory_file = File.join('spec/factories/user.rb')
+        content = File.read(factory_file)
+
+        expect(content).to include('full_name')
+        expect(content).to include('email')
+        expect(content).to include('age')
+        expect(content).to include('active')
+        # Static values should be quoted strings or literal values, not Faker calls
+        expect(content).not_to include('Faker::')
+        # Should contain actual static values
+        expect(content).to match(/full_name \{ '[^']+' \}/)
+        expect(content).to match(/email \{ '[^']+@[^']+' \}/)
+      end
+    end
+  end
+
+  it 'keeps Time.zone.now for time fields even with --static option' do
+    stub_const('Models', Module.new)
+    stub_const('Models::Event', 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('start_time', :datetime),
+          Struct.new(:name, :type).new('end_time', :timestamp),
+          Struct.new(:name, :type).new('reminder_time', :time),
+          Struct.new(:name, :type).new('created_at', :datetime),
+          Struct.new(:name, :type).new('updated_at', :datetime)
+        ]
+      end
+    end)
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        FileUtils.mkdir_p('spec/factories')
+
+        instance = klass.new(['Models::Event'], {}, {})
+        instance.options = { static: true }
+        instance.generate_factory
+
+        factory_file = File.join('spec/factories/event.rb')
+        content = File.read(factory_file)
+
+        # Title should be static
+        expect(content).to match(/title \{ '[^']+' \}/)
+
+        # Time fields should NOT be static, should remain Time.zone.now
+        expect(content).to include('start_time { Time.zone.now }')
+        expect(content).to include('end_time { Time.zone.now }')
+        expect(content).to include('reminder_time { Time.zone.now }')
+
+        # Should not contain static datetime strings
+        expect(content).not_to match(/start_time \{ '[0-9]{4}-[0-9]{2}-[0-9]{2}/)
+        expect(content).not_to match(/end_time \{ '[0-9]{4}-[0-9]{2}-[0-9]{2}/)
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/repositories_contract_spec.rb

@@ -4,22 +4,21 @@
 require 'rails/generators'
 require 'tmpdir'
 require 'fileutils'
-require 'ostruct'
 require 'generators/rider_kick/scaffold_generator'
 
 RSpec.describe 'repositories scaffolded content' do
   let(:klass) { RiderKick::ScaffoldGenerator }
 
-  it 'memuat filter resource_owner + pagination + (opsional) search_able' do
+  it 'memuat filter resource_owner + pagination + (opsional) search_able ketika resource_owner_id ada di contract' do
     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
+        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'
         ]
         File.write('app/models/models/user.rb', "class Models::User < ApplicationRecord; end\n")
         File.write('db/structures/users_structure.yaml', <<~YAML)
@@ -27,35 +26,109 @@ RSpec.describe 'repositories scaffolded content' do
           resource_name: users
           actor: owner
           resource_owner_id: owner_id
+          resource_owner: owner
           uploaders: []
           search_able: [name]
           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: { skipped_fields: [id, created_at, updated_at] }
+            action_list:
+              use_case:
+                contract:
+                  - "required(:owner_id).filled(:string)"
+            action_fetch_by_id:
+              use_case:
+                contract:
+                  - "required(:owner_id).filled(:string)"
+            action_create:
+              use_case:
+                contract: []
+            action_update:
+              use_case:
+                contract:
+                  - "required(:owner_id).filled(:string)"
+            action_destroy:
+              use_case:
+                contract:
+                  - "required(:owner_id).filled(:string)"
+          entity: { db_attributes: [id, created_at, updated_at] }
         YAML
 
         klass.new(['users']).generate_use_case
 
-        list_repo = File.read('app/domains/core/repositories/users/list_user.rb')
-        expect(list_repo).to match(/resource_owner_id|owner_id|account_id/i) # salah satu pola filter kepemilikan
+        list_repo = File.read(RiderKick.configuration.domains_path + '/repositories/users/list_user.rb')
+        expect(list_repo).to match(/\.where\(owner_id: @params\.owner_id\)/) # filter resource_owner_id digunakan
         expect(list_repo).to match(/paginate|per_page|page/i)                # pagination hook
         expect(list_repo).to match(/name|search/i)                           # search_able minimal
 
-        fetch_repo = File.read('app/domains/core/repositories/users/fetch_user_by_id.rb')
-        expect(fetch_repo).to match(/find_by|where\(.+id:/i)
+        fetch_repo = File.read(RiderKick.configuration.domains_path + '/repositories/users/fetch_user_by_id.rb')
+        expect(fetch_repo).to match(/find_by\(id: @id, owner_id: @params\.owner_id\)/)
 
-        create_repo = File.read('app/domains/core/repositories/users/create_user.rb')
-        update_repo = File.read('app/domains/core/repositories/users/update_user.rb')
-        destroy_repo = File.read('app/domains/core/repositories/users/destroy_user.rb')
+        create_repo = File.read(RiderKick.configuration.domains_path + '/repositories/users/create_user.rb')
+        update_repo = File.read(RiderKick.configuration.domains_path + '/repositories/users/update_user.rb')
+        destroy_repo = File.read(RiderKick.configuration.domains_path + '/repositories/users/destroy_user.rb')
 
         # repos utama terbentuk & memanggil ActiveRecord target
         [create_repo, update_repo, destroy_repo].each do |src|
           expect(src).to include('Models::User')
         end
+
+        # Update dan destroy harus punya filter karena ada di contract
+        expect(update_repo).to match(/find_by\(id: @id, owner_id: @params\.owner_id\)/)
+        expect(destroy_repo).to match(/find_by\(id: @id, owner_id: @params\.owner_id\)/)
+      end
+    end
+  end
+
+  it 'tidak memuat filter resource_owner ketika resource_owner_id tidak ada di contract' 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'
+        ]
+        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: owner_id
+          resource_owner: owner
+          uploaders: []
+          search_able: [name]
+          domains:
+            action_list:
+              use_case:
+                contract: []
+                # owner_id TIDAK ADA di 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']).generate_use_case
+
+        list_repo = File.read(RiderKick.configuration.domains_path + '/repositories/users/list_user.rb')
+        expect(list_repo).not_to match(/\.where\(owner_id:/) # filter resource_owner_id TIDAK digunakan
+        expect(list_repo).to match(/resources = Models::User\s*$/) # langsung query tanpa filter
+        expect(list_repo).to match(/paginate|per_page|page/i)     # pagination hook tetap ada
+        expect(list_repo).to match(/name|search/i)                # search_able minimal
+
+        fetch_repo = File.read(RiderKick.configuration.domains_path + '/repositories/users/fetch_user_by_id.rb')
+        expect(fetch_repo).to match(/find_by\(id: @id\)/) # tanpa filter owner_id
+        expect(fetch_repo).not_to match(/find_by\(id: @id, owner_id:/)
       end
     end
   end