dry-types 1.7.2 → 1.8.2

data/lib/dry/types/composition.rb

@@ -12,7 +12,11 @@ module Dry
       include Options
       include Meta
       include Printable
-      include Dry::Equalizer(:left, :right, :options, :meta, inspect: false, immutable: true)
+      include ::Dry::Equalizer(
+        :left, :right, :options, :meta,
+        inspect: false,
+        immutable: true
+      )
 
       # @return [Type]
       attr_reader :left
@@ -35,7 +39,7 @@ module Dry
         ast_type = Inflector.underscore(composition_name).to_sym
         base.define_singleton_method(:ast_type) { ast_type }
         base.define_singleton_method(:composition_name) { composition_name }
-        base.const_set("Constrained", Class.new(base) { include Constrained })
+        base.const_set("Constrained", ::Class.new(base) { include Constrained })
       end
 
       # @param [Type] left
@@ -52,55 +56,41 @@ module Dry
       # @return [String]
       #
       # @api public
-      def name
-        [left, right].map(&:name).join(" #{self.class.operator} ")
-      end
+      def name = "#{left.name} #{self.class.operator} #{right.name}"
 
       # @return [false]
       #
       # @api public
-      def default?
-        false
-      end
+      def default? = false
 
       # @return [false]
       #
       # @api public
-      def constrained?
-        false
-      end
+      def constrained? = false
 
       # @return [Boolean]
       #
       # @api public
-      def optional?
-        false
-      end
+      def optional? = false
 
       # @param [Object] input
       #
       # @return [Object]
       #
       # @api private
-      def call_unsafe(input)
-        raise NotImplementedError
-      end
+      def call_unsafe(input) = raise ::NotImplementedError
 
       # @param [Object] input
       #
       # @return [Object]
       #
       # @api private
-      def call_safe(input, &block)
-        raise NotImplementedError
-      end
+      def call_safe(input, &) = raise ::NotImplementedError
 
       # @param [Object] input
       #
       # @api public
-      def try(input)
-        raise NotImplementedError
-      end
+      def try(input, &) = raise ::NotImplementedError
 
       # @api private
       def success(input)
@@ -108,7 +98,7 @@ module Dry
         if result.success?
           result
         else
-          raise ArgumentError, "Invalid success value '#{input}' for #{inspect}"
+          raise ::ArgumentError, "Invalid success value '#{input}' for #{inspect}"
         end
       end
 
@@ -118,7 +108,7 @@ module Dry
         if result.failure?
           result
         else
-          raise ArgumentError, "Invalid failure value '#{input}' for #{inspect}"
+          raise ::ArgumentError, "Invalid failure value '#{input}' for #{inspect}"
         end
       end
 
@@ -127,9 +117,7 @@ module Dry
       # @return [Boolean]
       #
       # @api private
-      def primitive?(value)
-        raise NotImplementedError
-      end
+      def primitive?(value) = raise ::NotImplementedError
 
       # @see Nominal#to_ast
       #
@@ -144,9 +132,7 @@ module Dry
       # @return [Proc]
       #
       # @api public
-      def to_proc
-        proc { |value| self.(value) }
-      end
+      def to_proc = proc { |value| self.(value) }
     end
   end
 end

data/lib/dry/types/constrained/coercible.rb

@@ -37,7 +37,7 @@ module Dry
         # @see Dry::Types::Constrained#try
         #
         # @api public
-        def try(input, &block)
+        def try(input, &)
           result = type.try(input)
 
           if result.success?
@@ -47,10 +47,10 @@ module Dry
               result
             else
               failure = failure(result.input, ConstraintError.new(validation, input))
-              block ? yield(failure) : failure
+              block_given? ? yield(failure) : failure
             end
           else
-            block ? yield(result) : result
+            block_given? ? yield(result) : result
           end
         end
       end

data/lib/dry/types/constrained.rb

@@ -10,7 +10,7 @@ module Dry
       include Decorator
       include Builder
       include Printable
-      include Dry::Equalizer(:type, :rule, inspect: false, immutable: true)
+      include ::Dry::Equalizer(:type, :rule, inspect: false, immutable: true)
 
       # @return [Dry::Logic::Rule]
       attr_reader :rule
@@ -41,9 +41,9 @@ module Dry
       # @return [Object]
       #
       # @api private
-      def call_safe(input, &block)
+      def call_safe(input, &)
         if rule[input]
