dry-types 0.14.0 → 0.15.0

data/lib/dry/types/{definition.rb → nominal.rb}

@@ -1,14 +1,16 @@
+require 'dry/core/deprecations'
 require 'dry/types/builder'
 require 'dry/types/result'
 require 'dry/types/options'
 
 module Dry
   module Types
-    class Definition
+    class Nominal
       include Type
       include Options
       include Builder
-      include Dry::Equalizer(:primitive, :options, :meta)
+      include Printable
+      include Dry::Equalizer(:primitive, :options, :meta, inspect: false)
 
       # @return [Class]
       attr_reader :primitive
@@ -96,15 +98,19 @@ module Dry
       alias_method :valid?, :primitive?
       alias_method :===, :primitive?
 
-      # Return AST representation of a type definition
+      # Return AST representation of a type nominal
       #
       # @api public
       #
       # @return [Array]
       def to_ast(meta: true)
-        [:definition, [primitive, meta ? self.meta : EMPTY_HASH]]
+        [:nominal, [primitive, meta ? self.meta : EMPTY_HASH]]
       end
     end
+
+    extend Dry::Core::Deprecations[:'dry-types']
+    Definition = Nominal
+    deprecate_constant(:Definition, message: "Nominal")
   end
 end
 

data/lib/dry/types/options.rb

@@ -4,7 +4,7 @@ module Dry
       # @return [Hash]
       attr_reader :options
 
-      # @see Definition#initialize
+      # @see Nominal#initialize
       def initialize(*args, meta: EMPTY_HASH, **options)
         @__args__ = args.freeze
         @options = options.freeze
@@ -13,7 +13,7 @@ module Dry
 
       # @param [Hash] new_options
       # @return [Type]
-      def with(new_options)
+      def with(**new_options)
         self.class.new(*@__args__, **options, meta: @meta, **new_options)
       end
 

data/lib/dry/types/params.rb

@@ -3,27 +3,27 @@ require 'dry/types/coercions/params'
 module Dry
   module Types
     register('params.nil') do
-      self['nil'].constructor(Coercions::Params.method(:to_nil))
+      self['nominal.nil'].constructor(Coercions::Params.method(:to_nil))
     end
 
     register('params.date') do
-      self['date'].constructor(Coercions::Params.method(:to_date))
+      self['nominal.date'].constructor(Coercions::Params.method(:to_date))
     end
 
     register('params.date_time') do
-      self['date_time'].constructor(Coercions::Params.method(:to_date_time))
+      self['nominal.date_time'].constructor(Coercions::Params.method(:to_date_time))
     end
 
     register('params.time') do
-      self['time'].constructor(Coercions::Params.method(:to_time))
+      self['nominal.time'].constructor(Coercions::Params.method(:to_time))
     end
 
     register('params.true') do
-      self['true'].constructor(Coercions::Params.method(:to_true))
+      self['nominal.true'].constructor(Coercions::Params.method(:to_true))
     end
 
     register('params.false') do
-      self['false'].constructor(Coercions::Params.method(:to_false))
+      self['nominal.false'].constructor(Coercions::Params.method(:to_false))
     end
 
     register('params.bool') do
@@ -31,23 +31,23 @@ module Dry
     end
 
     register('params.integer') do
-      self['integer'].constructor(Coercions::Params.method(:to_int))
+      self['nominal.integer'].constructor(Coercions::Params.method(:to_int))
     end
 
     register('params.float') do
-      self['float'].constructor(Coercions::Params.method(:to_float))
+      self['nominal.float'].constructor(Coercions::Params.method(:to_float))
     end
 
     register('params.decimal') do
-      self['decimal'].constructor(Coercions::Params.method(:to_decimal))
+      self['nominal.decimal'].constructor(Coercions::Params.method(:to_decimal))
     end
 
     register('params.array') do
-      self['array'].constructor(Coercions::Params.method(:to_ary)).safe
+      self['nominal.array'].constructor(Coercions::Params.method(:to_ary)).safe
     end
 
     register('params.hash') do
