dry-types 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c1311828855bfe56729ac94279d1522da021a55
-  data.tar.gz: 20154b9c7e7cdbd446d722e3f472382d7563008d
+  metadata.gz: 9622054be99e8e44c40fe7cb054f81df88904d69
+  data.tar.gz: ea4110e3046187010e0b1c70f178ef90e50cbf37
 SHA512:
-  metadata.gz: 244f03d865c9c63d2a1bf7b84bdf1dd5e52d6c4066a86b2603b5b2462411dc5f0411ff014e7567ccc5eda9eb325e82c26c9eec81656976ad3a48e77d1822c944
-  data.tar.gz: ef5a74967de5c2a3824cac9717ec80982f3749858751af79d0ff32f1368220c17b6e6d7ddfa9c8337596cb119ad97555d12aaf0030ed403fe915c1f99acfd533
+  metadata.gz: 02330a45f810e8a15f1dc47c2778360cede0a686136bce6d39f9f8b726d654c143b0d1546f36e9143e2cf539c0768ff3be3588e9e6e42568b5067eb96a9e909c
+  data.tar.gz: 193d63f9c8acbc4a266cbaf9ccfac6d3aba6cfcd9de25323d040bfb5c2a325273cb98890787fe2b38fe9faa8ebb54371fd58f875fb2de814d18acaa7a0c2bbbb

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+# v0.8.0 2016-07-01
+
+## Added
+
+* `Struct` now implements `Type` interface so ie `SomeStruct | String` works now (flash-gordon)
+* `:weak` Hash constructor which can partially coerce a hash even when it includes invalid values (solnic)
+* Types include `Dry::Equalizer` now (flash-gordon)
+
+## Fixed
+
+* `Struct#to_hash` descends into arrays too (nepalez)
+* `Default#with` works now (flash-gordon)
+
+## Changed
+
+* `:symbolized` hash schema is now based on `:weak` schema (solnic)
+* `Struct::Value` instances are now **deeply frozen** via ice_nine (backus)
+
+[Compare v0.7.2...v0.8.0](https://github.com/dryrb/dry-types/compare/v0.7.2...v0.8.0)
+
 # v0.7.2 2016-05-11
 
 ## Fixed
@@ -6,6 +26,7 @@
 - Creating an empty schema with input processor no longer fails (lasseebert)
 
 ## Changes
+
 - Allow multiple calls to meta (solnic)
 - Allow capitalised versions of true and false values for boolean coercions (nil0bject)
 - Replace kleisli with dry-monads (flash-gordon)
@@ -14,7 +35,7 @@
 - Coerce empty strings in form posts to blank arrays and hashes (timriley)
 - update to use dry-logic v0.2.3 (fran-worley)
 
-[Compare v0.7.0...v0.7.1](https://github.com/dryrb/dry-types/compare/v0.7.1...v0.7.2)
+[Compare v0.7.1...v0.7.2](https://github.com/dryrb/dry-types/compare/v0.7.1...v0.7.2)
 
 # v0.7.1 2016-04-06
 

data/Gemfile

@@ -21,4 +21,4 @@ group :benchmarks do
   gem 'attrio'
 end
 
-gem "dry-logic", git: 'https://github.com/dry-rb/dry-logic.git', branch: "master"
+gem "dry-logic", git: 'https://github.com/dry-rb/dry-logic.git', branch: "master"

data/dry-types.gemspec

@@ -31,9 +31,10 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'dry-container', '~> 0.3'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
   spec.add_runtime_dependency 'dry-configurable', '~> 0.1'
-  spec.add_runtime_dependency 'dry-logic', '~> 0.2', '>= 0.2.3'
+  spec.add_runtime_dependency 'dry-logic', '~> 0.3', '>= 0.3.0'
   spec.add_runtime_dependency 'inflecto', '~> 0.0.0', '>= 0.0.2'
   spec.add_runtime_dependency 'dry-monads', '>= 0.0.1'
+  spec.add_runtime_dependency 'ice_nine', '~> 0.11'
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 11.0"

data/lib/dry/types/array/member.rb

@@ -15,12 +15,18 @@ module Dry
         alias_method :[], :call
 
         def try(input, &block)
-          result = call(input, :try)
+          if input.is_a?(::Array)
+            result = call(input, :try)
+            output = result.map(&:input)
 
-          if result.all?(&:success?)
-            success(result.map(&:input))
+            if result.all?(&:success?)
+              success(output)
+            else
+              failure = failure(output, result.select(&:failure?))
+              block ? yield(failure) : failure
+            end
           else
-            failure = failure(input, result.select(&:failure?))
+            failure = failure(input, "#{input} is not an array")
             block ? yield(failure) : failure
           end
         end

data/lib/dry/types/builder.rb

@@ -26,7 +26,7 @@ module Dry
         value = input == Undefined ? block : input
 
         if value.is_a?(Proc) || valid?(value)
-          Default[value].new(self, value: value)
+          Default[value].new(self, value)
         else
           raise ConstraintError, "default value #{value.inspect} violates constraints"
         end

data/lib/dry/types/constrained.rb

@@ -5,6 +5,7 @@ require 'dry/types/constrained/coercible'
 module Dry
   module Types
     class Constrained
+      include Dry::Equalizer(:type, :options, :rule)
       include Decorator
       include Builder
 

data/lib/dry/types/constraints.rb

@@ -3,22 +3,14 @@ require 'dry/logic/predicates'
 
 module Dry
   module Types
-    module Predicates
-      include Logic::Predicates
-
-      predicate(:type?) do |type, value|
-        value.kind_of?(type)
-      end
-    end
-
     def self.Rule(options)
       rule_compiler.(
-        options.map { |key, val| [:val, [:predicate, [:"#{key}?", [val]]]] }
+        options.map { |key, val| [:val, Logic::Predicates[:"#{key}?"].curry(val).to_ast] }
       ).reduce(:and)
     end
 
     def self.rule_compiler
-      @rule_compiler ||= Logic::RuleCompiler.new(Types::Predicates)
+      @rule_compiler ||= Logic::RuleCompiler.new(Logic::Predicates)
     end
   end
 end

data/lib/dry/types/decorator.rb

@@ -1,25 +1,37 @@
+require 'dry/types/options'
+
 module Dry
   module Types
     module Decorator
-      attr_reader :type, :options
+      include Options
+
+      attr_reader :type
 
-      def initialize(type, options = {})
+      def initialize(type, *)
+        super
         @type = type
-        @options = options
       end
 
       def constructor
         type.constructor
       end
 
-      def with(new_options)
-        self.class.new(type, options.merge(new_options))
+      def try(input, &block)
+        type.try(input, &block)
       end
 
       def valid?(value)
         type.valid?(value)
       end
 
+      def default?
+        type.default?
+      end
+
+      def maybe?
+        type.maybe?
+      end
+
       def respond_to_missing?(meth, include_private = false)
         super || type.respond_to?(meth)
       end

data/lib/dry/types/default.rb

@@ -3,10 +3,13 @@ require 'dry/types/decorator'
 module Dry
   module Types
     class Default
+      include Dry::Equalizer(:type, :options, :value)
       include Decorator
       include Builder
 
       class Callable < Default
+        include Dry::Equalizer(:type, :options)
+
         def evaluate
           value.call
         end
@@ -24,15 +27,23 @@ module Dry
         end
       end
 
-      def initialize(type, options)
+      def initialize(type, value, *)
         super
-        @value = options.fetch(:value)
+        @value = value
       end
 
       def constrained(*args)
         type.constrained(*args).default(value)
       end
 
+      def default?
+        true
+      end
+
+      def try(input)
+        success(call(input))
+      end
+
       def call(input)
         if input.nil?
           evaluate

data/lib/dry/types/definition.rb

@@ -33,6 +33,14 @@ module Dry
         primitive.name
       end
 
+      def default?
+        false
+      end
+
+      def maybe?
+        false
+      end
+
       def call(input)
         input
       end

data/lib/dry/types/enum.rb

@@ -3,6 +3,7 @@ require 'dry/types/decorator'
 module Dry
   module Types
     class Enum
+      include Dry::Equalizer(:type, :options, :values)
       include Decorator
 
       attr_reader :values, :mapping

data/lib/dry/types/errors.rb

@@ -43,7 +43,8 @@ module Dry
       def failure_message
         if result.respond_to?(:rule)
           rule = result.rule
-          "#{rule.predicate.id}(#{rule.predicate.args.map(&:inspect).join(', ')}) failed"
+          args = rule.predicate.args - [rule.predicate.args.last]
+          "#{rule.predicate.id}(#{args.map(&:inspect).join(', ')}) failed"
         else
           result.inspect
         end

data/lib/dry/types/form.rb

@@ -43,11 +43,11 @@ module Dry
     end
 
     register('form.array') do
-      self['array'].safe.constructor(Coercions::Form.method(:to_ary))
+      self['array'].constructor(Coercions::Form.method(:to_ary)).safe
     end
 
     register('form.hash') do
-      self['hash'].safe.constructor(Coercions::Form.method(:to_hash))
+      self['hash'].constructor(Coercions::Form.method(:to_hash)).safe
     end
   end
 end

data/lib/dry/types/hash.rb

@@ -3,7 +3,7 @@ require 'dry/types/hash/schema'
 module Dry
   module Types
     class Hash < Definition
-      def schema(type_map, klass = Safe)
+      def schema(type_map, klass = Schema)
         member_types = type_map.each_with_object({}) { |(name, type), result|
           result[name] =
             case type
@@ -15,6 +15,10 @@ module Dry
         klass.new(primitive, options.merge(member_types: member_types))
       end
 
+      def weak(type_map)
+        schema(type_map, Weak)
+      end
+
       def strict(type_map)
         schema(type_map, Strict)
       end

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

@@ -9,13 +9,25 @@ module Dry
           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
+        end
+        alias_method :[], :call
+
         def try(hash, &block)
           result = call(hash, :try)
+          output = result.each_with_object({}) { |(key, res), h| h[key] = res.input }
 
           if result.values.all?(&:success?)
-            success(result.each_with_object({}) { |(key, res), h| h[key] = res.input })
+            success(output)
           else
-            failure = failure(hash, result)
+            failure = failure(output, result)
             block ? yield(failure) : failure
           end
         end
@@ -23,28 +35,50 @@ module Dry
         private
 
         def resolve_missing_value(result, key, type)
-          if type.is_a?(Default)
+          if type.default?
             result[key] = type.evaluate
-          elsif type.is_a?(Maybe)
+          elsif type.maybe?
             result[key] = type[nil]
           end
         end
       end
 
-      class Safe < Schema
+      class Strict < Schema
         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)
+            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
           end
         end
         alias_method :[], :call
       end
 
-      class Symbolized < Schema
+      class Weak < Schema
+        def self.new(primitive, options = {})
+          member_types = options.
+            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)
+            super
+          else
+            result = failure(hash, "#{hash} must be a hash")
+            block ? yield(result) : result
+          end
+        end
+      end
+
+      class Symbolized < Weak
         def call(hash, meth = :call)
           member_types.each_with_object({}) do |(key, type), result|
             if hash.key?(key)
@@ -62,22 +96,6 @@ module Dry
         end
         alias_method :[], :call
       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
-          end
-        end
-        alias_method :[], :call
-      end
     end
   end
 end

data/lib/dry/types/hashify.rb

@@ -0,0 +1,12 @@
+# Converts value to hash recursively
+module Hashify
+  def self.[](value)
+    if value.respond_to?(:to_hash)
+      value.to_hash
+    elsif value.respond_to?(:map)
+      value.map { |item| self[item] }
+    else
+      value
+    end
+  end
+end

data/lib/dry/types/maybe.rb

@@ -4,6 +4,7 @@ require 'dry/types/decorator'
 module Dry
   module Types
     class Maybe
+      include Dry::Equalizer(:type, :options)
       include Decorator
       include Builder
       include Dry::Monads::Maybe::Mixin
@@ -13,6 +14,14 @@ module Dry
       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"

data/lib/dry/types/options.rb

@@ -5,7 +5,7 @@ module Dry
 
       attr_reader :meta
 
-      def initialize(*args, **options )
+      def initialize(*args, **options)
         @__args__ = args
         @options = options
         @meta = options.fetch(:meta, {})

data/lib/dry/types/safe.rb

@@ -3,22 +3,20 @@ require 'dry/types/decorator'
 module Dry
   module Types
     class Safe
+      include Dry::Equalizer(:type, :options)
       include Decorator
       include Builder
 
       def call(input)
-        if type.primitive?(input) || type.is_a?(Sum) || type.is_a?(Constructor)
-          type[input]
-        else
-          input
-        end
-      rescue TypeError
-        input
+        try(input).input
       end
       alias_method :[], :call
 
       def try(input, &block)
         type.try(input, &block)
+      rescue TypeError, ArgumentError => e
+        result = failure(input, e.message)
+        block ? yield(result) : result
       end
 
       private

data/lib/dry/types/struct.rb

@@ -1,76 +1,10 @@
+require_relative 'hashify'
+require 'dry/types/struct/class_interface'
+
 module Dry
   module Types
     class Struct
-      class << self
-        attr_reader :constructor
-      end
-
-      def self.inherited(klass)
-        super
-
-        klass.instance_variable_set('@equalizer', Equalizer.new(*schema.keys))
-        klass.instance_variable_set('@constructor_type', constructor_type)
-        klass.send(:include, klass.equalizer)
-
-        unless klass == Value
-          klass.instance_variable_set('@constructor', Types['coercible.hash'])
-          Types.register_class(klass)
-        end
-
-        klass.attributes({}) unless equal?(Struct)
-      end
-
-      def self.equalizer
-        @equalizer
-      end
-
-      def self.attribute(name, type)
-        attributes(name => type)
-      end
-
-      def self.attributes(new_schema)
-        check_schema_duplication(new_schema)
-
-        prev_schema = schema
-
-        @schema = prev_schema.merge(new_schema)
-        @constructor = Types['coercible.hash'].public_send(constructor_type, schema)
-
-        attr_reader(*new_schema.keys)
-        equalizer.instance_variable_get('@keys').concat(new_schema.keys)
-
-        self
-      end
-
-      def self.check_schema_duplication(new_schema)
-        shared_keys = new_schema.keys & schema.keys
-
-        fail RepeatedAttributeError, shared_keys.first if shared_keys.any?
-      end
-      private_class_method :check_schema_duplication
-
-      def self.constructor_type(type = nil)
-        if type
-          @constructor_type = type
-        else
-          @constructor_type || :strict
-        end
-      end
-
-      def self.schema
-        super_schema = superclass.respond_to?(:schema) ? superclass.schema : {}
-        super_schema.merge(@schema || {})
-      end
-
-      def self.new(attributes = {})
-        if attributes.instance_of?(self)
-          attributes
-        else
-          super(constructor[attributes])
-        end
-      rescue SchemaError, SchemaKeyError => error
-        raise StructError, "[#{self}.new] #{error}"
-      end
+      extend ClassInterface
 
       def initialize(attributes)
         attributes.each { |key, value| instance_variable_set("@#{key}", value) }
@@ -81,10 +15,9 @@ module Dry
       end
 
       def to_hash
-        self.class.schema.keys.each_with_object({}) { |key, result|
-          value = self[key]
-          result[key] = value.respond_to?(:to_hash) ? value.to_hash : value
-        }
+        self.class.schema.keys.each_with_object({}) do |key, result|
+          result[key] = Hashify[self[key]]
+        end
       end
       alias_method :to_h, :to_hash
     end

data/lib/dry/types/struct/class_interface.rb

@@ -0,0 +1,107 @@
+module Dry
+  module Types
+    class Struct
+      module ClassInterface
+        include Builder
+
+        attr_accessor :constructor
+
+        attr_accessor :equalizer
+
+        attr_writer :constructor_type
+
+        protected :constructor=, :equalizer=, :constructor_type=
+
+        def inherited(klass)
+          super
+
+          klass.equalizer = Equalizer.new(*schema.keys)
+          klass.constructor_type = constructor_type
+          klass.send(:include, klass.equalizer)
+
+          unless klass == Value
+            klass.constructor = Types['coercible.hash']
+            Types.register(Types.identifier(klass), klass)
+          end
+
+          klass.attributes({}) unless equal?(Struct)
+        end
+
+        def attribute(name, type)
+          attributes(name => type)
+        end
+
+        def attributes(new_schema)
+          check_schema_duplication(new_schema)
+
+          prev_schema = schema
+
+          @schema = prev_schema.merge(new_schema)
+          @constructor = Types['coercible.hash'].public_send(constructor_type, schema)
+
+          attr_reader(*new_schema.keys)
+          equalizer.instance_variable_get('@keys').concat(new_schema.keys)
+
+          self
+        end
+
+        def check_schema_duplication(new_schema)
+          shared_keys = new_schema.keys & schema.keys
+
+          fail RepeatedAttributeError, shared_keys.first if shared_keys.any?
+        end
+        private :check_schema_duplication
+
+        def constructor_type(type = nil)
+          if type
+            @constructor_type = type
+          else
+            @constructor_type || :strict
+          end
+        end
+
+        def schema
+          super_schema = superclass.respond_to?(:schema) ? superclass.schema : {}
+          super_schema.merge(@schema || {})
+        end
+
+        def new(attributes = default_attributes)
+          if attributes.instance_of?(self)
+            attributes
+          else
+            super(constructor[attributes])
+          end
+        rescue SchemaError, SchemaKeyError => error
+          raise StructError, "[#{self}.new] #{error}"
+        end
+        alias_method :call, :new
+        alias_method :[], :new
+
+        def default_attributes
+          schema.each_with_object({}) { |(name, type), result|
+            result[name] = type.default? ? type.evaluate : type[nil]
+          }
+        end
+
+        def try(input)
+          Result::Success.new(self[input])
+        rescue StructError => e
+          failure = Result::Failure.new(input, e.message)
+          block_given? ? yield(failure) : failure
+        end
+
+        def maybe?
+          false
+        end
+
+        def default?
+          false
+        end
+
+        def valid?(value)
+          self === value
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/sum.rb

@@ -27,6 +27,14 @@ module Dry
         [left, right].map(&:name).join(' | ')
       end
 
+      def default?
+        false
+      end
+
+      def maybe?
+        false
+      end
+
       def call(input)
         try(input) do |result|
           raise ConstraintError, result

data/lib/dry/types/value.rb

@@ -1,10 +1,12 @@
+require 'ice_nine'
+
 require 'dry/types/struct'
 
 module Dry
   module Types
     class Value < Struct
       def self.new(*)
-        super.freeze
+        IceNine.deep_freeze(super)
       end
     end
   end

data/lib/dry/types/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Types
-    VERSION = '0.7.2'.freeze
+    VERSION = '0.8.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-types
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-11 00:00:00.000000000 Z
+date: 2016-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -72,20 +72,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.3
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.3
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: inflecto
   requirement: !ruby/object:Gem::Requirement
@@ -120,6 +120,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: ice_nine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -206,12 +220,14 @@ files:
 - lib/dry/types/form.rb
 - lib/dry/types/hash.rb
 - lib/dry/types/hash/schema.rb
+- lib/dry/types/hashify.rb
 - lib/dry/types/json.rb
 - lib/dry/types/maybe.rb
 - lib/dry/types/options.rb
 - lib/dry/types/result.rb
 - lib/dry/types/safe.rb
 - lib/dry/types/struct.rb
+- lib/dry/types/struct/class_interface.rb
 - lib/dry/types/sum.rb
 - lib/dry/types/value.rb
 - lib/dry/types/version.rb
@@ -236,9 +252,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Type system for Ruby supporting coercions, constraints and complex types
   like structs, value objects, enums etc.
 test_files: []
+has_rdoc: