rider-kick 0.0.13 → 0.0.14

data/lib/generators/rider_kick/USAGE

@@ -7,3 +7,5 @@ Example:
         bin/rails generate rider_kick:clean_arch --setup
         bin/rails generate rider_kick:structure Models::User actor:owner uploaders:asset,images
         bin/rails generate rider_kick:scaffold users scope:dashboard
+        bin/rails generate rider_kick:factory Models::Article scope:core
+        bin/rails generate rider_kick:factory Models::Article scope:core --static

data/lib/generators/rider_kick/base_generator.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'active_support/inflector'
+require 'active_support/core_ext/object/blank'
+require 'yaml'
+require_relative 'errors'
+require_relative '../../rider-kick'
+
+module RiderKick
+  class BaseGenerator < Rails::Generators::Base
+    protected
+
+    def template_path_for(template_name)
+      # Check for custom template path first
+      custom_path = RiderKick.configuration.template_path
+      if custom_path && Dir.exist?(custom_path)
+        custom_template_path = File.join(custom_path, template_name)
+        return custom_template_path if File.exist?(custom_template_path)
+      end
+      # Fallback to default template path
+      File.join(self.class.source_root, template_name)
+    end
+
+    def configure_engine
+      if options[:engine].present?
+        RiderKick.configuration.engine_name = options[:engine]
+        # Jika --engine dispecify, selalu ada scope engine nya
+        engine_prefix = options[:engine].underscore
+        domain_part = options[:domain] || ''
+        RiderKick.configuration.domain_scope = domain_part.empty? ? engine_prefix + '/' : engine_prefix + '/' + domain_part
+        say "Using engine: #{RiderKick.configuration.engine_name}", :green
+        say "Using domain scope: #{RiderKick.configuration.domain_scope}", :green
+      elsif options[:domain].present?
+        # Jika hanya --domain yang dispecify, gunakan konfigurasi existing
+        RiderKick.configuration.domain_scope = options[:domain]
+        say "Using domain scope: #{RiderKick.configuration.domain_scope}", :blue
+      else
+        # Jika tidak ada options, pertahankan konfigurasi existing
+        # Hanya tampilkan pesan jika belum pernah di-set
+        unless @engine_configured
+          if RiderKick.configuration.engine_name
+            say "Using engine: #{RiderKick.configuration.engine_name}", :green
+            say "Using domain scope: #{RiderKick.configuration.domain_scope}", :green
+          else
+            say 'Using main app (no engine specified)', :blue
+            say "Using domain scope: #{RiderKick.configuration.domain_scope}", :blue
+          end
+          @engine_configured = true
+        end
+      end
+    end
+
+    def validate_file_exists!(path, context = '')
+      unless File.exist?(path)
+        error_message = "File not found: #{path}"
+        error_message += " (#{context})" if context.present?
+        raise FileNotFoundError.new(error_message, file_path: path, context: context)
+      end
+    end
+
+    def validate_yaml_format!(file_path)
+      validate_file_exists!(file_path, 'YAML validation')
+      begin
+        YAML.load_file(file_path)
+      rescue Psych::SyntaxError => e
+        raise YamlFormatError.new(
+                "Invalid YAML format in #{file_path}: #{e.message}",
+                file_path:  file_path,
+                yaml_error: e.message
+        )
+      rescue => e
+        raise YamlFormatError.new(
+                "Error reading YAML file #{file_path}: #{e.message}",
+                file_path: file_path,
+                error:     e.message
+        )
+      end
+    end
+
+    def validate_model_exists!(model_name)
+      # Try to constantize the model name
+      # This will raise NameError if the model doesn't exist
+
+      model_name.constantize
+    rescue NameError => e
+      # Try to load the model file if it exists (for test scenarios where file exists but not loaded)
+      model_path = find_model_file(model_name)
+      if model_path && File.exist?(model_path)
+        # Try loading the file
+        begin
+          load model_path
+          model_name.constantize
+        rescue => load_error
+          # If loading also fails, raise the original error
+          raise ModelNotFoundError.new(
+                  "Model #{model_name} not found. Make sure the model exists and is valid.",
+                  model_name:     model_name,
+                  original_error: e.message,
+                  load_error:     load_error.message
+          )
+        end
+      else
+        # Model file doesn't exist, raise error
+        raise ModelNotFoundError.new(
+                "Model #{model_name} not found. Make sure the model exists.",
+                model_name:     model_name,
+                original_error: e.message
+        )
+      end
+    end
+
+    def find_model_file(model_name)
+      # Convert model name to file path
+      # Models::User -> app/models/models/user.rb or engines/.../app/models/.../user.rb
+      parts = model_name.split('::')
+      return nil if parts.empty?
+
+      file_name = parts.last.underscore + '.rb'
+
+      # Check main app models path first
+      main_path = File.join(RiderKick.configuration.models_path, file_name)
+      return main_path if File.exist?(main_path)
+
+      # Check engine models path if engine is set
+      if RiderKick.configuration.engine_name
+        engine_path = File.join(
+                        'engines',
+                        RiderKick.configuration.engine_name.underscore,
+                        'app/models',
+                        RiderKick.configuration.engine_name.underscore,
+                        'models',
+                        file_name
+        )
+        return engine_path if File.exist?(engine_path)
+      end
+
+      nil
+    end
+
+    def validate_domains_path!
+      unless Dir.exist?(RiderKick.configuration.domains_path)
+        raise ValidationError.new(
+                'Clean architecture structure not found. Run: bin/rails generate rider_kick:clean_arch --setup',
+                domains_path: RiderKick.configuration.domains_path
+        )
+      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_domains_path
+      if RiderKick.configuration.engine_name
+        # Engine: engines/<engine_name>/app/domains/<domain_scope>
+        File.join('engines', RiderKick.configuration.engine_name.underscore, 'app/domains', RiderKick.configuration.domain_scope)
+      else
+        # Main app: app/domains/<domain_scope>
+        File.join('app/domains', RiderKick.configuration.domain_scope)
+      end
+    end
+  end
+end

