dry-validation 0.2.0 → 0.3.0

data/examples/form.rb

@@ -9,7 +9,6 @@ end
 
 schema = UserFormSchema.new
 
-errors = schema.messages('email' => '', 'age' => '18')
+errors = schema.call('email' => '', 'age' => '18').messages
 
 puts errors.inspect
-# [[:email, ["email must be filled"]], [:age, ["age must be greater than 18 (18 was given)"]]]

data/examples/nested.rb

@@ -21,12 +21,10 @@ end
 
 schema = Schema.new
 
-errors = schema.messages({})
+errors = schema.call({}).messages
 
 puts errors.inspect
-#<Dry::Validation::Error::Set:0x007fc4f89c4360 @errors=[#<Dry::Validation::Error:0x007fc4f89c4108 @result=#<Dry::Validation::Result::Value success?=false input=nil rule=#<Dry::Validation::Rule::Key name=:address predicate=#<Dry::Validation::Predicate id=:key?>>>>]>
 
-errors = schema.messages(address: { city: 'NYC' })
+errors = schema.call(address: { city: 'NYC' }).messages
 
 puts errors.inspect
-#<Dry::Validation::Error::Set:0x007fd151189b18 @errors=[#<Dry::Validation::Error:0x007fd151188e20 @result=#<Dry::Validation::Result::Set success?=false input={:city=>"NYC"} rule=#<Dry::Validation::Rule::Set name=:address predicate=[#<Dry::Validation::Rule::Conjunction left=#<Dry::Validation::Rule::Key name=:city predicate=#<Dry::Validation::Predicate id=:key?>> right=#<Dry::Validation::Rule::Value name=:city predicate=#<Dry::Validation::Predicate id=:min_size?>>>, #<Dry::Validation::Rule::Conjunction left=#<Dry::Validation::Rule::Key name=:street predicate=#<Dry::Validation::Predicate id=:key?>> right=#<Dry::Validation::Rule::Value name=:street predicate=#<Dry::Validation::Predicate id=:filled?>>>, #<Dry::Validation::Rule::Conjunction left=#<Dry::Validation::Rule::Key name=:country predicate=#<Dry::Validation::Predicate id=:key?>> right=#<Dry::Validation::Rule::Set name=:country predicate=[#<Dry::Validation::Rule::Conjunction left=#<Dry::Validation::Rule::Key name=:name predicate=#<Dry::Validation::Predicate id=:key?>> right=#<Dry::Validation::Rule::Value name=:name predicate=#<Dry::Validation::Predicate id=:filled?>>>, #<Dry::Validation::Rule::Conjunction left=#<Dry::Validation::Rule::Key name=:code predicate=#<Dry::Validation::Predicate id=:key?>> right=#<Dry::Validation::Rule::Value name=:code predicate=#<Dry::Validation::Predicate id=:filled?>>>]>>]>>>]>

data/examples/rule_ast.rb

@@ -21,13 +21,5 @@ compiler = Dry::Validation::RuleCompiler.new(Dry::Validation::Predicates)
 rules = compiler.call(ast)
 
 puts rules.inspect
-# [
-#   #<Dry::Validation::Rule::Conjunction
-#     left=#<Dry::Validation::Rule::Key name=:age predicate=#<Dry::Validation::Predicate id=:key?>>
-#     right=#<Dry::Validation::Rule::Conjunction
-#       left=#<Dry::Validation::Rule::Value name=:age predicate=#<Dry::Validation::Predicate id=:filled?>>
-#       right=#<Dry::Validation::Rule::Value name=:age predicate=#<Dry::Validation::Predicate id=:gt?>>>>
-# ]
 
 puts rules.map(&:to_ary).inspect
-# [[:and, [:key, [:age, [:predicate, [:key?, [:age]]]]], [[:and, [:val, [:age, [:predicate, [:filled?, []]]]], [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]]]

data/lib/dry/validation.rb

@@ -6,11 +6,6 @@ require 'dry-container'
 # a common task in Ruby
 module Dry
   module Validation
