dry-validation 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16fb2c50b37c5d1aff843031ff3d7af6e87ab05a
-  data.tar.gz: 64f74fc7df4b183322908ec96120d4dbbb4b38c2
+  metadata.gz: f2a8ab72eef1372d4c7e77ca26f239505a4bc8e3
+  data.tar.gz: cdf67dd43d094a74a2e1b7426e465e8a1207de70
 SHA512:
-  metadata.gz: 244e25e33c6a1795436fc015cab5d4c23961c974eaf7208144faf69a81c040ede351c54e7225efc1695283f061225b0543e2ee6120fce29c00069725fc0ee791
-  data.tar.gz: fc89edb2c0f6862d1771b46a77863b644947db429861a34d944cab9799d328df01e7bb0554291fa23f12d67ba545a276fe8f3c98435837485fb002bee55b5101
+  metadata.gz: 171bc1e3cd30d4b5d6bcb04fbaeaf3d3150a35dd07eadd293f9f4295845caa453e071c342f50fbab1f78d9f877ffb8030a5bf940c65b3a0211a8bcbd91117bdd
+  data.tar.gz: 0ad0b772fffd453b7f948169568fbebc57b8731d4baf18f6be47be330bf36540f2a30d99312af786489e8be633edf08601a8b4fdae3860eacb775f69714c3a40

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 sudo: false
 cache: bundler
-bundler_args: --full-index --without console benchmarks
+bundler_args: --without console benchmarks
 script:
   - bundle exec rake spec
 rvm:

data/CHANGELOG.md

