expectant 0.3.0 → 0.3.2

data/lib/expectant/dsl.rb

@@ -1,119 +1,132 @@
-# frozen_string_literal: true
-
-require_relative "utils"
-require_relative "schema"
-require_relative "bound_schema"
-
-module Expectant
-  module DSL
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      def self.extended(base)
-        base.class_eval do
-          @_expectant_schemas = {}
-        end
-      end
-
-      def inherited(sub)
-        return unless instance_variable_defined?(:@_expectant_schemas)
-        return if @_expectant_schemas.empty?
-
-        # Deep copy each schema (fields + validators)
-        parent_schemas = @_expectant_schemas
-        duped = parent_schemas.transform_values { |schema| schema.duplicate }
-
-        sub.instance_variable_set(:@_expectant_schemas, duped)
-      end
-
-      # Define a new expectation schema
-      # Options:
-      #   collision: :error|:force -> method name collision policy for dynamic definitions
-      #   singular: string|symbol  -> control singular name for the schema
-      def expects(schema_name, collision: :error, singular: nil)
-        field_method_name = Utils.singularize(schema_name.to_sym)
-        if !singular.nil?
-          if singular.is_a?(String) || singular.is_a?(Symbol)
-            field_method_name = singular.to_sym
-          else
-            raise ConfigurationError, "Invalid singular option: #{singular.inspect}"
-          end
-        end
-        schema = schema_name.to_sym
-
-        if @_expectant_schemas.key?(schema)
-          raise SchemaError, "Schema :#{schema} already defined"
-        else
-          create_schema(schema, collision: collision, field_method_name: field_method_name)
-        end
-
-        self
-      end
-
-      def reset_inherited_expectations!
-        @_expectant_schemas = {}
-      end
-
-      private
-
-      def create_schema(schema_name, collision: :error, field_method_name: nil)
-        @_expectant_schemas[schema_name] = Schema.new(schema_name)
-
-        # Dynamically define the field definition method
-        # (e.g. input for :inputs, datum for :data)
-        Utils.define_with_collision_policy(singleton_class, field_method_name, collision: collision) do
-          define_singleton_method(field_method_name) do |name, **options|
-            expectation = Expectation.new(name, **options)
-            @_expectant_schemas[schema_name].add_field(expectation)
-            expectation
-          end
-        end
-
-        # Reset a schema
-        reset_method_name = "reset_#{schema_name}!"
-        Utils.define_with_collision_policy(singleton_class, reset_method_name, collision: collision) do
-          define_singleton_method(reset_method_name) do
-            @_expectant_schemas[schema_name].reset!
-          end
-        end
-
-        # Define validators
-        method_name = Utils.validator_method_name(field_method_name, Expectant.configuration)
-        Utils.define_with_collision_policy(singleton_class, method_name, collision: collision) do
-          define_singleton_method(method_name) do |*field_names, &block|
-            @_expectant_schemas[schema_name].add_validator({
-              name: if field_names.empty?
-                      nil
-                    else
-                      ((field_names.size == 1) ? field_names.first : field_names)
-                    end,
-              block: block
-            })
-          end
-        end
-
-        # Add class-level schema accessor method (e.g. MyClass.inputs)
-        Utils.define_with_collision_policy(singleton_class, schema_name, collision: collision) do
-          define_singleton_method(schema_name) do
-            @_expectant_schemas[schema_name]
-          end
-        end
-
-        # Add instance-level schema accessor method (e.g. instance.inputs)
-        if !instance_methods(false).include?(schema_name)
-          define_method(schema_name) do
-            BoundSchema.new(self, self.class.instance_variable_get(:@_expectant_schemas)[schema_name])
-          end
-        elsif collision == :force
-          define_method(schema_name) do
-            BoundSchema.new(self, self.class.instance_variable_get(:@_expectant_schemas)[schema_name])
-          end
-        elsif collision == :error
-          raise ConfigurationError, "Instance method #{schema_name} already defined"
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative "utils"
+require_relative "schema"
+require_relative "bound_schema"
+
+module Expectant
+  module DSL
+    def self.included(base)
+      base.include(Types)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def self.extended(base)
+        base.class_eval do
+          @_expectant_schemas = {}
+        end
+      end
+
+      def inherited(sub)
+        return unless instance_variable_defined?(:@_expectant_schemas)
+        return if @_expectant_schemas.empty?
+
+        # Deep copy each schema (fields + validators)
+        parent_schemas = @_expectant_schemas
+        duped = parent_schemas.transform_values { |schema| schema.duplicate }
+
+        sub.instance_variable_set(:@_expectant_schemas, duped)
+      end
+
+      # Define a new expectation schema
+      # Options:
+      #   collision: :error|:force -> method name collision policy for dynamic definitions
+      #   singular: string|symbol  -> control singular name for the schema
+      #   validation: :permissive|:strict -> unknown key handling
+      def expects(schema_name, collision: :error, singular: nil, validation: :permissive)
+        field_method_name = Utils.singularize(schema_name.to_sym)
+        if !singular.nil?
+          if singular.is_a?(String) || singular.is_a?(Symbol)
+            field_method_name = singular.to_sym
+          else
+            raise ConfigurationError, "Invalid singular option: #{singular.inspect}"
+          end
+        end
+
+        validation = validation.to_sym
+        if ![:permissive, :strict].include?(validation)
+          raise ConfigurationError, "Invalid validation option: #{validation.inspect}"
+        end
+
+        schema = schema_name.to_sym
+
+        if @_expectant_schemas.key?(schema)
+          raise SchemaError, "Schema :#{schema} already defined"
+        else
+          create_schema(
+            schema,
+            collision: collision,
+            field_method_name: field_method_name,
+            validation: validation
+          )
+        end
+
+        self
+      end
+
+      def reset_inherited_expectations!
+        @_expectant_schemas = {}
+      end
+
+      private
+
+      def create_schema(schema_name, collision: :error, field_method_name: nil, validation: :permissive)
+        @_expectant_schemas[schema_name] = Schema.new(schema_name, validation: validation)
+
+        # Dynamically define the field definition method
+        # (e.g. input for :inputs, datum for :data)
+        Utils.define_with_collision_policy(singleton_class, field_method_name, collision: collision) do
+          define_singleton_method(field_method_name) do |name, **options|
+            expectation = Expectation.new(name, **options)
+            @_expectant_schemas[schema_name].add_field(expectation)
+            expectation
+          end
+        end
+
+        # Reset a schema
+        reset_method_name = "reset_#{schema_name}!"
+        Utils.define_with_collision_policy(singleton_class, reset_method_name, collision: collision) do
+          define_singleton_method(reset_method_name) do
+            @_expectant_schemas[schema_name].reset!
+          end
+        end
+
+        # Define validators
+        method_name = Utils.validator_method_name(field_method_name, Expectant.configuration)
+        Utils.define_with_collision_policy(singleton_class, method_name, collision: collision) do
+          define_singleton_method(method_name) do |*field_names, &block|
+            @_expectant_schemas[schema_name].add_validator({
+              name: if field_names.empty?
+                      nil
+                    else
+                      ((field_names.size == 1) ? field_names.first : field_names)
+                    end,
+              block: block
+            })
+          end
+        end
+
+        # Add class-level schema accessor method (e.g. MyClass.inputs)
+        Utils.define_with_collision_policy(singleton_class, schema_name, collision: collision) do
+          define_singleton_method(schema_name) do
+            @_expectant_schemas[schema_name]
+          end
+        end
+
+        # Add instance-level schema accessor method (e.g. instance.inputs)
+        if !instance_methods(false).include?(schema_name)
+          define_method(schema_name) do
+            BoundSchema.new(self, self.class.instance_variable_get(:@_expectant_schemas)[schema_name])
+          end
+        elsif collision == :force
+          define_method(schema_name) do
+            BoundSchema.new(self, self.class.instance_variable_get(:@_expectant_schemas)[schema_name])
+          end
+        elsif collision == :error
+          raise ConfigurationError, "Instance method #{schema_name} already defined"
+        end
+      end
+    end
+  end
+end

data/lib/expectant/errors.rb

@@ -1,8 +1,8 @@
-# frozen_string_literal: true
-
-module Expectant
-  class Error < StandardError; end
-  class ConfigurationError < Error; end
-  class SchemaError < Error; end
-  class ValidationError < Error; end
-end
+# frozen_string_literal: true
+
+module Expectant
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class SchemaError < Error; end
+  class ValidationError < Error; end
+end

data/lib/expectant/expectation.rb

@@ -1,37 +1,37 @@
-# frozen_string_literal: true
-
-module Expectant
-  class Expectation
-    attr_reader :name, :type, :dry_type, :fallback, :default
-
-    def initialize(name, type: nil, default: nil, optional: false, fallback: nil, **options)
-      @name = name
-      @type = type
-      @default = default
-      @fallback = fallback
-      @options = options
-
-      base_type = Types.resolve(type)
-      base_type = base_type.optional if optional
-      # if default is a proc, we call it at runtime
-      @dry_type = if !default.nil? && !default.respond_to?(:call)
-        base_type.default(default)
-      else
-        base_type
-      end
-    end
-
-    # A field is required if it's not optional and has no default
-    def required?
-      !@dry_type.optional? && !has_default?
-    end
-
-    def has_default?
-      @dry_type.default? || !@default.nil?
-    end
-
-    def has_fallback?
-      !@fallback.nil?
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Expectant
+  class Expectation
+    attr_reader :name, :type, :dry_type, :fallback, :default, :metadata
+
+    def initialize(name, type: nil, default: nil, optional: false, fallback: nil, **options)
+      @name = name
+      @type = type
+      @default = default
+      @fallback = fallback
+      @metadata = options
+
+      base_type = Types.resolve(type)
+      base_type = base_type.optional if optional
+      # if default is a proc, we call it at runtime
+      @dry_type = if !default.nil? && !default.respond_to?(:call)
+        base_type.default(default)
+      else
+        base_type
+      end
+    end
+
+    # A field is required if it's not optional and has no default
+    def required?
+      !@dry_type.optional? && !has_default?
+    end
+
+    def has_default?
+      @dry_type.default? || !@default.nil?
+    end
+
+    def has_fallback?
+      !@fallback.nil?
+    end
+  end
+end

