rider-kick 0.0.13 → 0.0.15

data/lib/rider_kick/configuration.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+module RiderKick
+  DEFAULT_TYPE_MAPPING = {
+    'uuid'     => ':string',
+    'string'   => ':string',
+    'text'     => ':string',
+    'integer'  => ':integer',
+    'boolean'  => ':bool',
+    'float'    => ':float',
+    'decimal'  => ':decimal',
+    'date'     => ':date',
+    'upload'   => 'Types::File',
+    'datetime' => ':time'
+  }.freeze
+  public_constant :DEFAULT_TYPE_MAPPING
+
+  DEFAULT_ENTITY_TYPE_MAPPING = {
+    'uuid'     => 'Types::Strict::String',
+    'string'   => 'Types::Strict::String',
+    'text'     => 'Types::Strict::String',
+    'integer'  => 'Types::Strict::Integer',
+    'boolean'  => 'Types::Strict::Bool',
+    'float'    => 'Types::Strict::Float',
+    'decimal'  => 'Types::Strict::Decimal',
+    'date'     => 'Types::Strict::Date',
+    'datetime' => 'Types::Strict::Time'
+  }.freeze
+  public_constant :DEFAULT_ENTITY_TYPE_MAPPING
+  # Backward compatibility constants
+  TYPE_MAPPING = DEFAULT_TYPE_MAPPING
+  ENTITY_TYPE_MAPPING = DEFAULT_ENTITY_TYPE_MAPPING
+  public_constant :TYPE_MAPPING
+  public_constant :ENTITY_TYPE_MAPPING
+
+  # Faker mapping registry for factory generator customization
+  class FakerMapping
+    @mappings = {}
+
+    class << self
+      attr_reader :mappings
+
+      def register(expression, &block)
+        @mappings[expression] = block
+      end
+
+      def get(expression)
+        @mappings[expression]
+      end
+
+      def clear
+        @mappings = {}
+      end
+    end
+  end
+
+  class Configuration
+    attr_reader :domains_path, :models_path, :engine_name, :domain_scope, :template_path
+    attr_accessor :entities_path, :adapters_path, :use_cases_dir, :entities_dir, :adapters_dir, :repositories_dir, :builders_dir, :utils_dir
+
+    def initialize
+      @engine_name   = detect_engine_name
+      @domain_scope  = ''
+      @use_cases_dir = 'use_cases'
+      @entities_dir = 'entities'
+      @adapters_dir = 'adapters'
+      @repositories_dir = 'repositories'
+      @builders_dir = 'builders'
+      @utils_dir = 'utils'
+      @domains_path  = detect_domains_path
+      @entities_path = File.join(@domains_path, @entities_dir)
+      @adapters_path = File.join(@domains_path, @adapters_dir)
+      @models_path   = detect_models_path
+      @template_path = nil
+      @type_mapping = DEFAULT_TYPE_MAPPING.dup
+      @entity_type_mapping = DEFAULT_ENTITY_TYPE_MAPPING.dup
+
+      @domains_path_overridden = false
+      @models_path_overridden = false
+    end
+
+    attr_reader :type_mapping
+
+    attr_reader :entity_type_mapping
+
+    def register_type_mapping(db_type, dry_type)
+      @type_mapping[db_type.to_s] = dry_type.to_s
+    end
+
+    def register_entity_type_mapping(db_type, dry_type)
+      @entity_type_mapping[db_type.to_s] = dry_type.to_s
+    end
+
+    def domains_path=(path)
+      validate_path_format!(path, 'domains_path')
+      @domains_path = File.expand_path(path)
+      @entities_path = File.join(@domains_path, @entities_dir)
+      @adapters_path = File.join(@domains_path, @adapters_dir)
+      @domains_path_overridden = true
+    end
+
+    def models_path=(path)
+      validate_path_format!(path, 'models_path')
+      @models_path = File.expand_path(path)
+      @models_path_overridden = true
+    end
+
+    def template_path=(path)
+      if path.nil? || path.to_s.strip.empty?
+        @template_path = nil
+      else
+        validate_path_format!(path, 'template_path')
+        @template_path = File.expand_path(path)
+      end
+    end
+
+    def engine_name=(name)
+      if name.nil? || name.to_s.strip.empty?
+        @engine_name = nil
+      else
+        validate_engine_name_format!(name)
+        @engine_name = name.to_s
+      end
+
+      unless @models_path_overridden
+        @models_path = detect_models_path
+      end
+
+      unless @domains_path_overridden
+        @domains_path = detect_domains_path
+        @entities_path = File.join(@domains_path, 'entities')
+        @adapters_path = File.join(@domains_path, 'adapters')
+      end
+    end
+
+    def domain_scope=(scope)
+      if scope.nil? || scope.to_s.strip.empty?
+        @domain_scope = ''
+      else
+        validate_domain_scope_format!(scope)
+        @domain_scope = scope.to_s
+      end
+
+      unless @domains_path_overridden
+        @domains_path = detect_domains_path
+        @entities_path = File.join(@domains_path, 'entities')
+        @adapters_path = File.join(@domains_path, 'adapters')
+      end
+    end
+
+    private
+
+    def validate_path_format!(path, attribute_name)
+      path_str = path.to_s.strip
+      return if path_str.empty?
+
+      # Basic path validation - should not contain invalid characters
+      if path_str.match?(/[<>:"|?*\x00-\x1f]/)
+        raise RiderKick::ConfigurationError.new(
+                "Invalid #{attribute_name} format: contains invalid characters",
+                attribute: attribute_name,
+                value:     path_str
+        )
+      end
+    end
+
+    def validate_engine_name_format!(name)
+      name_str = name.to_s.strip
+      return if name_str.empty?
+
+      # Engine name can be CamelCase (e.g., 'Core', 'Admin') or underscore_case (e.g., 'order_engine')
+      # Both formats are acceptable and will be converted as needed
+      unless name_str.match?(/^[A-Z][a-zA-Z0-9]*$/) || name_str.match?(/^[a-z][a-z0-9_]*$/)
+        raise RiderKick::ConfigurationError.new(
+                "Invalid engine_name format: must be CamelCase (e.g., 'Core', 'Admin') or underscore_case (e.g., 'order_engine')",
+                attribute:  'engine_name',
+                value:      name_str,
+                suggestion: "Use CamelCase format like 'Core' or 'Admin', or underscore_case like 'order_engine'"
+        )
+      end
+    end
+
+    def validate_domain_scope_format!(scope)
+      scope_str = scope.to_s.strip
+      return if scope_str.empty?
+
+      # Domain scope should contain only alphanumeric, slash, underscore, hyphen
+      unless scope_str.match?(/^[a-zA-Z0-9\/_-]+$/)
+        raise RiderKick::ConfigurationError.new(
+                'Invalid domain_scope format: must contain only alphanumeric characters, slashes, underscores, and hyphens',
+                attribute:  'domain_scope',
+                value:      scope_str,
+                suggestion: "Use format like 'core/', 'admin/', 'api/v1/'"
+        )
+      end
+    end
+
+    def detect_engine_name
+      # Detect engine dari struktur file system
+      # Cek apakah ada lib/<name>/engine.rb
+      return nil unless Dir.exist?('lib')
+
+      engines = []
+      Dir.glob('lib/*/engine.rb').each do |engine_file|
+        engine_name = File.basename(File.dirname(engine_file))
+        engines << engine_name.camelize if File.exist?(engine_file)
+      end
+
+      # Jika hanya ada satu engine, return itu
+      return engines.first if engines.length == 1
+
+      # Jika ada multiple engines, return nil (user harus specify via --engine option)
+      # Atau cek dari gem name di gemspec (fallback)
+      gemspec_files = Dir.glob('*.gemspec')
+      unless gemspec_files.empty?
+        gemspec_content = File.read(gemspec_files.first)
+        if gemspec_content =~ /\.name\s*=\s*["']([^"']+)["']/
+          gem_name = Regexp.last_match(1)
+          # Extract engine name dari gem name (e.g., "my_app-core" -> "Core")
+          engine_name = gem_name.split(/[-_]/).last.camelize
+          return engine_name if Dir.exist?("lib/#{engine_name.underscore}") && engines.include?(engine_name)
+        end
+      end
+
+      nil
+    end
+
+    def detect_models_path
+      if @engine_name
+        # Engine: engines/<engine_name>/app/models/<engine_name>/models
+        File.join('engines', @engine_name.underscore, 'app/models', @engine_name.underscore, 'models')
+      else
+        # Main app: app/models/models
+        'app/models/models'
+      end
+    end
+
+    def detect_domains_path
+      if @engine_name
+        # Engine: engines/<engine_name>/app/domains/<domain_scope>
+        File.join('engines', @engine_name.underscore, 'app/domains', @domain_scope)
+      else
+        # Main app: app/domains/<domain_scope>
+        File.join('app/domains', @domain_scope)
+      end
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/rider_kick/configuration_engine_spec.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+require 'rider_kick/configuration'
+
+RSpec.describe RiderKick::Configuration do
+  describe '#engine_name detection' do
+    it 'returns nil when no engine found' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          FileUtils.mkdir_p('lib')
+          config = RiderKick::Configuration.new
+          expect(config.engine_name).to be_nil
+        end
+      end
+    end
+
+    it 'returns engine name when single engine found' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          FileUtils.mkdir_p('lib/core')
+          File.write('lib/core/engine.rb', 'module Core; class Engine < ::Rails::Engine; end; end')
+
+          config = RiderKick::Configuration.new
+          expect(config.engine_name).to eq('Core')
+        end
+      end
+    end
+
+    it 'returns nil when multiple engines found (requires explicit specification)' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          FileUtils.mkdir_p(['lib/core', 'lib/admin'])
+          File.write('lib/core/engine.rb', 'module Core; class Engine < ::Rails::Engine; end; end')
+          File.write('lib/admin/engine.rb', 'module Admin; class Engine < ::Rails::Engine; end; end')
+
+          config = RiderKick::Configuration.new
+          expect(config.engine_name).to be_nil
+        end
+      end
+    end
+
+    it 'can be set explicitly via engine_name=' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = 'Core'
+          expect(config.engine_name).to eq('Core')
+        end
+      end
+    end
+
+    it 'sets engine_name to nil when given nil' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = 'Core'
+          config.engine_name = nil
+          expect(config.engine_name).to be_nil
+        end
+      end
+    end
+
+    it 'sets engine_name to nil when given empty string' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = ''
+          expect(config.engine_name).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#models_path' do
+    it 'returns app/models/models when no engine' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = nil
+          expect(config.models_path).to eq('app/models/models')
+        end
+      end
+    end
+
+    it 'returns engines/<engine_name>/app/models/<engine_name>/models when engine is set' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = 'Core'
+          expect(config.models_path).to eq('engines/core/app/models/core/models')
+        end
+      end
+    end
+
+    it 'updates models_path when engine_name changes' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+
+          config.engine_name = nil
+          expect(config.models_path).to eq('app/models/models')
+
+          config.engine_name = 'Admin'
+          expect(config.models_path).to eq('engines/admin/app/models/admin/models')
+
+          config.engine_name = nil
+          expect(config.models_path).to eq('app/models/models')
+        end
+      end
+    end
+  end
+
+  describe '#detect_engine_name' do
+    it 'returns nil when lib directory does not exist' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          expect(config.engine_name).to be_nil
+        end
+      end
+    end
+
+    it 'detects engine from gemspec fallback when multiple engines exist' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          FileUtils.mkdir_p(['lib/core', 'lib/admin'])
+          File.write('lib/core/engine.rb', 'module Core; class Engine < ::Rails::Engine; end; end')
+          File.write('lib/admin/engine.rb', 'module Admin; class Engine < ::Rails::Engine; end; end')
+          File.write('test-admin.gemspec', "Gem::Specification.new do |s|\n  s.name = 'test-admin'\nend")
+
+          config = RiderKick::Configuration.new
+          # Should return Admin because gemspec name matches Admin engine
+          # The logic checks if gemspec name matches an existing engine
+          expect(config.engine_name).to eq('Admin')
+        end
+      end
+    end
+
+    it 'detects engine from gemspec fallback when single matching engine' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          FileUtils.mkdir_p('lib/core')
+          File.write('lib/core/engine.rb', 'module Core; class Engine < ::Rails::Engine; end; end')
+          File.write('test-core.gemspec', "Gem::Specification.new do |s|\n  s.name = 'test-core'\nend")
+
+          config = RiderKick::Configuration.new
+          # Should return Core because it matches the gemspec name
+          expect(config.engine_name).to eq('Core')
+        end
+      end
+    end
+  end
+
+  describe '#detect_domains_path' do
+    it 'returns app/domains/<domain_scope> when no engine' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = nil
+          config.domain_scope = 'admin/'
+          expect(config.domains_path).to eq('app/domains/admin/')
+        end
+      end
+    end
+
+    it 'returns engines/<engine_name>/app/domains/<domain_scope> when engine is set' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = 'Core'
+          config.domain_scope = 'admin/'
+          expect(config.domains_path).to eq('engines/core/app/domains/admin/')
+        end
+      end
+    end
+
+    it 'handles empty domain_scope' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = nil
+          config.domain_scope = ''
+          expect(config.domains_path).to eq('app/domains/')
+        end
+      end
+    end
+  end
+
+  describe '#domains_path=' do
+    it 'updates @domains_path with expanded path' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.domains_path = 'custom/path'
+          expect(config.domains_path).to eq(File.expand_path('custom/path'))
+        end
+      end
+    end
+
+    it 'updates @entities_path' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.domains_path = 'custom/path'
+          expect(config.entities_path).to eq(File.join(File.expand_path('custom/path'), 'entities'))
+        end
+      end
+    end
+
+    it 'updates @adapters_path' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.domains_path = 'custom/path'
+          expect(config.adapters_path).to eq(File.join(File.expand_path('custom/path'), 'adapters'))
+        end
+      end
+    end
+  end
+
+  describe '#models_path=' do
+    it 'updates @models_path with expanded path' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.models_path = 'custom/models'
+          expect(config.models_path).to eq(File.expand_path('custom/models'))
+        end
+      end
+    end
+  end
+
+  describe '#engine_name=' do
+    it 'updates paths when engine_name is set' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = 'Core'
+          expect(config.models_path).to eq('engines/core/app/models/core/models')
+          expect(config.domains_path).to eq('engines/core/app/domains/')
+        end
+      end
+    end
+
+    it 'updates entities_path and adapters_path when engine_name is set' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = 'Core'
+          expect(config.entities_path).to eq('engines/core/app/domains/entities')
+          expect(config.adapters_path).to eq('engines/core/app/domains/adapters')
+        end
+      end
+    end
+
+    it 'handles nil' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = 'Core'
+          config.engine_name = nil
+          expect(config.engine_name).to be_nil
+          expect(config.models_path).to eq('app/models/models')
+        end
+      end
+    end
+
+    it 'handles empty string' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = 'Core'
+          config.engine_name = ''
+          expect(config.engine_name).to be_nil
+        end
+      end
+    end
+
+    it 'handles whitespace-only string' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = '   '
+          expect(config.engine_name).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#domain_scope=' do
+    it 'updates domains_path when domain_scope is set' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.domain_scope = 'admin/'
+          expect(config.domains_path).to eq('app/domains/admin/')
+        end
+      end
+    end
+
+    it 'updates entities_path and adapters_path when domain_scope is set' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.domain_scope = 'admin/'
+          expect(config.entities_path).to eq('app/domains/admin/entities')
+          expect(config.adapters_path).to eq('app/domains/admin/adapters')
+        end
+      end
+    end
+
+    it 'handles nil' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.domain_scope = 'admin/'
+          config.domain_scope = nil
+          expect(config.domain_scope).to eq('')
+        end
+      end
+    end
+
+    it 'handles empty string' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.domain_scope = 'admin/'
+          config.domain_scope = ''
+          expect(config.domain_scope).to eq('')
+        end
+      end
+    end
+
+    it 'handles whitespace-only string' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.domain_scope = '   '
+          expect(config.domain_scope).to eq('')
+        end
+      end
+    end
+
+    it 'updates paths correctly with engine and domain_scope' do
+      Dir.mktmpdir do |dir|
+        Dir.chdir(dir) do
+          config = RiderKick::Configuration.new
+          config.engine_name = 'Core'
+          config.domain_scope = 'admin/'
+          expect(config.domains_path).to eq('engines/core/app/domains/admin/')
+          expect(config.entities_path).to eq('engines/core/app/domains/admin/entities')
+          expect(config.adapters_path).to eq('engines/core/app/domains/admin/adapters')
+        end
+      end
+    end
+  end
+
+  describe 'RiderKick.configuration' do
+    it 'returns singleton Configuration instance' do
+      config1 = RiderKick.configuration
+      config2 = RiderKick.configuration
+      expect(config1.object_id).to eq(config2.object_id)
+    end
+  end
+
+  describe 'RiderKick.configure' do
+    it 'yields configuration instance' do
+      RiderKick.configure do |config|
+        expect(config).to be_a(RiderKick::Configuration)
+        config.engine_name = 'TestEngine'
+        expect(config.engine_name).to eq('TestEngine')
+      end
+    end
+  end
+end

data/lib/rider_kick/entities/failure_details.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rider_kick/types'
+require_relative '../types'
 require 'dry/struct'
 
 module RiderKick

data/lib/rider_kick/entities/failure_details_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe RiderKick::Entities::FailureDetails do
   it 'from_array menggabungkan pesan secara dinamis' do
-    fd = described_class.from_array(%w[alpha beta gamma])
+    fd = described_class.from_array(['alpha', 'beta', 'gamma'])
     expect(fd.message).to eq('alpha, beta, gamma')
     expect(fd.type).to eq(:error)
     expect(fd.other_properties).to eq({})

data/lib/rider_kick/matchers/use_case_result.rb

@@ -1,7 +1,7 @@
 # typed: true
 # frozen_string_literal: true
 
-require 'rider_kick/entities/failure_details'
+require_relative '../entities/failure_details'
 require 'dry-matcher'
 require 'dry/monads/all'
 

data/lib/rider_kick/use_cases/abstract_use_case.rb

@@ -4,7 +4,7 @@
 require 'dry/monads/result'
 require 'dry/validation'
 require 'dry/matcher/result_matcher'
-require 'rider_kick/use_cases/contract'
+require_relative 'contract'
 
 module RiderKick
   module UseCases

data/lib/rider_kick/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module RiderKick
-  VERSION = '0.0.13'
+  VERSION = '0.0.15'
   public_constant :VERSION
 end