dry-validation 0.9.5 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8275fd162e586ba1fcbb31efe723708f553e31f6
-  data.tar.gz: d95d66f951d31033be04e04258b3ac0dca700c8a
+  metadata.gz: 94d71785e9206636cca2df3765b30ebbf7009b38
+  data.tar.gz: 4d725f61ebc1f28a9dc54a0f6363caa8b66108a1
 SHA512:
-  metadata.gz: 147d0f89a321c42bfa3799f37c3bd5700faefd22189a1c8bd49af812de16f4de80ab0bb9a98b253c688c66582f433bccacaccbcda5f0820fb3d6fb13c9c26ae5
-  data.tar.gz: 7e32822ddbe928051bceab4e7bf4e0ad9378d63e5e95972c4c6f98056dd5a7a66a81e3e4b4a8c85c8391de782d95e1fdfd6932ffeeb96776743bf0f9cf1ee63e
+  metadata.gz: 1fe8b86ff9acc5ee111d271a9e20b6a1d07af65719090f65cebe3ec45337bef7534abec1ec4cc9879b281546986cd197c0c6e75d96f7a1994ca9fba890ab7382
+  data.tar.gz: 252091265ccc93ca446e77fc2895ace365505a602f9ff4274df1fb9d00e3d3e582b976c2c3bb58a74ca9bcc1107db1f09b0d996b0687426dc43c6578c84ebc5c

data/.travis.yml

@@ -3,26 +3,19 @@ sudo: false
 cache: bundler
 bundler_args: --without console benchmarks
 script:
-  - bundle exec rake spec
+  - bundle exec rake
 rvm:
-  - 2.0
   - 2.1.10
   - 2.2.5
   - 2.3.1
   - rbx-2
   - jruby-9.1.1.0
-  - ruby-head
 env:
   global:
     - JRUBY_OPTS='--dev -J-Xmx1024M'
 matrix:
   allow_failures:
     - rvm: rbx-2
-    - rvm: ruby-head
-    - rvm: jruby-head
-  include:
-    - rvm: jruby-head
-      before_install: gem install bundler --no-ri --no-rdoc
 
 notifications:
   email: false

data/CHANGELOG.md

