dry-validation 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d2494cc932a3cd69938b609aa9ad9b19477097a
-  data.tar.gz: 1f8ea70284ddb90ef3c84f05f78684e66cfd040d
+  metadata.gz: 341f5b1e89f76e09d7a1d8d2d20cdb68a50a88c1
+  data.tar.gz: 6dada3ab87730f7fe97e600bb73868c2afba511f
 SHA512:
-  metadata.gz: a1acce326a10195fe64fd864aa784b5c975122636e194b658572ff1bde82fd7eb5f31fb13bd785447243446f4cd6c31c7e2594feb6082270feb1e43a9fbe2395
-  data.tar.gz: 61f64697186fd3ad6ca35b5a1ee5d9b9725fe705a45a72fc5fd0fb1b1c3f4180f9564d0bb85ed1302195d3c5a2b3fb27ea548412ad57167b0d9a50928bb461d5
+  metadata.gz: 331d2cd4ea7c0f2b3b96046ad46faf7de8746b1538aaaba8f0fdf07a71546088962653d96cc8b71a3ecba0b04850367b19841f0418d083702666e154890bf29c
+  data.tar.gz: ec3ec948092ab30ad982498ca234b385c66e136ec351cc0b8754f041a46a23cc59049b34fae76aec31d2cc46a2f11d91b9f469c862cc991c4605531600d31d39

data/.codeclimate.yml

@@ -0,0 +1,16 @@
+engines:
+  rubocop:
+    enabled: true
+    checks:
+      Rubocop/Style/LambdaCall:
+        enabled: false
+      Rubocop/Style/StabbyLambdaParentheses:
+        enabled: false
+      Rubocop/Metrics/CyclomaticComplexity:
+        Max: 10
+ratings:
+  paths:
+    - lib/**/*.rb
+  exclude_paths:
+    - spec/**/*
+    - examples/**/*

data/CHANGELOG.md

