treaty 0.11.0 → 0.13.0

data/lib/treaty/controller/dsl.rb

@@ -11,11 +11,23 @@ module Treaty
       module ClassMethods
         private
 
-        def treaty(action_name)
+        def treaty(action_name, &block) # rubocop:disable Metrics/MethodLength
+          # Capture block in a local variable before using in define_method.
+          # This is necessary because define_method creates a new closure,
+          # and the block parameter might not be accessible without explicit capture.
+          inventory_block = block
+
           define_method(action_name) do
-            treaty = treaty_class.call!(version: treaty_version, params:)
+            inventory_collection = treaty_build_inventory_for(action_name, inventory_block)
+
+            treaty_result = treaty_class.call!(
+              context: self,
+              inventory: inventory_collection,
+              version: treaty_version,
+              params:
+            )
 
-            render json: treaty.data, status: treaty.status
+            render json: treaty_result.data, status: treaty_result.status
           end
         end
       end
@@ -39,6 +51,16 @@ module Treaty
         def treaty_version
           Treaty::Engine.config.treaty.version.call(self)
         end
+
+        private
+
+        def treaty_build_inventory_for(action_name, block)
+          return nil unless block
+
+          factory = Treaty::Inventory::Factory.new(action_name)
+          factory.instance_eval(&block)
+          factory.collection
+        end
       end
     end
   end

data/lib/treaty/exceptions/base.rb

@@ -37,7 +37,6 @@ module Treaty
     # - Deprecated - API version deprecation
     # - SpecifiedVersionNotFound - No version specified and no default configured
     # - VersionNotFound - Requested version doesn't exist
-    # - Strategy - Invalid strategy specification
     # - ClassName - Treaty class not found
     # - MethodName - Unknown method in DSL
     # - NestedAttributes - Nesting depth exceeded

data/lib/treaty/exceptions/inventory.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    # Raised when inventory definition or processing fails
+    #
+    # ## Purpose
+    #
+    # Indicates errors during inventory DSL processing, including invalid method calls,
+    # missing parameters, and invalid source types. Provides consistent error handling
+    # for the inventory system.
+    #
+    # ## Usage
+    #
+    # Raised in various inventory scenarios:
+    #
+    # ### Invalid DSL Method
+    # ```ruby
+    # # When calling unknown method in treaty block
+    # treaty :index do
+    #   unknown_method :something
+    # end
+    # # => Treaty::Exceptions::Inventory: Unknown method 'unknown_method' in treaty block for action 'index'
+    # ```
+    #
+    # ### Missing Required Parameters
+    # ```ruby
+    # # When 'from' parameter is missing
+    # treaty :index do
+    #   provide :posts
+    # end
+    # # => Treaty::Exceptions::Inventory: Inventory 'posts' requires 'from' parameter
+    #
+    # # When inventory name is not a symbol
+    # treaty :index do
+    #   provide "posts", from: :load_posts
+    # end
+    # # => Treaty::Exceptions::Inventory: Inventory name must be a Symbol, got "posts"
+    # ```
+    #
+    # ### Invalid Source
+    # ```ruby
+    # # When source is nil
+    # treaty :index do
+    #   provide :posts, from: nil
+    # end
+    # # => Treaty::Exceptions::Inventory: Inventory source cannot be nil
+    # ```
+    #
+    # ## Integration
+    #
+    # Can be rescued by application controllers:
+    #
+    # ```ruby
+    # rescue_from Treaty::Exceptions::Inventory, with: :render_inventory_error
+    #
+    # def render_inventory_error(exception)
+    #   render json: { error: exception.message }, status: :internal_server_error
+    # end
+    # ```
+    #
+    # ## Valid Sources
+    #
+    # - Symbol: Method name to call on controller (e.g., `:load_posts`)
+    # - Proc/Lambda: Callable object (e.g., `-> { Post.all }`)
+    # - Direct value: String, number, or any other value (e.g., `"Welcome"`)
+    class Inventory < Base
+    end
+  end
+end

data/lib/treaty/exceptions/method_name.rb

@@ -15,7 +15,6 @@ module Treaty
     #
     # ```ruby
     # version 1 do
-    #   strategy Treaty::Strategy::ADAPTER  # Valid
     #   deprecated true                     # Valid
     #   summary "Version 1"                 # Valid
     #