@@ -1,4 +1,37 @@
-# v0.9.5 2016-08-15
+# v0.10.0 to-be-released
+
+### Added
+
+* Support for `validate` DSL which accepts an arbitratry validation block that gets executed in the context of a schema object and is treated as a custom predicate (solnic)
+* Support for `or` error messages ie "must be a string or must be an integer" (solnic)
+* Support for retrieving error messages exclusively via `schema.(input).errors` (solnic)
+* Support for retrieving hint messages exclusively via `schema.(input).hints` (solnic)
+* Support for opt-in extensions loaded via `Dry::Validation.load_extensions(:my_ext)` (flash-gordon)
+* Add `:monads` extension which transforms a result instance to `Either` monad, `schema.(input).to_either` (flash-gordon)
+* Add `dry-struct` integration via an extension activated by `Dry::Validation.load_extension(:struct)` (flash-gordon)
+
+### Fixed
+
+* Input rules (defined via `input` macro) are now lazy-initialized which makes it work with predicates defined on the schema object (solnic)
+* Hints are properly generated based on argument type in cases like `size?`, where the message should be different for strings (uses "length") or other types (uses "size") (solnic)
+* Defining nested keys without `schema` blocks results in `ArgumentError` (solnic)
+
+### Changed
+
+* [BREAKING] `when` macro no longer supports multiple disconnected rules in its block, whatever the block returns will be used for the implication (solnic)
+* [BREAKING] `rule(some_name: %i(some keys))` will *always* use `:some_name` as the key for failure messages (solnic)
+
+### Internal
+
+* ~2 x performance boost (solnic)
+* Rule AST was updated to latest dry-logic (solnic)
+* `MessageCompiler` was drastically simplified based on the new result AST from dry-logic (solnic)
+* `HintCompiler` is gone as hints are now part of the result AST (solnic)
+* `maybe` macro creates an implication instead of a disjunction (`not(none?).then(*your-predicates)`) (solnic)
+
+[Compare v0.9.5...v0.10.0](https://github.com/dryrb/dry-validation/compare/v0.9.5...v0.10.0)
+
+# v0.9.5 2016-08-16
 
 ### Fixed
 

data/Gemfile

@@ -5,6 +5,8 @@ gemspec
 group :test do
   gem 'i18n', require: false
   gem 'codeclimate-test-reporter', platform: :rbx
+  gem 'dry-monads', require: false
+  gem 'dry-struct', github: 'dry-rb/dry-struct', branch: 'master', require: false
 end
 
 group :tools do

data/Rakefile

@@ -6,7 +6,16 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
 require 'rspec/core'
 require 'rspec/core/rake_task'
 
-task default: :spec
-
 desc 'Run all specs in spec directory'
-RSpec::Core::RakeTask.new(:spec)
+task :run_specs do
+  require 'rspec/core'
+
+  RSpec::Core::Runner.run(['spec/integration', 'spec/unit'])
+  RSpec.clear_examples
+  Dir[SPEC_ROOT.join('shared/**/*.rb')].each(&method(:load))
+
+  Dry::Validation.load_extensions(:monads, :struct)
+  RSpec::Core::Runner.run(['spec'])
+end
+
+task default: :run_specs

data/config/errors.yml

@@ -1,5 +1,6 @@
 en:
   errors:
+    or: "or"
     array?: "must be an array"
 
     empty?: "must be empty"

data/dry-validation.gemspec

@@ -19,8 +19,9 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'dry-configurable', '~> 0.1', '>= 0.1.3'
   spec.add_runtime_dependency 'dry-container', '~> 0.2', '>= 0.2.8'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-  spec.add_runtime_dependency 'dry-logic', '~> 0.3', '>= 0.3.0'
-  spec.add_runtime_dependency 'dry-types', '~> 0.8', '>= 0.8.1'
+  spec.add_runtime_dependency 'dry-logic', '~> 0.4', '>= 0.4.0'
+  spec.add_runtime_dependency 'dry-types', '~> 0.9', '>= 0.9.0'
+  spec.add_runtime_dependency 'dry-core', '~> 0.1'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

data/lib/dry/validation/executor.rb

@@ -52,40 +52,16 @@ module Dry
     end
 
     class BuildErrors
-      attr_reader :path
-
-      def self.[](path)
-        path.nil? || path.empty? ? Flat.new : Nested.new(path)
-      end
-
-      class Flat < BuildErrors
-        def error_path(name)
-          name
-        end
-      end
-
-      class Nested < BuildErrors
-        def initialize(path)
-          @path = path
-        end
-
-        def error_path(name)
-          [*path, name]
-        end
-      end
-
       def call(result)
-        result
-          .select { |_, r| r.failure? }
-          .map { |name, r| Error.new(error_path(name), r) }
+        result.values.select(&:failure?)
       end
     end
 
     class Executor
       attr_reader :steps, :final
 
-      def self.new(path, &block)
-        super(BuildErrors[path]).tap { |executor| yield(executor.steps) }.freeze
+      def self.new(&block)
+        super(BuildErrors.new).tap { |executor| yield(executor.steps) }.freeze
       end
 
       def initialize(final)

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

@@ -0,0 +1,17 @@
+require 'dry/monads/either'
+
+module Dry
+  module Validation
+    class Result
+      include Dry::Monads::Either::Mixin
+
+      def to_either(options = EMPTY_HASH)
+        if success?
+          Right(output)
+        else
+          Left(messages(options))
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/extensions/struct.rb

@@ -0,0 +1,32 @@
+require 'dry-struct'
+
+module Dry
+  module Validation
+    class Schema
+      module StructClassBuilder
+        def create_class(target, other = nil)
+          if other.is_a?(Class) && other < Dry::Struct
+            super do
+              other.schema.each { |attr, type| required(attr).filled(type) }
+            end
+          else
+            super
+          end
+        end
+      end
+
+      module StructNode
+        def node(input, *)
+          if input.is_a?(::Class) && input < ::Dry::Struct
+            [type, [name, [:schema, Schema.create_class(self, input)]]]
+          else
+            super
+          end
+        end
+      end
+
+      singleton_class.prepend(StructClassBuilder)
+      Value.prepend(StructNode)
+    end
+  end
+end

data/lib/dry/validation/extensions.rb

@@ -0,0 +1,7 @@
+Dry::Validation.register_extension(:monads) do
+  require 'dry/validation/extensions/monads'
+end
+
+Dry::Validation.register_extension(:struct) do
+  require 'dry/validation/extensions/struct'
+end

data/lib/dry/validation/input_processor_compiler.rb

@@ -24,6 +24,11 @@ module Dry
         send(:"visit_#{node[0]}", node[1], *args)
       end
 
+      def visit_rule(node, *args)
+        _, rule = node
+        visit(rule, *args)
+      end
+
       def visit_type(type, *args)
         if type.is_a?(Types::Constructor)
           [:constructor, [type.primitive, type.fn]]
@@ -63,9 +68,20 @@ module Dry
         end
       end
 
-      def visit_implication(node)
-        key, types = node
-        [:key, [visit(key), visit(types, false)]]
+      def visit_implication(node, *args)
+        left, right = node
+
+        key = visit(left)
+
+        if key.is_a?(Symbol)
+          [:key, [key, visit(right, false)]]
+        else
+          [:sum, [key, visit(right, false)]]
+        end
+      end
+
+      def visit_not(node, *args)
+        visit(node, *args)
       end
 
       def visit_key(node, *args)

data/lib/dry/validation/message.rb

@@ -1,32 +1,55 @@
-require 'dry/validation/constants'
+require 'dry/core/constants'
 
 module Dry
   module Validation
     class Message
+      include Core::Constants
       include Dry::Equalizer(:predicate, :path, :text, :options)
 
-      Index = Class.new {
-        def inspect
-          "index"
+      attr_reader :predicate, :path, :text, :rule, :args, :options
+
+      class Or
+        attr_reader :left
+
+        attr_reader :right
+
+        attr_reader :path
+
+        attr_reader :messages
+
+        def initialize(left, right, messages)
+          @left = left
+          @right = right
+          @messages = messages
+          @path = left.path
         end
-        alias_method :to_s, :inspect
-      }.new
 
-      attr_reader :predicate, :path, :text, :rule, :args, :options
+        def hint?
+          false
+        end
+
+        def root?
+          path.empty?
+        end
 
-      class Each < Message
-        def index_path
-          @index_path ||= [*path[0..path.size-2], Index]
+        def to_s
+          [left, right].uniq.join(" #{messages[:or]} ")
         end
+      end
 
-        def each?
-          true
+      class Check < Message
+        def initialize(*args)
+          super
+          @path = [rule] unless rule.to_s.end_with?('?') || path.include?(rule)
         end
       end
 
       def self.[](predicate, path, text, options)
-        klass = options[:each] ? Message::Each : Message
-        klass.new(predicate, path, text, options)
+        if options[:check]
+          Message::Check.new(predicate, path, text, options)
+        else
+          Message.new(predicate, path, text, options)
+        end
       end
 
       def initialize(predicate, path, text, options)
@@ -35,22 +58,19 @@ module Dry
         @text = text
         @options = options
         @rule = options[:rule]
-        @each = options[:each] || false
         @args = options[:args] || EMPTY_ARRAY
-      end
 
-      alias_method :index_path, :path
+        if predicate == :key?
+          @path << rule
+        end
+      end
 
       def to_s
         text
       end
 
       def signature
-        @signature ||= [predicate, args, index_path].hash
-      end
-
-      def each?
-        @each
+        @signature ||= [predicate, args, path].hash
       end
 
       def hint?
@@ -68,14 +88,7 @@ module Dry
 
     class Hint < Message
       def self.[](predicate, path, text, options)
-        klass = options[:each] ? Hint::Each : Hint
-        klass.new(predicate, path, text, options)
-      end
-
-      class Each < Hint
-        def index_path
-          @index_path ||= [*path, Index]
-        end
+        Hint.new(predicate, path, text, options)
       end
 
       def hint?

data/lib/dry/validation/message_compiler/visitor_opts.rb

@@ -0,0 +1,39 @@
+require 'dry/core/constants'
+
+module Dry
+  module Validation
+    class MessageCompiler
+      class VisitorOpts < Hash
+        def self.new
+          opts = super
+          opts[:path] = Core::Constants::EMPTY_ARRAY
+          opts[:rule] = nil
+          opts[:message_type] = :failure
+          opts
+        end
+
+        def path?
+          ! path.empty?
+        end
+
+        def path
+          self[:path]
+        end
+
+        def rule
+          self[:rule]
+        end
+
+        def with_rule(new_rule, **other)
+          opts = dup
+          opts[:rule] = new_rule unless opts.rule
+          opts.(other)
+        end
+
+        def call(other)
+          merge(other.update(path: [*path, *other[:path]]))
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/message_compiler.rb

@@ -1,85 +1,144 @@
-require 'dry/validation/constants'
+require 'dry/core/constants'
 require 'dry/validation/message'
 require 'dry/validation/message_set'
+require 'dry/validation/message_compiler/visitor_opts'
 
 module Dry
   module Validation
     class MessageCompiler
+      include Core::Constants
+
       attr_reader :messages, :options, :locale, :default_lookup_options
 
+      EMPTY_OPTS = VisitorOpts.new
+      LIST_SEPARATOR = ', '.freeze
+
       def initialize(messages, options = {})
         @messages = messages
         @options = options
         @full = @options.fetch(:full, false)
+        @hints = @options.fetch(:hints, true)
         @locale = @options.fetch(:locale, messages.default_locale)
-        @default_lookup_options = { message_type: message_type, locale: locale }
-      end
-
-      def call(ast)
-        MessageSet[ast.map { |node| visit(node) }]
+        @default_lookup_options = { locale: locale }
       end
 
       def full?
         @full
       end
 
+      def hints?
+        @hints
+      end
+
       def with(new_options)
         return self if new_options.empty?
         self.class.new(messages, options.merge(new_options))
       end
 
+      def call(ast)
+        MessageSet[ast.map { |node| visit(node) }, failures: options.fetch(:failures, true)]
+      end
+
       def visit(node, *args)
         __send__(:"visit_#{node[0]}", node[1], *args)
       end
 
-      def visit_predicate(node, base_opts = EMPTY_HASH)
-        predicate, args = node
+      def visit_failure(node, opts = EMPTY_OPTS)
+        rule, other = node
+        visit(other, opts.(rule: rule))
+      end
+
+      def visit_hint(node, opts = EMPTY_OPTS)
+        if hints?
+          visit(node, opts.(message_type: :hint))
+        end
+      end
 
-        *arg_vals, _ = args.map(&:last)
+      def visit_each(node, opts = EMPTY_OPTS)
+        # TODO: we can still generate a hint for elements here!
+        []
+      end
 
-        tokens = message_tokens(args)
+      def visit_not(node, opts = EMPTY_OPTS)
+        visit(node, opts.(not: true))
+      end
+
+      def visit_check(node, opts = EMPTY_OPTS)
+        keys, other = node
+        visit(other, opts.(path: keys.last, check: true))
+      end
 
-        if base_opts[:message] == false
-          return [predicate, arg_vals, tokens]
+      def visit_rule(node, opts = EMPTY_OPTS)
+        name, other = node
+        visit(other, opts.(rule: name))
+      end
+
+      def visit_schema(node, opts = EMPTY_OPTS)
+        node.rule_ast.map { |rule| visit(rule, opts) }
+      end
+
+      def visit_and(node, opts = EMPTY_OPTS)
+        left, right = node.map { |n| visit(n, opts) }
+
+        if right
+          [left, right]
+        else
+          left
         end
+      end
+
+      def visit_or(node, opts = EMPTY_OPTS)
+        left, right = node.map { |n| visit(n, opts) }
 
-        options = base_opts.update(lookup_options(base_opts, arg_vals))
+        if [left, right].flatten.map(&:path).uniq.size == 1
+          Message::Or.new(left, right, -> k { messages[k, default_lookup_options] })
+        elsif right.is_a?(Array)
+          right
+        else
+          [left, right]
+        end
+      end
+
+      def visit_predicate(node, base_opts = EMPTY_OPTS)
+        predicate, args = node
+
+        *arg_vals, val = args.map(&:last)
+        tokens = message_tokens(args)
+
+        input = val != Undefined ? val : nil
+
+        options = base_opts.update(lookup_options(arg_vals: arg_vals, input: input))
         msg_opts = options.update(tokens)
 
-        name = msg_opts[:name]
-        rule = msg_opts[:rule] || name
+        rule = msg_opts[:rule]
+        path = msg_opts[:path]
 
-        template = messages[predicate, msg_opts]
+        template = messages[rule] || messages[predicate, msg_opts]
 
         unless template
           raise MissingMessageError, "message for #{predicate} was not found"
         end
 
         text = message_text(rule, template, tokens, options)
-        path = message_path(msg_opts, name)
+
+        message_class = options[:message_type] == :hint ? Hint : Message
 
         message_class[
           predicate, path, text,
-          args: arg_vals, rule: rule, each: base_opts[:each] == true
+          args: arg_vals,
+          input: input,
+          rule: rule,
+          check: base_opts[:check]
         ]
       end
 
-      def visit_key(node, opts = EMPTY_HASH)
-        name, predicate = node
-        visit(predicate, opts.merge(name: name))
+      def visit_key(node, opts = EMPTY_OPTS)
+        name, other = node
+        visit(other, opts.(path: name))
       end
 
-      def visit_val(node, opts = EMPTY_HASH)
-        visit(node, opts)
-      end
-
-      def visit_set(node, opts = EMPTY_HASH)
-        node.map { |input| visit(input, opts) }
-      end
-
-      def visit_el(node, opts = EMPTY_HASH)
-        idx, el = node
-        visit(el, opts.merge(path: opts[:path] + [idx]))
+      def visit_set(node, opts = EMPTY_OPTS)
+        node.map { |el| visit(el, opts) }
       end
 
       def visit_implication(node, *args)
@@ -87,14 +146,15 @@ module Dry
         visit(right, *args)
       end
 
-      def visit_xor(node, *args)
-        _, right = node
-        visit(right, *args)
+      def visit_xor(node, opts = EMPTY_OPTS)
+        left, right = node
+        [visit(left, opts), visit(right, opts)].uniq
       end
 
-      def lookup_options(_opts, arg_vals = [])
+      def lookup_options(arg_vals: [], input: nil)
         default_lookup_options.merge(
-          arg_type: arg_vals.size == 1 && arg_vals[0].class
+          arg_type: arg_vals.size == 1 && arg_vals[0].class,
+          val_type: input.class
         )
       end
 
@@ -109,25 +169,11 @@ module Dry
         end
       end
 
-      def message_path(opts, name)
-        if name.is_a?(Array)
-          name
-        else
-          path = opts[:path] || Array(name)
-
-          if name && path.last != name
-            path += [name]
-          end
-
-          path
-        end
-      end
-
       def message_tokens(args)
         args.each_with_object({}) { |arg, hash|
           case arg[1]
           when Array
-            hash[arg[0]] = arg[1].join(', ')
+            hash[arg[0]] = arg[1].join(LIST_SEPARATOR)
           when Range
             hash["#{arg[0]}_left".to_sym] = arg[1].first
             hash["#{arg[0]}_right".to_sym] = arg[1].last