dry-schema 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af5d9afb30c697c7ff8e028dff66ed3a1e28a8d0ed9c6f03ac4bd0e0ff73a364
-  data.tar.gz: 94c6bb4243dfc12bd478e715e716deb1fd9b278761d1822324ed7b8920b0de55
+  metadata.gz: 91cccc18d1227997d8a7d14d0e73372625e11f3180bf0dede6ec38dc60e9acde
+  data.tar.gz: d900bd76107b6ac3825a32ead9e0a9818426a96d7ee4b591c55a49e53b84e79f
 SHA512:
-  metadata.gz: cf8a06bf211c79bed5ccfc9e02800e47318535036a47b626c29438cae91e3388c380bd9b8b936391718f88c784318f9ef5e88d41a19d06240d9773d2ee7b8270
-  data.tar.gz: 7eaa15a99a94bdcd301fed7d636879a0ef7241d7cf5721bd87ef053c8684ece4b65a0a6aa6fb2f10d7d0947bb66b27548f575749b83190ea2db3bab04f4f08d2
+  metadata.gz: e7457d70d6e82e2691d067ebf33c9fa1512938856bfda50304f20010e2b3313804b37215acd972e659968af60dc317d2771e8efa017dc0b43072d3aef7008a9b
+  data.tar.gz: 81467419fdc896a52e9013677d17b0c9cfd91e16ea4323efb007554899eb69e43a7c20b5426eb5213687631ed5e04e34f79fbf780e9e9d4748a1971faa4385c0

data/CHANGELOG.md