@@ -1,15 +1,36 @@
+# v0.6.0 2016-01-20
+
+### Added
+
+* Support for validating objects with attr readers via `attr` (SunnyMagadan)
+* Support for `value` interface in the DSL for composing high-level rules based on values (solnic)
+* Support for `rule(name: :something)` syntax for grouping high-level rules under
+  the same name (solnic)
+* Support for `confirmation(:foo, some_predicate: some_argument)` shortcut syntax (solnic)
+* Support for error messages for grouped rules (like `confirmation`) (solnic)
+* Schemas support injecting rules from the outside (solnic)
+
+## Changed
+
+* `rule` uses objects that inherit from `BasicObject` to avoid conflicts with
+  predicate names and built-in `Object` methods (solnic)
+* In `Schema::Form` both `key` and `optional` will apply `filled?` predicate by
+  default when no block is passed (solnic)
+
+[Compare v0.5.0...v0.6.0](https://github.com/dryrb/dry-validation/compare/v0.5.0...v0.6.0)
+
 # v0.5.0 2016-01-11
 
 ### Changed
 
-* Now depends on `[dry-logic](https://github.com/dryrb/dry-logic` for predicates and rules (solnic)
+* Now depends on [dry-logic](https://github.com/dryrb/dry-logic) for predicates and rules (solnic)
 * `dry/validation/schema/form` is now required by default (solnic)
 
 ### Fixed
 
 * `Schema::Form` uses safe `form.array` and `form.hash` types which fixes #42 (solnic)
 
-[Compare v0.5.1...v0.5.0](https://github.com/dryrb/dry-validation/compare/v0.4.1...v0.5.0)
+[Compare v0.4.1...v0.5.0](https://github.com/dryrb/dry-validation/compare/v0.4.1...v0.5.0)
 
 # v0.4.1 2015-12-27
 

data/Gemfile

@@ -4,6 +4,7 @@ gemspec
 
 group :test do
   gem 'i18n'
+  gem 'codeclimate-test-reporter', platform: :rbx
 end
 
 group :tools do

data/config/errors.yml

@@ -36,6 +36,8 @@ en:
 
     key?: "%{name} is missing"
 
+    attr?: "%{name} is missing"
+
     lt?: "%{name} must be less than %{num} (%{value} was given)"
 
     lteq?: "%{name} must be less than or equal to %{num}"

data/dry-validation.gemspec

@@ -15,10 +15,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'dry-configurable', '~> 0.1'
-  spec.add_runtime_dependency 'dry-container', '~> 0.2', '>= 0.2.6'
+  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.1'
+  spec.add_runtime_dependency 'dry-logic', '~> 0.1', '>= 0.1.2'
   spec.add_runtime_dependency 'dry-data', '~> 0.5', '>= 0.5.0'
 
   spec.add_development_dependency 'bundler'

data/lib/dry/validation/error_compiler.rb

@@ -4,6 +4,7 @@ module Dry
       attr_reader :messages, :options
 
       DEFAULT_RESULT = {}.freeze
+      KEY_SEPARATOR = '.'.freeze
 
       def initialize(messages, options = {})
         @messages = messages
@@ -11,7 +12,7 @@ module Dry
       end
 
       def call(ast)
-        ast.map { |node| visit(node) }.reduce(:merge) || DEFAULT_RESULT
+        merge(ast.map { |node| visit(node) }) || DEFAULT_RESULT
       end
 
       def with(new_options)
@@ -26,13 +27,25 @@ module Dry
         visit(error)
       end
 
-      def visit_input(input, *args)
-        name, value, rules = input
-        { name => [rules.map { |rule| visit(rule, name, value) }, value] }
+      def visit_input(input, *)
+        name = normalize_name(input[0])
+        _, value, rules = input
+        errors = [rules.map { |rule| visit(rule, name, value) }, value]
+
+        if input[0].is_a?(Hash)
+          root, sub = input[0].to_a.flatten
+          { root => { sub => errors } }
+        else
+          { input[0] => errors }
+        end
+      end
+
+      def visit_group(_, name, _)
+        messages[name, rule: name]
       end
 
-      def visit_check(node, *args)
-        name, _ = node
+      def visit_check(node, *)
+        name = normalize_name(node[0])
         messages[name, rule: name]
       end
 
@@ -41,6 +54,11 @@ module Dry
         visit(predicate, value, name)
       end
 
+      def visit_attr(rule, name, value)
+        _, predicate = rule
+        visit(predicate, value, name)
+      end
+
       def visit_val(rule, name, value)
         name, predicate = rule
         visit(predicate, value, name)
@@ -59,15 +77,19 @@ module Dry
         template % tokens
       end
 
-      def visit_key?(*args, value)
+      def visit_key?(*args, _value)
         { name: args[0][0] }
       end
 
-      def visit_exclusion?(*args, value)
+      def visit_attr?(*args, _value)
+        { name: args[0][0] }
+      end
+
+      def visit_exclusion?(*args, _value)
         { list: args[0][0].join(', ') }
       end
 
-      def visit_inclusion?(*args, value)
+      def visit_inclusion?(*args, _value)
         { list: args[0][0].join(', ') }
       end
 
@@ -113,7 +135,21 @@ module Dry
         end
       end
 
-      def method_missing(meth, *args)
+      private
+
+      def normalize_name(name)
+        Array(name).join(KEY_SEPARATOR).to_sym
+      end
+
+      def merge(result)
+        result.reduce do |a, e|
+          e.merge(a) do |_, l, r|
+            l.is_a?(Hash) ? l.merge(r) : l + r
+          end
+        end
+      end
+
+      def method_missing(_meth, *args)
         { value: args[1] }
       end
     end

data/lib/dry/validation/hint_compiler.rb

@@ -61,6 +61,11 @@ module Dry
         name
       end
 
+      def visit_attr(node)
+        name, _ = node
+        name
+      end
+
       def method_missing(name, *args)
         nil
       end

data/lib/dry/validation/result.rb

@@ -13,8 +13,12 @@ module Dry
         rule_results.each(&block)
       end
 
+      def [](name)
+        to_h[name]
+      end
+
       def to_h
-        each_with_object({}) { |result, hash| hash[result.name] = result }
+        @to_h ||= each_with_object({}) { |result, hash| hash[result.name] = result }
       end
 
       def merge!(other)

data/lib/dry/validation/schema.rb

@@ -38,7 +38,7 @@ module Dry
           when :yaml then Messages.default
           when :i18n then Messages::I18n.new
           else
-            raise RuntimeError, "+#{config.messages}+ is not a valid messages identifier"
+            fail "+#{config.messages}+ is not a valid messages identifier"
           end
 
         if config.messages_file && config.namespace
@@ -70,18 +70,20 @@ module Dry
 
       attr_reader :rules, :schemas, :groups, :checks
 
+      attr_reader :rule_compiler
+
       attr_reader :error_compiler
 
       attr_reader :hint_compiler
 
-      def initialize(error_compiler = self.class.error_compiler, hint_compiler = self.class.hint_compiler)
-        compiler = Logic::RuleCompiler.new(self)
-        @rules = compiler.(self.class.rules.map(&:to_ary))
-        @checks = self.class.checks
-        @groups = compiler.(self.class.groups.map(&:to_ary))
+      def initialize(rules = [])
+        @rule_compiler = Logic::RuleCompiler.new(self)
+        @rules = rule_compiler.(self.class.rules.map(&:to_ary) + rules.map(&:to_ary))
+        @checks = self.class.checks.map(&:to_ary)
+        @groups = rule_compiler.(self.class.groups.map(&:to_ary))
         @schemas = self.class.schemas.map(&:new)
-        @error_compiler = error_compiler
-        @hint_compiler = hint_compiler
+        @error_compiler = self.class.error_compiler
+        @hint_compiler = self.class.hint_compiler
       end
 
       def call(input)
@@ -92,10 +94,11 @@ module Dry
         end
 
         if checks.size > 0
-          compiled_checks = Logic::RuleCompiler.new(result.to_h).(checks)
+          resolver = -> name { result[name] || self[name] }
+          compiled_checks = Logic::RuleCompiler.new(resolver).(checks)
 
           compiled_checks.each do |rule|
-            result << rule.()
+            result << rule.(result)
           end
         end
 
@@ -116,7 +119,7 @@ module Dry
         elsif respond_to?(name)
           Logic::Predicate.new(name, &method(name))
         else
-          raise ArgumentError, "+#{name}+ is not a valid predicate name"
+          fail ArgumentError, "+#{name}+ is not a valid predicate name"
         end
       end
 

data/lib/dry/validation/schema/attr.rb

@@ -0,0 +1,37 @@
+module Dry
+  module Validation
+    class Schema
+      class Attr < BasicObject
+        attr_reader :name, :rules
+
+        def initialize(name, rules, &block)
+          @name = name
+          @rules = rules
+        end
+
+        private
+
+        def method_missing(meth, *args, &block)
+          attr_rule = [:attr, [name, [:predicate, [meth, args]]]]
+
+          if block
+            val_rule = yield(Value.new(name))
+
+            rules <<
+              if val_rule.is_a?(::Array)
+                Schema::Rule.new(name, [:and, [attr_rule, [:set, [name, val_rule.map(&:to_ary)]]]])
+              else
+                Schema::Rule.new(name, [:and, [attr_rule, val_rule.to_ary]])
+              end
+          else
+            Schema::Rule.new(name, attr_rule)
+          end
+        end
+
+        def respond_to_missing?(*)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/schema/definition.rb

@@ -13,10 +13,18 @@ module Dry
           Key.new(name, rules).key?(&block)
         end
 
+        def attr(name, &block)
+          Attr.new(name, rules).attr?(&block)
+        end
+
         def optional(name, &block)
           Key.new(name, rules).optional(&block)
         end
 
+        def value(name)
+          Schema::Rule::Result.new(name, [])
+        end
+
         def rule(name, **options, &block)
           if options.any?
             predicate, rule_names = options.to_a.first
@@ -32,13 +40,22 @@ module Dry
           end
         end
 
-        def confirmation(name)
-          identifier = :"#{name}_confirmation"
+        def confirmation(name, options = {})
+          conf_name = :"#{name}_confirmation"
+
+          unless rule_by_name(name)
+            if options.any?
+              key(name) do |value|
+                options.map { |p, args| value.__send__(:"#{p}?", *args) }.reduce(:&)
+              end
+            else
+              key(name, &:filled?)
+            end
+          end
 
-          key(name, &:filled?)
-          key(identifier, &:filled?)
+          key(conf_name, &:filled?)
 
-          rule(identifier, eql?: [name, identifier])
+          rule(conf_name, eql?: [name, conf_name])
         end
 
         private
@@ -54,3 +71,4 @@ end
 require 'dry/validation/schema/rule'
 require 'dry/validation/schema/value'
 require 'dry/validation/schema/key'
+require 'dry/validation/schema/attr'

data/lib/dry/validation/schema/form.rb

@@ -6,6 +6,22 @@ module Dry
     class Schema::Form < Schema
       attr_reader :input_type
 
+      def self.key(name, &block)
+        if block
+          super
+        else
+          super(name, &:filled?)
+        end
+      end
+
+      def self.optional(name, &block)
+        if block
+          super
+        else
+          super(name, &:filled?)
+        end
+      end
+
       def initialize
         super
         @input_type = InputTypeCompiler.new.(self.class.rules.map(&:to_ary))

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

@@ -41,7 +41,7 @@ module Dry
           end
         end
 
-        def respond_to_missing?(meth, _include_private = false)
+        def respond_to_missing?(*)
           true
         end
       end

data/lib/dry/validation/schema/result.rb

@@ -40,11 +40,19 @@ module Dry
             all_msgs = error_compiler.with(options).(errors.map(&:to_ary))
             hints = hint_compiler.with(options).call
 
-            all_msgs.each do |(name, data)|
-              data[0].concat(hints[name]).uniq!
+            msgs_data = all_msgs.map do |(name, data)|
+              msgs, input =
+                if data.is_a?(Hash)
+                  values = data.values
+                  [values.map(&:first).flatten.concat(hints[name]).uniq, values[0][1]]
+                else
+                  [data[0].concat(hints[name]).uniq.flatten, data[1]]
+                end
+
+              [name, [msgs, input]]
             end
 
-            all_msgs
+            Hash[msgs_data]
           end
       end
 

data/lib/dry/validation/schema/rule.rb

@@ -1,20 +1,38 @@
 module Dry
   module Validation
     class Schema
-      class Rule
+      class Rule < BasicObject
         attr_reader :name, :node
 
         class Check < Rule
+          def class
+            Schema::Rule::Check
+          end
+
           def method_missing(meth, *)
             self.class.new(name, [:check, [name, [:predicate, [name, [meth]]]]])
           end
         end
 
+        class Result < Rule
+          def class
+            Schema::Rule::Result
+          end
+
+          def method_missing(meth, *args)
+            self.class.new(name, [:res, [name, [:predicate, [meth, args]]]])
+          end
+        end
+
         def initialize(name, node)
           @name = name
           @node = node
         end
 
+        def class
+          Schema::Rule
+        end
+
         def to_ary
           node
         end
@@ -24,6 +42,10 @@ module Dry
           Rule::Check.new(name, [:check, [name, [:predicate, [name, []]]]])
         end
 
+        def is_a?(other)
+          self.class == other
+        end
+
         def not
           self.class.new(:"not_#{name}", [:not, node])
         end