@@ -38,7 +37,6 @@ module Treaty
     # ## Valid DSL Methods
     #
     # Within a version block, these methods are valid:
-    # - strategy(code) - Set version strategy (DIRECT/ADAPTER)
     # - deprecated(condition) - Mark version as deprecated
     # - summary(text) - Add version description
     # - request(&block) - Define request schema

data/lib/treaty/executor/inventory.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Executor
+    # Inventory wrapper that provides method-based access to inventory items.
+    #
+    # ## Purpose
+    #
+    # Wraps inventory collection and controller context, providing lazy evaluation
+    # of inventory items through method calls. This encapsulates all inventory logic
+    # within the class and provides a clean API for services.
+    #
+    # ## Usage
+    #
+    # ```ruby
+    # # Created internally by Treaty
+    # inventory = Treaty::Executor::Inventory.new(inventory_collection, controller_context)
+    #
+    # # Access via method calls - evaluates lazily
+    # inventory.posts          # => Calls controller method or evaluates proc
+    # inventory.current_user   # => Returns evaluated value
+    #
+    # # Raises exception for missing items
+    # inventory.missing_item   # => Treaty::Exceptions::Inventory
+    #
+    # # Convert to hash - evaluates all items
+    # inventory.to_h           # => { posts: [...], current_user: ... }
+    # ```
+    #
+    # ## Architecture
+    #
+    # The class encapsulates:
+    # - Inventory collection (from controller's treaty block)
+    # - Controller context (for method calls and proc evaluation)
+    # - Lazy evaluation logic (items evaluated on access)
+    #
+    # ## Error Handling
+    #
+    # If an inventory item is not found, raises `Treaty::Exceptions::Inventory` with
+    # an I18n-translated error message listing available items.
+    class Inventory
+      # Creates a new inventory instance
+      #
+      # @param inventory [Treaty::Inventory::Collection] Collection of inventory items
+      # @param context [Object] Controller instance for evaluation
+      def initialize(inventory, context)
+        @inventory = inventory
+        @context = context
+        @evaluated_cache = {}
+      end
+
+      # Provides method-based access to inventory items with lazy evaluation
+      #
+      # @param method_name [Symbol] The inventory item name
+      # @param _args [Array] Arguments (not used, for compatibility)
+      # @return [Object] The evaluated inventory item value
+      # @raise [Treaty::Exceptions::Inventory] If item not found
+      def method_missing(method_name, *_args)
+        # Check cache first
+        return @evaluated_cache[method_name] if @evaluated_cache.key?(method_name)
+
+        # Find inventory item
+        item = find_inventory_item(method_name)
+
+        # Evaluate and cache
+        @evaluated_cache[method_name] = item.evaluate(@context)
+      end
+
+      # Checks if inventory responds to a method
+      #
+      # @param method_name [Symbol] The method name to check
+      # @param include_private [Boolean] Whether to include private methods
+      # @return [Boolean] True if inventory has the item
+      def respond_to_missing?(method_name, include_private = false)
+        return false if @inventory.nil?
+
+        @inventory.names.include?(method_name) || super
+      end
+
+      # Converts inventory to hash, evaluating all items
+      #
+      # @return [Hash] Hash of all evaluated inventory items
+      def to_h
+        return {} if @inventory.nil?
+
+        @inventory.evaluate(@context)
+      end
+
+      # Returns string representation
+      #
+      # @return [String] Inventory description
+      def inspect
+        items = @inventory&.names || []
+        "#<Treaty::Executor::Inventory items=#{items.inspect}>"
+      end
+
+      private
+
+      # Finds inventory item by name
+      #
+      # @param name [Symbol] Inventory item name
+      # @return [Treaty::Inventory::Inventory] The inventory item
+      # @raise [Treaty::Exceptions::Inventory] If not found or inventory is nil
+      def find_inventory_item(name)
+        # Use find method for cleaner search
+        item = @inventory&.find { |item| item.name == name }
+
+        return item if item
+
+        # Item not found - list available items
+        available = @inventory&.names || []
+
+        raise Treaty::Exceptions::Inventory,
+              I18n.t(
+                "treaty.executor.inventory.item_not_found",
+                name:,
+                available: available.join(", ")
+              )
+      end
+    end
+  end
+end

data/lib/treaty/info/rest/builder.rb

@@ -36,7 +36,6 @@ module Treaty
               segments: gem_version.segments,
               default: version.default_result,
               summary: version.summary_text,
