dry-types 0.15.0 → 1.5.1

data/lib/dry/types/printer.rb

@@ -7,7 +7,6 @@ module Dry
       MAPPING = {
         Nominal => :visit_nominal,
         Constructor => :visit_constructor,
-        Hash::Constructor => :visit_constructor,
         Constrained => :visit_constrained,
         Constrained::Coercible => :visit_constrained,
         Hash => :visit_hash,
@@ -16,7 +15,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,
@@ -28,15 +27,17 @@ module Dry
       def call(type)
         output = "".dup
         visit(type) { |str| output << str }
-        "#<Dry::Types[#{ output }]>"
+        "#<Dry::Types[#{output}]>"
       end
 
       def visit(type, &block)
         print_with = MAPPING.fetch(type.class) do
-          if type.is_a?(Type)
+          if type.class < Constructor
+            :visit_constructor
+          elsif 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)
@@ -46,24 +47,28 @@ module Dry
         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
@@ -91,25 +96,26 @@ module Dry
 
         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 }
@@ -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 }>"
+              yield "Enum<#{type} values={#{values}}#{opts}>"
             else
               mapping_str = mapping.map { |key, value|
-                "#{ key.inspect }=>#{ value.inspect }"
+                "#{key.inspect}=>#{value.inspect}"
               }.join(", ")
-              yield "Enum<#{ type } mapping={#{ mapping_str }}#{ opts }>"
+              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,13 +222,13 @@ 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
 
@@ -232,7 +238,7 @@ module Dry
 
         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
 
@@ -240,7 +246,7 @@ module Dry
           if opts.empty? && type_fn_str.empty?
             yield "Hash"
           else
-            yield "Hash<#{ type_fn_str }#{ opts }>"
+            yield "Hash<#{type_fn_str}#{opts}>"
           end
         end
       end
@@ -249,22 +255,22 @@ module Dry
         fn = callable.is_a?(String) ? FnContainer[callable] : callable
 
         case fn
-        when Method
-          yield "#{ fn.receiver }.#{ fn.name }"
-        when Proc
+        when ::Method
+          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 }"
-          elsif fn.lambda?
-            yield "(lambda)"
+            yield "#{path.sub(Dir.pwd + "/", EMPTY_STRING)}:#{line}"
           else
-            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(\w+)\)>\z/)
+            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(?<name>\w+)\)(:? \(lambda\))?>\z/)
 
             if match
-              yield ".#{ match[1] }"
+              yield ".#{match[:name]}"
+            elsif fn.lambda?
+              yield "(lambda)"
             else
               yield "(proc)"
             end
@@ -273,18 +279,18 @@ module Dry
           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 ""
         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

data/lib/dry/types/result.rb

@@ -1,54 +1,80 @@
-require 'dry/equalizer'
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
 
 module Dry
   module Types
+    # Result class used by {Type#try}
+    #
+    # @api public
     class Result
-      include Dry::Equalizer(:input, inspect: false)
+      include ::Dry::Equalizer(:input, immutable: true)
 
       # @return [Object]
       attr_reader :input
 
       # @param [Object] input
+      #
+      # @api private
       def initialize(input)
         @input = input
       end
 
+      # Success result
+      #
+      # @api public
       class Success < Result
         # @return [true]
+        #
+        # @api public
         def success?
           true
         end
 
         # @return [false]
+        #
+        # @api public
         def failure?
           false
         end
       end
 
+      # Failure result
+      #
+      # @api public
       class Failure < Result
-        include Dry::Equalizer(:input, :error, inspect: false)
+        include ::Dry::Equalizer(:input, :error, immutable: true)
 
         # @return [#to_s]
         attr_reader :error
 
         # @param [Object] input
+        #
         # @param [#to_s] error
+        #
+        # @api private
         def initialize(input, error)
           super(input)
           @error = error
         end
 
         # @return [String]
+        #
+        # @api private
         def to_s
           error.to_s
         end
 
         # @return [false]
+        #
+        # @api public
         def success?
           false
         end
 
         # @return [true]
+        #
+        # @api public
         def failure?
           true
         end

data/lib/dry/types/schema/key.rb