-    def self.symbolize_keys(hash)
-      hash.each_with_object({}) do |(k, v), r|
-        r[k.to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v
-      end
-    end
   end
 end
 

data/lib/dry/validation/error.rb

@@ -6,8 +6,8 @@ module Dry
 
         attr_reader :errors
 
-        def initialize
-          @errors = []
+        def initialize(errors)
+          @errors = errors
         end
 
         def each(&block)
@@ -18,10 +18,6 @@ module Dry
           errors.empty?
         end
 
-        def <<(error)
-          errors << error
-        end
-
         def to_ary
           errors.map { |error| error.to_ary }
         end

data/lib/dry/validation/error_compiler.rb

@@ -1,14 +1,19 @@
 module Dry
   module Validation
     class ErrorCompiler
-      attr_reader :messages
+      attr_reader :messages, :options
 
-      def initialize(messages)
+      def initialize(messages, options = {})
         @messages = messages
+        @options = options
       end
 
       def call(ast)
-        ast.map { |node| visit(node) }
+        ast.map { |node| visit(node) }.reduce(:merge)
+      end
+
+      def with(options)
+        self.class.new(messages, options)
       end
 
       def visit(node, *args)
@@ -21,7 +26,7 @@ module Dry
 
       def visit_input(input, *args)
         name, value, rules = input
-        [name, rules.map { |rule| visit(rule, name, value) }]
+        { name => rules.map { |rule| visit(rule, name, value) } }
       end
 
       def visit_key(rule, name, value)
@@ -35,7 +40,16 @@ module Dry
       end
 
       def visit_predicate(predicate, value, name)
-        messages.lookup(predicate[0], name, predicate[1][0]) % visit(predicate, value).merge(name: name)
+        predicate_name, args = predicate
+
+        lookup_options = options.merge(
+          rule: name, val_type: value.class, arg_type: args[0].class
+        )
+
+        template = messages[predicate_name, lookup_options]
+        tokens = visit(predicate, value).merge(name: name)
+
+        [template % tokens, value]
       end
 
       def visit_key?(*args, value)

data/lib/dry/validation/input_type_compiler.rb

@@ -55,7 +55,8 @@ module Dry
       end
 
       def visit_implication(node)
-        [:key, node.map(&method(:visit))]
+        key, types = node
+        [:key, [visit(key), visit(types, false)]]
       end
 
       def visit_key(node, *args)

data/lib/dry/validation/messages.rb

@@ -1,65 +1,14 @@
-require 'yaml'
-require 'pathname'
-
 module Dry
   module Validation
-    class Messages
-      DEFAULT_PATH = Pathname(__dir__).join('../../../config/errors.yml').freeze
-
-      attr_reader :data
-
+    module Messages
       def self.default
-        load(DEFAULT_PATH)
-      end
-
-      def self.load(path)
-        new(load_yaml(path))
-      end
-
-      def self.load_yaml(path)
-        Validation.symbolize_keys(YAML.load_file(path))
-      end
-
-      class Namespaced
-        attr_reader :namespace, :fallback
-
-        def initialize(namespace, fallback)
-          @namespace = namespace
-          @fallback = fallback
-        end
-
-        def lookup(*args)
-          namespace.lookup(*args) { fallback.lookup(*args) }
-        end
-      end
-
-      def initialize(data)
-        @data = data
-      end
-
-      def merge(overrides)
-        if overrides.is_a?(Hash)
-          self.class.new(data.merge(overrides))
-        else
-          self.class.new(data.merge(Messages.load_yaml(overrides)))
-        end
-      end
-
-      def namespaced(namespace)
-        Namespaced.new(Messages.new(data[namespace]), self)
-      end
-
-      def lookup(identifier, key, arg, &block)
-        message = data.fetch(:attributes, {}).fetch(key, {}).fetch(identifier) do
-          data.fetch(identifier, &block)
-        end
-
-        if message.is_a?(Hash)
-          message.fetch(arg.class.name.downcase.to_sym, message.fetch(:default))
-        else
-          message
-        end
+        Messages::YAML.load
       end
     end
   end
 end
+
+require 'dry/validation/messages/abstract'
+require 'dry/validation/messages/namespaced'
+require 'dry/validation/messages/yaml'
+require 'dry/validation/messages/i18n' if defined?(I18n)

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

@@ -0,0 +1,75 @@
+require 'thread_safe/cache'
+
+module Dry
+  module Validation
+    module Messages
+      class Abstract
+        extend Dry::Configurable
+
+        setting :path, Pathname(__dir__).join('../../../../config/errors.yml').realpath.freeze
+        setting :root, 'errors'.freeze
+        setting :lookup_options, [:root, :predicate, :rule, :val_type, :arg_type].freeze
+
+        setting :lookup_paths, %w(
+          %{root}.rules.%{rule}.%{predicate}.arg.%{arg_type}
+          %{root}.rules.%{rule}.%{predicate}
+          %{root}.%{predicate}.value.%{val_type}.arg.%{arg_type}
+          %{root}.%{predicate}.value.%{val_type}
+          %{root}.%{predicate}.arg.%{arg_type}
+          %{root}.%{predicate}
+        ).freeze
+
+        setting :arg_type_default, 'default'.freeze
+        setting :val_type_default, 'default'.freeze
+
+        setting :arg_types, Hash.new { |*| config.arg_type_default }.update(
+          Range => 'range'
+        )
+
+        setting :val_types, Hash.new { |*| config.val_type_default }.update(
+          Range => 'range',
+          String => 'string'
+        )
+
+        def call(*args)
+          cache.fetch_or_store(args.hash) { get(*lookup(*args)) }
+        end
+        alias_method :[], :call
+
+        def lookup(predicate, options)
+          tokens = options.merge(
+            root: root,
+            predicate: predicate,
+            arg_type: config.arg_types[options[:arg_type]],
+            val_type: config.val_types[options[:val_type]]
+          )
+
+          opts = options.reject { |k, _| config.lookup_options.include?(k) }
+          path = lookup_paths(tokens).detect { |key| key?(key, opts) && get(key).is_a?(String) }
+
+          [path, opts]
+        end
+
+        def lookup_paths(tokens)
+          config.lookup_paths.map { |path| path % tokens }
+        end
+
+        def namespaced(namespace)
+          Messages::Namespaced.new(namespace, self)
+        end
+
+        def root
+          config.root
+        end
+
+        def config
+          self.class.config
+        end
+
+        def cache
+          @cache ||= ThreadSafe::Cache.new
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/messages/i18n.rb

@@ -0,0 +1,24 @@
+require 'i18n'
+require 'dry/validation/messages/abstract'
+
+module Dry
+  module Validation
+    class Messages::I18n < Messages::Abstract
+      attr_reader :t
+
+      ::I18n.load_path << config.path
+
+      def initialize
+        @t = I18n.method(:t)
+      end
+
+      def get(key, options = {})
+        t.(key, options)
+      end
+
+      def key?(key, options)
+        I18n.exists?(key, options.fetch(:locale, I18n.default_locale))
+      end
+    end
+  end
+end

data/lib/dry/validation/messages/namespaced.rb

@@ -0,0 +1,27 @@
+module Dry
+  module Validation
+    module Messages
+      class Namespaced < Messages::Abstract
+        attr_reader :namespace, :messages, :root
+
+        def initialize(namespace, messages)
+          @namespace = namespace
+          @messages = messages
+          @root = messages.root
+        end
+
+        def key?(key, *args)
+          messages.key?(key, *args)
+        end
+
+        def get(key, options = {})
+          messages.get(key, options)
+        end
+
+        def lookup_paths(tokens)
+          super(tokens.merge(root: "#{root}.rules.#{namespace}")) + super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'yaml'
+require 'pathname'
+
+require 'dry/validation/messages/abstract'
+
+module Dry
+  module Validation
+    class Messages::YAML < Messages::Abstract
+      attr_reader :data
+
+      configure do |config|
+        config.root = 'en.errors'.freeze
+      end
+
+      def self.load(path = config.path)
+        new(load_file(path))
+      end
+
+      def self.load_file(path)
+        flat_hash(YAML.load_file(path))
+      end
+
+      def self.flat_hash(h, f = [], g = {})
+        return g.update(f.join('.'.freeze) => h) unless h.is_a? Hash
+        h.each { |k, r| flat_hash(r, f + [k], g) }
+        g
+      end
+
+      def initialize(data)
+        @data = data
+      end
+
+      def get(key, _options = {})
+        data[key]
+      end
+
+      def key?(key, *args)
+        data.key?(key)
+      end
+
+      def merge(overrides)
+        if overrides.is_a?(Hash)
+          self.class.new(data.merge(self.class.flat_hash(overrides)))
+        else
+          self.class.new(data.merge(Messages::YAML.load_file(overrides)))
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/result.rb

@@ -1,71 +1,41 @@
 module Dry
   module Validation
-    def self.Result(input, value, rule)
-      case value
-      when Array then Result::Set.new(input, value, rule)
-      else Result::Value.new(input, value, rule)
-      end
-    end
-
     class Result
-      include Dry::Equalizer(:success?, :input, :rule)
-
-      attr_reader :input, :value, :rule
+      include Enumerable
 
-      class Set < Result
-        def success?
-          value.all?(&:success?)
-        end
+      attr_reader :rule_results
 
-        def to_ary
-          indices = value.map { |v| v.failure? ? value.index(v) : nil }.compact
-          [:input, [rule.name, input, value.values_at(*indices).map(&:to_ary)]]
-        end
+      def initialize(rule_results)
+        @rule_results = rule_results
       end
 
-      class Value < Result
-        def to_ary
-          [:input, [rule.name, input, [rule.to_ary]]]
-        end
-        alias_method :to_a, :to_ary
+      def each(&block)
+        rule_results.each(&block)
       end
 
-      def initialize(input, value, rule)
-        @input = input
-        @value = value
-        @rule = rule
+      def to_ary
+        failures.map(&:to_ary)
       end
 
-      def >(other)
-        if success?
-          other.(input)
-        else
-          Validation.Result(input, true, rule)
-        end
+      def <<(rule_result)
+        rule_results << rule_result
       end
 
-      def and(other)
-        if success?
-          other.(input)
-        else
-          self
-        end
+      def with_values(names, &block)
+        values = names.map { |name| by_name(name) }.compact.map(&:input)
+        yield(values) if values.size == names.size
       end
 
-      def or(other)
-        if success?
-          self
-        else
-          other.(input)
-        end
+      def by_name(name)
+        successes.detect { |rule_result| rule_result.name == name }
       end
 
-      def success?
-        @value
+      def successes
+        rule_results.select(&:success?)
       end
 
-      def failure?
-        ! success?
+      def failures
+        rule_results.select(&:failure?)
       end
     end
   end