dry-types 1.0.0 → 1.2.1

data/lib/dry/types/builder.rb

@@ -75,7 +75,7 @@ module Dry
             ' Be careful: types will return the same instance of the default'\
             ' value every time. Call `.freeze` when setting the default'\
             ' or pass `shared: true` to discard this warning.'\
-            "\n#{ where }",
+            "\n#{where}",
             tag: :'dry-types'
           )
         end
@@ -127,7 +127,7 @@ module Dry
       #
       # @api public
       def constructor(constructor = nil, **options, &block)
-        constructor_type.new(with(options), fn: constructor || block)
+        constructor_type.new(with(**options), fn: constructor || block)
       end
     end
   end

data/lib/dry/types/builder_methods.rb

@@ -25,7 +25,7 @@ module Dry
       #
       # @return [Dry::Types::Array]
       def Array(type)
-        self::Array.of(type)
+        Strict(::Array).of(type)
       end
 
       # Build a hash schema
@@ -34,7 +34,7 @@ module Dry
       #
       # @return [Dry::Types::Array]
       def Hash(type_map)
-        self::Hash.schema(type_map)
+        Strict(::Hash).schema(type_map)
       end
 
       # Build a type which values are instances of a given class
@@ -49,7 +49,7 @@ module Dry
       #
       # @return [Dry::Types::Type]
       def Instance(klass)
-        Nominal.new(klass).constrained(type: klass)
+        Nominal(klass).constrained(type: klass)
       end
       alias_method :Strict, :Instance
 
@@ -60,7 +60,7 @@ module Dry
       #
       # @return [Dry::Types::Type]
       def Value(value)
-        Nominal.new(value.class).constrained(eql: value)
+        Nominal(value.class).constrained(eql: value)
       end
 
       # Build a type with a single value
@@ -70,7 +70,7 @@ module Dry
       #
       # @return [Dry::Types::Type]
       def Constant(object)
-        Nominal.new(object.class).constrained(is: object)
+        Nominal(object.class).constrained(is: object)
       end
 
       # Build a constructor type
@@ -82,7 +82,11 @@ module Dry
       #
       # @return [Dry::Types::Type]
       def Constructor(klass, cons = nil, &block)
-        Nominal.new(klass).constructor(cons || block || klass.method(:new))
+        if klass.is_a?(Type)
+          klass.constructor(cons || block || klass.method(:new))
+        else
+          Nominal(klass).constructor(cons || block || klass.method(:new))
+        end
       end
 
       # Build a nominal type
@@ -91,7 +95,13 @@ module Dry
       #
       # @return [Dry::Types::Type]
       def Nominal(klass)
-        Nominal.new(klass)
+        if klass <= ::Array
+          Array.new(klass)
+        elsif klass <= ::Hash
+          Hash.new(klass)
+        else
+          Nominal.new(klass)
+        end
       end
 
       # Build a map type
@@ -105,7 +115,23 @@ module Dry
       #
       # @return [Dry::Types::Map]
       def Map(key_type, value_type)
-        Types['nominal.hash'].map(key_type, value_type)
+        Nominal(::Hash).map(key_type, value_type)
+      end
+
+      # Builds a constrained nominal type accepting any value that
+      # responds to given methods
+      #
+      # @example
+      #   Types::Callable = Types.Interface(:call)
+      #   Types::Contact = Types.Interface(:name, :address)
+      #
+      # @param methods [Array<String, Symbol>] Method names
+      #
+      # @return [Dry::Types::Contrained]
+      def Interface(*methods)
+        methods.reduce(Types['nominal.any']) do |type, method|
+          type.constrained(respond_to: method)
+        end
       end
     end
   end

data/lib/dry/types/coercions.rb

@@ -36,8 +36,8 @@ module Dry
         if input.respond_to?(:to_str)
           begin
             ::Date.parse(input)
-          rescue ArgumentError, RangeError => error
-            CoercionError.handle(error, &block)
+          rescue ArgumentError, RangeError => e
+            CoercionError.handle(e, &block)
           end
         elsif block_given?
           yield
@@ -57,8 +57,8 @@ module Dry
         if input.respond_to?(:to_str)
           begin
             ::DateTime.parse(input)
-          rescue ArgumentError => error
-            CoercionError.handle(error, &block)
+          rescue ArgumentError => e
+            CoercionError.handle(e, &block)
           end
         elsif block_given?
           yield
@@ -78,8 +78,8 @@ module Dry
         if input.respond_to?(:to_str)
           begin
             ::Time.parse(input)
