dry-types 0.14.1 → 1.5.1

data/lib/dry/types/builder_methods.rb

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
+    # Common API for building type objects in a convenient way
+    #
+    #
+    # @api public
     module BuilderMethods
       # @api private
       def included(base)
@@ -8,7 +14,8 @@ module Dry
       end
 
       # Build an array type.
-      # It is a shortcut for Array.of
+      #
+      # Shortcut for Array#of.
       #
       # @example
       #   Types::Strings = Types.Array(Types::String)
@@ -17,18 +24,16 @@ module Dry
       #
       # @return [Dry::Types::Array]
       def Array(type)
-        self::Array.of(type)
+        Strict(::Array).of(type)
       end
 
       # Build a hash schema
       #
-      # @param [Symbol] schema Schema type
       # @param [Hash{Symbol => Dry::Types::Type}] type_map
       #
       # @return [Dry::Types::Array]
-      # @api public
-      def Hash(schema, type_map)
-        self::Hash.public_send(schema, type_map)
+      def Hash(type_map)
+        Strict(::Hash).schema(type_map)
       end
 
       # Build a type which values are instances of a given class
@@ -42,9 +47,8 @@ module Dry
       # @param [Class,Module] klass Class or module
       #
       # @return [Dry::Types::Type]
-      # @api public
       def Instance(klass)
-        Definition.new(klass).constrained(type: klass)
+        Nominal(klass).constrained(type: klass)
       end
       alias_method :Strict, :Instance
 
@@ -54,9 +58,8 @@ module Dry
       # @param [Object] value
       #
       # @return [Dry::Types::Type]
-      # @api public
       def Value(value)
-        Definition.new(value.class).constrained(eql: value)
+        Nominal(value.class).constrained(eql: value)
       end
 
       # Build a type with a single value
@@ -65,9 +68,8 @@ module Dry
       # @param [Object] object
       #
       # @return [Dry::Types::Type]
-      # @api public
       def Constant(object)
-        Definition.new(object.class).constrained(is: object)
+        Nominal(object.class).constrained(is: object)
       end
 
       # Build a constructor type
@@ -78,19 +80,31 @@ module Dry
       # @param [#call,nil] block Value constructor
       #
       # @return [Dry::Types::Type]
-      # @api public
       def Constructor(klass, cons = nil, &block)
-        Definition.new(klass).constructor(cons || block || klass.method(:new))
+        if klass.is_a?(Type)
+          if cons || block
+            klass.constructor(cons || block)
+          else
+            klass
+          end
+        else
+          Nominal(klass).constructor(cons || block || klass.method(:new))
+        end
       end
 
-      # Build a definition type
+      # Build a nominal type
       #
       # @param [Class] klass
       #
       # @return [Dry::Types::Type]
-      # @api public
-      def Definition(klass)
-        Definition.new(klass)
+      def Nominal(klass)
+        if klass <= ::Array
+          Array.new(klass)
+        elsif klass <= ::Hash
+          Hash.new(klass)
+        else
+          Nominal.new(klass)
+        end
       end
 
       # Build a map type
@@ -103,9 +117,24 @@ module Dry
       # @param [Type] value_type Value type
       #
       # @return [Dry::Types::Map]
-      # @api public
       def Map(key_type, value_type)
