dry-types 0.9.2 → 0.9.3

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] block
+        # @yieldparam [Failure] failure
+        # @yieldreturn [Result]
+        # @return [Result]
         def try(input, &block)
           result = type.try(input)
 

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

@@ -5,36 +5,54 @@ module Dry
     class Constructor < Definition
       include Dry::Equalizer(:type)
 
+      # @return [#call]
       attr_reader :fn
 
+      # @return [Definition]
       attr_reader :type
 
+      # @param [Builder, Object] input
+      # @param [Hash] options
+      # @param [#call] block
       def self.new(input, options = {}, &block)
         type = input.is_a?(Builder) ? input : Definition.new(input)
         super(type, options, &block)
       end
 
+      # @param [Definition] type
+      # @param [Hash] options
+      # @param [#proc] block
       def initialize(type, options = {}, &block)
         @type = type
         @fn = options.fetch(:fn, block)
         super
       end
 
+      # @return [Class]
       def primitive
         type.primitive
       end
 
+      # @param [Object] input
+      # @return [Object]
       def call(input)
         type[fn[input]]
       end
       alias_method :[], :call
 
+      # @param [Object] input
+      # @param [#call] block
+      # @return [Result]
       def try(input, &block)
         type.try(fn[input], &block)
       rescue TypeError => e
         failure(input, e.message)
       end
 
+      # @param [#call, nil] new_fn
+      # @param [Hash] options
+      # @param [#call] block
+      # @return [Constructor]
       def constructor(new_fn = nil, **options, &block)
         left = new_fn || block
         right = fn
@@ -42,20 +60,30 @@ module Dry
         with(options.merge(fn: -> input { left[right[input]] }))
       end
 
+      # @param [Object] value
+      # @return [Boolean]
       def valid?(value)
         super && type.valid?(value)
       end
 
+      # @return [Class]
       def constrained_type
         Constrained::Coercible
       end
 
       private
 
+      # @param [Symbol] meth
+      # @param [Boolean] include_private
+      # @return [Boolean]
       def respond_to_missing?(meth, include_private = false)
         super || type.respond_to?(meth)
       end
 
+      # Delegates missing methods to {#type}
+      # @param [Symbol] meth
+      # @param [Array] args
+      # @param [#call] block
       def method_missing(meth, *args, &block)
         if type.respond_to?(meth)
           response = type.__send__(meth, *args, &block)

data/lib/dry/types/decorator.rb

@@ -5,43 +5,62 @@ module Dry
     module Decorator
       include Options
 
+      # @return [Definition]
       attr_reader :type
 
+      # @param [Definition] type
       def initialize(type, *)
         super
         @type = type
       end
 
+      # @return [Constructor]
       def constructor
         type.constructor
       end
 
+      # @param [Object] input
+      # @param [#call] block
+      # @return [Result]
       def try(input, &block)
         type.try(input, &block)
       end
 
+      # @param [Object] value
+      # @return [Boolean]
       def valid?(value)
         type.valid?(value)
       end
 
+      # @return [Boolean]
       def default?
         type.default?
       end
 
+      # @return [Boolean]
       def constrained?
         type.constrained?
       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] block
       def method_missing(meth, *args, &block)
         if type.respond_to?(meth)
           response = type.__send__(meth, *args, &block)

data/lib/dry/types/default.rb

@@ -10,15 +10,20 @@ module Dry
       class Callable < Default
         include Dry::Equalizer(:type, :options)
 
+        # Evaluates given callable
+        # @return [Object]
         def evaluate
           value.call
         end
       end
 
+      # @return [Object]
       attr_reader :value
 
       alias_method :evaluate, :value
 
+      # @param [Object, #call] value
+      # @return [Default, Dry::Types::Default::Callable]
       def self.[](value)
         if value.respond_to?(:call)
           Callable
@@ -27,23 +32,32 @@ module Dry
         end
       end
 
+      # @param [Definition] type
+      # @param [Object] value
       def initialize(type, value, *)
         super
         @value = value
       end
 
+      # @param [Array] args see {Dry::Types::Builder#constrained}
+      # @return [Default]
       def constrained(*args)
         type.constrained(*args).default(value)
       end
 
+      # @return [true]
       def default?
         true
       end
 
+      # @param [Object] input
+      # @return [Success]
       def try(input)
         success(call(input))
       end
 
+      # @param [Object] input
+      # @return [Object] value passed through {#type} or {#default} value
       def call(input)
         if input.nil?
           evaluate

data/lib/dry/types/definition.rb

@@ -9,10 +9,14 @@ module Dry
       include Options
       include Builder
 
+      # @return [Hash]
       attr_reader :options
 
+      # @return [Class]
       attr_reader :primitive
 
+      # @param [Class] primitive
+      # @return [Definition]
       def self.[](primitive)
         if primitive == ::Array
           Types::Array
@@ -23,29 +27,41 @@ module Dry
         end
       end
 
+      # @param [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
 
+      # @param [Object] input
+      # @return [Object]
       def call(input)
         input
       end
       alias_method :[], :call
 