-      self['hash'].constructor(Coercions::Params.method(:to_hash)).safe
+      self['nominal.hash'].constructor(Coercions::Params.method(:to_hash)).safe
     end
   end
 end

data/lib/dry/types/printable.rb

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

data/lib/dry/types/printer.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # @api private
+    class Printer
+      MAPPING = {
+        Nominal => :visit_nominal,
+        Constructor => :visit_constructor,
+        Hash::Constructor => :visit_constructor,
+        Constrained => :visit_constrained,
+        Constrained::Coercible => :visit_constrained,
+        Hash => :visit_hash,
+        Schema => :visit_schema,
+        Schema::Key => :visit_key,
+        Map => :visit_map,
+        Array => :visit_array,
+        Array::Member => :visit_array_member,
+        Safe => :visit_safe,
+        Enum => :visit_enum,
+        Default => :visit_default,
+        Default::Callable => :visit_default,
+        Sum => :visit_sum,
+        Sum::Constrained => :visit_sum,
+        Any.class => :visit_any
+      }
+
+      def call(type)
+        output = "".dup
+        visit(type) { |str| output << str }
+        "#<Dry::Types[#{ output }]>"
+      end
+
+      def visit(type, &block)
+        print_with = MAPPING.fetch(type.class) do
+          if type.is_a?(Type)
+            return yield type.inspect
+          else
+            raise ArgumentError, "Do not know how to print #{ type.class }"
+          end
+        end
+        send(print_with, type, &block)
+      end
+
+      def visit_any(_)
+        yield "Any"
+      end
+
+      def visit_array(_)
+         yield "Array"
+      end
+
+      def visit_array_member(array)
+        visit(array.member) do |type|
+          yield "Array<#{ type }>"
+        end
+      end
+
+      def visit_constructor(constructor)
+        visit(constructor.type) do |type|
+          visit_callable(constructor.fn) do |fn|
+            options = constructor.options.dup
+            options.delete(:fn)
+
+            visit_options(options, constructor.meta) do |opts|
+              yield "Constructor<#{ type } fn=#{ fn }#{ opts }>"
+            end
+          end
+        end
+      end
+
+      def visit_constrained(constrained)
+        visit(constrained.type) do |type|
+          options = constrained.options.dup
+          rule = options.delete(:rule)
+
+          visit_options(options, constrained.meta) do |opts|
+            yield "Constrained<#{ type } rule=[#{ rule.to_s }]>"
+          end
+        end
+      end
+
+      def visit_schema(schema)
+        options = schema.options.dup
+        size = schema.count
+        key_fn_str = ""
+        type_fn_str = ""
+        strict_str = ""
+
+        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 } "
+          end
+        end
+
+        if type_fn = options.delete(:type_transform_fn)
+          visit_callable(type_fn) do |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 }"
+
+          header = "Schema<#{ schema_parameters }keys={"
+
+          if size.zero?
+            yield "#{ header}}>"
+          else
+            yield header.dup << keys.map { |key|
+              visit(key) { |type| type }
+            }.join(" ") << "}>"
+          end
+        end
+      end
+
+      def visit_map(map)
+        visit(map.key_type) do |key|
+          visit(map.value_type) do |value|
+            options = map.options.dup
+            options.delete(:key_type)
+            options.delete(:value_type)
+
+            visit_options(options, map.meta) do |opts|
+              yield "Map<#{ key } => #{ value }>"
+            end
+          end
+        end
+      end
+
+      def visit_key(key)
+        visit(key.type) do |type|
+          if key.required?
+            yield "#{ key.name }: #{ type }"
+          else
+            yield "#{ key.name }?: #{ type }"
+          end
+        end
+      end
+
+      def visit_sum(sum)
+        visit_sum_constructors(sum) do |constructors|
+          visit_options(sum.options, sum.meta) do |opts|
+            yield "Sum<#{ constructors }#{ opts }>"
+          end
+        end
+      end
+
+      def visit_sum_constructors(sum)
+        case sum.left
+        when Sum
+          visit_sum_constructors(sum.left) do |left|
+            case sum.right
+            when Sum
+              visit_sum_constructors(sum.right) do |right|
+                yield "#{ left } | #{ right }"
+              end
+            else
+              visit(sum.right) do |right|
+                yield "#{ left } | #{ right }"
+              end
+            end
+          end
+        else
+          visit(sum.left) do |left|
+            case sum.right
+            when Sum
+              visit_sum_constructors(sum.right) do |right|
+                yield "#{ left } | #{ right }"
+              end
+            else
+              visit(sum.right) do |right|
+                yield "#{ left } | #{ right }"
+              end
+            end
+          end
+        end
+      end
+
+      def visit_enum(enum)
+        visit(enum.type) do |type|
+          options = enum.options.dup
+          mapping = options.delete(:mapping)
+
+          visit_options(options, enum.meta) do |opts|
+            if mapping == enum.inverted_mapping
+              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 }>"
+            end
+          end
+        end
+      end
+
+      def visit_default(default)
+        visit(default.type) do |type|
+          visit_options(default.options, default.meta) do |opts|
+            if default.is_a?(Default::Callable)
+              visit_callable(default.value) do |fn|
+                yield "Default<#{ type } value_fn=#{ fn }#{ opts }>"
+              end
+            else
+              yield "Default<#{ type } value=#{ default.value.inspect }#{ opts }>"
+            end
+          end
+        end
+      end
+
+      def visit_nominal(type)
+        visit_options(type.options, type.meta) do |opts|
+          yield "Nominal<#{ type.primitive }#{ opts }>"
+        end
+      end
+
+      def visit_safe(safe)
+        visit(safe.type) do |type|
+          yield "Safe<#{ type }>"
+        end
+      end
+
+      def visit_hash(hash)
+        options = hash.options.dup
+        type_fn_str = ""
+
+        if type_fn = options.delete(:type_transform_fn)
+          visit_callable(type_fn) do |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"
+          else
+            yield "Hash<#{ type_fn_str }#{ opts }>"
+          end
+        end
+      end
+
+      def visit_callable(callable)
+        fn = callable.is_a?(String) ? FnContainer[callable] : callable
+
+        case fn
+        when Method
+          yield "#{ fn.receiver }.#{ fn.name }"
+        when Proc
+          path, line = fn.source_location
+
+          if line && line.zero?
+            yield ".#{ path }"
+          elsif path
+            yield "#{ path.sub(Dir.pwd + "/", EMPTY_STRING) }:#{ line }"
+          elsif fn.lambda?
+            yield "(lambda)"
+          else
+            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(\w+)\)>\z/)
+
+            if match
+              yield ".#{ match[1] }"
+            else
+              yield "(proc)"
+            end
+          end
+        else
+          call = fn.method(:call)
+
+          if call.owner == fn.class
+            yield "#{ fn.class.to_s }#call"
+          else
+            yield "#{ fn.to_s }.call"
+          end
+        end
+      end
+
+      def visit_options(options, meta)
+        if options.empty? && meta.empty?
+          yield ""
+        else
+          opts = options.empty? ? "" : " options=#{ options.inspect }"
+
+          if meta.empty?
+            yield opts
+          else
+            values = meta.map do |key, value|
+              case key
+              when Symbol
+                "#{ key }: #{ value.inspect }"
+              else
+                "#{ key.inspect }=>#{ value.inspect }"
+              end
+            end
+
+            yield "#{ opts } meta={#{ values.join(", ") }}"
+          end
+        end
+      end
+    end
+
+    PRINTER = Printer.new.freeze
+  end
+end

data/lib/dry/types/result.rb

@@ -3,7 +3,7 @@ require 'dry/equalizer'
 module Dry
   module Types
     class Result
-      include Dry::Equalizer(:input)
+      include Dry::Equalizer(:input, inspect: false)
 
       # @return [Object]
       attr_reader :input
@@ -26,7 +26,7 @@ module Dry
       end
 
       class Failure < Result
-        include Dry::Equalizer(:input, :error)
+        include Dry::Equalizer(:input, :error, inspect: false)
 
         # @return [#to_s]
         attr_reader :error