-          rescue ArgumentError => error
-            CoercionError.handle(error, &block)
+          rescue ArgumentError => e
+            CoercionError.handle(e, &block)
           end
         elsif block_given?
           yield
@@ -88,6 +88,19 @@ module Dry
         end
       end
 
+      # @param [#to_sym, Object] input
+      #
+      # @return [Symbol, Object]
+      #
+      # @raise CoercionError
+      #
+      # @api public
+      def to_symbol(input, &block)
+        input.to_sym
+      rescue NoMethodError => e
+        CoercionError.handle(e, &block)
+      end
+
       private
 
       # Checks whether String is empty

data/lib/dry/types/coercions/params.rb

@@ -71,8 +71,8 @@ module Dry
           else
             Integer(input)
           end
-        rescue ArgumentError, TypeError => error
-          CoercionError.handle(error, &block)
+        rescue ArgumentError, TypeError => e
+          CoercionError.handle(e, &block)
         end
 
         # @param [#to_f, Object] input
@@ -84,8 +84,8 @@ module Dry
         # @api public
         def self.to_float(input, &block)
           Float(input)
-        rescue ArgumentError, TypeError => error
-          CoercionError.handle(error, &block)
+        rescue ArgumentError, TypeError => e
+          CoercionError.handle(e, &block)
         end
 
         # @param [#to_d, Object] input

data/lib/dry/types/compiler.rb

@@ -68,12 +68,12 @@ module Dry
 
       def visit_hash(node)
         opts, meta = node
-        registry['nominal.hash'].with(opts.merge(meta: meta))
+        registry['nominal.hash'].with(**opts, meta: meta)
       end
 
       def visit_schema(node)
         keys, options, meta = node
-        registry['nominal.hash'].schema(keys.map { |key| visit(key) }).with(options.merge(meta: meta))
+        registry['nominal.hash'].schema(keys.map { |key| visit(key) }).with(**options, meta: meta)
       end
 
       def visit_json_hash(node)

data/lib/dry/types/constrained.rb

@@ -24,7 +24,7 @@ module Dry
       # @param [Hash] options
       #
       # @api public
-      def initialize(type, options)
+      def initialize(type, **options)
         super
         @rule = options.fetch(:rule)
       end
@@ -126,6 +126,11 @@ module Dry
         [:constrained, [type.to_ast(meta: meta), rule.to_ast]]
       end
 
+      # @api private
+      def constructor_type
+        type.constructor_type
+      end
+
       private
 
       # @param [Object] response

data/lib/dry/types/constructor.rb

@@ -12,15 +12,13 @@ module Dry
     class Constructor < Nominal
       include Dry::Equalizer(:type, :options, inspect: false)
 
-      private :meta
-
       # @return [#call]
       attr_reader :fn
 
       # @return [Type]
       attr_reader :type
 
-      undef :constrained?
+      undef :constrained?, :meta, :optional?, :primitive, :default?, :name
 
       # @param [Builder, Object] input
       # @param [Hash] options
@@ -46,36 +44,11 @@ module Dry
         super(type, **options, fn: fn)
       end
 
-      # Return the inner type's primitive
-      #
-      # @return [Class]
-      #
-      # @api public
-      def primitive
-        type.primitive
-      end
-
-      # Return the inner type's name
-      #
-      # @return [String]
-      #
-      # @api public
-      def name
-        type.name
-      end
-
-      # @return [Boolean]
-      #
-      # @api public
-      def default?
-        type.default?
-      end
-
       # @return [Object]
       #
       # @api private
       def call_safe(input)
-        coerced = fn.(input) { return yield }
+        coerced = fn.(input) { |output = input| return yield(output) }
         type.call_safe(coerced) { |output = coerced| yield(output) }
       end
 
@@ -95,8 +68,8 @@ module Dry
       # @api public
       def try(input, &block)
         value = fn.(input)
-      rescue CoercionError => error
-        failure = failure(input, error)
+      rescue CoercionError => e
+        failure = failure(input, e)
         block_given? ? yield(failure) : failure
       else
         type.try(value, &block)
@@ -112,7 +85,7 @@ module Dry
       #
       # @api public
       def constructor(new_fn = nil, **options, &block)
-        with({**options, fn: fn >> (new_fn || block)})
+        with(**options, fn: fn >> (new_fn || block))
       end
       alias_method :append, :constructor
       alias_method :>>, :constructor
@@ -141,7 +114,7 @@ module Dry
       #
       # @api public
       def prepend(new_fn = nil, **options, &block)
-        with({**options, fn: fn << (new_fn || block)})
+        with(**options, fn: fn << (new_fn || block))
       end
       alias_method :<<, :prepend
 
