dry-types 1.0.0 → 1.2.1

data/lib/dry/types/enum.rb

@@ -11,6 +11,7 @@ module Dry
       include Type
       include Dry::Equalizer(:type, :mapping, inspect: false)
       include Decorator
+      include Builder
 
       # @return [Array]
       attr_reader :values
@@ -26,7 +27,7 @@ module Dry
       # @option options [Array] :values
       #
       # @api private
-      def initialize(type, options)
+      def initialize(type, **options)
         super
         @mapping = options.fetch(:mapping).freeze
         @values = @mapping.keys.freeze

data/lib/dry/types/extensions.rb

@@ -3,3 +3,7 @@
 Dry::Types.register_extension(:maybe) do
   require 'dry/types/extensions/maybe'
 end
+
+Dry::Types.register_extension(:monads) do
+  require 'dry/types/extensions/monads'
+end

data/lib/dry/types/extensions/maybe.rb

@@ -79,7 +79,7 @@ module Dry
       # @api public
       def default(value)
         if value.nil?
-          raise ArgumentError, "nil cannot be used as a default of a maybe type"
+          raise ArgumentError, 'nil cannot be used as a default of a maybe type'
         else
           super
         end
@@ -97,6 +97,14 @@ module Dry
       end
     end
 
+    # @api private
+    class Schema::Key
+      # @api private
+      def maybe
+        __new__(type.maybe)
+      end
+    end
+
     # @api private
     class Printer
       MAPPING[Maybe] = :visit_maybe

data/lib/dry/types/extensions/monads.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'dry/monads/result'
+
+module Dry
+  module Types
+    # Monad extension for Result
+    #
+    # @api public
+    class Result
+      include Dry::Monads::Result::Mixin
+
+      # Turn result into a monad
+      #
+      # This makes result objects work with dry-monads (or anything with a compatible interface)
+      #
+      # @return [Dry::Monads::Success,Dry::Monads::Failure]
+      #
+      # @api public
+      def to_monad
+        if success?
+          Success(input)
+        else
+          Failure([error, input])
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/hash.rb

@@ -50,8 +50,8 @@ module Dry
 
       # @api private
       def weak(*)
-        raise "Support for old hash schemas was removed, please refer to the CHANGELOG "\
-              "on how to proceed with the new API https://github.com/dry-rb/dry-types/blob/master/CHANGELOG.md"
+        raise 'Support for old hash schemas was removed, please refer to the CHANGELOG '\
+              'on how to proceed with the new API https://github.com/dry-rb/dry-types/blob/master/CHANGELOG.md'
       end
       alias_method :permissive, :weak
       alias_method :strict, :weak
@@ -69,9 +69,7 @@ module Dry
       def with_type_transform(proc = nil, &block)
         fn = proc || block
 
-        if fn.nil?
-          raise ArgumentError, "a block or callable argument is required"
-        end
+        raise ArgumentError, 'a block or callable argument is required' if fn.nil?
 
         handle = Dry::Types::FnContainer.register(fn)
         with(type_transform_fn: handle)
@@ -97,11 +95,11 @@ module Dry
       #
       # @api public
       def to_ast(meta: true)
-        if RUBY_VERSION >= "2.5"
-          opts = options.slice(:type_transform_fn)
-        else
-          opts = options.select { |k, _| k == :type_transform_fn }
-        end
+        opts = if RUBY_VERSION >= '2.5'
+                 options.slice(:type_transform_fn)
+               else
+                 options.select { |k, _| k == :type_transform_fn }
+               end
 
         [:hash, [opts, meta ? self.meta : EMPTY_HASH]]
       end
@@ -115,7 +113,7 @@ module Dry
 
         type_map.map do |map_key, type|
           name, options = key_name(map_key)
-          key = Schema::Key.new(resolve_type(type), name, options)
+          key = Schema::Key.new(resolve_type(type), name, **options)
           type_transform.(key)
         end
       end
@@ -123,7 +121,8 @@ module Dry
       # @api private
       def resolve_type(type)
         case type
-        when String, Class then Types[type]
+        when Type then type
+        when ::Class, ::String then Types[type]
         else type
         end
       end

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

@@ -21,11 +21,11 @@ module Dry
           type.lax.constructor(fn, meta: meta)
         end
 