-              strategy: version.strategy_instance.code,
               deprecated: version.deprecated_result,
               executor: build_executor_with(version),
               request: build_request_with(version),

data/lib/treaty/inventory/collection.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Inventory
+    # Collection wrapper for sets of inventory items.
+    #
+    # ## Purpose
+    #
+    # Provides a unified interface for working with collections of inventory items.
+    # Uses Ruby Set internally for uniqueness but exposes Array-like interface.
+    #
+    # ## Usage
+    #
+    # Used internally by:
+    # - Inventory::Factory (to store inventory items during DSL processing)
+    #
+    # ## Methods
+    #
+    # Delegates common collection methods to internal Set:
+    # - `<<` - Add inventory item
+    # - `empty?` - Check if collection is empty
+    #
+    # Custom methods:
+    # - `exists?` - Returns true if collection is not empty
+    # - `evaluate` - Evaluates all inventory items with context
+    #
+    # ## Example
+    #
+    #   collection = Collection.new
+    #   collection << Inventory.new(name: :posts, source: :load_posts)
+    #   collection << Inventory.new(name: :meta, source: -> { { count: 10 } })
+    #   collection.size  # => 2
+    #   collection.exists?  # => true
+    class Collection
+      extend Forwardable
+
+      def_delegators :@collection, :<<, :each_with_object, :find, :empty?
+
+      # Creates a new collection instance
+      #
+      # @param collection [Set] Initial collection (default: empty Set)
+      def initialize(collection = Set.new)
+        @collection = collection
+      end
+
+      # Checks if collection has any elements
+      #
+      # @return [Boolean] True if collection is not empty
+      def exists?
+        !empty?
+      end
+
+      # Returns array of all inventory item names
+      #
+      # @return [Array<Symbol>] Array of inventory item names
+      def names
+        @collection.each_with_object([]) { |item, names| names << item.name }
+      end
+
+      # Evaluates all inventory items with the given context
+      #
+      # @param context [Object] The controller instance to call methods on
+      # @return [Hash{Symbol => Object}] Hash of inventory name => resolved value
+      def evaluate(context)
+        @collection.each_with_object({}) do |inventory_item, hash|
+          hash[inventory_item.name] = inventory_item.evaluate(context)
+        end
+      end
+    end
+  end
+end

data/lib/treaty/inventory/factory.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Inventory
+    # Factory for building inventory collections via DSL.
+    #
+    # ## Purpose
+    #
+    # Provides the `provide` DSL method for defining inventory items in controller blocks.
+    # Captures calls like `provide :posts, from: :load_posts` and builds a collection.
+    #
+    # ## Usage
+    #
+    # Used internally by Controller::DSL when processing treaty blocks:
+    #
+    # ```ruby
+    # treaty :index do
+    #   provide :posts, from: :load_posts       # Explicit source
+    #   provide :meta, from: -> { { count: 10 } } # Lambda source
+    #   provide :current_user                   # Shorthand: uses :current_user as source
+    # end
+    # ```
+    #
+    # ## Valid Sources
+    #
+    # - Symbol: Method name to call on controller (e.g., `:load_posts`)
+    # - Proc/Lambda: Callable object (e.g., `-> { Post.all }`)
+    # - Direct value: String, number, or any other value (e.g., `"Welcome"`)
+    # - Omitted: Uses inventory name as source (e.g., `provide :posts` → `from: :posts`)
+    #
+    # ## Invalid Sources
+    #
+    # - Direct method calls without symbol/proc (e.g., `from: load_posts`)
+    # - Explicit nil values (e.g., `from: nil`)
+    class Factory
+      attr_reader :collection
+
+      def initialize(action_name)
+        @action_name = action_name
+        @collection = Collection.new
+      end
+
+      # Handles the `provide` DSL method via method_missing
+      #
+      # @param method_name [Symbol] Should be :provide
+      # @param args [Array] First argument is the inventory name
+      # @param options [Hash] Optional :from key with source (defaults to inventory name)
+      # @return [Collection] The collection being built
+      # @raise [Treaty::Exceptions::Inventory] For invalid method or missing parameters
+      def method_missing(method_name, *args, **options, &_block) # rubocop:disable Metrics/MethodLength
+        # Only handle 'provide' method
+        unless method_name == :provide
+          raise Treaty::Exceptions::Inventory,
+                I18n.t(
+                  "treaty.inventory.unknown_method",
+                  method: method_name,
+                  action: @action_name
+                )
+        end
+
+        # Extract inventory name
+        inventory_name = args.first
+
+        unless inventory_name.is_a?(Symbol)
+          raise Treaty::Exceptions::Inventory,
+                I18n.t(
+                  "treaty.inventory.name_must_be_symbol",
+                  name: inventory_name.inspect
+                )
+        end
+
+        # Extract source from options (default to inventory name if not provided)
+        source = if options.key?(:from)
+                   options.fetch(:from)
+                 else
+                   inventory_name
+                 end
+
+        # Create and add inventory item to collection
+        @collection << Inventory.new(name: inventory_name, source:)
+
+        # Return collection for potential chaining
+        @collection
+      end
+
+      def respond_to_missing?(method_name, *)
+        method_name == :provide || super
+      end
+    end
+  end
+end

