rampart-core 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 498ffbe558ca941b070948c4f39530085f8c2d1a73917186bd7b6ecab59192ab
-  data.tar.gz: 1181ec35e2cd89d2afa0991fa1d6e421a3c43d82099b7eafd97ae88ce8ca6600
+  metadata.gz: 153fe0a9dfec68247636c637d29acc8405bc6d123fd9d43e8beea3e4e4cf6d9f
+  data.tar.gz: c93f4f3ac48733d1e6017560c4466c73da6da23ba1d1a658b55e8d6170c45c60
 SHA512:
-  metadata.gz: fe575a9f4e72c5c2759bf00f5358fd563464e0074590fbf1e8b5c1c3c44c710ac0e381230646e2713c8e64aed4befaf0e668c55c1d4f1df59d3e75d21cc0a8aa
-  data.tar.gz: 0d9cdd05bf982ba344967e37ebd880f7d0139dc32bfa8f7d0276879a99f1344bb0428ace2595d8cc08905292162a1ebeb7b1a14a65cff60614aed0a647cd2d8b
+  metadata.gz: f44a2e70c2668cd1275976b3675e6c2a54914b83c3b6828dd0ed63ab4115398d506ee1eccd28d53ed17c34b6dba0be85aa38cc7e7976f8d39eaf32da0241316d
+  data.tar.gz: d4afcfe18c00e66d495415ab7468d4b371cd52911c1c074021153a26fa5cce5500fbaedb5fca0baf2f1d4f6d36090c1e3e1b33c45a2975378f2db47f21f84d20

data/lib/rampart/engine_loader.rb

@@ -3,50 +3,115 @@
 module Rampart
   # Generic loader for Rails engines using hexagonal architecture
   #
-  # This loader handles auto-discovery and loading of domain, application, and
-  # infrastructure components in the correct order. It works around the mismatch
-  # between directory structure (app/{layer}/{context}/) and Ruby namespace
-  # conventions by using explicit eager loading.
+  # This loader configures Zeitwerk to properly handle the mismatch between
+  # hexagonal architecture directory structure (app/{layer}/{context}/{subdirs}/)
+  # and flat Ruby namespace conventions (Context::ClassName instead of
+  # Context::Subdirs::ClassName).
+  #
+  # It collapses ALL subdirectories within the context namespace so that
+  # Zeitwerk expects files to define constants directly under the context
+  # namespace (e.g., CatContent::CatListing, not CatContent::Aggregates::CatListing).
   #
   # Usage in your engine:
   #   module YourContext
   #     class Engine < ::Rails::Engine
-  #       config.to_prepare do
-  #         Rampart::EngineLoader.load_all(
-  #           engine_root: YourContext::Engine.root,
-  #           context_name: "your_context"
-  #         )
-  #       end
+  #       Rampart::EngineLoader.setup(self)
   #     end
   #   end
   class EngineLoader
+    # Hexagonal architecture layers in load order
+    LAYERS = %w[domain application infrastructure].freeze
     class << self
+      # Set up hexagonal architecture loading for an engine
+      #
+      # This configures:
+      # 1. Autoload paths for domain, application, and infrastructure layers
+      # 2. Eager load paths for CI/production
+      # 3. Zeitwerk collapse for flat namespaces (before eager loading)
+      # 4. File loading in correct dependency order (via config.to_prepare)
+      #
+      # @param engine_class [Class] The Rails::Engine class (e.g., YourContext::Engine)
+      def setup(engine_class)
+        # Infer context_name from engine module (e.g., CatContent::Engine -> "cat_content")
+        context_name = engine_class.module_parent.name.underscore
+        root = engine_class.root
+
+        # Add hexagonal layer directories to autoload and eager_load paths
+        layer_paths = LAYERS.map { |layer| root.join("app/#{layer}") }
+        engine_class.config.autoload_paths += layer_paths
+        engine_class.config.eager_load_paths += layer_paths
+
+        # Register initializer to configure Zeitwerk collapse before autoload paths are set
+        engine_class.initializer "#{context_name}.zeitwerk", before: :set_autoload_paths do
+          Rampart::EngineLoader.configure_autoloading(
+            engine_root: root,
+            context_name: context_name
+          )
+        end
+
+        # Register config.to_prepare to load files in correct order
+        engine_class.config.to_prepare do
+          Rampart::EngineLoader.load_all(
+            engine_root: root,
+            context_name: context_name
+          )
+        end
+      end
+
+      # Configure Zeitwerk to collapse all subdirectories within hexagonal layers
+      #
+      # @param engine_root [Pathname] Root path of the Rails engine
+      # @param context_name [String] Snake-case name of the bounded context
+      def configure_autoloading(engine_root:, context_name:)
+        return unless defined?(Rails) && Rails.respond_to?(:autoloaders)
+
+        loader = Rails.autoloaders.main
+
+        # Configure collapse for each hexagonal layer
+        LAYERS.each do |layer|
+          layer_path = engine_root.join("app/#{layer}/#{context_name}")
+          next unless layer_path.exist?
+
+          # Recursively collapse ALL subdirectories within the context path
+          collapse_all_subdirectories(loader, layer_path)
+        end
+      end
+
       # Load all hexagonal architecture components for an engine
       #
       # @param engine_root [Pathname] Root path of the Rails engine
