dry-types 0.9.0 → 0.15.0

data/lib/dry/types/module.rb

@@ -0,0 +1,115 @@
+require 'dry/core/deprecations'
+require 'dry/types/builder_methods'
+
+module Dry
+  module Types
+    # Export types registered in a container as module constants.
+    # @example
+    #   module Types
+    #     include Dry::Types.module(:strict, :coercible, :nominal, default: :strict)
+    #   end
+    #   # Types.constants
+    #   # => [:Class, :Strict, :Symbol, :Integer, :Float, :String, :Array, :Hash,
+    #   #     :Decimal, :Nil, :True, :False, :Bool, :Date, :Nominal, :DateTime, :Range,
+    #   #     :Coercible, :Time]
+    class Module < ::Module
+      def initialize(registry, *args)
+        @registry = registry
+        check_parameters(*args)
+        constants = type_constants(*args)
+        define_constants(constants)
+        extend(BuilderMethods)
+
+        if constants.key?(:Nominal)
+          singleton_class.send(:define_method, :included) do |base|
+            super(base)
+            base.instance_exec(const_get(:Nominal, false)) do |nominal|
+              extend Dry::Core::Deprecations[:'dry-types']
+              const_set(:Definition, nominal)
+              deprecate_constant(:Definition, message: "Nominal")
+            end
+          end
+        end
+      end
+
+      # @api private
+      def type_constants(*namespaces, default: Undefined, **aliases)
+        if namespaces.empty? && aliases.empty? && Undefined.equal?(default)
+          default_ns = :Strict
+        elsif Undefined.equal?(default)
+          default_ns = Undefined
+        else
+          default_ns = Inflector.camelize(default).to_sym
+        end
+
+        tree = registry_tree
+
+        if namespaces.empty? && aliases.empty?
+          modules = tree.select { |_, v| v.is_a?(::Hash) }.map(&:first)
+        else
+          modules = (namespaces + aliases.keys).map { |n| Inflector.camelize(n).to_sym }
+        end
+
+        tree.each_with_object({}) do |(key, value), constants|
+          if modules.include?(key)
+            name = aliases.fetch(Inflector.underscore(key).to_sym, key)
+            constants[name] = value
+          end
+
+          constants.update(value) if key == default_ns
+        end
+      end
+
+      # @api private
+      def registry_tree
+        @registry_tree ||= @registry.keys.each_with_object({}) { |key, tree|
+          type = @registry[key]
+          *modules, const_name = key.split('.').map { |part|
+            Inflector.camelize(part).to_sym
+          }
+          next if modules.empty?
+
+          modules.reduce(tree) { |br, name| br[name] ||= {} }[const_name] = type
+        }.freeze
+      end
+
+      private
+
+      # @api private
+      def check_parameters(*namespaces, default: Undefined, **aliases)
+        referenced = namespaces.dup
+        referenced << default unless false.equal?(default) || Undefined.equal?(default)
+        referenced.concat(aliases.keys)
+
+        known = @registry.keys.map { |k|
+          ns, *path = k.split('.')
+          ns.to_sym unless path.empty?
+        }.compact.uniq
+
+        (referenced.uniq - known).each do |name|
+          raise ArgumentError,
+                "#{ name.inspect } is not a known type namespace. "\
+                "Supported options are #{ known.map(&:inspect).join(', ') }"
+        end
+      end
+
+      # @api private
+      def define_constants(constants, mod = self)
+        constants.each do |name, value|
+          case value
+          when ::Hash
+            if mod.const_defined?(name, false)
+              define_constants(value, mod.const_get(name, false))
+            else
+              m = ::Module.new
+              mod.const_set(name, m)
+              define_constants(value, m)
+            end
+          else
+            mod.const_set(name, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/nominal.rb

@@ -0,0 +1,119 @@
+require 'dry/core/deprecations'
+require 'dry/types/builder'
+require 'dry/types/result'
+require 'dry/types/options'
+
+module Dry
+  module Types
+    class Nominal
+      include Type
+      include Options
+      include Builder
+      include Printable
+      include Dry::Equalizer(:primitive, :options, :meta, inspect: false)
+
+      # @return [Class]
+      attr_reader :primitive
+
+      # @param [Class] primitive
+      # @return [Type]
+      def self.[](primitive)
+        if primitive == ::Array
+          Types::Array
+        elsif primitive == ::Hash
+          Types::Hash
+        else
+          self
+        end
+      end
+
+      # @param [Type,Class] primitive
+      # @param [Hash] options
+      def initialize(primitive, **options)
+        super
+        @primitive = primitive
+        freeze
+      end
+
+      # @return [String]
+      def name
+        primitive.name
+      end
+
+      # @return [false]
+      def default?
+        false
+      end
+
+      # @return [false]
+      def constrained?
+        false
+      end
+
+      # @return [false]
+      def optional?
+        false
+      end
+
+      # @param [BasicObject] input
+      # @return [BasicObject]
+      def call(input)
+        input
+      end
+      alias_method :[], :call
+
+      # @param [Object] input
+      # @param [#call,nil] block
+      # @yieldparam [Failure] failure
+      # @yieldreturn [Result]
+      # @return [Result,Logic::Result] when a block is not provided
+      # @return [nil] otherwise
+      def try(input, &block)
+        if valid?(input)
+          success(input)
+        else
+          failure = failure(input, "#{input.inspect} must be an instance of #{primitive}")
+          block ? yield(failure) : failure
+        end
+      end
+
+      # @param (see Dry::Types::Success#initialize)
+      # @return [Result::Success]
+      def success(input)
+        Result::Success.new(input)
+      end
+
+      # @param (see Failure#initialize)
+      # @return [Result::Failure]
+      def failure(input, error)
+        Result::Failure.new(input, error)
+      end
+
+      # Checks whether value is of a #primitive class
+      # @param [Object] value
+      # @return [Boolean]
+      def primitive?(value)
+        value.is_a?(primitive)
+      end
+      alias_method :valid?, :primitive?
+      alias_method :===, :primitive?
+
+      # Return AST representation of a type nominal
+      #
+      # @api public
+      #
+      # @return [Array]
+      def to_ast(meta: true)
+        [:nominal, [primitive, meta ? self.meta : EMPTY_HASH]]
+      end
+    end
+
+    extend Dry::Core::Deprecations[:'dry-types']
+    Definition = Nominal
+    deprecate_constant(:Definition, message: "Nominal")
+  end
+end
+
+require 'dry/types/array'
+require 'dry/types/hash'
+require 'dry/types/map'

data/lib/dry/types/options.rb

@@ -1,20 +1,42 @@
 module Dry
   module Types
     module Options
+      # @return [Hash]
       attr_reader :options
 
-      def initialize(*args, **options)
-        @__args__ = args
-        @options = options
-        @meta = options.fetch(:meta, {})
+      # @see Nominal#initialize
+      def initialize(*args, meta: EMPTY_HASH, **options)
+        @__args__ = args.freeze
+        @options = options.freeze
+        @meta = meta.freeze
       end
 
-      def with(new_options)
-        self.class.new(*@__args__, options.merge(new_options))
+      # @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)
-        data ? with(meta: @meta.merge(data)) : @meta
+        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)
       end
     end
   end

