dry-types 0.9.0 → 0.15.0

data/lib/dry/types/compiler.rb

@@ -11,74 +11,101 @@ module Dry
         visit(ast)
       end
 
-      def visit(node, *args)
-        send(:"visit_#{node[0]}", node[1], *args)
+      def visit(node)
+        type, body = node
+        send(:"visit_#{ type }", body)
+      end
+
+      def visit_constrained(node)
+        nominal, rule, meta = node
+        Types::Constrained.new(visit(nominal), rule: visit_rule(rule)).meta(meta)
       end
 
       def visit_constructor(node)
-        primitive, fn = node
-        Types::Constructor.new(primitive, &fn)
+        nominal, fn_register_name, meta = node
+        fn = Dry::Types::FnContainer[fn_register_name]
+        primitive = visit(nominal)
+        Types::Constructor.new(primitive, meta: meta, fn: fn)
+      end
+
+      def visit_safe(node)
+        ast, meta = node
+        Types::Safe.new(visit(ast), meta: meta)
       end
 
-      def visit_type(node)
-        type, args = node
-        meth = :"visit_#{type.tr('.', '_')}"
+      def visit_nominal(node)
+        type, meta = node
+        nominal_name = "nominal.#{ Types.identifier(type) }"
 
-        if respond_to?(meth) && args
-          send(meth, args)
+        if registry.registered?(nominal_name)
+          registry[nominal_name].meta(meta)
         else
-          registry[type]
+          Nominal.new(type, meta: meta)
         end
       end
 
+      def visit_rule(node)
+        Dry::Types.rule_compiler.([node])[0]
+      end
+
       def visit_sum(node)
-        node.map { |type| visit(type) }.reduce(:|)
+        *types, meta = node
+        types.map { |type| visit(type) }.reduce(:|).meta(meta)
       end
 
       def visit_array(node)
-        registry['array'].member(call(node))
+        member, meta = node
+        member = member.is_a?(Class) ? member : visit(member)
+        registry['nominal.array'].of(member).meta(meta)
       end
 
-      def visit_form_array(node)
-        registry['form.array'].member(call(node))
+      def visit_hash(node)
+        opts, meta = node
+        registry['nominal.hash'].with(opts.merge(meta: meta))
       end
 
-      def visit_json_array(node)
-        registry['json.array'].member(call(node))
+      def visit_schema(node)
+        keys, options, meta = node
+        registry['nominal.hash'].schema(keys.map { |key| visit(key) }).with(options.merge(meta: meta))
       end
 
-      def visit_hash(node)
-        constructor, schema = node
-        merge_with('hash', constructor, schema)
+      def visit_json_hash(node)
+        keys, meta = node
+        registry['json.hash'].schema(keys.map { |key| visit(key) }, meta)
       end
 
-      def visit_form_hash(node)
-        if node
-          constructor, schema = node
-          merge_with('form.hash', constructor, schema)
-        else
-          registry['form.hash']
-        end
+      def visit_json_array(node)
+        member, meta = node
+        registry['json.array'].of(visit(member)).meta(meta)
       end
 
-      def visit_json_hash(node)
-        if node
-          constructor, schema = node
-          merge_with('json.hash', constructor, schema)
-        else
-          registry['json.hash']
-        end
+      def visit_params_hash(node)
+        keys, meta = node
+        registry['params.hash'].schema(keys.map { |key| visit(key) }, meta)
+      end
+
+      def visit_params_array(node)
+        member, meta = node
+        registry['params.array'].of(visit(member)).meta(meta)
       end
 
       def visit_key(node)
-        name, types = node
-        { name => visit(types) }
+        name, required, type = node
+        Schema::Key.new(visit(type), name, required: required)
+      end
+
+      def visit_enum(node)
+        type, mapping, meta = node
+        Enum.new(visit(type), mapping: mapping, meta: meta)
+      end
+
+      def visit_map(node)
+        key_type, value_type, meta = node
+        registry['nominal.hash'].map(visit(key_type), visit(value_type)).meta(meta)
       end
 
-      def merge_with(hash_id, constructor, schema)
-        registry[hash_id].__send__(
-          constructor, schema.map { |key| visit(key) }.reduce({}, :merge)
-        )
+      def visit_any(meta)
+        registry['any'].meta(meta)
       end
     end
   end

data/lib/dry/types/constrained/coercible.rb

@@ -2,6 +2,11 @@ module Dry
   module Types
     class Constrained
       class Coercible < Constrained
