dry-types 0.15.0 → 1.2.0

data/lib/dry/types/options.rb

@@ -1,42 +1,29 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
+    # Common API for types with options
+    #
+    # @api private
     module Options
       # @return [Hash]
       attr_reader :options
 
       # @see Nominal#initialize
-      def initialize(*args, meta: EMPTY_HASH, **options)
+      #
+      # @api private
+      def initialize(*args, **options)
         @__args__ = args.freeze
         @options = options.freeze
-        @meta = meta.freeze
       end
 
       # @param [Hash] new_options
+      #
       # @return [Type]
-      def with(**new_options)
-        self.class.new(*@__args__, **options, meta: @meta, **new_options)
-      end
-
-      # @overload meta
-      #   @return [Hash] metadata associated with type
       #
-      # @overload meta(data)
-      #   @param [Hash] new metadata to merge into existing metadata
-      #   @return [Type] new type with added metadata
-      def meta(data = nil)
-        if !data
-          @meta
-        elsif data.empty?
-          self
-        else
-          with(meta: @meta.merge(data))
-        end
-      end
-
-      # Resets meta
-      # @return [Dry::Types::Type]
-      def pristine
-        with(meta: EMPTY_HASH)
+      # @api private
+      def with(**new_options)
+        self.class.new(*@__args__, **options, **new_options)
       end
     end
   end

data/lib/dry/types/params.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/types/coercions/params'
 
 module Dry
@@ -27,7 +29,7 @@ module Dry
     end
 
     register('params.bool') do
-      (self['params.true'] | self['params.false']).safe
+      self['params.true'] | self['params.false']
     end
 
     register('params.integer') do
@@ -43,11 +45,20 @@ module Dry
     end
 
     register('params.array') do
-      self['nominal.array'].constructor(Coercions::Params.method(:to_ary)).safe
+      self['nominal.array'].constructor(Coercions::Params.method(:to_ary))
     end
 
     register('params.hash') do
-      self['nominal.hash'].constructor(Coercions::Params.method(:to_hash)).safe
+      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

data/lib/dry/types/predicate_registry.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'dry/logic/predicates'
+
+module Dry
+  module Types
+    # A registry with predicate objects from `Dry::Logic::Predicates`
+    #
+    # @api private
+    class PredicateRegistry
+      # @api private
+      attr_reader :predicates
+
+      # @api private
+      attr_reader :has_predicate
+
+      # @api private
+      def initialize(predicates = Logic::Predicates)
+        @predicates = predicates
+        @has_predicate = ::Kernel.instance_method(:respond_to?).bind(@predicates)
+      end
+
+      # @api private
+      def [](name)
+        predicates[name]
+      end
+
+      # @api private
+      def key?(name)
+        has_predicate.(name)
+      end
+    end
+  end
+end