data/lib/dry/types/params.rb

@@ -0,0 +1,53 @@
+require 'dry/types/coercions/params'
+
+module Dry
+  module Types
+    register('params.nil') do
+      self['nominal.nil'].constructor(Coercions::Params.method(:to_nil))
+    end
+
+    register('params.date') do
+      self['nominal.date'].constructor(Coercions::Params.method(:to_date))
+    end
+
+    register('params.date_time') do
+      self['nominal.date_time'].constructor(Coercions::Params.method(:to_date_time))
+    end
+
+    register('params.time') do
+      self['nominal.time'].constructor(Coercions::Params.method(:to_time))
+    end
+
+    register('params.true') do
+      self['nominal.true'].constructor(Coercions::Params.method(:to_true))
+    end
+
+    register('params.false') do
+      self['nominal.false'].constructor(Coercions::Params.method(:to_false))
+    end
+
+    register('params.bool') do
+      (self['params.true'] | self['params.false']).safe
+    end
+
+    register('params.integer') do
+      self['nominal.integer'].constructor(Coercions::Params.method(:to_int))
+    end
+
+    register('params.float') do
+      self['nominal.float'].constructor(Coercions::Params.method(:to_float))
+    end
+
+    register('params.decimal') do
+      self['nominal.decimal'].constructor(Coercions::Params.method(:to_decimal))
+    end
+
+    register('params.array') do
+      self['nominal.array'].constructor(Coercions::Params.method(:to_ary)).safe
+    end
+
+    register('params.hash') do
+      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,42 +3,52 @@ require 'dry/equalizer'
 module Dry
   module Types
     class Result
-      include Dry::Equalizer(:input)
+      include Dry::Equalizer(:input, inspect: false)
 
+      # @return [Object]
       attr_reader :input
 
+      # @param [Object] input
       def initialize(input)
         @input = input
       end
 
       class Success < Result
+        # @return [true]
         def success?
           true
         end
 
+        # @return [false]
         def failure?
           false
         end
       end
 
       class Failure < Result
-        include Dry::Equalizer(:input, :error)
+        include Dry::Equalizer(:input, :error, inspect: false)
 
+        # @return [#to_s]
         attr_reader :error
 
+        # @param [Object] input
+        # @param [#to_s] error
         def initialize(input, error)
           super(input)
           @error = error
         end
 
+        # @return [String]
         def to_s
           error.to_s
         end
 
+        # @return [false]
         def success?
           false
         end
 
+        # @return [true]
         def failure?
           true
         end