@@ -1,3 +1,43 @@
+# 0.5.0 2019-04-04
+
+### Added
+
+* Support for arbitrary meta-data in messages, ie:
+
+  ```yaml
+  en:
+    dry_schema:
+      errors:
+        filled?:
+          text: "cannot be blank"
+          code: 123
+  ```
+
+  Now your error hash will include `{ foo: [{ text: 'cannot be blank', code: 123 }] }` (solnic + flash-gordon)
+
+* Support for type specs in `array` macro, ie `required(:tags).array(:integer)` (solnic)
+* Support for type specs in `each` macro, ie `required(:tags).each(:integer)` (solnic)
+* Shortcut for defining an array with hash as its member, ie:
+  
+  ```ruby
+  Dry::Schema.Params do
+    required(:tags).array(:hash) do
+      required(:name).filled(:string)
+    end
+  end
+  ```
+
+### Fixed
+
+* Inferring type specs when type is already set works correctly (solnic)
+
+### Changed
+
+* [BREAKING] `:monads` extension wraps entire result objects in `Success` or `Failure` (flash-gordon)
+* When `:hints` are disabled, result AST will not include hint nodes (solnic)
+
+[Compare v0.4.0...v0.5.0](https://github.com/dry-rb/dry-schema/compare/v0.4.0...v0.5.0)
+
 # 0.4.0 2019-03-26
 
 ### Added

data/README.md

@@ -1,10 +1,10 @@
 [gem]: https://rubygems.org/gems/dry-schema
 [travis]: https://travis-ci.org/dry-rb/dry-schema
 [codeclimate]: https://codeclimate.com/github/dry-rb/dry-schema
-[coveralls]: https://coveralls.io/r/dry-rb/dry-schema
+[chat]: https://dry-rb.zulipchat.com
 [inchpages]: http://inch-ci.org/github/dry-rb/dry-schema
 
-# dry-schema [![Join the chat at https://gitter.im/dry-rb/chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/dry-rb/chat)
+# dry-schema [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![Gem Version](https://badge.fury.io/rb/dry-schema.svg)][gem]
 [![Build Status](https://travis-ci.org/dry-rb/dry-schema.svg?branch=master)][travis]

data/config/errors.yml

@@ -1,6 +1,7 @@
 en:
   dry_schema:
     or: "or"
+
     errors:
       array?: "must be an array"
 
@@ -12,6 +13,7 @@ en:
         arg:
           default: "must not be one of: %{list}"
           range: "must not be one of: %{list_left} - %{list_right}"
+
       exclusion?: "must not be one of: %{list}"
 
       eql?: "must be equal to %{left}"
@@ -38,6 +40,7 @@ en:
         arg:
           default: "must be one of: %{list}"
           range: "must be one of: %{list_left} - %{list_right}"
+
       inclusion?: "must be one of: %{list}"
 
       includes?: "must include %{value}"
@@ -88,5 +91,6 @@ en:
             arg:
               default: "length must be %{size}"
               range: "length must be within %{size_left} - %{size_right}"
+
       not:
         empty?: "cannot be empty"

data/lib/dry/schema/compiler.rb

@@ -19,6 +19,11 @@ module Dry
         super
       end
 
+      # @api private
+      def visit_and(node)
+        super.with(hints: false)
+      end
+
       # Build a special rule that will produce namespaced failures
       #
       # This is needed for schemas that are namespaced and they are

data/lib/dry/schema/dsl.rb

@@ -247,6 +247,22 @@ module Dry
         types[name] = type.meta(meta)
       end
 
+      # Resolve type object from the provided spec
+      #
+      # @param [Symbol, Array<Symbol>, Dry::Types::Type]
+      #
+      # @return [Dry::Types::Type]
+      #
+      # @api private
+      def resolve_type(spec)
+        case spec
+        when ::Dry::Types::Type then spec
+        when ::Array then spec.map { |s| resolve_type(s) }.reduce(:|)
+        else
+          type_registry[spec]
+        end
+      end
+
       protected
 
       # Build a rule applier
@@ -345,22 +361,6 @@ module Dry
         end
       end
 
-      # Resolve type object from the provided spec
-      #
-      # @param [Symbol, Array<Symbol>, Dry::Types::Type]
-      #
-      # @return [Dry::Types::Type]
-      #
-      # @api private
-      def resolve_type(spec)
-        case spec
-        when ::Dry::Types::Type then spec
-        when ::Array then spec.map { |s| resolve_type(s) }.reduce(:|)
-        else
-          type_registry[spec]
-        end
-      end
-
       # @api private
       def parent_rules
         parent&.rules || EMPTY_HASH

data/lib/dry/schema/extensions/hints.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'dry/schema/compiler'
 require 'dry/schema/message'
 require 'dry/schema/message_compiler'
 
+require 'dry/schema/extensions/hints/compiler_methods'
 require 'dry/schema/extensions/hints/message_compiler_methods'
 require 'dry/schema/extensions/hints/message_set_methods'
 require 'dry/schema/extensions/hints/result_methods'
@@ -35,10 +37,6 @@ module Dry
     #
     # @api private
     class Hint < Message
-      def self.[](predicate, path, text, options)
-        Hint.new(predicate, path, text, options)
-      end
-
       # @api private
       def hint?
         true
@@ -46,6 +44,7 @@ module Dry
     end
 
     module Extensions
+      Compiler.prepend(Hints::CompilerMethods)
       MessageCompiler.prepend(Hints::MessageCompilerMethods)
       MessageSet.prepend(Hints::MessageSetMethods)
       Result.prepend(Hints::ResultMethods)

data/lib/dry/schema/extensions/hints/compiler_methods.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    module Extensions
+      module Hints
+        # Tweaks AND visitor to enable :hints
+        #
+        # @api private
+        module CompilerMethods
+          # @api private
+          def visit_and(node)
+            super.with(hints: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/extensions/hints/message_set_methods.rb

@@ -16,7 +16,7 @@ module Dry
 
           # @api public
           def to_h
-            failures ? messages_map : messages_map(hints)
+            @to_h ||= failures ? messages_map : messages_map(hints)
           end
           alias_method :to_hash, :to_h
         end

data/lib/dry/schema/extensions/monads.rb

@@ -7,11 +7,11 @@ module Dry
     class Result
       include Dry::Monads::Result::Mixin
 
-      def to_monad(options = EMPTY_HASH)
+      def to_monad
         if success?
-          Success(output)
+          Success(self)
         else
-          Failure(message_set(options).to_h)
+          Failure(self)
         end
       end
     end

data/lib/dry/schema/macros/array.rb

@@ -10,9 +10,22 @@ module Dry
       # @api public
       class Array < DSL
         # @api private
-        def value(*args, &block)
-          schema_dsl.set_type(name, :array)
-          super
+        def value(*args, **opts, &block)
+          type(:array)
+
+          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:|
+            type(schema_dsl.array[type_spec]) if type_spec
+
+            is_hash_block = type_spec.equal?(:hash)
+
+            if predicates.any? || opts.any? || !is_hash_block
+              super(*predicates, type_spec: type_spec, **opts, &(is_hash_block ? nil : block))
+            end
+
+            hash(&block) if is_hash_block
+          end
+
+          self
         end
 
         # @api private

data/lib/dry/schema/macros/dsl.rb

@@ -19,6 +19,11 @@ module Dry
         # @api private
         option :chain, default: -> { true }
 
+        # @!attribute [r] predicate_inferrer
+        #   @return [PredicateInferrer]
+        #   @api private
+        option :predicate_inferrer, default: proc { PredicateInferrer.new(compiler.predicates) }
+
         # Specify predicates that should be applied to a value
         #
         # @api public
@@ -75,10 +80,22 @@ module Dry
           end
         end
 
+        # Set type spec
+        #
+        # @param [Symbol, Array, Dry::Types::Type]
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def type(spec)
+          schema_dsl.set_type(name, spec)
+          self
+        end
+
         private
 
         # @api private
-        def append_macro(macro_type, &block)
+        def append_macro(macro_type)
           macro = macro_type.new(schema_dsl: schema_dsl, name: name)
 
           yield(macro)
@@ -90,6 +107,39 @@ module Dry
             macro
           end
         end
+
+        # @api private
+        def extract_type_spec(*args, nullable: false, set_type: true)
+          type_spec = args[0]
+
+          is_type_spec = type_spec.is_a?(Dry::Schema::Processor) ||
+                         type_spec.is_a?(Symbol) &&
+                         type_spec.to_s.end_with?(QUESTION_MARK)
+
+          type_spec = nil if is_type_spec
+
+          predicates = Array(type_spec ? args[1..-1] : args)
+
+          if type_spec
+            resolved_type = schema_dsl.resolve_type(
+              nullable && !type_spec.is_a?(::Array) ? [:nil, type_spec] : type_spec
+            )
+
+            type(resolved_type) if set_type
+
+            type_predicates = predicate_inferrer[resolved_type]
+
+            unless predicates.include?(type_predicates)
+              if type_predicates.is_a?(::Array) && type_predicates.size.equal?(1)
+                predicates.unshift(type_predicates[0])
+              else
+                predicates.unshift(type_predicates)
+              end
+            end
+          end
+
+          yield(*predicates, type_spec: type_spec)
+        end
       end
     end
   end

data/lib/dry/schema/macros/each.rb

@@ -9,6 +9,15 @@ module Dry
       #
       # @api public
       class Each < DSL
+        # @api private
+        def value(*args, **opts)
+          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:|
+            type(schema_dsl.array[type_spec]) if type_spec
+
+            super(*predicates, type_spec: type_spec, **opts)
+          end
+        end
+
         # @api private
         def to_ast(*)
           [:each, trace.to_ast]

data/lib/dry/schema/macros/filled.rb

@@ -18,8 +18,8 @@ module Dry
             raise ::Dry::Schema::InvalidSchemaError, 'Using filled with filled? is redundant'
           end
 
-          if opts[:type_spec].equal?(true)
-            value(predicates[0], :filled?, *predicates[1..predicates.size-1], **opts, &block)
+          if opts[:type_spec]
+            value(predicates[0], :filled?, *predicates[1..predicates.size - 1], **opts, &block)
           else
             value(:filled?, *predicates, **opts, &block)
           end

data/lib/dry/schema/macros/key.rb

@@ -19,13 +19,6 @@ module Dry
         #   @api private
         option :filter_schema, optional: true, default: proc { schema_dsl&.new }
 
-        # @!attribute [r] predicate_inferrer
-        #   @return [PredicateInferrer]
-        #   @api private
-        option :predicate_inferrer, default: proc {
-          PredicateInferrer.new(compiler.predicates)
-        }
-
         # Specify predicates that should be used to filter out values
         # before coercion is applied
         #
@@ -80,18 +73,6 @@ module Dry
           end
         end
 
-        # Set type spec
-        #
-        # @param [Symbol, Array, Dry::Types::Type]
-        #
-        # @return [Macros::Key]
-        #
-        # @api public
-        def type(spec)
-          schema_dsl.set_type(name, spec)
-          self
-        end
-
         # Coerce macro to a rule
         #
         # @return [Dry::Logic::Rule]
@@ -109,37 +90,6 @@ module Dry
         def to_ast
           [:predicate, [:key?, [[:name, name], [:input, Undefined]]]]
         end
-
-        private
-
-        # @api private
-        def extract_type_spec(*args, nullable: false)
-          type_spec = args[0]
-
-          is_type_spec = type_spec.kind_of?(Dry::Schema::Processor) ||
-                         type_spec.is_a?(Symbol) &&
-                         type_spec.to_s.end_with?(QUESTION_MARK)
-
-          type_spec = nil if is_type_spec
-
-          predicates = Array(type_spec ? args[1..-1] : args)
-
-          if type_spec
-            type(nullable && !type_spec.is_a?(::Array) ? [:nil, type_spec] : type_spec)
-
-            type_predicates = predicate_inferrer[schema_dsl.types[name]]
-
-            unless predicates.include?(type_predicates)
-              if type_predicates.is_a?(::Array) && type_predicates.size.equal?(1)
-                predicates.unshift(type_predicates[0])
-              else
-                predicates.unshift(type_predicates)
-              end
-            end
-          end
-
-          yield(*predicates, type_spec: !type_spec.nil?)
-        end
       end
     end
   end

data/lib/dry/schema/message.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require 'dry/initializer'
 require 'dry/equalizer'
+
 require 'dry/schema/path'
+require 'dry/schema/message/or'
 
 module Dry
   module Schema
@@ -9,76 +12,31 @@ module Dry
     #
     # @api public
     class Message
-      include Dry::Equalizer(:predicate, :path, :text, :options)
+      include Dry::Equalizer(:text, :path, :predicate, :input)
 
-      attr_reader :predicate, :path, :text, :args, :options
+      extend Dry::Initializer
 
-      # A message sub-type used by OR operations
-      #
-      # @api public
-      class Or
-        include Enumerable
+      option :text
 
-        # @api private
-        attr_reader :left
+      option :path
 
-        # @api private
-        attr_reader :right
+      option :predicate
 
-        # @api private
-        attr_reader :path
+      option :args, default: proc { EMPTY_ARRAY }
 
-        # @api private
-        attr_reader :messages
+      option :input
 
-        # @api private
-        def initialize(left, right, messages)
-          @left = left
-          @right = right
-          @messages = messages
-          @path = left.path
-        end
+      option :meta, optional: true, default: proc { EMPTY_HASH }
 
-        # Return a string representation of the message
-        #
-        # @api public
-        def to_s
-          uniq.join(" #{messages[:or]} ")
-        end
-
-        # @api private
-        def each(&block)
-          to_a.each(&block)
-        end
-
-        # @api private
-        def to_a
-          [left, right]
-        end
-      end
-
-      # Build a new message object
+      # Dump the message to a representation suitable for the message set hash
       #
-      # @api private
-      def self.[](predicate, path, text, options)
-        Message.new(predicate, path, text, options)
-      end
-
-      # @api private
-      def initialize(predicate, path, text, options)
-        @predicate = predicate
-        @path = path
-        @text = text
-        @options = options
-        @args = options[:args] || EMPTY_ARRAY
-      end
-
-      # Return a string representation of the message
+      # @return [String,Hash]
       #
       # @api public
-      def to_s
-        text
+      def dump
+        @dump ||= meta.empty? ? text : { text: text, **meta }
       end
+      alias to_s dump
 
       # @api private
       def eql?(other)

data/lib/dry/schema/message/or.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'dry/equalizer'
+
+module Dry
+  module Schema
+    # Message objects used by message sets
+    #
+    # @api public
+    class Message
+      # A message sub-type used by OR operations
+      #
+      # @api public
+      class Or
+        # @api private
+        attr_reader :left
+
+        # @api private
+        attr_reader :right
+
+        # @api private
+        attr_reader :path
+
+        # @api private
+        attr_reader :messages
+
+        # @api private
+        def initialize(left, right, messages)
+          @left = left
+          @right = right
+          @messages = messages
+          @path = left.path
+        end
+
+        # @see Message#dump
+        #
+        # @return [String]
+        #
+        # @api public
+        def dump
+          to_a.map(&:dump).join(" #{messages[:or][:text]} ")
+        end
+        alias to_s dump
+
+        # @api private
+        def to_a
+          [left, right]
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/message_compiler.rb

@@ -28,6 +28,7 @@ module Dry
         .new(resolve_predicate).update(key?: resolve_key_predicate).freeze
 
       EMPTY_OPTS = VisitorOpts.new
+      EMPTY_MESSAGE_SET = MessageSet.new(EMPTY_ARRAY).freeze
 
       param :messages
 
@@ -50,11 +51,17 @@ module Dry
       def with(new_options)
         return self if new_options.empty?
 
-        self.class.new(messages, options.merge(new_options))
+        updated_opts = options.merge(new_options)
+
+        return self if updated_opts.eql?(options)
+
+        self.class.new(messages, updated_opts)
       end
 
       # @api private
       def call(ast)
+        return EMPTY_MESSAGE_SET if ast.empty?
+
         current_messages = EMPTY_ARRAY.dup
         compiled_messages = ast.map { |node| visit(node, EMPTY_OPTS.dup(current_messages)) }
 
@@ -123,15 +130,13 @@ module Dry
           path: path.last, **tokens, **lookup_options(arg_vals: arg_vals, input: input)
         ).to_h
 
-        template = messages[predicate, options] || raise(MissingMessageError, path)
+        template, meta = messages[predicate, options] || raise(MissingMessageError, path)
 
         text = message_text(template, tokens, options)
 
-        message_type(options)[
-          predicate, path, text,
-          args: arg_vals,
-          input: input
-        ]
+        message_type(options).new(
+          text: text, path: path, predicate: predicate, args: arg_vals, input: input, meta: meta
+        )
       end
 
       # @api private

data/lib/dry/schema/message_set.rb

@@ -29,13 +29,15 @@ module Dry
 
       # @api public
       def each(&block)
+        return self if empty?
         return to_enum unless block
+
         messages.each(&block)
       end
 
       # @api public
       def to_h
-        messages_map
+        @to_h ||= messages_map
       end
       alias_method :to_hash, :to_h
 
@@ -51,13 +53,22 @@ module Dry
 
       # @api private
       def empty?
-        messages.empty?
+        @empty ||= messages.empty?
+      end
+
+      # @api private
+      def freeze
+        to_h
+        empty?
+        super
       end
 
       private
 
       # @api private
       def messages_map(messages = self.messages)
+        return EMPTY_HASH if empty?
+
         messages.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
           node = path.reduce(hash) { |a, e| a[e] }
 
@@ -65,7 +76,7 @@ module Dry
             node << msg
           end
 
-          node.map!(&:to_s)
+          node.map!(&:dump)
 
           hash
         end
@@ -78,12 +89,14 @@ module Dry
 
       # @api private
       def initialize_placeholders!
-        @placeholders = messages.map(&:path).uniq.reduce({}) do |hash, path|
+        return @placeholders = EMPTY_HASH if empty?
+
+        @placeholders = paths.reduce(EMPTY_HASH.dup) do |hash, path|
           curr_idx = 0
           last_idx = path.size - 1
           node = hash
 
-          while curr_idx <= last_idx do
+          while curr_idx <= last_idx
             key = path[curr_idx]
             node = (node[key] || node[key] = curr_idx < last_idx ? {} : [])
             curr_idx += 1

data/lib/dry/schema/messages/abstract.rb

@@ -27,7 +27,6 @@ module Dry
           '%<root>s.rules.%<path>s.%<predicate>s.arg.%<arg_type>s',
           '%<root>s.rules.%<path>s.%<predicate>s',
           '%<root>s.%<predicate>s.%<message_type>s',
-          '%<root>s.%<predicate>s.value.%<path>s.arg.%<arg_type>s',
           '%<root>s.%<predicate>s.value.%<path>s',
           '%<root>s.%<predicate>s.value.%<val_type>s.arg.%<arg_type>s',
           '%<root>s.%<predicate>s.value.%<val_type>s',
@@ -87,7 +86,8 @@ module Dry
           tokens = { name: name, locale: options.fetch(:locale, default_locale) }
           path = rule_lookup_paths(tokens).detect { |key| key?(key, options) }
 
-          get(path, options) if path
+          rule = get(path, options) if path
+          rule.is_a?(Hash) ? rule[:text] : rule
         end
 
         # Retrieve a message template
@@ -97,8 +97,8 @@ module Dry
         # @api public
         def call(*args)
           cache.fetch_or_store(args.hash) do
-            path, opts = lookup(*args)
-            Template[get(path, opts)] if path
+            text, meta = lookup(*args)
+            [Template[text], meta] if text
           end
         end
         alias_method :[], :call
@@ -106,10 +106,12 @@ module Dry
         # Try to find a message for the given predicate and its options
         #
         # @api private
-        def lookup(predicate, options = {})
+        #
+        # rubocop:disable Metrics/AbcSize
+        def lookup(predicate, options)
           tokens = options.merge(
-            root: options[:not] ? "#{root}.not" : root,
             predicate: predicate,
+            root: options[:not] ? "#{root}.not" : root,
             arg_type: config.arg_types[options[:arg_type]],
             val_type: config.val_types[options[:val_type]],
             message_type: options[:message_type] || :failure
@@ -117,12 +119,19 @@ module Dry
 
           opts = options.reject { |k, _| config.lookup_options.include?(k) }
 
-          path = lookup_paths(tokens).detect do |key|
-            key?(key, opts) && get(key, opts).is_a?(String)
-          end
+          path = lookup_paths(tokens).detect { |key| key?(key, opts) }
 
-          [path, opts]
+          return unless path
+
+          text = get(path, opts)
+
+          if text.is_a?(Hash)
+            text.values_at(:text, :meta)
+          else
+            [text, EMPTY_HASH]
+          end
         end
+        # rubocop:enable Metrics/AbcSize
 
         # @api private
         def lookup_paths(tokens)

data/lib/dry/schema/messages/yaml.rb

@@ -31,11 +31,23 @@ module Dry
       end
 
       # @api private
-      def self.flat_hash(hash, acc = [], result = {})
-        return result.update(acc.join(DOT) => hash) unless hash.is_a?(Hash)
-
-        hash.each { |k, v| flat_hash(v, acc + [k], result) }
-        result
+      def self.flat_hash(hash, path = [], keys = {})
+        hash.each do |key, value|
+          flat_hash(value, [*path, key], keys) if value.is_a?(Hash)
+
+          if value.is_a?(String) && hash['text'] != value
+            keys[[*path, key].join(DOT)] = {
+              text: value,
+              meta: EMPTY_HASH
+            }
+          elsif value.is_a?(Hash) && value['text'].is_a?(String)
+            keys[[*path, key].join(DOT)] = {
+              text: value['text'],
+              meta: value.dup.delete_if { |k| k == 'text' }.map { |k, v| [k.to_sym, v] }.to_h
+            }
+          end
+        end
+        keys
       end
 
       # @api private

data/lib/dry/schema/predicate_inferrer.rb

@@ -107,6 +107,11 @@ module Dry
           other, * = node
           visit(other)
         end
+
+        # @api private
+        def visit_any(_)
+          nil
+        end
       end
 
       # @!attribute [r] compiler

data/lib/dry/schema/result.rb

@@ -139,7 +139,7 @@ module Dry
       #
       # @api private
       def result_ast
-        @__result__ast ||= results.map(&:to_ast)
+        @result_ast ||= results.map(&:to_ast)
       end
     end
   end

data/lib/dry/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module Schema
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-schema
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-26 00:00:00.000000000 Z
+date: 2019-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -98,20 +98,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: dry-types
   requirement: !ruby/object:Gem::Requirement
@@ -193,6 +193,7 @@ files:
 - lib/dry/schema/dsl.rb
 - lib/dry/schema/extensions.rb
 - lib/dry/schema/extensions/hints.rb
+- lib/dry/schema/extensions/hints/compiler_methods.rb
 - lib/dry/schema/extensions/hints/message_compiler_methods.rb
 - lib/dry/schema/extensions/hints/message_set_methods.rb
 - lib/dry/schema/extensions/hints/result_methods.rb
@@ -215,6 +216,7 @@ files:
 - lib/dry/schema/macros/schema.rb
 - lib/dry/schema/macros/value.rb
 - lib/dry/schema/message.rb
+- lib/dry/schema/message/or.rb
 - lib/dry/schema/message_compiler.rb
 - lib/dry/schema/message_compiler/visitor_opts.rb
 - lib/dry/schema/message_set.rb
@@ -250,7 +252,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="