data/lib/expectant/schema.rb

@@ -1,94 +1,98 @@
-# frozen_string_literal: true
-
-require "dry/validation"
-
-module Expectant
-  class Schema
-    attr_reader :name, :fields, :validators
-
-    def initialize(name)
-      @name = name
-      @fields = []
-      @validators = []
-      @contract_class = nil
-    end
-
-    def keys
-      @fields.map(&:name)
-    end
-
-    def contract
-      @contract_class ||= build_contract
-    end
-
-    def duplicate
-      dup = self.class.new(@name)
-      dup.instance_variable_set(:@fields, @fields.dup)
-      dup.instance_variable_set(:@validators, @validators.dup)
-      dup
-    end
-
-    def add_field(expectation)
-      @fields << expectation
-      @contract_class = nil
-    end
-
-    def add_validator(validator_def)
-      @validators << validator_def
-      @contract_class = nil
-    end
-
-    def freeze
-      @fields.freeze
-      @validators.freeze
-      super
-    end
-
-    def reset!
-      @fields = []
-      @validators = []
-      @contract_class = nil
-    end
-
-    private
-
-    def build_contract
-      fields = @fields
-      validators = @validators
-
-      Class.new(Dry::Validation::Contract) do
-        # Enable option passing (allows context and instance to be passed at validation time)
-        option :context, default: proc { {} }
-        option :instance, optional: true
-
-        # Define schema based on fields using dry-types
-        params do
-          fields.each do |field|
-            dry_type = field.dry_type
-
-            if field.required?
-              required(field.name).value(dry_type)
-            else
-              optional(field.name).value(dry_type)
-            end
-          end
-        end
-
-        # Add custom validators
-        validators.each do |validator_def|
-          if validator_def[:name]
-            # Single key or multiple keys
-            if validator_def[:name].is_a?(Array)
-              rule(*validator_def[:name], &validator_def[:block])
-            else
-              rule(validator_def[:name], &validator_def[:block])
-            end
-          else
-            # Global rule without a specific field
-            rule(&validator_def[:block])
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "dry/validation"
+
+module Expectant
+  class Schema
+    attr_reader :name, :fields, :validators, :validation
+
+    def initialize(name, validation: :permissive)
+      @name = name
+      @fields = []
+      @validators = []
+      @contract_class = nil
+      @validation = validation
+    end
+
+    def keys
+      @fields.map(&:name)
+    end
+
+    def contract
+      @contract_class ||= build_contract
+    end
+
+    def duplicate
+      dup = self.class.new(@name, validation: @validation)
+      dup.instance_variable_set(:@fields, @fields.dup)
+      dup.instance_variable_set(:@validators, @validators.dup)
+      dup
+    end
+
+    def add_field(expectation)
+      @fields << expectation
+      @contract_class = nil
+    end
+
+    def add_validator(validator_def)
+      @validators << validator_def
+      @contract_class = nil
+    end
+
+    def freeze
+      @fields.freeze
+      @validators.freeze
+      super
+    end
+
+    def reset!
+      @fields = []
+      @validators = []
+      @contract_class = nil
+    end
+
+    private
+
+    def build_contract
+      fields = @fields
+      validators = @validators
+      validation_mode = @validation
+
+      Class.new(Dry::Validation::Contract) do
+        # Enable option passing (allows context and instance to be passed at validation time)
+        option :context, default: proc { {} }
+        option :instance, optional: true
+
+        # Define schema based on fields using dry-types
+        params do
+          config.validate_keys = true if validation_mode == :strict
+
+          fields.each do |field|
+            dry_type = field.dry_type
+
+            if field.required?
+              required(field.name).value(dry_type)
+            else
+              optional(field.name).value(dry_type)
+            end
+          end
+        end
+
+        # Add custom validators
+        validators.each do |validator_def|
+          if validator_def[:name]
+            # Single key or multiple keys
+            if validator_def[:name].is_a?(Array)
+              rule(*validator_def[:name], &validator_def[:block])
+            else
+              rule(validator_def[:name], &validator_def[:block])
+            end
+          else
+            # Global rule without a specific field
+            rule(&validator_def[:block])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/expectant/types.rb