+        # @param [Object] input
+        # @param [#call,nil] block
+        # @yieldparam [Failure] failure
+        # @yieldreturn [Result]
+        # @return [Result,nil]
         def try(input, &block)
           result = type.try(input)
 
@@ -11,7 +16,8 @@ module Dry
             if validation.success?
               result
             else
-              block ? yield(validation) : validation
+              failure = failure(result.input, validation)
+              block ? yield(failure) : failure
             end
           else
             block ? yield(result) : result

data/lib/dry/types/constrained.rb

@@ -5,24 +5,38 @@ require 'dry/types/constrained/coercible'
 module Dry
   module Types
     class Constrained
-      include Dry::Equalizer(:type, :options, :rule)
+      include Type
       include Decorator
       include Builder
+      include Printable
+      include Dry::Equalizer(:type, :options, :rule, :meta, inspect: false)
 
+      # @return [Dry::Logic::Rule]
       attr_reader :rule
 
+      # @param [Type] type
+      # @param [Hash] options
       def initialize(type, options)
         super
         @rule = options.fetch(:rule)
       end
 
+      # @param [Object] input
+      # @return [Object]
+      # @raise [ConstraintError]
       def call(input)
-        try(input) do |result|
+        try(input) { |result|
           raise ConstraintError.new(result, input)
-        end.input
+        }.input
       end
       alias_method :[], :call
 
+      # @param [Object] input
+      # @param [#call,nil] block
+      # @yieldparam [Failure] failure
+      # @yieldreturn [Result]
+      # @return [Logic::Result, Result]
+      # @return [Object] if block given and try fails
       def try(input, &block)
         result = rule.(input)
 
@@ -34,20 +48,45 @@ module Dry
         end
       end
 
+      # @param [Object] value
+      # @return [Boolean]
       def valid?(value)
         rule.(value).success? && type.valid?(value)
       end
 
+      # @param [Hash] options
+      #   The options hash provided to {Types.Rule} and combined
+      #   using {&} with previous {#rule}
+      # @return [Constrained]
+      # @see Dry::Logic::Operators#and
       def constrained(options)
         with(rule: rule & Types.Rule(options))
       end
 
+      # @return [true]
       def constrained?
         true
       end
 
+      # @param [Object] value
+      # @return [Boolean]
+      def ===(value)
+        valid?(value)
+      end
+
+      # @api public
+      #
+      # @see Nominal#to_ast
+      def to_ast(meta: true)
+        [:constrained, [type.to_ast(meta: meta),
+                        rule.to_ast,
+                        meta ? self.meta : EMPTY_HASH]]
+      end
+
       private
 
+      # @param [Object] response
+      # @return [Boolean]
       def decorate?(response)
         super || response.kind_of?(Constructor)
       end

data/lib/dry/types/constraints.rb

@@ -4,12 +4,15 @@ require 'dry/logic/rule/predicate'
 
 module Dry
   module Types
+    # @param [Hash] options
+    # @return [Dry::Logic::Rule]
     def self.Rule(options)
       rule_compiler.(
         options.map { |key, val| Logic::Rule::Predicate.new(Logic::Predicates[:"#{key}?"]).curry(val).to_ast }
       ).reduce(:and)
     end
 
+    # @return [Dry::Logic::RuleCompiler]
     def self.rule_compiler
       @rule_compiler ||= Logic::RuleCompiler.new(Logic::Predicates)
     end

data/lib/dry/types/constructor.rb

@@ -1,67 +1,145 @@
-require 'dry/types/decorator'
+require 'dry/types/fn_container'
 
 module Dry
   module Types
-    class Constructor < Definition
-      include Dry::Equalizer(:type)
+    class Constructor < Nominal
+      include Dry::Equalizer(:type, :options, :meta, inspect: false)
 
+      # @return [#call]
       attr_reader :fn
 
+      # @return [Type]
       attr_reader :type
 
-      def self.new(input, options = {}, &block)
-        type = input.is_a?(Builder) ? input : Definition.new(input)
-        super(type, options, &block)
+      undef :constrained?
+
+      # @param [Builder, Object] input
+      # @param [Hash] options
+      # @param [#call, nil] block
+      def self.new(input, **options, &block)
+        type = input.is_a?(Builder) ? input : Nominal.new(input)
+        super(type, **options, &block)
       end
 
