dry-types 0.8.1 → 0.9.0

data/lib/dry/types/definition.rb

@@ -37,7 +37,7 @@ module Dry
         false
       end
 
-      def maybe?
+      def constrained?
         false
       end
 

data/lib/dry/types/errors.rb

@@ -10,44 +10,37 @@ module Dry
       end
     end
 
-    class SchemaKeyError < KeyError
+    SchemaKeyError = Class.new(KeyError)
+    private_constant(:SchemaKeyError)
+
+    class MissingKeyError < SchemaKeyError
       def initialize(key)
         super(":#{key} is missing in Hash input")
       end
     end
 
-    StructError = Class.new(TypeError)
-
-    class RepeatedAttributeError < ArgumentError
-      def initialize(key)
-        super("Attribute :#{key} has already been defined")
+    class UnknownKeysError < SchemaKeyError
+      def initialize(*keys)
+        super("unexpected keys #{keys.inspect} in Hash input")
       end
     end
 
     ConstraintError = Class.new(TypeError) do
-      attr_reader :result
+      attr_reader :result, :input
 
-      def initialize(result)
+      def initialize(result, input)
         @result = result
+        @input = input
+
         if result.is_a?(String)
-          super
+          super(result)
         else
-          super("#{result.input.inspect} violates constraints (#{failure_message})")
+          super(to_s)
         end
       end
 
-      def input
-        result.input
-      end
-
-      def failure_message
-        if result.respond_to?(:rule)
-          rule = result.rule
-          args = rule.predicate.args - [rule.predicate.args.last]
-          "#{rule.predicate.id}(#{args.map(&:inspect).join(', ')}) failed"
-        else
-          result.inspect
-        end
+      def to_s
+        "#{input.inspect} violates constraints (#{result} failed)"
       end
     end
   end

data/lib/dry/types/extensions.rb

@@ -0,0 +1,3 @@
+Dry::Types.register_extension(:maybe) do
+  require 'dry/types/extensions/maybe'
+end

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

@@ -0,0 +1,64 @@
+require 'dry/monads/maybe'
+require 'dry/types/decorator'
+
+module Dry
+  module Types
+    class Maybe
+      include Dry::Equalizer(:type, :options)
+      include Decorator
+      include Builder
+      include Dry::Monads::Maybe::Mixin
+
+      def call(input)
+        input.is_a?(Dry::Monads::Maybe) ? input : Maybe(type[input])
+      end
+      alias_method :[], :call
+
+      def try(input)
+        Result::Success.new(Maybe(type[input]))
+      end
+
+      def maybe?
+        true
+      end
+
+      def default(value)
+        if value.nil?
+          raise ArgumentError, "nil cannot be used as a default of a maybe type"
+        else
+          super
+        end
+      end
+    end
+
+    module Builder
+      def maybe
+        Maybe.new(Types['strict.nil'] | self)
+      end
+    end
+
+    class Hash
+      module MaybeTypes
+        def resolve_missing_value(result, key, type)
+          if type.respond_to?(:maybe?) && type.maybe?
+            result[key] = type[nil]
+          else
+            super
+          end
+        end
+      end
+
+      Schema.include MaybeTypes
+    end
+
+    # Register non-coercible maybe types
+    NON_NIL.each_key do |name|
+      register("maybe.strict.#{name}", self["strict.#{name}"].maybe)
+    end
+
+    # Register coercible maybe types
+    COERCIBLE.each_key do |name|
+      register("maybe.coercible.#{name}", self["coercible.#{name}"].maybe)
+    end
+  end
+end

data/lib/dry/types/hash.rb

@@ -19,13 +19,27 @@ module Dry
         schema(type_map, Weak)
       end
 
+      def permissive(type_map)
+        schema(type_map, Permissive)
+      end
+
       def strict(type_map)
         schema(type_map, Strict)
       end
 
+      def strict_with_defaults(type_map)
+        schema(type_map, StrictWithDefaults)
+      end
+
       def symbolized(type_map)
         schema(type_map, Symbolized)
       end
+
+      private
+
+      def resolve_missing_value(_result, _key, _type)
+        # noop
+      end
     end
   end
 end

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

@@ -4,27 +4,33 @@ module Dry
       class Schema < Hash
         attr_reader :member_types
 
-        def initialize(primitive, options = {})
+        def initialize(_primitive, options)
           @member_types = options.fetch(:member_types)
           super
         end
 
-        def call(hash, meth = :call)
-          member_types.each_with_object({}) do |(key, type), result|
-            if hash.key?(key)
-              result[key] = type.__send__(meth, hash[key])
-            else
-              resolve_missing_value(result, key, type)
-            end
-          end
+        def call(hash)
+          coerce(hash)
         end
         alias_method :[], :call
 
         def try(hash, &block)
-          result = call(hash, :try)
-          output = result.each_with_object({}) { |(key, res), h| h[key] = res.input }
+          success = true
+          output  = {}
+
+          begin
+            result = try_coerce(hash) do |key, member_result|
+              success &&= member_result.success?
+              output[key] = member_result.input
+
+              member_result
+            end
+          rescue ConstraintError, UnknownKeysError, SchemaError => e
+            success = false
+            result = e
+          end
 
-          if result.values.all?(&:success?)
+          if success
             success(output)
           else
             failure = failure(output, result)