-        Types['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/json.rb

@@ -1,19 +1,55 @@
-require 'date'
-require 'bigdecimal'
-require 'bigdecimal/util'
-require 'time'
+# frozen_string_literal: true
+
+require "date"
+require "bigdecimal"
+require "bigdecimal/util"
+require "time"
 
 module Dry
   module Types
     module Coercions
+      # JSON-specific coercions
+      #
+      # @api public
       module JSON
         extend Coercions
 
+        # @param [Object] input
+        #
+        # @return [nil] if the input is nil
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_nil(input, &_block)
+          if input.nil?
+            nil
+          elsif block_given?
+            yield
+          else
+            raise CoercionError, "#{input.inspect} is not nil"
+          end
+        end
+
         # @param [#to_d, Object] input
+        #
         # @return [BigDecimal,nil]
-        def self.to_decimal(input)
-          return if input.nil?
-          input.to_d unless empty_str?(input)
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_decimal(input, &_block)
+          if input.is_a?(::Float)
+            input.to_d
+          else
+            BigDecimal(input)
+          end
+        rescue ArgumentError, TypeError
+          if block_given?
+            yield
+          else
+            raise CoercionError, "#{input} cannot be coerced to decimal"
+          end
         end
       end
     end

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

@@ -1,78 +1,165 @@
-require 'bigdecimal'
-require 'bigdecimal/util'
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
 
 module Dry
   module Types
     module Coercions
+      # Params-specific coercions
+      #
+      # @api public
       module Params
         TRUE_VALUES = %w[1 on On ON t true True TRUE T y yes Yes YES Y].freeze
         FALSE_VALUES = %w[0 off Off OFF f false False FALSE F n no No NO N].freeze
-        BOOLEAN_MAP = ::Hash[TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])].freeze
+        BOOLEAN_MAP = ::Hash[
+          TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])
+        ].merge(true => true, false => false).freeze
 
         extend Coercions
 
+        # @param [Object] input
+        #
+        # @return [nil] if the input is an empty string or nil
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_nil(input, &_block)
+          if input.nil? || empty_str?(input)
+            nil
+          elsif block_given?
+            yield
+          else
+            raise CoercionError, "#{input.inspect} is not nil"
+          end
+        end
+
         # @param [String, Object] input
+        #
         # @return [Boolean,Object]
+        #
         # @see TRUE_VALUES
         # @see FALSE_VALUES
-        def self.to_true(input)
-          BOOLEAN_MAP.fetch(input.to_s, input)
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_true(input, &_block)
+          BOOLEAN_MAP.fetch(input.to_s) do
+            if block_given?
+              yield
+            else
+              raise CoercionError, "#{input} cannot be coerced to true"
+            end
+          end
         end
 
         # @param [String, Object] input
+        #
         # @return [Boolean,Object]
+        #
         # @see TRUE_VALUES
         # @see FALSE_VALUES
-        def self.to_false(input)
-          BOOLEAN_MAP.fetch(input.to_s, input)
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_false(input, &_block)
+          BOOLEAN_MAP.fetch(input.to_s) do
+            if block_given?
+              yield
+            else
+              raise CoercionError, "#{input} cannot be coerced to false"
+            end
+          end
         end
 
         # @param [#to_int, #to_i, Object] input
+        #
         # @return [Integer, nil, Object]
-        def self.to_int(input)
-          if empty_str?(input)
-            nil
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_int(input, &block)
+          if input.is_a? String
+            Integer(input, 10)
           else
             Integer(input)
           end
-        rescue ArgumentError, TypeError
-          input
+        rescue ArgumentError, TypeError => e
+          CoercionError.handle(e, &block)
         end
 
         # @param [#to_f, Object] input
+        #
         # @return [Float, nil, Object]
-        def self.to_float(input)
-          if empty_str?(input)
-            nil
-          else
-            Float(input)
-          end
-        rescue ArgumentError, TypeError
-          input
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_float(input, &block)
+          Float(input)
+        rescue ArgumentError, TypeError => e
+          CoercionError.handle(e, &block)
         end
 
         # @param [#to_d, Object] input
+        #
         # @return [BigDecimal, nil, Object]
-        def self.to_decimal(input)
-          result = to_float(input)
-
-          if result.instance_of?(Float)
-            input.to_d
-          else
-            result
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_decimal(input, &_block)
+          to_float(input) do
+            if block_given?
+              return yield
+            else
+              raise CoercionError, "#{input.inspect} cannot be coerced to decimal"
+            end
           end
+
+          input.to_d
         end
 
         # @param [Array, String, Object] input
+        #
         # @return [Array, Object]
-        def self.to_ary(input)
-          empty_str?(input) ? [] : input
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_ary(input, &_block)
+          if empty_str?(input)
+            []
+          elsif input.is_a?(::Array)
+            input
+          elsif block_given?
+            yield
+          else
+            raise CoercionError, "#{input.inspect} cannot be coerced to array"
+          end
         end
 
         # @param [Hash, String, Object] input
+        #
         # @return [Hash, Object]