-      def initialize(type, options = {}, &block)
+      # @param [Type] type
+      # @param [Hash] options
+      # @param [#call, nil] block
+      def initialize(type, **options, &block)
         @type = type
         @fn = options.fetch(:fn, block)
-        super
+
+        raise ArgumentError, 'Missing constructor block' if fn.nil?
+
+        super(type, **options, fn: fn)
       end
 
+      # @return [Class]
       def primitive
         type.primitive
       end
 
+      # @return [String]
+      def name
+        type.name
+      end
+
+      # @return [Boolean]
+      def default?
+        type.default?
+      end
+
+      # @param [Object] input
+      # @return [Object]
       def call(input)
         type[fn[input]]
       end
       alias_method :[], :call
 
+      # @param [Object] input
+      # @param [#call,nil] block
+      # @return [Logic::Result, Types::Result]
+      # @return [Object] if block given and try fails
       def try(input, &block)
         type.try(fn[input], &block)
-      rescue TypeError => e
+      rescue TypeError, ArgumentError => e
         failure(input, e.message)
       end
 
+      # @param [#call, nil] new_fn
+      # @param [Hash] options
+      # @param [#call, nil] block
+      # @return [Constructor]
       def constructor(new_fn = nil, **options, &block)
         left = new_fn || block
         right = fn
 
-        with(options.merge(fn: -> input { left[right[input]] }))
+        with(**options, fn: -> input { left[right[input]] })
       end
+      alias_method :append, :constructor
+      alias_method :>>, :constructor
 
+      # @param [Object] value
+      # @return [Boolean]
       def valid?(value)
-        super && type.valid?(value)
+        constructed_value = fn[value]
+      rescue NoMethodError, TypeError, ArgumentError
+        false
+      else
+        type.valid?(constructed_value)
       end
+      alias_method :===, :valid?
 
+      # @return [Class]
       def constrained_type
         Constrained::Coercible
       end
 
+      # @api public
+      #
+      # @see Nominal#to_ast
+      def to_ast(meta: true)
+        [:constructor, [type.to_ast(meta: meta),
+                        register_fn(fn),
+                        meta ? self.meta : EMPTY_HASH]]
+      end
+
+      # @api public
+      #
+      # @param [#call, nil] new_fn
+      # @param [Hash] options
+      # @param [#call, nil] block
+      # @return [Constructor]
+      def prepend(new_fn = nil, **options, &block)
+        left = new_fn || block
+        right = fn
+
+        with(**options, fn: -> input { right[left[input]] })
+      end
+      alias_method :<<, :prepend
+
       private
 
+      def register_fn(fn)
+        Dry::Types::FnContainer.register(fn)
+      end
+
+      # @param [Symbol] meth
+      # @param [Boolean] include_private
+      # @return [Boolean]
       def respond_to_missing?(meth, include_private = false)
         super || type.respond_to?(meth)
       end
 
-      def method_missing(meth, *args, &block)
-        if type.respond_to?(meth)
-          response = type.__send__(meth, *args, &block)
+      # Delegates missing methods to {#type}
+      # @param [Symbol] method
+      # @param [Array] args
+      # @param [#call, nil] block
+      def method_missing(method, *args, &block)
+        if type.respond_to?(method)
+          response = type.__send__(method, *args, &block)
 
-          if response.kind_of?(Builder)
-            self.class.new(response, options)
+          if composable?(response)
+            response.constructor_type.new(response, options)
           else
             response
           end
@@ -69,6 +147,10 @@ module Dry
           super
         end
       end
+
+      def composable?(value)
+        value.kind_of?(Builder)
+      end
     end
   end
 end

data/lib/dry/types/container.rb

@@ -1,3 +1,5 @@
+require 'dry/container'
+
 module Dry
   module Types
     class Container

data/lib/dry/types/core.rb

@@ -1,14 +1,18 @@
+require 'dry/types/any'
+
 module Dry
   module Types
+    # Primitives with {Kernel} coercion methods
     COERCIBLE = {
       string: String,
-      int: Integer,
+      integer: Integer,
       float: Float,
       decimal: BigDecimal,
       array: ::Array,
       hash: ::Hash
     }.freeze
 
+    # Primitives that are non-coercible through {Kernel} methods
     NON_COERCIBLE = {
       nil: NilClass,
       symbol: Symbol,
@@ -17,44 +21,56 @@ module Dry
       false: FalseClass,
       date: Date,
       date_time: DateTime,
-      time: Time
+      time: Time,
+      range: Range
     }.freeze
 