@@ -1,7 +1,13 @@
-require 'dry/equalizer'
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/core/deprecations"
 
 module Dry
   module Types
+    # Schema is a hash with explicit member types defined
+    #
+    # @api public
     class Schema < Hash
       # Proxy type for schema keys. Contains only key name and
       # whether it's required or not. All other calls deletaged
@@ -9,8 +15,9 @@ module Dry
       #
       # @see Dry::Types::Schema
       class Key
+        extend ::Dry::Core::Deprecations[:'dry-types']
         include Type
-        include Dry::Equalizer(:name, :type, :options, inspect: false)
+        include Dry::Equalizer(:name, :type, :options, inspect: false, immutable: true)
         include Decorator
         include Builder
         include Printable
@@ -24,16 +31,27 @@ module Dry
             type.meta.fetch(:required) { !type.meta.fetch(:omittable, false) }
           end
 
+          unless name.is_a?(::Symbol)
+            raise ArgumentError, "Schemas can only contain symbol keys, #{name.inspect} given"
+          end
+
           super(type, name, required: required, **options)
           @name = name
         end
 
-        # @see Dry::Types::Nominal#call
-        def call(input, &block)
-          type.(input, &block)
+        # @api private
+        def call_safe(input, &block)
+          type.call_safe(input, &block)
+        end
+
+        # @api private
+        def call_unsafe(input)
+          type.call_unsafe(input)
         end
 
         # @see Dry::Types::Nominal#try
+        #
+        # @api public
         def try(input, &block)
           type.try(input, &block)
         end
@@ -41,6 +59,8 @@ module Dry
         # Whether the key is required in schema input
         #
         # @return [Boolean]
+        #
+        # @api public
         def required?
           options.fetch(:required)
         end
@@ -55,6 +75,8 @@ module Dry
         #
         #   @param [Boolean] required New value
         #   @return [Dry::Types::Schema::Key]
+        #
+        # @api public
         def required(required = Undefined)
           if Undefined.equal?(required)
             options.fetch(:required)
@@ -66,36 +88,35 @@ module Dry
         # Make key not required
         #
         # @return [Dry::Types::Schema::Key]
+        #
+        # @api public
         def omittable
           required(false)
         end
 
-        # Construct a default type. Default values are
-        # evaluated/applied when key is absent in schema
-        # input.
+        # Turn key into a lax type. Lax types are not strict hence such keys are not required
         #
-        # @see Dry::Types::Default
-        # @return [Dry::Types::Schema::Key]
-        def default(input = Undefined, &block)
-          new(type.default(input, &block))
-        end
-
-        # Replace the underlying type
-        # @param [Dry::Types::Type] type
-        # @return [Dry::Types::Schema::Key]
-        def new(type)
-          self.class.new(type, name, options)
+        # @return [Lax]
+        #
+        # @api public
+        def lax
+          __new__(type.lax).required(false)
         end
 
-        # @see Dry::Types::Safe
-        # @return [Dry::Types::Schema::Key]
-        def safe
-          new(type.safe)
+        # Make wrapped type optional
+        #
+        # @return [Key]
+        #
+        # @api public
+        def optional
+          __new__(type.optional)
         end
 
         # Dump to internal AST representation
         #
         # @return [Array]
+        #
+        # @api public
         def to_ast(meta: true)
           [
             :key,
@@ -107,23 +128,28 @@ module Dry
           ]
         end
 
-        # Get/set type metadata. The Key type doesn't have
-        # its out meta, it delegates these calls to the underlying
-        # type.
-        #
-        # @overload meta
-        #   @return [Hash] metadata associated with type
+        # @see Dry::Types::Meta#meta
         #
-        # @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.nil?
-            type.meta
+        # @api public
+        def meta(data = Undefined)
+          if Undefined.equal?(data) || !data.key?(:omittable)
+            super
           else
-            new(type.meta(data))
+            self.class.warn(
+              "Using meta for making schema keys is deprecated, " \
+              "please use .omittable or .required(false) instead" \
+              "\n" + Core::Deprecations::STACK.()
+            )
+            super.required(!data[:omittable])
           end
         end
+
+        private
+
+        # @api private
+        def decorate?(response)
+          response.is_a?(Type)
+        end
       end
     end
   end