-        private
-
-        # @api private
-        def composable?(value)
-          super && !value.is_a?(Schema::Key)
+        # @see Dry::Types::Array#of
+        #
+        # @api public
+        def schema(*args)
+          type.schema(*args).constructor(fn, meta: meta)
         end
       end
     end

data/lib/dry/types/json.rb

@@ -24,6 +24,10 @@ module Dry
       self['nominal.decimal'].constructor(Coercions::JSON.method(:to_decimal))
     end
 
+    register('json.symbol') do
+      self['nominal.symbol'].constructor(Coercions::JSON.method(:to_symbol))
+    end
+
     register('json.array') { self['array'] }
 
     register('json.hash') { self['hash'] }

data/lib/dry/types/lax.rb

@@ -15,7 +15,7 @@ module Dry
       include Printable
       include Dry::Equalizer(:type, inspect: false)
 
-      private :options, :constructor
+      undef :options, :constructor
 
       # @param [Object] input
       #
@@ -40,8 +40,8 @@ module Dry
       # @api public
       def try(input, &block)
         type.try(input, &block)
-      rescue CoercionError => error
-        result = failure(input, error.message)
+      rescue CoercionError => e
+        result = failure(input, e.message)
         block ? yield(result) : result
       end
 
@@ -67,7 +67,7 @@ module Dry
       #
       # @api private
       def decorate?(response)
-        super || response.is_a?(constructor_type)
+        super || response.is_a?(type.constructor_type)
       end
     end
 

data/lib/dry/types/map.rb

@@ -74,6 +74,7 @@ module Dry
       def try(hash)
         result = coerce(hash)
         return result if result.success? || !block_given?
+
         yield(result)
       end
 
@@ -100,11 +101,14 @@ module Dry
 
       # @api private
       def coerce(input)
-        return failure(
-          input, CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
-        ) unless primitive?(input)
+        unless primitive?(input)
+          return failure(
+            input, CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
+          )
+        end
 
-        output, failures = {}, []
+        output = {}
+        failures = []
 
         input.each do |k, v|
           res_k = key_type.try(k)

data/lib/dry/types/meta.rb

@@ -16,7 +16,7 @@ module Dry
       # @return [Type]
       #
       # @api public
-      def with(options)
+      def with(**options)
         super(meta: @meta, **options)
       end
 

data/lib/dry/types/module.rb

@@ -18,10 +18,10 @@ module Dry
     #
     # @api public
     class Module < ::Module
-      def initialize(registry, *args)
+      def initialize(registry, *args, **kwargs)
         @registry = registry
-        check_parameters(*args)
-        constants = type_constants(*args)
+        check_parameters(*args, **kwargs)
+        constants = type_constants(*args, **kwargs)
         define_constants(constants)
         extend(BuilderMethods)
 
@@ -31,7 +31,7 @@ module Dry
             base.instance_exec(const_get(:Nominal, false)) do |nominal|
               extend Dry::Core::Deprecations[:'dry-types']
               const_set(:Definition, nominal)
-              deprecate_constant(:Definition, message: "Nominal")
+              deprecate_constant(:Definition, message: 'Nominal')
             end
           end
         end
@@ -93,8 +93,8 @@ module Dry
 
         (referenced.uniq - known).each do |name|
           raise ArgumentError,
-                "#{ name.inspect } is not a known type namespace. "\
-                "Supported options are #{ known.map(&:inspect).join(', ') }"
+                "#{name.inspect} is not a known type namespace. "\
+                "Supported options are #{known.map(&:inspect).join(', ')}"
         end
       end
 

data/lib/dry/types/nominal.rb

@@ -126,9 +126,8 @@ module Dry
       #
       # @api public
       def failure(input, error)
-        unless error.is_a?(CoercionError)
-          raise ArgumentError, "error must be a CoercionError"
-        end
+        raise ArgumentError, 'error must be a CoercionError' unless error.is_a?(CoercionError)
+
         Result::Failure.new(input, error)
       end
 
@@ -202,7 +201,7 @@ module Dry
 
     extend Dry::Core::Deprecations[:'dry-types']
     Definition = Nominal
-    deprecate_constant(:Definition, message: "Nominal")
+    deprecate_constant(:Definition, message: 'Nominal')
   end
 end
 

data/lib/dry/types/params.rb

@@ -51,5 +51,14 @@ module Dry
     register('params.hash') do
       self['nominal.hash'].constructor(Coercions::Params.method(:to_hash))
     end