data/lib/treaty/inventory/inventory.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Inventory
+    # Represents a single inventory item that provides data to the treaty execution.
+    #
+    # An inventory item has a name and a source. The source can be:
+    # - Symbol: A method name to call on the controller (e.g., :load_posts)
+    # - Proc/Lambda: A callable object (e.g., -> { Post.all })
+    # - Direct value: Any other value to pass directly (e.g., "text", 42)
+    #
+    # ## Usage
+    #
+    # ```ruby
+    # # In controller
+    # treaty :index do
+    #   provide :posts, from: :load_posts
+    #   provide :meta, from: -> { { count: 10 } }
+    #   provide :title, from: "Welcome"
+    # end
+    # ```
+    class Inventory
+      attr_reader :name, :source
+
+      def initialize(name:, source:)
+        validate_name!(name)
+        validate_source!(source)
+
+        @name = name
+        @source = source
+      end
+
+      # Evaluates the inventory source with the given context
+      #
+      # @param context [Object] The controller instance to call methods on
+      # @return [Object] The resolved value
+      # @raise [Treaty::Exceptions::Inventory] If evaluation fails
+      def evaluate(context) # rubocop:disable Metrics/MethodLength
+        case source
+        when Symbol
+          evaluate_symbol(context)
+        when Proc
+          evaluate_proc(context)
+        else
+          source
+        end
+      rescue StandardError => e
+        raise Treaty::Exceptions::Inventory,
+              I18n.t(
+                "treaty.inventory.evaluation_error",
+                name: @name,
+                error: e.message
+              )
+      end
+
+      private
+
+      # Evaluates Symbol source by calling method on context
+      #
+      # @param context [Object] The controller instance
+      # @return [Object] The method return value
+      def evaluate_symbol(context)
+        context.send(source)
+      end
+
+      # Evaluates Proc source within controller context
+      #
+      # @param context [Object] The controller instance
+      # @return [Object] The proc return value
+      def evaluate_proc(context)
+        # Execute proc in controller context to access instance variables and methods
+        context.instance_exec(&source)
+      end
+
+      def validate_name!(name)
+        return if name.is_a?(Symbol) && !name.to_s.empty?
+
+        raise Treaty::Exceptions::Inventory,
+              I18n.t("treaty.inventory.invalid_name", name: name.inspect)
+      end
+
+      def validate_source!(source)
+        # Source must be Symbol, Proc, or any other direct value
+        # We don't allow nil as it's likely a mistake
+        return unless source.nil?
+
+        raise Treaty::Exceptions::Inventory,
+              I18n.t("treaty.inventory.source_required")
+      end
+    end
+  end
+end

data/lib/treaty/request/validator.rb

@@ -34,11 +34,10 @@ module Treaty
         end
       end
 
-      def validate_request_attributes! # rubocop:disable Metrics/MethodLength
-        return request_data unless adapter_strategy?
+      def validate_request_attributes!
         return request_data unless request_attributes_exist?
 
-        # For adapter strategy with attributes defined:
+        # Validate request attributes with orchestrator:
         orchestrator_class = Class.new(Treaty::Attribute::Validation::Orchestrator::Base) do
           define_method(:collection_of_attributes) do
             @version_factory.request_factory.collection_of_attributes
@@ -51,10 +50,6 @@ module Treaty
         )
       end
 
-      def adapter_strategy?
-        !@version_factory.strategy_instance.direct?
-      end
-
       def request_attributes_exist?
         return false if @version_factory.request_factory&.collection_of_attributes&.empty?
 