+      # @param [Object] input
+      # @param [#call] block
+      # @yieldparam [Failure] failure
+      # @yieldreturn [Result]
+      # @return [Result]
       def try(input, &block)
         if valid?(input)
           success(input)
@@ -55,18 +71,29 @@ module Dry
         end
       end
 
-      def success(*args)
-        Result::Success.new(*args)
+      # @param (see Dry::Types::Success#initialize)
+      # @return [Success]
+      def success(input)
+        Result::Success.new(input)
       end
 
-      def failure(*args)
-        Result::Failure.new(*args)
+
+      # @param (see Failure#initialize)
+      # @return [Failure]
+      def failure(input, error)
+        Result::Failure.new(input, error)
       end
 
+      # @param [Object] klass class of the result instance
+      # @param [Array] args arguments for the +klass#initialize+ method
+      # @return [Object] new instance of the given +klass+
       def result(klass, *args)
         klass.new(*args)
       end
 
+      # Checks whether value is of a #primitive class
+      # @param [Object] value
+      # @return [Boolean]
       def primitive?(value)
         value.is_a?(primitive)
       end

data/lib/dry/types/enum.rb

@@ -6,8 +6,15 @@ module Dry
       include Dry::Equalizer(:type, :options, :values)
       include Decorator
 
-      attr_reader :values, :mapping
+      # @return [Array]
+      attr_reader :values
 
+      # @return [Hash]
+      attr_reader :mapping
+
+      # @param [Definition] type
+      # @param [Hash] options
+      # @option options [Array] :values
       def initialize(type, options)
         super
         @values = options.fetch(:values).freeze
@@ -15,6 +22,8 @@ module Dry
         @mapping = values.each_with_object({}) { |v, h| h[values.index(v)] = v }.freeze
       end
 
+      # @param [Object] input
+      # @return [Object]
       def call(input)
         value =
           if values.include?(input)

data/lib/dry/types/errors.rb

@@ -2,9 +2,13 @@ module Dry
   module Types
     extend Dry::Configurable
 
+    # @!attribute [r] namespace
+    #   @return [Container{String => Definition}]
     setting :namespace, self
 
     class SchemaError < TypeError
+      # @param [String] key
+      # @param [Object] value
       def initialize(key, value)
         super("#{value.inspect} (#{value.class}) has invalid type for :#{key}")
       end
@@ -14,20 +18,27 @@ module Dry
     private_constant(:SchemaKeyError)
 
     class MissingKeyError < SchemaKeyError
+      # @param [String] key
       def initialize(key)
         super(":#{key} is missing in Hash input")
       end
     end
 
     class UnknownKeysError < SchemaKeyError
+      # @param [<String, Symbol>] keys
       def initialize(*keys)
         super("unexpected keys #{keys.inspect} in Hash input")
       end
     end
 
-    ConstraintError = Class.new(TypeError) do
-      attr_reader :result, :input
+    class ConstraintError < TypeError
+      # @return [String, #to_s]
+      attr_reader :result
+      # @return [Object]
+      attr_reader :input
 
+      # @param [String, #to_s] result
+      # @param [Object] input
       def initialize(result, input)
         @result = result
         @input = input
@@ -39,6 +50,7 @@ module Dry
         end
       end
 
+      # @return [String]
       def to_s
         "#{input.inspect} violates constraints (#{result} failed)"
       end

data/lib/dry/types/extensions/maybe.rb

@@ -9,19 +9,27 @@ module Dry
       include Builder
       include Dry::Monads::Maybe::Mixin
 
+      # @param [Dry::Monads::Maybe, Object] input
+      # @return [Dry::Monads::Maybe]
       def call(input)
         input.is_a?(Dry::Monads::Maybe) ? input : Maybe(type[input])
       end
       alias_method :[], :call
 
+      # @param [Object] input
+      # @return [Result::Success]
       def try(input)
         Result::Success.new(Maybe(type[input]))
       end
 
+      # @return [true]
       def maybe?
         true
       end
 
+      # @param [Object] value
+      # @see Dry::Types::Builder#default
+      # @raise [ArgumentError] if nil provided as default value
       def default(value)
         if value.nil?
           raise ArgumentError, "nil cannot be used as a default of a maybe type"
@@ -32,6 +40,7 @@ module Dry
     end
 
     module Builder
+      # @return [Maybe]
       def maybe
         Maybe.new(Types['strict.nil'] | self)
       end
@@ -39,6 +48,9 @@ module Dry
 
     class Hash
       module MaybeTypes
+        # @param [Hash] result
+        # @param [Symbol] key
+        # @param [Definition] type
         def resolve_missing_value(result, key, type)
           if type.respond_to?(:maybe?) && type.maybe?
             result[key] = type[nil]
@@ -48,8 +60,13 @@ module Dry
         end
       end
 
-      StrictWithDefaults.include MaybeTypes
-      Schema.include MaybeTypes
+      class StrictWithDefaults < Strict
+        include MaybeTypes
+      end
+
+      class Schema < Hash
+        include MaybeTypes
+      end
     end
 
     # Register non-coercible maybe types