-          type.call_safe(input, &block)
+          type.call_safe(input, &)
         else
           yield
         end
@@ -64,19 +64,22 @@ module Dry
       #   @return [Object]
       #
       # @api public
-      def try(input, &block)
+      def try(input, &)
         result = rule.(input)
 
         if result.success?
-          type.try(input, &block)
+          type.try(input, &)
         else
           failure = failure(input, ConstraintError.new(result, input))
           block_given? ? yield(failure) : failure
         end
       end
 
-      # @param [Hash] options
-      #   The options hash provided to {Types.Rule} and combined
+      # @param *nullary_rules [Array<Symbol>] a list of rules that do not require an additional
+      #   argument (e.g., :odd)
+      # @param **unary_rules [Hash] a list of rules that require an additional argument
+      #   (e.g., gt: 0)
+      #   The parameters are merger to create a rules hash provided to {Types.Rule} and combined
       #   using {&} with previous {#rule}
       #
       # @return [Constrained]
@@ -84,33 +87,31 @@ module Dry
       # @see Dry::Logic::Operators#and
       #
       # @api public
-      def constrained(options)
-        with(rule: rule & Types.Rule(options))
+      def constrained(*nullary_rules, **unary_rules)
+        nullary_rules_hash = parse_arguments(nullary_rules)
+
+        rules = nullary_rules_hash.merge(unary_rules)
+
+        with(rule: rule & Types.Rule(rules))
       end
 
       # @return [true]
       #
       # @api public
-      def constrained?
-        true
-      end
+      def constrained? = true
 
       # @param [Object] value
       #
       # @return [Boolean]
       #
       # @api public
-      def ===(value)
-        valid?(value)
-      end
+      def ===(value) = valid?(value)
 
       # Build lax type. Constraints are not applicable to lax types hence unwrapping
       #
       # @return [Lax]
       # @api public
-      def lax
-        type.lax
-      end
+      def lax = type.lax
 
       # @see Nominal#to_ast
       # @api public
@@ -119,9 +120,7 @@ module Dry
       end
 
       # @api private
-      def constructor_type
-        type.constructor_type
-      end
+      def constructor_type = type.constructor_type
 
       private
 
@@ -130,8 +129,17 @@ module Dry
       # @return [Boolean]
       #
       # @api private
-      def decorate?(response)
-        super || response.is_a?(Constructor)
+      def decorate?(response) = super || response.is_a?(Constructor)
+
+      # @param [Array] positional_args
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def parse_arguments(positional_arguments)
+        return positional_arguments.first if positional_arguments.first.is_a?(::Hash)
+
+        positional_arguments.flatten.zip([]).to_h
       end
     end
   end

data/lib/dry/types/constructor/function.rb

@@ -13,10 +13,10 @@ module Dry
         #
         # @api private
         class Safe < Function
-          def call(input, &block)
-            @fn.(input, &block)
+          def call(input, &)
+            @fn.(input)
           rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
-            CoercionError.handle(e, &block)
+            CoercionError.handle(e, &)
           end
         end
 
@@ -61,16 +61,16 @@ module Dry
                 ::Module.new do
                   if safe
                     module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-                      def call(input, &block)              # def call(input, &block)
-                        @target.#{method}(input, &block)   #   @target.coerve(input, &block)
-                      end                                  # end
+                      def call(input, &)             # def call(input, &)
+                        @target.#{method}(input, &)  #   @target.coerce(input, &)
+                      end                            # end
                     RUBY
                   else
                     module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-                      def call(input, &block)                                        # def call(input, &block)
+                      def call(input, &)                                             # def call(input, &)
                         @target.#{method}(input)                                     #   @target.coerce(input)
                       rescue ::NoMethodError, ::TypeError, ::ArgumentError => error  # rescue ::NoMethodError, ::TypeError, ::ArgumentError => error
-                        CoercionError.handle(error, &block)                          #   CoercionError.handle(error, &block)
+                        CoercionError.handle(error, &)                               #   CoercionError.handle(error, &)
                       end                                                            # end
                     RUBY
                   end
@@ -83,19 +83,17 @@ module Dry
           #
           # @api private
           class PrivateCall < MethodCall
-            def call(input, &block)
-              @target.send(@name, input, &block)
-            end
+            def call(input, &) = @target.send(@name, input, &)
           end
 
           # Coercion via an unsafe private method call
           #
           # @api private
           class PrivateSafeCall < PrivateCall