data/lib/treaty/response/validator.rb

@@ -29,7 +29,7 @@ module Treaty
       def validate_response_attributes!
         return @response_data unless response_attributes_exist?
 
-        # Create orchestrator for both DIRECT and ADAPTER strategies
+        # Create orchestrator for response validation
         # Orchestrator filters data by attributes and performs transformation
         orchestrator_class = Class.new(Treaty::Attribute::Validation::Orchestrator::Base) do
           define_method(:collection_of_attributes) do
@@ -43,10 +43,6 @@ module Treaty
         )
       end
 
-      def adapter_strategy?
-        !@version_factory.strategy_instance.direct?
-      end
-
       def response_attributes_exist?
         return false if @version_factory.response_factory&.collection_of_attributes&.empty?
 

data/lib/treaty/version.rb

@@ -3,7 +3,7 @@
 module Treaty
   module VERSION
     MAJOR = 0
-    MINOR = 11
+    MINOR = 13
     PATCH = 0
     PRE = nil
 

data/lib/treaty/versions/execution/request.rb

@@ -8,7 +8,9 @@ module Treaty
           new(...).execute!
         end
 
-        def initialize(version_factory:, validated_params:)
+        def initialize(version_factory:, validated_params:, inventory: nil, context: nil)
+          @inventory = inventory
+          @context = context
           @version_factory = version_factory
           @validated_params = validated_params
         end
@@ -89,15 +91,26 @@ module Treaty
         ########################################################################
         ########################################################################
 
+        # Creates inventory wrapper with lazy evaluation
+        #
+        # @return [Treaty::Executor::Inventory] Inventory wrapper with method-based access
+        def evaluated_inventory
+          @evaluated_inventory ||= Treaty::Executor::Inventory.new(@inventory, @context)
+        end
+
+        ########################################################################
+
         def execute_proc
-          executor.call(params: @validated_params)
+          # For Proc executors, pass inventory if collection exists
+          executor.call(**build_call_params)
         rescue StandardError => e
           raise Treaty::Exceptions::Execution,
                 I18n.t("treaty.execution.proc_error", message: e.message)
         end
 
         def execute_servactory # rubocop:disable Metrics/MethodLength
-          executor.call!(params: @validated_params)
+          # For Servactory services, pass inventory if collection exists
+          executor.call!(**build_call_params)
         rescue Servactory::Exceptions::Input => e
           raise Treaty::Exceptions::Execution,
                 I18n.t("treaty.execution.servactory_input_error", message: e.message)
@@ -124,7 +137,8 @@ module Treaty
                   )
           end
 
-          executor.public_send(method_name, params: @validated_params)
+          # For regular classes, pass inventory if collection exists
+          executor.public_send(method_name, **build_call_params)
         rescue StandardError => e
           raise Treaty::Exceptions::Execution,
                 I18n.t("treaty.execution.regular_service_error", message: e.message)
@@ -134,6 +148,17 @@ module Treaty
         ########################################################################
         ########################################################################
 
+        # Builds call parameters hash with inventory if it exists
+        #
+        # @return [Hash] Parameters hash with :params and optionally :inventory
+        def build_call_params
+          if @inventory&.exists?
+            { params: @validated_params, inventory: evaluated_inventory }
+          else
+            { params: @validated_params }
+          end
+        end
+
         def raise_executor_missing_error!
           raise Treaty::Exceptions::Execution,
                 I18n.t(

data/lib/treaty/versions/factory.rb

@@ -6,7 +6,6 @@ module Treaty
       attr_reader :version,
                   :default_result,
                   :summary_text,
-                  :strategy_instance,
                   :deprecated_result,
                   :executor,
                   :request_factory,
@@ -16,7 +15,6 @@ module Treaty
         @version = Semantic.new(version)
         @default_result = default.is_a?(Proc) ? default.call : default
         @summary_text = nil
-        @strategy_instance = Strategy.new(Strategy::ADAPTER) # without .validate!
         @deprecated_result = false
         @executor = nil
 
@@ -35,10 +33,6 @@ module Treaty
         @summary_text = text
       end
 
-      def strategy(code)
-        @strategy_instance = Strategy.new(code).validate!
-      end
-
       def deprecated(condition = nil)
         result =
           if condition.is_a?(Proc)