+
+    register('params.symbol') do
+      self['nominal.symbol'].constructor(Coercions::Params.method(:to_symbol))
+    end
+
+    COERCIBLE.each_key do |name|
+      next if name.equal?(:string)
+      register("optional.params.#{name}", self['params.nil'] | self["params.#{name}"])
+    end
   end
 end

data/lib/dry/types/predicate_inferrer.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'dry/core/cache'
+require 'dry/types/predicate_registry'
+
+module Dry
+  module Types
+    # PredicateInferrer returns the list of predicates used by a type.
+    #
+    # @api public
+    class PredicateInferrer
+      extend Core::Cache
+
+      TYPE_TO_PREDICATE = {
+        DateTime => :date_time?,
+        FalseClass => :false?,
+        Integer => :int?,
+        NilClass => :nil?,
+        String => :str?,
+        TrueClass => :true?,
+        BigDecimal => :decimal?
+      }.freeze
+
+      REDUCED_TYPES = {
+        [[[:true?], [:false?]]] => %i[bool?]
+      }.freeze
+
+      HASH = %i[hash?].freeze
+
+      ARRAY = %i[array?].freeze
+
+      NIL = %i[nil?].freeze
+
+      # Compiler reduces type AST into a list of predicates
+      #
+      # @api private
+      class Compiler
+        # @return [PredicateRegistry]
+        # @api private
+        attr_reader :registry
+
+        # @api private
+        def initialize(registry)
+          @registry = registry
+        end
+
+        # @api private
+        def infer_predicate(type)
+          [TYPE_TO_PREDICATE.fetch(type) { :"#{type.name.split('::').last.downcase}?" }]
+        end
+
+        # @api private
+        def visit(node)
+          meth, rest = node
+          public_send(:"visit_#{meth}", rest)
+        end
+
+        # @api private
+        def visit_nominal(node)
+          type = node[0]
+          predicate = infer_predicate(type)
+
+          if registry.key?(predicate[0])
+            predicate
+          else
+            [type?: type]
+          end
+        end
+
+        # @api private
+        def visit_hash(_)
+          HASH
+        end
+
+        # @api private
+        def visit_array(_)
+          ARRAY
+        end
+
+        # @api private
+        def visit_lax(node)
+          visit(node)
+        end
+
+        # @api private
+        def visit_constructor(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_enum(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_sum(node)
+          left_node, right_node, = node
+          left = visit(left_node)
+          right = visit(right_node)
+
+          if left.eql?(NIL)
+            right
+          else
+            [[left, right]]
+          end
+        end
+
+        # @api private
+        def visit_constrained(node)
+          other, rules = node
+          predicates = visit(rules)
+
+          if predicates.empty?
+            visit(other)
+          else
+            [*visit(other), *merge_predicates(predicates)]
+          end
+        end
+
+        # @api private
+        def visit_any(_)
+          EMPTY_ARRAY
+        end
+
+        # @api private
+        def visit_and(node)
+          left, right = node
+          visit(left) + visit(right)
+        end
+
+        # @api private
+        def visit_predicate(node)
+          pred, args = node
+
+          if pred.equal?(:type?)
+            EMPTY_ARRAY
+          elsif registry.key?(pred)
+            *curried, _ = args
+            values = curried.map { |_, v| v }
+
+            if values.empty?
+              [pred]
+            else
+              [pred => values[0]]
+            end
+          else
+            EMPTY_ARRAY
+          end
+        end
+
+        private
+
+        # @api private
+        def merge_predicates(nodes)
+          preds, merged = nodes.each_with_object([[], {}]) do |predicate, (ps, h)|
+            if predicate.is_a?(::Hash)
+              h.update(predicate)
+            else
+              ps << predicate
+            end
+          end
+
+          merged.empty? ? preds : [*preds, merged]
+        end
+      end
+
+      # @return [Compiler]
+      # @api private
+      attr_reader :compiler
+
+      # @api private
+      def initialize(registry = PredicateRegistry.new)
+        @compiler = Compiler.new(registry)
+      end
+
+      # Infer predicate identifier from the provided type
+      #
+      # @param [Type] type
+      # @return [Symbol]
+      #
+      # @api private
+      def [](type)
+        self.class.fetch_or_store(type) do
+          predicates = compiler.visit(type.to_ast)
+
+          if predicates.is_a?(::Hash)
+            predicates
+          else
+            REDUCED_TYPES[predicates] || predicates
+          end
+        end
+      end
+    end
+  end
+end