-      # @param context_name [String] Snake-case name of the bounded context (e.g., "cat_content")
+      # @param context_name [String] Snake-case name of the bounded context
       def load_all(engine_root:, context_name:)
-        load_domain_layer(engine_root, context_name)
-        load_application_layer(engine_root, context_name)
-        load_infrastructure_layer(engine_root, context_name)
+        LAYERS.each do |layer|
+          send("load_#{layer}_layer", engine_root, context_name)
+        end
       end
 
       private
 
+      # Recursively collapse all subdirectories
+      def collapse_all_subdirectories(loader, path)
+        return unless path.exist?
+
+        Dir.glob(path.join("*/")).each do |subdir|
+          subdir_path = Pathname.new(subdir)
+          loader.collapse(subdir_path.to_s)
+          # Recursively collapse nested subdirectories
+          collapse_all_subdirectories(loader, subdir_path)
+        end
+      end
+
       def load_domain_layer(root, context_name)
         domain = root.join("app/domain/#{context_name}")
         return unless domain.exist?
 
-        # Load files in specific order: errors, value objects, entities, events, aggregates, services, ports
+        # Load errors/exceptions first (they have no dependencies)
         load_directory(domain, pattern: "*_error.rb")
         load_directory(domain, pattern: "*_exception.rb")
-        load_directory(domain.join("value_objects"))
-        load_directory(domain.join("entities"))
-        load_directory(domain.join("events"))
-        load_directory(domain.join("aggregates"))
-        load_directory(domain.join("services"))
-        load_directory(domain.join("ports"))
-        
+
+        # Load all subdirectories
+        load_all_subdirectories(domain)
+
         # Load any remaining files at domain root
         load_directory(domain, pattern: "*.rb")
       end
@@ -55,10 +120,8 @@ module Rampart
         app = root.join("app/application/#{context_name}")
         return unless app.exist?
 
-        # Load all application layer files
-        load_directory(app.join("commands"))
-        load_directory(app.join("queries"))
-        load_directory(app.join("services"))
+        # Load all subdirectories and root files
+        load_all_subdirectories(app)
         load_directory(app, pattern: "*.rb")
       end
 
@@ -66,35 +129,34 @@ module Rampart
         infra = root.join("app/infrastructure/#{context_name}")
         return unless infra.exist?
 
-        # Load persistence layer first (base_record before models)
+        # Load base_record.rb first (models depend on it)
         persistence = infra.join("persistence")
-        if persistence.exist?
-          load_directory(persistence, pattern: "base_record.rb")
-          load_directory(persistence.join("models"))
-          load_directory(persistence.join("mappers"))
-          load_directory(persistence.join("repositories"))
-        end
+        load_directory(persistence, pattern: "base_record.rb") if persistence.exist?
 
-        # Load other infrastructure components
-        load_directory(infra.join("adapters"))
-        load_directory(infra.join("http"))
-        load_directory(infra.join("wiring"))
+        # Load all subdirectories
+        load_all_subdirectories(infra)
+
+        # Load any remaining files at infrastructure root
         load_directory(infra, pattern: "*.rb")
       end
 
+      def load_all_subdirectories(dir)
+        return unless dir.exist?
+
+        Dir.glob(dir.join("*/")).sort.each do |subdir|
+          load_directory(Pathname.new(subdir))
+        end
+      end
+
       def load_directory(dir, pattern: "**/*.rb")
         return unless dir.exist?
 
         Dir.glob(dir.join(pattern)).sort.each do |file|
           next if File.directory?(file)
-          if Rails.env.development? || Rails.env.test?
-            # support auto-reloading in development and test environments
-            load file.to_s
-          else
-            # In eager load environments (CI/production), Zeitwerk has already loaded these files.
-            # Using require instead of load prevents re-execution and duplicate definitions.
-            require file.to_s
-          end
+          # With Zeitwerk collapse configured, Zeitwerk manages autoloading and hot-reloading.
+          # Use require to ensure files are loaded in correct dependency order without
+          # re-executing already-loaded files. Zeitwerk handles reloading on code changes.
+          require file.to_s
         end
       end
     end

data/lib/rampart/version.rb

@@ -1,3 +1,3 @@
 module Rampart
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rampart-core
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Rampart Team