@@ -150,7 +123,7 @@ module Dry
       # @return [Lax]
       # @api public
       def lax
-        Lax.new(Constructor.new(type.lax, options))
+        Lax.new(Constructor.new(type.lax, **options))
       end
 
       # Wrap the type with a proc
@@ -182,10 +155,10 @@ module Dry
       # @api private
       def method_missing(method, *args, &block)
         if type.respond_to?(method)
-          response = type.__send__(method, *args, &block)
+          response = type.public_send(method, *args, &block)
 
-          if composable?(response)
-            response.constructor_type.new(response, options)
+          if response.is_a?(Type) && type.class == response.class
+            response.constructor_type.new(response, **options)
           else
             response
           end
@@ -193,11 +166,6 @@ module Dry
           super
         end
       end
-
-      # @api private
-      def composable?(value)
-        value.is_a?(Builder)
-      end
     end
   end
 end

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

@@ -1,4 +1,3 @@
-
 # frozen_string_literal: true
 
 require 'concurrent/map'
@@ -16,8 +15,8 @@ module Dry
         class Safe < Function
           def call(input, &block)
             @fn.(input, &block)
-          rescue NoMethodError, TypeError, ArgumentError => error
-            CoercionError.handle(error, &block)
+          rescue NoMethodError, TypeError, ArgumentError => e
+            CoercionError.handle(e, &block)
           end
         end
 
@@ -91,8 +90,8 @@ module Dry
           class PrivateSafeCall < PrivateCall
             def call(input, &block)
               @target.send(@name, input)
-            rescue NoMethodError, TypeError, ArgumentError => error
-              CoercionError.handle(error, &block)
+            rescue NoMethodError, TypeError, ArgumentError => e
+              CoercionError.handle(e, &block)
             end
           end
 

data/lib/dry/types/core.rb

@@ -5,7 +5,7 @@ require 'dry/types/any'
 module Dry
   module Types
     # Primitives with {Kernel} coercion methods
-    COERCIBLE = {
+    KERNEL_COERCIBLE = {
       string: String,
       integer: Integer,
       float: Float,
@@ -14,10 +14,19 @@ module Dry
       hash: ::Hash
     }.freeze
 
-    # Primitives that are non-coercible through {Kernel} methods
+    # Primitives with coercions through by convention `to_*` methods
+    METHOD_COERCIBLE = {
+      symbol: Symbol
+    }.freeze
+
+    # By convention methods to coerce {METHOD_COERCIBLE} primitives
+    METHOD_COERCIBLE_METHODS = {
+      symbol: :to_sym
+    }.freeze
+
+    # Primitives that are non-coercible
     NON_COERCIBLE = {
       nil: NilClass,
-      symbol: Symbol,
       class: Class,
       true: TrueClass,
       false: FalseClass,
@@ -28,7 +37,10 @@ module Dry
     }.freeze
 
     # All built-in primitives
-    ALL_PRIMITIVES = COERCIBLE.merge(NON_COERCIBLE).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
@@ -46,11 +58,18 @@ module Dry
       register("strict.#{name}", type)
     end
 
-    # Register {COERCIBLE} types
-    COERCIBLE.each do |name, primitive|
+    # Register {KERNEL_COERCIBLE} types
+    KERNEL_COERCIBLE.each do |name, primitive|
       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])
+      )
+    end
+
     # Register optional strict {NON_NIL} types
     NON_NIL.each_key do |name|
       register("optional.strict.#{name}", self["strict.#{name}"].optional)
@@ -64,8 +83,8 @@ module Dry
     # Register `:bool` since it's common and not a built-in Ruby type :(
     register('nominal.bool', self['nominal.true'] | self['nominal.false'])
     bool = self['strict.true'] | self['strict.false']
-    register("strict.bool", bool)
-    register("bool", bool)
+    register('strict.bool', bool)
+    register('bool', bool)
 
     register('any', Any)
     register('nominal.any', Any)

data/lib/dry/types/decorator.rb

@@ -14,7 +14,7 @@ module Dry
       attr_reader :type
 
       # @param [Type] type
-      def initialize(type, *)
+      def initialize(type, *, **)
         super
         @type = type
       end
@@ -90,7 +90,7 @@ module Dry
       # @api private
       def method_missing(meth, *args, &block)
         if type.respond_to?(meth)
-          response = type.__send__(meth, *args, &block)
+          response = type.public_send(meth, *args, &block)
 
           if decorate?(response)
             __new__(response)
@@ -101,6 +101,7 @@ module Dry
           super
         end
       end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
       # Replace underlying type
       #