treaty 0.18.0 → 0.20.0

data/lib/treaty/context/callable.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Context
-    module Callable
-      def call!(version:, params:, context: nil, inventory: nil)
-        treaty_instance = send(:new)
-
-        _call!(treaty_instance, context:, inventory:, version:, params:)
-      end
-
-      private
-
-      def _call!(treaty_instance, context:, inventory:, version:, params:)
-        treaty_instance.send(
-          :_call!,
-          context:,
-          inventory:,
-          version:,
-          params:,
-          collection_of_versions:
-        )
-      end
-    end
-  end
-end

data/lib/treaty/context/dsl.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Context
-    module DSL
-      def self.included(base)
-        base.extend(Callable)
-        base.include(Workspace)
-      end
-    end
-  end
-end

data/lib/treaty/context/workspace.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Context
-    module Workspace
-      private
-
-      def _call!(
-        context:,
-        inventory:,
-        version:,
-        params:,
-        collection_of_versions:
-      )
-        call!(
-          context:,
-          inventory:,
-          version:,
-          params:,
-          collection_of_versions:
-        )
-      end
-
-      def call!(
-        collection_of_versions:,
-        **
-      )
-        @collection_of_versions = collection_of_versions
-      end
-    end
-  end
-end

data/lib/treaty/executor/inventory.rb

@@ -1,122 +0,0 @@
-# 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/inventory/collection.rb

@@ -1,71 +0,0 @@
-# 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

@@ -1,91 +0,0 @@
-# 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

@@ -1,92 +0,0 @@
-# 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/attribute/attribute.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Request
-    module Attribute
-      # Request-specific attribute that defaults to required: true
-      class Attribute < Treaty::Attribute::Base
-        private
-
-        def apply_defaults!
-          # For request: required by default (true).
-          # message: nil means use I18n default message from validators
-          @options[:required] ||= { is: true, message: nil }
-        end
-
-        def process_nested_attributes(&block)
-          return unless object_or_array?
-
-          builder = Builder.new(collection_of_attributes, @nesting_level + 1)
-          builder.instance_eval(&block)
-        end
-      end
-    end
-  end
-end

data/lib/treaty/request/attribute/builder.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Request
-    module Attribute
-      # Request-specific attribute builder
-      class Builder < Treaty::Attribute::Builder::Base
-        private
-
-        def create_attribute(name, type, *helpers, nesting_level:, **options, &block)
-          Attribute.new(
-            name,
-            type,
-            *helpers,
-            nesting_level:,
-            **options,
-            &block
-          )
-        end
-
-        # Deep copies an attribute with adjusted nesting level for Request context.
-        #
-        # @param source_attribute [Treaty::Attribute::Base] Attribute to copy
-        # @param new_nesting_level [Integer] New nesting level
-        # @return [Request::Attribute::Attribute] Copied attribute
-        def deep_copy_attribute(source_attribute, new_nesting_level) # rubocop:disable Metrics/MethodLength
-          copied = Attribute.new(
-            source_attribute.name,
-            source_attribute.type,
-            nesting_level: new_nesting_level,
-            **deep_copy_options(source_attribute.options)
-          )
-
-          return copied unless source_attribute.nested?
-
-          source_attribute.collection_of_attributes.each do |nested_source|
-            nested_copied = deep_copy_attribute(nested_source, new_nesting_level + 1)
-            copied.collection_of_attributes << nested_copied
-          end
-
-          copied
-        end
-      end
-    end
-  end
-end

data/lib/treaty/request/entity.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Request
-    # Entity class for request definitions.
-    # Attributes are required by default.
-    #
-    # This class is used internally when defining request blocks.
-    # When you write a request block, Treaty creates an anonymous
-    # class based on Request::Entity.
-    class Entity
-      include Treaty::Attribute::DSL
-
-      class << self
-        private
-
-        # Creates a Request::Attribute::Attribute for this Request::Entity class
-        #
-        # @return [Request::Attribute::Attribute] Created attribute instance
-        def create_attribute(name, type, *helpers, nesting_level:, **options, &block)
-          Attribute::Attribute.new(
-            name,
-            type,
-            *helpers,
-            nesting_level:,
-            **options,
-            &block
-          )
-        end
-      end
-    end
-  end
-end