-            def call(input, &block)
+            def call(input, &)
               @target.send(@name, input)
             rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
-              CoercionError.handle(e, &block)
+              CoercionError.handle(e, &)
             end
           end
 
@@ -115,23 +113,19 @@ module Dry
             @name = fn.name
           end
 
-          def to_ast
-            [:method, target, name]
-          end
+          def to_ast = [:method, target, name]
         end
 
         class Wrapper < Function
           # @return [Object]
-          def call(input, type, &block)
-            @fn.(input, type, &block)
+          def call(input, type, &)
+            @fn.(input, type, &)
           rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
-            CoercionError.handle(e, &block)
+            CoercionError.handle(e, &)
           end
           alias_method :[], :call
 
-          def arity
-            2
-          end
+          def arity = 2
         end
 
         # Choose or build specialized invokation code for a callable
@@ -175,19 +169,13 @@ module Dry
         end
 
         # @return [Object]
-        def call(input, &block)
-          @fn.(input, &block)
-        end
+        def call(input, &) = @fn.(input, &)
         alias_method :[], :call
 
         # @return [Integer]
-        def arity
-          1
-        end
+        def arity = 1
 
-        def wrapper?
-          arity.equal?(2)
-        end
+        def wrapper? = arity.equal?(2)
 
         # @return [Array]
         def to_ast

data/lib/dry/types/constructor/wrapper.rb

@@ -8,16 +8,12 @@ module Dry
         # @return [Object]
         #
         # @api private
-        def call_safe(input, &block)
-          fn.(input, type, &block)
-        end
+        def call_safe(input, &) = fn.(input, type, &)
 
         # @return [Object]
         #
         # @api private
-        def call_unsafe(input)
-          fn.(input, type)
-        end
+        def call_unsafe(input) = fn.(input, type)
 
         # @param [Object] input
         # @param [#call,nil] block
@@ -26,13 +22,13 @@ module Dry
         # @return [Object] if block given and try fails
         #
         # @api public
-        def try(input, &block)
+        def try(input, &)
           value = fn.(input, type)
         rescue CoercionError => e
           failure = failure(input, e)
           block_given? ? yield(failure) : failure
         else
-          type.try(value, &block)
+          type.try(value, &)
         end
 
         # Define a constructor for the type
@@ -85,9 +81,7 @@ module Dry
         # Replace underlying type
         #
         # @api private
-        def __new__(type)
-          self.class.new(type, *@__args__.drop(1), **@options)
-        end
+        def __new__(type) = self.class.new(type, *@__args__.drop(1), **@options)
       end
     end
   end

data/lib/dry/types/constructor.rb

@@ -7,7 +7,7 @@ module Dry
     #
     # @api public
     class Constructor < Nominal
-      include Dry::Equalizer(:type, :options, inspect: false, immutable: true)
+      include ::Dry::Equalizer(:type, :options, inspect: false, immutable: true)
 
       # @return [#call]
       attr_reader :fn
@@ -77,9 +77,7 @@ module Dry
       # @return [Object]
       #
       # @api private
-      def call_unsafe(input)
-        type.call_unsafe(fn.(input))
-      end
+      def call_unsafe(input) = type.call_unsafe(fn.(input))
 
       # @param [Object] input
       # @param [#call,nil] block
@@ -88,13 +86,13 @@ module Dry
       # @return [Object] if block given and try fails
       #
       # @api public
-      def try(input, &block)
+      def try(input, &)
         value = fn.(input)
       rescue CoercionError => e
         failure = failure(input, e)
         block_given? ? yield(failure) : failure
       else
-        type.try(value, &block)
+        type.try(value, &)
       end
 
       # Build a new constructor by appending a block to the coercion function
@@ -121,9 +119,7 @@ module Dry
       # @return [Class]
       #
       # @api private
-      def constrained_type
-        Constrained::Coercible
-      end
+      def constrained_type = Constrained::Coercible
 
       # @see Nominal#to_ast
       #
@@ -150,18 +146,14 @@ module Dry
       #
       # @return [Lax]
       # @api public
-      def lax
-        Lax.new(constructor_type[type.lax, **options])
-      end
+      def lax = Lax.new(constructor_type[type.lax, **options])
 
       # Wrap the type with a proc
       #
       # @return [Proc]
       #
       # @api public
