dry-types 0.15.0 → 1.2.0

data/lib/dry/types/coercions.rb

@@ -1,50 +1,115 @@
+# 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)
+      #
+      # @return [nil] if the input is an empty string or nil
+      #
+      # @raise CoercionError
+      #
+      # @api public
+      def 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 [#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 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 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 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/coercions/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'bigdecimal'
 require 'bigdecimal/util'
@@ -6,14 +8,31 @@ require 'time'
 module Dry
   module Types
     module Coercions
+      # JSON-specific coercions
+      #
+      # @api public
       module JSON
         extend Coercions
 
         # @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,80 +1,148 @@
+# 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])
+        ].freeze
 
         extend Coercions
 
         # @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
-          elsif input.is_a? String
+        #
+        # @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/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,29 +20,29 @@ module Dry
 
       def visit(node)
         type, body = node
-        send(:"visit_#{ type }", body)
+        send(:"visit_#{type}", body)
       end
 
       def visit_constrained(node)
-        nominal, rule, meta = node
-        Types::Constrained.new(visit(nominal), 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)
-        nominal, fn_register_name, meta = node
-        fn = Dry::Types::FnContainer[fn_register_name]
+        nominal, fn = node
         primitive = visit(nominal)
-        Types::Constructor.new(primitive, meta: meta, fn: fn)
+        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_nominal(node)
         type, meta = node
-        nominal_name = "nominal.#{ Types.identifier(type) }"
+        nominal_name = "nominal.#{Types.identifier(type)}"
 
         if registry.registered?(nominal_name)
           registry[nominal_name].meta(meta)
@@ -95,8 +102,8 @@ module Dry
       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)
@@ -107,6 +114,22 @@ module Dry
       def visit_any(meta)
         registry['any'].meta(meta)
       end
+
+      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
 end

data/lib/dry/types/constrained.rb

@@ -1,94 +1,145 @@
+# frozen_string_literal: true
+
 require 'dry/types/decorator'
 require 'dry/types/constraints'
 require 'dry/types/constrained/coercible'
 
 module Dry
   module Types
+    # Constrained types apply rules to the input
+    #
+    # @api public
     class Constrained
       include Type
       include Decorator
       include Builder
       include Printable
-      include Dry::Equalizer(:type, :options, :rule, :meta, inspect: false)
+      include Dry::Equalizer(:type, :rule, inspect: false)
 
       # @return [Dry::Logic::Rule]
       attr_reader :rule
 
       # @param [Type] type
+      #
       # @param [Hash] options
+      #
+      # @api public
       def initialize(type, options)
         super
         @rule = options.fetch(:rule)
       end
 
-      # @param [Object] input
+      # @api private
+      #
       # @return [Object]
-      # @raise [ConstraintError]
-      def call(input)
-        try(input) { |result|
+      #
+      # @api public
+      def call_unsafe(input)
+        result = rule.(input)
+
+        if result.success?
+          type.call_unsafe(input)
+        else
           raise ConstraintError.new(result, input)
-        }.input
+        end
       end
-      alias_method :[], :call
-
-      # @param [Object] input
-      # @param [#call,nil] block
-      # @yieldparam [Failure] failure
-      # @yieldreturn [Result]
-      # @return [Logic::Result, Result]
-      # @return [Object] if block given and try fails
+
+      # @api private
+      #
+      # @return [Object]
+      #
+      # @api public
+      def call_safe(input, &block)
+        if rule[input]
+          type.call_safe(input, &block)
+        else
+          yield
+        end
+      end
+
+      # Safe coercion attempt. It is similar to #call with a
+      # block given but returns a Result instance with metadata
+      # about errors (if any).
+      #
+      # @overload try(input)
+      #   @param [Object] input
+      #   @return [Logic::Result]
+      #
+      # @overload try(input)
+      #   @param [Object] input
+      #   @yieldparam [Failure] failure
+      #   @yieldreturn [Object]
+      #   @return [Object]
+      #
+      # @api public
       def try(input, &block)
         result = rule.(input)
 
         if result.success?
           type.try(input, &block)
         else
-          failure = failure(input, result)
-          block ? yield(failure) : failure
+          failure = failure(input, ConstraintError.new(result, input))
+          block_given? ? yield(failure) : failure
         end
       end
 
-      # @param [Object] value
-      # @return [Boolean]
-      def valid?(value)
-        rule.(value).success? && type.valid?(value)
-      end
-
       # @param [Hash] options
       #   The options hash provided to {Types.Rule} and combined
       #   using {&} with previous {#rule}
+      #
       # @return [Constrained]
+      #
       # @see Dry::Logic::Operators#and
+      #
+      # @api public
       def constrained(options)
         with(rule: rule & Types.Rule(options))
       end
 
       # @return [true]
+      #
+      # @api public
       def constrained?
         true
       end
 
       # @param [Object] value
+      #
       # @return [Boolean]
+      #
+      # @api public
       def ===(value)
         valid?(value)
       end
 
-      # @api public
+      # Build lax type. Constraints are not applicable to lax types hence unwrapping
       #
+      # @return [Lax]
+      # @api public
+      def lax
+        type.lax
+      end
+
       # @see Nominal#to_ast
+      # @api public
       def to_ast(meta: true)
-        [:constrained, [type.to_ast(meta: meta),
-                        rule.to_ast,
-                        meta ? self.meta : EMPTY_HASH]]
+        [:constrained, [type.to_ast(meta: meta), rule.to_ast]]
+      end
+
+      # @api private
+      def constructor_type
+        type.constructor_type
       end
 
       private
 
       # @param [Object] response
+      #
       # @return [Boolean]
+      #
+      # @api private
       def decorate?(response)
-        super || response.kind_of?(Constructor)
+        super || response.is_a?(Constructor)
       end
     end
   end