@@ -1,56 +1,56 @@
-# frozen_string_literal: true
-
-require "dry-types"
-
-module Expectant
-  module Types
-    include Dry.Types()
-
-    def self.resolve(type_definition)
-      case type_definition
-      when nil
-        Any
-      when Symbol
-        resolve_symbol(type_definition)
-      when Dry::Types::Type
-        # Already a dry-type, return as-is
-        type_definition
-      when Class
-        Instance(type_definition)
-      else
-        raise ConfigurationError, "Invalid type definition: #{type_definition}"
-      end
-    end
-
-    def self.resolve_symbol(symbol)
-      case symbol
-      when :string, :str
-        Params::String
-      when :integer, :int
-        Params::Integer
-      when :float
-        Params::Float
-      when :decimal
-        Params::Decimal
-      when :boolean, :bool
-        Params::Bool
-      when :date
-        Params::Date
-      when :datetime
-        Params::DateTime
-      when :time
-        Params::Time
-      when :array
-        Params::Array
-      when :hash
-        Params::Hash
-      when :symbol, :sym
-        Symbol
-      when :any, :nil
-        Any
-      else
-        raise ConfigurationError, "Unknown type symbol: #{symbol}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "dry-types"
+
+module Expectant
+  module Types
+    include Dry.Types()
+
+    def self.resolve(type_definition)
+      case type_definition
+      when nil
+        Any
+      when Symbol
+        resolve_symbol(type_definition)
+      when Dry::Types::Type
+        # Already a dry-type, return as-is
+        type_definition
+      when Class
+        Instance(type_definition)
+      else
+        raise ConfigurationError, "Invalid type definition: #{type_definition}"
+      end
+    end
+
+    def self.resolve_symbol(symbol)
+      case symbol
+      when :string, :str
+        Params::String
+      when :integer, :int
+        Params::Integer
+      when :float
+        Params::Float
+      when :decimal
+        Params::Decimal
+      when :boolean, :bool
+        Params::Bool
+      when :date
+        Params::Date
+      when :datetime
+        Params::DateTime
+      when :time
+        Params::Time
+      when :array
+        Params::Array
+      when :hash
+        Params::Hash
+      when :symbol, :sym
+        Symbol
+      when :any, :nil
+        Any
+      else
+        raise ConfigurationError, "Unknown type symbol: #{symbol}"
+      end
+    end
+  end
+end