data/lib/dry/types/primitive_inferrer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'dry/core/cache'
+
+module Dry
+  module Types
+    # PrimitiveInferrer returns the list of classes matching a type.
+    #
+    # @api public
+    class PrimitiveInferrer
+      extend Core::Cache
+
+      # Compiler reduces type AST into a list of primitives
+      #
+      # @api private
+      class Compiler
+        # @api private
+        def visit(node)
+          meth, rest = node
+          public_send(:"visit_#{meth}", rest)
+        end
+
+        # @api private
+        def visit_nominal(node)
+          type, _ = node
+          type
+        end
+
+        # @api private
+        def visit_hash(_)
+          ::Hash
+        end
+        alias_method :visit_schema, :visit_hash
+
+        # @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, right = node
+
+          [visit(left), visit(right)].flatten(1)
+        end
+
+        # @api private
+        def visit_constrained(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_any(_)
+          ::Object
+        end
+      end
+
+      # @return [Compiler]
+      # @api private
+      attr_reader :compiler
+
+      # @api private
+      def initialize
+        @compiler = Compiler.new
+      end
+
+      # Infer primitives from the provided type
+      #
+      # @return [Array[Class]]
+      #
+      # @api private
+      def [](type)
+        self.class.fetch_or_store(type) do
+          Array(compiler.visit(type.to_ast)).freeze
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/printable.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
+    # @api private
     module Printable
       # @return [String]
-      # @api public
+      #
+      # @api private
       def to_s
         PRINTER.(self) { super }
       end

data/lib/dry/types/printer.rb

@@ -8,6 +8,7 @@ module Dry
         Nominal => :visit_nominal,
         Constructor => :visit_constructor,
         Hash::Constructor => :visit_constructor,
+        Array::Constructor => :visit_constructor,
         Constrained => :visit_constrained,
         Constrained::Coercible => :visit_constrained,
         Hash => :visit_hash,
@@ -16,7 +17,7 @@ module Dry
         Map => :visit_map,
         Array => :visit_array,
         Array::Member => :visit_array_member,
-        Safe => :visit_safe,
+        Lax => :visit_lax,
         Enum => :visit_enum,
         Default => :visit_default,
         Default::Callable => :visit_default,
@@ -26,9 +27,9 @@ module Dry
       }
 
       def call(type)
-        output = "".dup
+        output = ''.dup
         visit(type) { |str| output << str }
-        "#<Dry::Types[#{ output }]>"
+        "#<Dry::Types[#{output}]>"
       end
 
       def visit(type, &block)
@@ -36,34 +37,38 @@ module Dry
           if type.is_a?(Type)
             return yield type.inspect
           else
-            raise ArgumentError, "Do not know how to print #{ type.class }"
+            raise ArgumentError, "Do not know how to print #{type.class}"
           end
         end
         send(print_with, type, &block)
       end
 
       def visit_any(_)
-        yield "Any"
+        yield 'Any'
       end
 
-      def visit_array(_)
-         yield "Array"
+      def visit_array(type)
+        visit_options(EMPTY_HASH, type.meta) do |opts|
+          yield "Array#{opts}"
+        end
       end
 
       def visit_array_member(array)
         visit(array.member) do |type|
-          yield "Array<#{ type }>"
+          visit_options(EMPTY_HASH, array.meta) do |opts|
+            yield "Array<#{type}#{opts}>"
+          end
         end
       end
 
       def visit_constructor(constructor)
         visit(constructor.type) do |type|
-          visit_callable(constructor.fn) do |fn|
+          visit_callable(constructor.fn.fn) do |fn|
             options = constructor.options.dup
             options.delete(:fn)
 
-            visit_options(options, constructor.meta) do |opts|
-              yield "Constructor<#{ type } fn=#{ fn }#{ opts }>"
+            visit_options(options) do |opts|
+              yield "Constructor<#{type} fn=#{fn}#{opts}>"
             end
           end
         end
@@ -74,8 +79,8 @@ module Dry
           options = constrained.options.dup
           rule = options.delete(:rule)
 
-          visit_options(options, constrained.meta) do |opts|
-            yield "Constrained<#{ type } rule=[#{ rule.to_s }]>"
+          visit_options(options) do |_opts|
+            yield "Constrained<#{type} rule=[#{rule}]>"
           end
         end
       end
@@ -83,37 +88,38 @@ module Dry
       def visit_schema(schema)
         options = schema.options.dup
         size = schema.count
-        key_fn_str = ""
-        type_fn_str = ""
-        strict_str = ""
+        key_fn_str = ''
+        type_fn_str = ''
+        strict_str = ''
 
-        strict_str = "strict " if options.delete(:strict)
+        strict_str = 'strict ' if options.delete(:strict)
 
         if key_fn = options.delete(:key_transform_fn)
           visit_callable(key_fn) do |fn|
-            key_fn_str = "key_fn=#{ fn } "
+            key_fn_str = "key_fn=#{fn} "
           end
         end
 
         if type_fn = options.delete(:type_transform_fn)
           visit_callable(type_fn) do |fn|