+    # All built-in primitives
     ALL_PRIMITIVES = COERCIBLE.merge(NON_COERCIBLE).freeze
 
+    # All built-in primitives except {NilClass}
     NON_NIL = ALL_PRIMITIVES.reject { |name, _| name == :nil }.freeze
 
-    # Register built-in types that are non-coercible through kernel methods
+    # Register generic types for {ALL_PRIMITIVES}
     ALL_PRIMITIVES.each do |name, primitive|
-      register(name.to_s, Definition[primitive].new(primitive))
+      type = Nominal[primitive].new(primitive)
+      register("nominal.#{name}", type)
     end
 
-    # Register strict built-in types that are non-coercible through kernel methods
+    # Register strict types for {ALL_PRIMITIVES}
     ALL_PRIMITIVES.each do |name, primitive|
-      register("strict.#{name}", self[name.to_s].constrained(type: primitive))
+      type = self["nominal.#{name}"].constrained(type: primitive)
+      register(name.to_s, type)
+      register("strict.#{name}", type)
     end
 
-    # Register built-in primitive types with kernel coercion methods
+    # Register {COERCIBLE} types
     COERCIBLE.each do |name, primitive|
-      register("coercible.#{name}", self[name.to_s].constructor(Kernel.method(primitive.name)))
+      register("coercible.#{name}", self["nominal.#{name}"].constructor(Kernel.method(primitive.name)))
     end
 
-    # Register non-coercible optional types
+    # Register optional strict {NON_NIL} types
     NON_NIL.each_key do |name|
       register("optional.strict.#{name}", self["strict.#{name}"].optional)
     end
 
-    # Register coercible optional types
+    # Register optional {COERCIBLE} types
     COERCIBLE.each_key do |name|
       register("optional.coercible.#{name}", self["coercible.#{name}"].optional)
     end
 
-    # Register :bool since it's common and not a built-in Ruby type :(
-    register("bool", self["true"] | self["false"])
-    register("strict.bool", self["strict.true"] | self["strict.false"])
+    # Register `:bool` since it's common and not a built-in Ruby type :(
+    register("nominal.bool", self["nominal.true"] | self["nominal.false"])
+    bool = self["strict.true"] | self["strict.false"]
+    register("strict.bool", bool)
+    register("bool", bool)
+
+    register("any", Any)
+    register("nominal.any", Any)
+    register("strict.any", Any)
   end
 end
 
 require 'dry/types/coercions'
-require 'dry/types/form'
+require 'dry/types/params'
 require 'dry/types/json'

data/lib/dry/types/decorator.rb

@@ -5,49 +5,70 @@ module Dry
     module Decorator
       include Options
 
+      # @return [Type]
       attr_reader :type
 
+      # @param [Type] type
       def initialize(type, *)
         super
         @type = type
       end
 
-      def constructor
-        type.constructor
-      end
-
+      # @param [Object] input
+      # @param [#call, nil] block
+      # @return [Result,Logic::Result]
+      # @return [Object] if block given and try fails
       def try(input, &block)
         type.try(input, &block)
       end
 
+      # @param [Object] value
+      # @return [Boolean]
       def valid?(value)
         type.valid?(value)
       end
+      alias_method :===, :valid?
 
+      # @return [Boolean]
       def default?
         type.default?
       end
 
+      # @return [Boolean]
       def constrained?
         type.constrained?
       end
 
+      # @return [Sum]
+      def optional
+        Types['strict.nil'] | self
+      end
+
+      # @param [Symbol] meth
+      # @param [Boolean] include_private
+      # @return [Boolean]
       def respond_to_missing?(meth, include_private = false)
         super || type.respond_to?(meth)
       end
 
       private
 
+      # @param [Object] response
+      # @return [Boolean]
       def decorate?(response)
         response.kind_of?(type.class)
       end
 
+      # Delegates missing methods to {#type}
+      # @param [Symbol] meth
+      # @param [Array] args
+      # @param [#call, nil] block
       def method_missing(meth, *args, &block)
         if type.respond_to?(meth)
           response = type.__send__(meth, *args, &block)
 
           if decorate?(response)
-            self.class.new(response, options)
+            __new__(response)
           else
             response
           end
@@ -55,6 +76,11 @@ module Dry
           super
         end
       end
+
+      # Replace underlying type
+      def __new__(type)
+        self.class.new(type, options)
+      end
     end
   end
 end