@@ -1,3 +1,41 @@
+# v0.9.0 2016-07-08
+
+### Added
+
+* Support for defining maybe-schemas via `maybe { schema { .. } }` (solnic)
+* Support for interpolation of custom failure messages for custom rules (solnic)
+* Support for defining a base schema **class** with config and rules (solnic)
+* Support for more than 1 predicate in `input` macro (solnic)
+* Class-level `define!` API for defining rules on a class (solnic)
+* `:i18n` messages support merging from other paths via `messages_file` setting (solnic)
+* Support for message token transformations in custom predicates (fran-worley)
+* [EXPERIMENTAL] Ability to compose predicates that accept dynamic args provided by the schema (solnic)
+
+### Changed
+
+* Tokens for `size?` were renamed `left` => `size_left` and `right` => `size_right` (fran-worley)
+
+### Fixed
+
+* Duped key names in nested schemas no longer result in invalid error messages structure (solnic)
+* Error message structure for deeply nested each/schema rules (solnic)
+* Values from `option` are passed down to nested schemas when using `Schema#with` (solnic)
+* Hints now work with array elements too (solnic)
+* Hints for elements are no longer provided for an array when the value is not an array (solnic)
+* `input` macro no longer messes up error messages for nested structures (solnic)
+* `messages` and `error_compiler` are now properly inherited from base schema class (solnic)
+
+### Internal
+
+* Compiling messages is now ~5% faster (solnic + splattael)
+* Refactored Error and Hint compilers (solnic)
+* Refactored Schema to use an internal executor objects with steps (solnic)
+* Extracted root-rule into a separate validation step (solnic)
+* Added `MessageSet` that result objects now use (in 1.0.0 it'll be exposed via public API) (solnic)
+* We can now distinguish error messages from validation hints via `Message` and `Hint` objects (solnic)
+
+[Compare v0.8.0...master](https://github.com/dryrb/dry-validation/compare/v0.8.0...master)
+
 # v0.8.0 2016-07-01
 
 ### Added
@@ -54,7 +92,7 @@
 * Make pry console optional with IRB as a default (flash-gordon)
 * Remove wrapping rules in :set nodes (solnic)
 
-[Compare v0.7.4...master](https://github.com/dryrb/dry-validation/compare/v0.7.4...master)
+[Compare v0.7.4...v0.8.0](https://github.com/dryrb/dry-validation/compare/v0.7.4...v0.8.0)
 
 # v0.7.4 2016-04-06
 

data/benchmarks/benchmark_schema_invalid_huge.rb

@@ -0,0 +1,52 @@
+require 'benchmark/ips'
+
+require 'active_model'
+require 'dry-validation'
+
+I18n.locale = :en
+I18n.backend.load_translations
+
+COUNT = ENV['COUNT'].to_i
+FIELDS = COUNT.times.map { |i| :"field_#{i}" }
+
+class User
+  include ActiveModel::Validations
+
+  attr_reader(*FIELDS)
+  validates(*FIELDS, presence: true, numericality: { greater_than: FIELDS.size / 2 })
+
+  def initialize(attrs)
+    attrs.each do |field, value|
+      instance_variable_set(:"@#{field}", value)
+    end
+  end
+end
+
+schema = Dry::Validation.Schema do
+  configure do
+    config.messages = :i18n
+  end
+
+  FIELDS.each do |field|
+    required(field).value(:int?, gt?: FIELDS.size / 2)
+  end
+end
+
+data = FIELDS.reduce({}) { |h, f| h.update(f => FIELDS.index(f) + 1) }
+
+puts schema.(data).inspect
+puts User.new(data).validate
+
+Benchmark.ips do |x|
+  x.report('ActiveModel::Validations') do
+    user = User.new(data)
+    user.validate
+    user.errors
+  end
+
+  x.report('dry-validation / schema') do
+    schema.(data).messages
+  end
+
+  x.compare!
+end

data/benchmarks/profile_schema_huge_invalid.rb

@@ -0,0 +1,30 @@
+require_relative 'suite'
+require 'hotch'
+
+require 'dry-validation'
+
+I18n.locale = :en
+I18n.backend.load_translations
+
+COUNT = ENV['COUNT'].to_i
+FIELDS = COUNT.times.map { |i| :"field_#{i}" }
+
+schema = Dry::Validation.Schema do
+  configure do
+    config.messages = :i18n
+  end
+
+  FIELDS.each do |field|
+    required(field).filled(gt?: FIELDS.size / 2)
+  end
+end
+
+data = FIELDS.reduce({}) { |h, f| h.update(f => FIELDS.index(f) + 1) }
+
+puts schema.(data).inspect
+
+Hotch() do
+  100.times do
+    schema.(data).messages
+  end
+end

data/config/errors.yml

@@ -7,6 +7,7 @@ en:
     excludes?: "must not include %{value}"
 
     excluded_from?: "must not be one of: %{list}"
+    exclusion?: "must not be one of: %{list}"
 
     eql?: "must be equal to %{left}"
 
@@ -72,10 +73,10 @@ en:
     size?:
       arg:
         default: "size must be %{size}"
-        range: "size must be within %{left} - %{right}"
+        range: "size must be within %{size_left} - %{size_right}"
 
       value:
         string:
           arg:
             default: "length must be %{size}"
-            range: "length must be within %{left} - %{right}"
+            range: "length must be within %{size_left} - %{size_right}"

data/dry-validation.gemspec

@@ -10,8 +10,8 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/dryrb/dry-validation'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.files         = `git ls-files -z`.split("\x0") - ['bin/console']
+  spec.executables   = []
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 

data/lib/dry/validation.rb

@@ -7,6 +7,25 @@ require 'dry/validation/schema/form'
 require 'dry/validation/schema/json'
 
 module Dry
+  # FIXME: move this to dry-logic if it works lol
+  require 'dry/logic/predicate'
+  module Logic
+    class Predicate
+      class Curried < Predicate
+        def evaluate_args!(schema)
+          @args = args.map { |arg|
+            arg.is_a?(UnboundMethod) ? arg.bind(schema).() : arg
+          }
+          self
+        end
+      end
+
+      def evaluate_args!(*)
+        self
+      end
+    end
+  end
+
   module Validation
     MissingMessageError = Class.new(StandardError)
     InvalidSchemaError = Class.new(StandardError)
@@ -17,38 +36,7 @@ module Dry
 
     def self.Schema(base = Schema, **options, &block)
       schema_class = Class.new(base.is_a?(Schema) ? base.class : base)
-
-      dsl_opts = {
-        schema_class: schema_class,
-        registry: schema_class.registry,
-        parent: options[:parent]
-      }
-
-      dsl_ext = schema_class.config.dsl_extensions
-
-      dsl = Schema::Value.new(dsl_opts)
-      dsl_ext.__send__(:extend_object, dsl) if dsl_ext
-      dsl.predicates(options[:predicates]) if options.key?(:predicates)
-      dsl.instance_exec(&block) if block
-
-      klass = dsl.schema_class
-
-      base_rules = klass.config.rules + (options.fetch(:rules, []) + dsl.rules)
-
-      rules =
-        if klass.config.input
-          input_rule = dsl.__send__(klass.config.input)
-          [input_rule.and(dsl.with(rules: base_rules))]
-        else
-          base_rules
-        end
-
-      klass.configure do |config|
-        config.rules = rules
-        config.checks = config.checks + dsl.checks
-        config.path = dsl.path
-        config.type_map = klass.build_type_map(dsl.type_map) if config.type_specs
-      end
+      klass = schema_class.define(options.merge(schema_class: schema_class), &block)
 
       if options[:build] == false
         klass

data/lib/dry/validation/constants.rb

@@ -0,0 +1,6 @@
+module Dry
+  module Validation
+    EMPTY_ARRAY = [].freeze
+    EMPTY_HASH = {}.freeze
+  end
+end

data/lib/dry/validation/error.rb

@@ -15,8 +15,11 @@ module Dry
       end
 
       def to_ast
-        node = [:error, [name, result.to_ast]]
-        schema? ? [:schema, node] : node
+        if schema?
+          [:schema, [name, result.response.to_ast]]
+        else
+          [:error, [name, result.to_ast]]
+        end
       end
     end
   end

data/lib/dry/validation/error_compiler.rb

@@ -1,147 +1,77 @@
+require 'dry/validation/message_compiler'
+
 module Dry
   module Validation
-    class ErrorCompiler
-      attr_reader :messages, :hints, :options
-
-      DEFAULT_RESULT = {}.freeze
-      EMPTY_HINTS = [].freeze
-      KEY_SEPARATOR = '.'.freeze
-
-      def initialize(messages, options = {})
-        @messages = messages
-        @options = Hash[options]
-        @hints = @options.fetch(:hints, DEFAULT_RESULT)
-        @full = options.fetch(:full, false)
+    class ErrorCompiler < MessageCompiler
+      def message_type
+        :failure
       end
 
-      def full?
-        @full
+      def message_class
+        Message
       end
 
-      def call(ast, *args)
-        merge(ast.map { |node| visit(node, *args) }) || DEFAULT_RESULT
-      end
+      def visit_error(node, opts = EMPTY_HASH)
+        rule, error = node
+        node_path = Array(opts.fetch(:path, rule))
 
-      def with(new_options)
-        self.class.new(messages, options.merge(new_options))
-      end
+        path = if rule.is_a?(Array) && rule.size > node_path.size
+                 rule
+               else
+                 node_path
+               end
 
-      def visit(node, *args)
-        __send__(:"visit_#{node[0]}", node[1], *args)
-      end
+        path.compact!
 
-      def visit_schema(node, *args)
-        visit_error(node[1], true)
-      end
+        template = messages[rule, default_lookup_options]
 
-      def visit_set(node, *args)
-        call(node, *args)
-      end
-
-      def visit_error(error, schema = false)
-        name, other = error
-        message = messages[name]
-
-        if message
-          { name => [message] }
+        if template
+          predicate, args, tokens = visit(error, opts.merge(path: path, message: false))
+          message_class[predicate, path, template % tokens, rule: rule, args: args]
         else
-          result = schema ? visit(other, name) : visit(other)
-
-          if result.is_a?(Array)
-            merge(result)
-          elsif !schema
-            merge_hints(result)
-          elsif schema
-            merge_hints(result, hints[schema] || DEFAULT_RESULT)
-          else
-            result
-          end
+          visit(error, opts.merge(rule: rule, path: path))
         end
       end
 
-      def visit_input(node, path = nil)
-        name, result = node
-        visit(result, path || name)
-      end
+      def visit_input(node, opts = EMPTY_HASH)
+        rule, result = node
+        opt_rule = opts[:rule]
 
-      def visit_result(node, name = nil)
-        value, other = node
-        input_visitor(name, value).visit(other)
-      end
-
-      def visit_implication(node)
-        _, right = node
-        visit(right)
-      end
-
-      def visit_key(rule)
-        _, predicate = rule
-        visit(predicate)
-      end
-
-      def visit_attr(rule)
-        _, predicate = rule
-        visit(predicate)
+        if opts[:each] && opt_rule.is_a?(Array)
+          visit(result, opts.merge(rule: rule, path: opts[:path] + [opt_rule.last]))
+        else
+          visit(result, opts.merge(rule: rule))
+        end
       end
 
-      def visit_val(node)
-        visit(node)
+      def visit_result(node, opts = EMPTY_HASH)
+        input, other = node
+        visit(other, opts.merge(input: input))
       end
 
-      def dump_messages(hash)
-        hash.each_with_object({}) do |(key, val), res|
-          res[key] =
-            case val
-            when Hash then dump_messages(val)
-            when Array then val.map(&:to_s)
-            end
-        end
+      def visit_each(node, opts = EMPTY_HASH)
+        node.map { |el| visit(el, opts.merge(each: true)) }
       end
 
-      private
-
-      def merge_hints(messages, hints = self.hints)
-        messages.each_with_object({}) do |(name, msgs), res|
-          res[name] =
-            if msgs.is_a?(Hash)
-              res[name] = merge_hints(msgs, hints)
-            else
-              all_hints = (hints[name] || EMPTY_HINTS)
+      def visit_schema(node, opts = EMPTY_HASH)
+        path, other = node
 
-              if all_hints.is_a?(Array)
-                all_msgs = msgs + all_hints
-                all_msgs.uniq!(&:signature)
-                all_msgs
-              else
-                msgs
-              end
-            end
+        if opts[:path]
+          opts[:path] << path.last
+          visit(other, opts)
+        else
+          visit(other, opts.merge(path: [path]))
         end
       end
 
-      def normalize_name(name)
-        Array(name).join('.').to_sym
-      end
-
-      def merge(result)
-        result.reduce { |a, e| deep_merge(a, e) } || DEFAULT_RESULT
+      def visit_check(node, opts = EMPTY_HASH)
+        path, other = node
+        visit(other, opts.merge(path: Array(path)))
       end
 
-      def deep_merge(left, right)
-        left.merge(right) do |_, a, e|
-          if a.is_a?(Hash)
-            deep_merge(a, e)
-          else
-            a + e
-          end
-        end
-      end
-
-      def input_visitor(name, input)
-        Input.new(messages, options.merge(name: name, input: input))
+      def lookup_options(opts, arg_vals = [])
+        super.update(val_type: opts[:input].class)
       end
     end
   end
 end
-
-require 'dry/validation/error_compiler/input'