-            type_fn_str = "type_fn=#{ fn } "
+            type_fn_str = "type_fn=#{fn} "
           end
         end
 
         keys = options.delete(:keys)
 
         visit_options(options, schema.meta) do |opts|
-          schema_parameters = "#{ key_fn_str }#{ type_fn_str }#{ strict_str }#{ opts }"
+          opts = "#{opts[1..-1]} " unless opts.empty?
+          schema_parameters = "#{key_fn_str}#{type_fn_str}#{strict_str}#{opts}"
 
-          header = "Schema<#{ schema_parameters }keys={"
+          header = "Schema<#{schema_parameters}keys={"
 
           if size.zero?
-            yield "#{ header}}>"
+            yield "#{header}}>"
           else
             yield header.dup << keys.map { |key|
               visit(key) { |type| type }
-            }.join(" ") << "}>"
+            }.join(' ') << '}>'
           end
         end
       end
@@ -125,8 +131,8 @@ module Dry
             options.delete(:key_type)
             options.delete(:value_type)
 
-            visit_options(options, map.meta) do |opts|
-              yield "Map<#{ key } => #{ value }>"
+            visit_options(options) do |_opts|
+              yield "Map<#{key} => #{value}>"
             end
           end
         end
@@ -135,9 +141,9 @@ module Dry
       def visit_key(key)
         visit(key.type) do |type|
           if key.required?
-            yield "#{ key.name }: #{ type }"
+            yield "#{key.name}: #{type}"
           else
-            yield "#{ key.name }?: #{ type }"
+            yield "#{key.name}?: #{type}"
           end
         end
       end
@@ -145,7 +151,7 @@ module Dry
       def visit_sum(sum)
         visit_sum_constructors(sum) do |constructors|
           visit_options(sum.options, sum.meta) do |opts|
-            yield "Sum<#{ constructors }#{ opts }>"
+            yield "Sum<#{constructors}#{opts}>"
           end
         end
       end
@@ -157,11 +163,11 @@ module Dry
             case sum.right
             when Sum
               visit_sum_constructors(sum.right) do |right|
-                yield "#{ left } | #{ right }"
+                yield "#{left} | #{right}"
               end
             else
               visit(sum.right) do |right|
-                yield "#{ left } | #{ right }"
+                yield "#{left} | #{right}"
               end
             end
           end
@@ -170,11 +176,11 @@ module Dry
             case sum.right
             when Sum
               visit_sum_constructors(sum.right) do |right|
-                yield "#{ left } | #{ right }"
+                yield "#{left} | #{right}"
               end
             else
               visit(sum.right) do |right|
-                yield "#{ left } | #{ right }"
+                yield "#{left} | #{right}"
               end
             end
           end
@@ -186,15 +192,15 @@ module Dry
           options = enum.options.dup
           mapping = options.delete(:mapping)
 
-          visit_options(options, enum.meta) do |opts|
+          visit_options(options) do |opts|
             if mapping == enum.inverted_mapping
-              values = mapping.values.map(&:inspect).join(", ")
-              yield "Enum<#{ type } values={#{ values }}#{ opts }>"
+              values = mapping.values.map(&:inspect).join(', ')
+              yield "Enum<#{type} values={#{values}}#{opts}>"
             else
               mapping_str = mapping.map { |key, value|
-                "#{ key.inspect }=>#{ value.inspect }"
-              }.join(", ")
-              yield "Enum<#{ type } mapping={#{ mapping_str }}#{ opts }>"
+                "#{key.inspect}=>#{value.inspect}"
+              }.join(', ')
+              yield "Enum<#{type} mapping={#{mapping_str}}#{opts}>"
             end
           end
         end
@@ -202,13 +208,13 @@ module Dry
 
       def visit_default(default)
         visit(default.type) do |type|