data/lib/treaty/request/factory.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Request
-    # Factory for creating request definitions.
-    #
-    # Supports two modes:
-    # 1. Block mode: Creates an anonymous Request::Entity class with the block
-    # 2. Entity mode: Uses a provided Entity class directly
-    #
-    # ## Block Mode
-    #
-    # ```ruby
-    # request do
-    #   object :post do
-    #     string :title
-    #   end
-    # end
-    # ```
-    #
-    # ## Entity Mode
-    #
-    # ```ruby
-    # request Posts::Create::RequestEntity
-    # ```
-    class Factory
-      # Uses a provided Entity class
-      #
-      # @param entity_class [Class] Entity class to use
-      # @return [void]
-      # @raise [Treaty::Exceptions::Validation] if entity_class is not a valid Treaty::Entity subclass
-      def use_entity(entity_class)
-        validate_entity_class!(entity_class)
-        @entity_class = entity_class
-      end
-
-      # Returns collection of attributes from the entity class
-      #
-      # @return [Collection] Collection of attributes
-      def collection_of_attributes
-        return Treaty::Attribute::Collection.new if @entity_class.nil?
-
-        @entity_class.collection_of_attributes
-      end
-
-      # Handles DSL methods for defining attributes
-      #
-      # This allows the factory to be used with method_missing
-      # for backwards compatibility with direct method calls.
-      # Creates an anonymous Request::Entity class on first use.
-      def method_missing(type, *helpers, **options, &block)
-        # If no entity class yet, create one
-        @entity_class ||= Class.new(Entity)
-
-        # Call the method on the entity class
-        @entity_class.public_send(type, *helpers, **options, &block)
-      end
-
-      def respond_to_missing?(name, *)
-        super
-      end
-
-      private
-
-      # Validates that the provided entity_class is a valid Treaty::Entity subclass
-      #
-      # @param entity_class [Class] Entity class to validate
-      # @raise [Treaty::Exceptions::Validation] if entity_class is not a valid Treaty::Entity subclass
-      def validate_entity_class!(entity_class)
-        return if entity_class.is_a?(Class) && entity_class < Treaty::Entity
-
-        raise Treaty::Exceptions::Validation,
-              I18n.t(
-                "treaty.request.factory.invalid_entity_class",
-                type: entity_class.class,
-                value: entity_class
-              )
-      end
-    end
-  end
-end

data/lib/treaty/request/validator.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Request
-    # Validator for request data
-    class Validator
-      class << self
-        # Validates request parameters against the request definition
-        #
-        # @param params [Hash] Request parameters to validate
-        # @param version_factory [Versions::Factory] Version factory with request definition
-        # @return [Hash] Validated and transformed parameters
-        def validate!(params:, version_factory:)
-          new(params:, version_factory:).validate!
-        end
-      end
-
-      def initialize(params:, version_factory:)
-        @params = params
-        @version_factory = version_factory
-      end
-
-      def validate!
-        validate_request_attributes!
-      end
-
-      private
-
-      def request_data
-        @request_data ||= begin
-          @params.to_unsafe_h
-        rescue NoMethodError
-          @params
-        end
-      end
-
-      def validate_request_attributes!
-        return request_data unless request_attributes_exist?
-
-        # 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
-          end
-        end
-
-        orchestrator_class.validate!(
-          version_factory: @version_factory,
-          data: request_data
-        )
-      end
-
-      def request_attributes_exist?
-        return false if @version_factory.request_factory&.collection_of_attributes&.empty?
-
-        @version_factory.request_factory.collection_of_attributes.exists?
-      end
-    end
-  end
-end