data/lib/generators/rider_kick/clean_arch_generator.rb

@@ -1,64 +1,146 @@
+require_relative 'base_generator'
+require_relative '../../rider-kick'
+
 module RiderKick
-  class CleanArchGenerator < Rails::Generators::Base
+  class CleanArchGenerator < BaseGenerator
     source_root File.expand_path('templates', __dir__)
 
     class_option :setup, type: :boolean, default: false, desc: 'Setup domain structure'
+    class_option :engine, type: :string, default: nil, desc: 'Specify engine name (e.g., Core, Admin)'
+    class_option :domain, type: :string, default: '', desc: 'Specify domain scope (e.g., core/, admin/, api/v1/)'
 
     def validate_setup_option
-      raise Thor::Error, 'The --setup option must be specified to create the domain structure.' unless options.setup
+      # Jika --engine dispecify, maka --setup otomatis dianggap true
+      return if options.engine.present?
+
+      unless options.setup
+        raise ValidationError.new(
+                'The --setup option must be specified to create the domain structure.',
+                suggestion: 'Run: bin/rails generate rider_kick:clean_arch --setup'
+        )
+      end
     end
 
     def create_gem_dependencies
-      append_to_file('Gemfile', gem_dependencies)
-      say 'Gems added to Gemfile', :green
+      if options[:engine].present?
+        # Untuk engine, tambahkan ke Gemfile engine
+        engine_gemfile_path = "engines/#{options[:engine].downcase}/Gemfile"
+        append_to_file(engine_gemfile_path, gem_dependencies)
+        say "Gems added to #{engine_gemfile_path}", :green
+      else
+        # Untuk main app, tambahkan ke Gemfile host
+        append_to_file('Gemfile', gem_dependencies)
+        say 'Gems added to Gemfile', :green
+      end
     end
 
     def setup_configuration
+      configure_engine
       setup_domain_structure
 
-      setup_initializers
-      setup_dotenv
-      setup_gitignore
-      setup_rubocop
-      setup_init_migration
-      setup_models
-      setup_active_storage
-      setup_rspec
-      setup_readme
+      if options[:engine].present?
+        # Untuk engine, hanya setup yang relevan
+        setup_init_migration
+        setup_models
+        setup_engine_generators
+      else
+        # Untuk main app, setup semua
+        setup_initializers
+        setup_dotenv
+        setup_gitignore
+        setup_rubocop
+        setup_init_migration
+        setup_models
+        setup_application_config
+        # setup_active_storage
+        setup_rspec
+        setup_readme
+      end
     end
 
     private
 