-        def self.to_hash(input)
-          empty_str?(input) ? {} : input
+        #
+        # @raise CoercionError
+        #
+        # @api public
+        def self.to_hash(input, &_block)
+          if empty_str?(input)
+            {}
+          elsif input.is_a?(::Hash)
+            input
+          elsif block_given?
+            yield
+          else
+            raise CoercionError, "#{input.inspect} cannot be coerced to hash"
+          end
         end
       end
     end

data/lib/dry/types/coercions.rb

@@ -1,50 +1,104 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
+    # Common coercion functions used by the built-in `Params` and `JSON` types
+    #
+    # @api public
     module Coercions
       include Dry::Core::Constants
 
-      # @param [String, Object] input
-      # @return [nil] if the input is an empty string
-      # @return [Object] otherwise the input object is returned
-      def to_nil(input)
-        input unless empty_str?(input)
-      end
-
       # @param [#to_str, Object] input
+      #
       # @return [Date, Object]
+      #
       # @see Date.parse
-      def to_date(input)
-        return input unless input.respond_to?(:to_str)
-        Date.parse(input)
-      rescue ArgumentError, RangeError
-        input
+      #
+      # @api public
+      def to_date(input, &block)
+        if input.respond_to?(:to_str)
+          begin
+            ::Date.parse(input)
+          rescue ArgumentError, RangeError => e
+            CoercionError.handle(e, &block)
+          end
+        elsif input.is_a?(::Date)
+          input
+        elsif block_given?
+          yield
+        else
+          raise CoercionError, "#{input.inspect} is not a string"
+        end
       end
 
       # @param [#to_str, Object] input
+      #
       # @return [DateTime, Object]
+      #
       # @see DateTime.parse
-      def to_date_time(input)
-        return input unless input.respond_to?(:to_str)
-        DateTime.parse(input)
-      rescue ArgumentError
-        input
+      #
+      # @api public
+      def to_date_time(input, &block)
+        if input.respond_to?(:to_str)
+          begin
+            ::DateTime.parse(input)
+          rescue ArgumentError => e
+            CoercionError.handle(e, &block)
+          end
+        elsif input.is_a?(::DateTime)
+          input
+        elsif block_given?
+          yield
+        else
+          raise CoercionError, "#{input.inspect} is not a string"
+        end
       end
 
       # @param [#to_str, Object] input
+      #
       # @return [Time, Object]
+      #
       # @see Time.parse
-      def to_time(input)
-        return input unless input.respond_to?(:to_str)
-        Time.parse(input)
-      rescue ArgumentError
-        input
+      #
+      # @api public
+      def to_time(input, &block)
+        if input.respond_to?(:to_str)
+          begin
+            ::Time.parse(input)
+          rescue ArgumentError => e
+            CoercionError.handle(e, &block)
+          end
+        elsif input.is_a?(::Time)
+          input
+        elsif block_given?
+          yield
+        else
+          raise CoercionError, "#{input.inspect} is not a string"
+        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
+      #
       # @param [String, Object] value
+      #
       # @return [Boolean]
+      #
+      # @api private
       def empty_str?(value)
         EMPTY_STRING.eql?(value)
       end

data/lib/dry/types/compat.rb

@@ -1,2 +0,0 @@
-require 'dry/types/compat/int'
-require 'dry/types/compat/form_types'

data/lib/dry/types/compiler.rb

@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
+require "dry/core/deprecations"
+
 module Dry
   module Types
+    # @api private
     class Compiler
+      extend ::Dry::Core::Deprecations[:'dry-types']
+
       attr_reader :registry
 
       def initialize(registry)
@@ -13,33 +20,34 @@ module Dry
 
       def visit(node)
         type, body = node
-        send(:"visit_#{ type }", body)
+        send(:"visit_#{type}", body)
       end
 
       def visit_constrained(node)
-        definition, rule, meta = node
-        Types::Constrained.new(visit(definition), rule: visit_rule(rule)).meta(meta)
+        nominal, rule = node
+        type = visit(nominal)
+        type.constrained_type.new(type, rule: visit_rule(rule))
       end
 
       def visit_constructor(node)