-          visit_options(default.options, default.meta) do |opts|
+          visit_options(default.options) do |opts|
             if default.is_a?(Default::Callable)
               visit_callable(default.value) do |fn|
-                yield "Default<#{ type } value_fn=#{ fn }#{ opts }>"
+                yield "Default<#{type} value_fn=#{fn}#{opts}>"
               end
             else
-              yield "Default<#{ type } value=#{ default.value.inspect }#{ opts }>"
+              yield "Default<#{type} value=#{default.value.inspect}#{opts}>"
             end
           end
         end
@@ -216,31 +222,31 @@ module Dry
 
       def visit_nominal(type)
         visit_options(type.options, type.meta) do |opts|
-          yield "Nominal<#{ type.primitive }#{ opts }>"
+          yield "Nominal<#{type.primitive}#{opts}>"
         end
       end
 
-      def visit_safe(safe)
-        visit(safe.type) do |type|
-          yield "Safe<#{ type }>"
+      def visit_lax(lax)
+        visit(lax.type) do |type|
+          yield "Lax<#{type}>"
         end
       end
 
       def visit_hash(hash)
         options = hash.options.dup
-        type_fn_str = ""
+        type_fn_str = ''
 
         if type_fn = options.delete(:type_transform_fn)
           visit_callable(type_fn) do |fn|
-            type_fn_str = "type_fn=#{ fn }"
+            type_fn_str = "type_fn=#{fn}"
           end
         end
 
         visit_options(options, hash.meta) do |opts|
           if opts.empty? && type_fn_str.empty?
-            yield "Hash"
+            yield 'Hash'
           else
-            yield "Hash<#{ type_fn_str }#{ opts }>"
+            yield "Hash<#{type_fn_str}#{opts}>"
           end
         end
       end
@@ -250,41 +256,41 @@ module Dry
 
         case fn
         when Method
-          yield "#{ fn.receiver }.#{ fn.name }"
+          yield "#{fn.receiver}.#{fn.name}"
         when Proc
           path, line = fn.source_location
 
-          if line && line.zero?
-            yield ".#{ path }"
+          if line&.zero?
+            yield ".#{path}"
           elsif path
-            yield "#{ path.sub(Dir.pwd + "/", EMPTY_STRING) }:#{ line }"
+            yield "#{path.sub(Dir.pwd + '/', EMPTY_STRING)}:#{line}"
           elsif fn.lambda?
-            yield "(lambda)"
+            yield '(lambda)'
           else
             match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(\w+)\)>\z/)
 
             if match
-              yield ".#{ match[1] }"
+              yield ".#{match[1]}"
             else
-              yield "(proc)"
+              yield '(proc)'
             end
           end
         else
           call = fn.method(:call)
 
           if call.owner == fn.class
-            yield "#{ fn.class.to_s }#call"
+            yield "#{fn.class}#call"
           else
-            yield "#{ fn.to_s }.call"
+            yield "#{fn}.call"
           end
         end
       end
 
-      def visit_options(options, meta)
+      def visit_options(options, meta = EMPTY_HASH)
         if options.empty? && meta.empty?
-          yield ""
+          yield ''
         else
-          opts = options.empty? ? "" : " options=#{ options.inspect }"
+          opts = options.empty? ? '' : " options=#{options.inspect}"
 
           if meta.empty?
             yield opts
@@ -292,13 +298,13 @@ module Dry
             values = meta.map do |key, value|
               case key
               when Symbol
-                "#{ key }: #{ value.inspect }"
+                "#{key}: #{value.inspect}"
               else
-                "#{ key.inspect }=>#{ value.inspect }"
+                "#{key.inspect}=>#{value.inspect}"
               end
             end
 
-            yield "#{ opts } meta={#{ values.join(", ") }}"
+            yield "#{opts} meta={#{values.join(', ')}}"
           end
         end
       end