+    def domain_class_name
+      # Convert domain scope to class name
+      # Engine: "<Engine>" for ApplicationRecord, "<Engine>::<Domain>" for other classes
+      # Main app: "" for ApplicationRecord, "<AppName>" for root domain, "<Domain>" for scoped domain
+      scope = RiderKick.configuration.domain_scope.chomp('/')
+
+      if RiderKick.configuration.engine_name.present?
+        # Engine context: domain_scope always starts with engine name
+        engine_prefix = RiderKick.configuration.engine_name.to_s.camelize
+        engine_underscored = RiderKick.configuration.engine_name.to_s.underscore
+
+        if scope == engine_underscored
+          # Default engine domain: engines/my_engine/app/domains/my_engine/
+          engine_prefix
+        else
+          # Engine with sub-domain: engines/my_engine/app/domains/my_engine/admin/
+          # Remove engine prefix from scope and create namespace
+          sub_scope = scope.sub(/^#{engine_underscored}\//, '')
+          if sub_scope.empty?
+            engine_prefix
+          else
+            "#{engine_prefix}::#{sub_scope.split('/').map(&:camelize).join('::')}"
+          end
+        end
+      elsif scope.empty?
+        # Main app context
+        # Root domain in main app: use application name
+        begin
+          Rails.application&.class&.module_parent_name || 'MyApp'
+        rescue
+          'MyApp' # Fallback for test environment
+        end
+      else
+        # Scoped domain in main app: use domain name only
+        scope.split('/').map(&:camelize).join('::')
+      end
+    end
+
+    def domain_class_name_for_application_record
+      # Special method for ApplicationRecord class names
+      # Engine: "<Engine>" (will become EngineApplicationRecord)
+      # Main app: "" (will become ApplicationRecord)
+      if RiderKick.configuration.engine_name.present?
+        # Engine context: use engine name
+        RiderKick.configuration.engine_name.to_s.camelize
+      else
+        # Main app context: empty string for ApplicationRecord
+        ''
+      end
+    end
+
     def setup_active_storage
       run 'rails active_storage:install'
       run 'rails db:migrate'
     end
 
     def setup_domain_structure
-      empty_directory File.join("#{path_app}/domains/core/use_cases/contract")
-      empty_directory File.join("#{path_app}/domains/core/repositories")
-      empty_directory File.join("#{path_app}/domains/core/builders")
-      empty_directory File.join("#{path_app}/domains/core/entities")
-      empty_directory File.join("#{path_app}/domains/core/utils")
+      empty_directory File.join(RiderKick.configuration.domains_path, 'use_cases/contract')
+      empty_directory File.join(RiderKick.configuration.domains_path, 'repositories')
+      empty_directory File.join(RiderKick.configuration.domains_path, 'builders')
+      empty_directory File.join(RiderKick.configuration.domains_path, 'entities')
+      empty_directory File.join(RiderKick.configuration.domains_path, 'utils')
 
       # then
       copy_domain_file
     end
 
     def copy_domain_file
-      template 'domains/core/use_cases/contract/pagination.rb.tt', File.join("#{path_app}/domains/core/use_cases/contract", 'pagination.rb')
-      template 'domains/core/use_cases/contract/default.rb.tt', File.join("#{path_app}/domains/core/use_cases/contract", 'default.rb')
-      template 'domains/core/use_cases/get_version.rb.tt', File.join("#{path_app}/domains/core/use_cases", 'get_version.rb')
+      template 'domains/core/use_cases/contract/pagination.rb.tt', File.join(RiderKick.configuration.domains_path, 'use_cases/contract', 'pagination.rb')
+      template 'domains/core/use_cases/contract/default.rb.tt', File.join(RiderKick.configuration.domains_path, 'use_cases/contract', 'default.rb')
+      template 'domains/core/use_cases/get_version.rb.tt', File.join(RiderKick.configuration.domains_path, 'use_cases', 'get_version.rb')
 
-      template 'domains/core/builders/error.rb.tt', File.join("#{path_app}/domains/core/builders", 'error.rb')
-      template 'domains/core/builders/pagination.rb.tt', File.join("#{path_app}/domains/core/builders", 'pagination.rb')
+      template 'domains/core/builders/error.rb.tt', File.join(RiderKick.configuration.domains_path, 'builders', 'error.rb')
+      template 'domains/core/builders/pagination.rb.tt', File.join(RiderKick.configuration.domains_path, 'builders', 'pagination.rb')
 
-      template 'domains/core/entities/error.rb.tt', File.join("#{path_app}/domains/core/entities", 'error.rb')
-      template 'domains/core/entities/pagination.rb.tt', File.join("#{path_app}/domains/core/entities", 'pagination.rb')
+      template 'domains/core/entities/error.rb.tt', File.join(RiderKick.configuration.domains_path, 'entities', 'error.rb')
+      template 'domains/core/entities/pagination.rb.tt', File.join(RiderKick.configuration.domains_path, 'entities', 'pagination.rb')
 
-      template 'domains/core/repositories/abstract_repository.rb.tt', File.join("#{path_app}/domains/core/repositories", 'abstract_repository.rb')
-      template 'domains/core/utils/abstract_utils.rb.tt', File.join("#{path_app}/domains/core/utils", 'abstract_utils.rb')
-      template 'domains/core/utils/request_methods.rb.tt', File.join("#{path_app}/domains/core/utils", 'request_methods.rb')
+      template 'domains/core/repositories/abstract_repository.rb.tt', File.join(RiderKick.configuration.domains_path, 'repositories', 'abstract_repository.rb')
+      template 'domains/core/utils/abstract_utils.rb.tt', File.join(RiderKick.configuration.domains_path, 'utils', 'abstract_utils.rb')
+      template 'domains/core/utils/request_methods.rb.tt', File.join(RiderKick.configuration.domains_path, 'utils', 'request_methods.rb')
     end
 
     def setup_initializers
@@ -89,7 +171,18 @@ module RiderKick
     end
 
     def setup_init_migration
-      template 'db/migrate/20220613145533_init_database.rb', File.join('db/migrate/20220613145533_init_database.rb')
+      if options[:engine].present?
+        # Untuk engine, buat migration dan structures directory di engine directory
+        engine_migrate_path = "engines/#{options[:engine].downcase}/db/migrate"
+        engine_structures_path = "engines/#{options[:engine].downcase}/db/structures"
+        empty_directory engine_migrate_path unless Dir.exist?(engine_migrate_path)
+        empty_directory engine_structures_path unless Dir.exist?(engine_structures_path)
+        template 'db/migrate/20220613145533_init_database.rb', File.join(engine_migrate_path, '20220613145533_init_database.rb')
+      else
+        # Untuk main app, buat di root db/migrate dan db/structures
+        template 'db/migrate/20220613145533_init_database.rb', File.join('db/migrate/20220613145533_init_database.rb')
+        empty_directory 'db/structures' unless Dir.exist?('db/structures')
+      end
     end
 
     # Helper untuk menyalin initializers
@@ -102,8 +195,21 @@ module RiderKick
     end
 
     def setup_models
-      template 'models/application_record.rb', File.join('app/models/application_record.rb')
-      template 'models/models.rb', File.join('app/models/models.rb')
+      if options[:engine].present?
+        # Untuk engine, buat application_record.rb di engine directory
+        engine_models_path = "engines/#{options[:engine].downcase}/app/models/#{options[:engine].downcase}"
+        empty_directory engine_models_path unless Dir.exist?(engine_models_path)
+        template 'models/application_record.rb', File.join(engine_models_path, 'application_record.rb')
+      else
+        # Untuk main app, buat di root app/models
+        template 'models/application_record.rb', File.join('app/models/application_record.rb')
+      end
+
+      # Untuk engine, models path akan di engines/<engine_name>/app/models/<engine_name>/models
+      # Untuk main app, models path akan di app/models/models
+      models_dir = RiderKick.configuration.models_path
+      empty_directory models_dir unless Dir.exist?(models_dir)
+      template 'models/models.rb', File.join(models_dir, 'models.rb')
     end
 
     def copy_env_development
@@ -114,16 +220,13 @@ module RiderKick
     end
 
     def gem_dependencies
-      inject_into_file 'Gemfile', after: "group :development, :test do\n" do
-        <<-CONFIG
-
-  gem "rspec-rails"
-  gem "factory_bot_rails"
-  gem "shoulda-matchers"
-        CONFIG
-      end
-
       <<~RUBY
+        group :development, :test do
+          gem "rspec-rails"
+          gem "factory_bot_rails"
+          gem "faker"
+          gem "shoulda-matchers"
+        end
 
         # Env Variables
         gem 'dotenv-rails'
@@ -132,11 +235,14 @@ module RiderKick
         gem 'hashie'
 
         # uploading
-        gem 'image_processing', '>= 1.2'
+        gem 'image_processing'
         gem 'ruby-vips'
 
         # pagination
-        gem 'pagy', '~> 9.2'
+        gem 'pagy'
+
+        # models validation
+        gem 'schema_validations'
       RUBY
     end
 
@@ -148,12 +254,96 @@ module RiderKick
       template '.rspec', File.join('.rspec')
       template 'spec/support/repository_stubber.rb', File.join('spec/support/repository_stubber.rb')
       template 'spec/support/file_stuber.rb', File.join('spec/support/file_stuber.rb')
-      say 'Mengonfigurasi FactoryBot...'
+      template 'spec/support/class_stubber.rb', File.join('spec/support/class_stubber.rb')
+      say 'Mengonfigurasi FactoryBot dan Faker...'
+      setup_factory_bot
       template 'spec/rails_helper.rb', File.join('spec/rails_helper.rb')
     end
 
-    def path_app
-      'app'
+    def setup_factory_bot
+      # Create factories directory structure
+      empty_directory 'spec/factories'
+
+      # Create FactoryBot support file
+      template 'spec/support/factory_bot.rb', File.join('spec/support/factory_bot.rb')
+
+      # Create Faker support file
+      template 'spec/support/faker.rb', File.join('spec/support/faker.rb')
+
+      # Create example factories file
+      template 'spec/factories/.gitkeep', File.join('spec/factories/.gitkeep')
+    end
+
+    def setup_application_config
+      application_config_path = 'config/application.rb'
+
+      # Check if file exists
+      unless File.exist?(application_config_path)
+        say "File #{application_config_path} not found, skipping application config setup", :yellow
+        return
+      end
+
+      # Check if config already exists
+      application_content = File.read(application_config_path)
+      if application_content.include?("config.paths['db/migrate']")
+        say "Migration paths config already exists in #{application_config_path}", :green
+        return
+      end
+
+      # Find the class Application block and inject config after class definition
+      # Look for pattern: class Application < Rails::Application
+      if /class\s+Application\s+<\s+Rails::Application/.match?(application_content)
+        # Try to inject right after class definition line
+        inject_into_file application_config_path, after: /class\s+Application\s+<\s+Rails::Application\s*\n/ do
+          <<~RUBY
+            # Load migrations from engines
+            config.paths['db/migrate'] << './**/db/migrate'
+
+          RUBY
+        end
+        say "Added migration paths config to #{application_config_path}", :green
+      else
+        say "Could not find Application class in #{application_config_path}, skipping", :yellow
+      end
+    end
+
+    def setup_engine_generators
+      engine_name_underscore = options[:engine].downcase
+      options[:engine].camelize
+      engine_rb_path = "engines/#{engine_name_underscore}/lib/#{engine_name_underscore}/engine.rb"
+
+      # Check if file exists
+      unless File.exist?(engine_rb_path)
+        say "File #{engine_rb_path} not found, skipping engine generators config setup", :yellow
+        return
+      end
+
+      # Check if config already exists
+      engine_content = File.read(engine_rb_path)
+      if engine_content.include?('config.generators do |generate|')
+        say "Generator config already exists in #{engine_rb_path}", :green
+        return
+      end
+
+      # Find the engine class definition and inject config inside it
+      # Look for pattern: class Engine < Rails::Engine (inside module)
+      if /class\s+Engine\s+<\s+::Rails::Engine/.match?(engine_content)
+        # Try to inject right after the class definition line
+        inject_into_file engine_rb_path, after: /class\s+Engine\s+<\s+::Rails::Engine\s*\n/ do
+          <<~RUBY
+            config.generators do |generate|
+              generate.orm :active_record, primary_key_type: :uuid
+              generate.assets = false
+              generate.helper = false
+              generate.test_framework nil
+            end
+
+          RUBY
+        end
+        say "Added generator config to #{engine_rb_path}", :green
+      else
+        say "Could not find Engine class in #{engine_rb_path}, skipping", :yellow
+      end
     end
   end
 end