-      def to_proc
-        proc { |value| self.(value) }
-      end
+      def to_proc = proc { self.(_1) }
 
       private
 
@@ -181,9 +173,9 @@ module Dry
       # @param [#call, nil] block
       #
       # @api private
-      def method_missing(method, *args, &block)
+      def method_missing(method, ...)
         if type.respond_to?(method)
-          response = type.public_send(method, *args, &block)
+          response = type.public_send(method, ...)
 
           if response.is_a?(Type) && response.instance_of?(type.class)
             response.constructor_type[response, **options]

data/lib/dry/types/core.rb

@@ -35,13 +35,15 @@ module Dry
     }.freeze
 
     # All built-in primitives
-    ALL_PRIMITIVES = [KERNEL_COERCIBLE, METHOD_COERCIBLE, NON_COERCIBLE].reduce(&:merge).freeze
+    ALL_PRIMITIVES = [
+      KERNEL_COERCIBLE, METHOD_COERCIBLE, NON_COERCIBLE
+    ].reduce(&:merge).freeze
 
     # All coercible types
     COERCIBLE = KERNEL_COERCIBLE.merge(METHOD_COERCIBLE).freeze
 
     # All built-in primitives except {NilClass}
-    NON_NIL = ALL_PRIMITIVES.reject { |name, _| name == :nil }.freeze
+    NON_NIL = ALL_PRIMITIVES.except(:nil).freeze
 
     # Register generic types for {ALL_PRIMITIVES}
     ALL_PRIMITIVES.each do |name, primitive|
@@ -58,14 +60,17 @@ module Dry
 
     # Register {KERNEL_COERCIBLE} types
     KERNEL_COERCIBLE.each do |name, primitive|
-      register("coercible.#{name}",
-               self["nominal.#{name}"].constructor(Kernel.method(primitive.name)))
+      register(
+        "coercible.#{name}",
+        self["nominal.#{name}"].constructor(::Kernel.method(primitive.name))
+      )
     end
 
     # Register {METHOD_COERCIBLE} types
     METHOD_COERCIBLE.each_key do |name|
       register(
-        "coercible.#{name}", self["nominal.#{name}"].constructor(&METHOD_COERCIBLE_METHODS[name])
+        "coercible.#{name}",
+        self["nominal.#{name}"].constructor(&METHOD_COERCIBLE_METHODS[name])
       )
     end
 
@@ -78,7 +83,10 @@ module Dry
 
     # Register optional {COERCIBLE} types
     COERCIBLE.each_key do |name|
-      register("optional.coercible.#{name}", self["coercible.#{name}"].optional)
+      register(
+        "optional.coercible.#{name}",
+        self["coercible.#{name}"].optional
+      )
     end
 
     # Register `:bool` since it's common and not a built-in Ruby type :(

data/lib/dry/types/decorator.rb

@@ -24,23 +24,17 @@ module Dry
       # @return [Object] if block given and try fails
       #
       # @api public
-      def try(input, &block)
-        type.try(input, &block)
-      end
+      def try(input, &) = type.try(input, &)
 
       # @return [Boolean]
       #
       # @api public
-      def default?
-        type.default?
-      end
+      def default? = type.default?
 
       # @return [Boolean]
       #
       # @api public
-      def constrained?
-        type.constrained?
-      end
+      def constrained? = type.constrained?
 
       # @param [Symbol] meth
       # @param [Boolean] include_private
@@ -57,9 +51,7 @@ module Dry
       # @return [Proc]
       #
       # @api public
-      def to_proc
-        proc { |value| self.(value) }
-      end
+      def to_proc = proc { |value| self.(value) }
 
       private
 
@@ -68,9 +60,7 @@ module Dry
       # @return [Boolean]
       #
       # @api private
-      def decorate?(response)
-        response.is_a?(type.class)
-      end
+      def decorate?(response) = response.is_a?(type.class)
 
       # Delegates missing methods to {#type}
       #
@@ -79,9 +69,9 @@ module Dry
       # @param [#call, nil] block
       #
       # @api private
-      def method_missing(meth, *args, &block)
+      def method_missing(meth, ...)
         if type.respond_to?(meth)
-          response = type.public_send(meth, *args, &block)
+          response = type.public_send(meth, ...)
 
           if decorate?(response)
             __new__(response)
@@ -92,7 +82,6 @@ module Dry
           super
         end
       end
-      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
       # Replace underlying type
       #