@@ -34,42 +40,87 @@ module Dry
 
         private
 
+        def try_coerce(hash)
+          resolve(hash) do |type, key, value|
+            yield(key, type.try(value))
+          end
+        end
+
+        def coerce(hash)
+          resolve(hash) do |type, key, value|
+            begin
+              type.call(value)
+            rescue ConstraintError
+              raise SchemaError.new(key, value)
+            end
+          end
+        end
+
+        def resolve(hash)
+          member_types.each_with_object({}) do |(key, type), result|
+            if hash.key?(key)
+              result[key] = yield(type, key, hash[key])
+            else
+              resolve_missing_value(result, key, type)
+            end
+          end
+        end
+
         def resolve_missing_value(result, key, type)
           if type.default?
             result[key] = type.evaluate
-          elsif type.maybe?
-            result[key] = type[nil]
+          else
+            super
           end
         end
       end
 
-      class Strict < Schema
-        def call(hash, meth = :call)
-          member_types.each_with_object({}) do |(key, type), result|
-            begin
-              value = hash.fetch(key)
-              result[key] = type.__send__(meth, value)
-            rescue TypeError
-              raise SchemaError.new(key, value)
-            rescue KeyError
-              raise SchemaKeyError.new(key)
-            end
+      class Permissive < Schema
+        private
+
+        def resolve_missing_value(_, key, _)
+          raise MissingKeyError, key
+        end
+      end
+
+      class Strict < Permissive
+        private
+
+        def resolve(hash)
+          unexpected = hash.keys - member_types.keys
+          raise UnknownKeysError.new(*unexpected) unless unexpected.empty?
+
+          super do |member_type, key, value|
+            type = member_type.default? ? member_type.type : member_type
+
+            yield(type, key, value)
+          end
+        end
+      end
+
+      class StrictWithDefaults < Strict
+        private
+
+        def resolve_missing_value(result, key, type)
+          if type.default?
+            result[key] = type.value
+          else
+            super
           end
         end
-        alias_method :[], :call
       end
 
       class Weak < Schema
-        def self.new(primitive, options = {})
+        def self.new(primitive, options)
           member_types = options.
-            fetch(:member_types, {}).
+            fetch(:member_types).
             each_with_object({}) { |(k, t), res| res[k] = t.safe }
 
           super(primitive, options.merge(member_types: member_types))
         end
 
         def try(hash, &block)
-          if hash.is_a?(::Hash)
+          if hash.instance_of?(::Hash)
             super
           else
             result = failure(hash, "#{hash} must be a hash")
@@ -79,23 +130,27 @@ module Dry
       end
 
       class Symbolized < Weak
-        def call(hash, meth = :call)
-          member_types.each_with_object({}) do |(key, type), result|
-            if hash.key?(key)
-              result[key] = type.__send__(meth, hash[key])
-            else
-              key_name = key.to_s
+        private
 
-              if hash.key?(key_name)
-                result[key] = type.__send__(meth, hash[key_name])
-              else
-                resolve_missing_value(result, key, type)
+        def resolve(hash)
+          member_types.each_with_object({}) do |(key, type), result|
+            keyname =
+              if hash.key?(key)
+                key
+              elsif hash.key?(string_key = key.to_s)
+                string_key
               end
+
+            if keyname
+              result[key] = yield(type, key, hash[keyname])
+            else
+              resolve_missing_value(result, key, type)
             end
           end
         end
-        alias_method :[], :call
       end
+
+      private_constant(*constants(false))
     end
   end
 end

data/lib/dry/types/options.rb

@@ -3,8 +3,6 @@ module Dry
     module Options
       attr_reader :options
 
-      attr_reader :meta
-
       def initialize(*args, **options)
         @__args__ = args
         @options = options

data/lib/dry/types/result.rb

@@ -1,7 +1,17 @@
+require 'dry/equalizer'
+
 module Dry
   module Types
-    module Result
-      class Success < Struct.new(:input)
+    class Result
+      include Dry::Equalizer(:input)
+
+      attr_reader :input
+
+      def initialize(input)
+        @input = input
+      end
+
+      class Success < Result
         def success?
           true
         end
@@ -11,7 +21,20 @@ module Dry
         end
       end
 
-      class Failure < Struct.new(:input, :error)
+      class Failure < Result
+        include Dry::Equalizer(:input, :error)
+
+        attr_reader :error
+
+        def initialize(input, error)
+          super(input)
+          @error = error
+        end
+
+        def to_s
+          error.to_s
+        end
+
         def success?
           false
         end

data/lib/dry/types/safe.rb

@@ -8,7 +8,13 @@ module Dry
       include Builder
 
       def call(input)
-        try(input).input
+        result = try(input)
+
+        if result.respond_to?(:input)
+          result.input
+        else
+          input
+        end
       end
       alias_method :[], :call
 

data/lib/dry/types/sum.rb

@@ -15,6 +15,10 @@ module Dry
         def rule
           left.rule | right.rule
         end
+
+        def constrained?
+          true
+        end
       end
 
       def initialize(left, right, options = {})
@@ -35,9 +39,13 @@ module Dry
         false
       end
 
+      def constrained?
+        false
+      end
+
       def call(input)
         try(input) do |result|
-          raise ConstraintError, result
+          raise ConstraintError.new(result, input)
         end.input
       end
       alias_method :[], :call