-        definition, fn_register_name, meta = node
-        fn = Dry::Types::FnContainer[fn_register_name]
-        primitive = visit(definition)
-        Types::Constructor.new(primitive, meta: meta, fn: fn)
+        nominal, fn = node
+        primitive = visit(nominal)
+        primitive.constructor(compile_fn(fn))
       end
 
-      def visit_safe(node)
-        ast, meta = node
-        Types::Safe.new(visit(ast), meta: meta)
+      def visit_lax(node)
+        Types::Lax.new(visit(node))
       end
+      deprecate(:visit_safe, :visit_lax)
 
-      def visit_definition(node)
+      def visit_nominal(node)
         type, meta = node
+        nominal_name = "nominal.#{Types.identifier(type)}"
 
-        if registry.registered?(type)
-          registry[type].meta(meta)
+        if registry.registered?(nominal_name)
+          registry[nominal_name].meta(meta)
         else
-          Definition.new(type, meta: meta)
+          Nominal.new(type, meta: meta)
         end
       end
 
@@ -55,65 +63,72 @@ module Dry
       def visit_array(node)
         member, meta = node
         member = member.is_a?(Class) ? member : visit(member)
-        registry['array'].of(member).meta(meta)
+        registry["nominal.array"].of(member).meta(meta)
       end
 
       def visit_hash(node)
-        constructor, schema, meta = node
-        merge_with('hash', constructor, schema).meta(meta)
+        opts, meta = node
+        registry["nominal.hash"].with(**opts, meta: meta)
       end
 
-      def visit_hash_schema(node)
-        schema, meta = node
-        merge_with_schema('hash', schema).meta(meta)
+      def visit_schema(node)
+        keys, options, meta = node
+        registry["nominal.hash"].schema(keys.map { |key| visit(key) }).with(**options, meta: meta)
       end
 
       def visit_json_hash(node)
-        schema, meta = node
-        merge_with('json.hash', :symbolized, schema).meta(meta)
+        keys, meta = node
+        registry["json.hash"].schema(keys.map { |key| visit(key) }, meta)
       end
 
       def visit_json_array(node)
         member, meta = node
-        registry['json.array'].of(visit(member)).meta(meta)
+        registry["json.array"].of(visit(member)).meta(meta)
       end
 
       def visit_params_hash(node)
-        schema, meta = node
-        merge_with('params.hash', :symbolized, schema).meta(meta)
+        keys, meta = node
+        registry["params.hash"].schema(keys.map { |key| visit(key) }, meta)
       end
 
       def visit_params_array(node)
         member, meta = node
-        registry['params.array'].of(visit(member)).meta(meta)
+        registry["params.array"].of(visit(member)).meta(meta)
       end
 
-      def visit_member(node)
-        name, type = node
-        { name => visit(type) }
+      def visit_key(node)
+        name, required, type = node
+        Schema::Key.new(visit(type), name, required: required)
       end
 
       def visit_enum(node)
-        type, mapping, meta = node
-        Enum.new(visit(type), mapping: mapping, meta: meta)
+        type, mapping = node
+        Enum.new(visit(type), mapping: mapping)
       end
 
       def visit_map(node)
         key_type, value_type, meta = node
-        registry['hash'].map(visit(key_type), visit(value_type)).meta(meta)
+        registry["nominal.hash"].map(visit(key_type), visit(value_type)).meta(meta)
       end
 
-      def merge_with(hash_id, constructor, schema)
-        registry[hash_id].schema(
-          schema.map { |key| visit(key) }.reduce({}, :update),
-          constructor
-        )
+      def visit_any(meta)
+        registry["any"].meta(meta)
       end
 
-      def merge_with_schema(hash_id, schema)
-        registry[hash_id].instantiate(
-          schema.map { |key| visit(key) }.reduce({}, :update)
-        )
+      def compile_fn(fn)
+        type, *node = fn
+
+        case type
+        when :id
+          Dry::Types::FnContainer[node.fetch(0)]
+        when :callable
+          node.fetch(0)
+        when :method
+          target, method = node
+          target.method(method)
+        else
+          raise ArgumentError, "Cannot build callable from #{fn.inspect}"
+        end
       end
     end
   end