dry-validation 0.1.0

data/lib/dry/validation/result.rb

@@ -0,0 +1,64 @@
+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
+
+      class Set < Result
+        def success?
+          value.all?(&:success?)
+        end
+
+        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
+      end
+
+      class Value < Result
+        def to_ary
+          [:input, [rule.name, input, [rule.to_ary]]]
+        end
+        alias_method :to_a, :to_ary
+      end
+
+      def initialize(input, value, rule)
+        @input = input
+        @value = value
+        @rule = rule
+      end
+
+      def and(other)
+        if success?
+          other.(input)
+        else
+          self
+        end
+      end
+
+      def or(other)
+        if success?
+          self
+        else
+          other.(input)
+        end
+      end
+
+      def success?
+        @value
+      end
+
+      def failure?
+        ! success?
+      end
+    end
+  end
+end

data/lib/dry/validation/rule.rb

@@ -0,0 +1,125 @@
+require 'dry/validation/result'
+
+module Dry
+  module Validation
+    class Rule
+      include Dry::Equalizer(:name, :predicate)
+
+      class Key < Rule
+        def self.new(name, predicate)
+          super(name, predicate.curry(name))
+        end
+
+        def type
+          :key
+        end
+
+        def call(input)
+          Validation.Result(input[name], predicate.(input), self)
+        end
+      end
+
+      class Value < Rule
+        def call(input)
+          Validation.Result(input, predicate.(input), self)
+        end
+
+        def type
+          :val
+        end
+      end
+
+      class Composite
+        include Dry::Equalizer(:left, :right)
+
+        attr_reader :name, :left, :right
+
+        def initialize(left, right)
+          @name = left.name
+          @left = left
+          @right = right
+        end
+
+        def to_ary
+          [type, left.to_ary, [right.to_ary]]
+        end
+        alias_method :to_a, :to_ary
+      end
+
+      class Conjunction < Composite
+        def call(input)
+          left.(input).and(right)
+        end
+
+        def type
+          :and
+        end
+      end
+
+      class Disjunction < Composite
+        def call(input)
+          left.(input).or(right)
+        end
+
+        def type
+          :or
+        end
+      end
+
+      class Each < Rule
+        def call(input)
+          Validation.Result(input, input.map { |element| predicate.(element) }, self)
+        end
+
+        def type
+          :each
+        end
+      end
+
+      class Set < Rule
+        def call(input)
+          Validation.Result(input, predicate.map { |rule| rule.(input) }, self)
+        end
+
+        def type
+          :set
+        end
+
+        def at(*args)
+          self.class.new(name, predicate.values_at(*args))
+        end
+
+        def to_ary
+          [type, [name, predicate.map(&:to_ary)]]
+        end
+        alias_method :to_a, :to_ary
+      end
+
+      attr_reader :name, :predicate
+
+      def initialize(name, predicate)
+        @name = name
+        @predicate = predicate
+      end
+
+      def to_ary
+        [type, [name, predicate.to_ary]]
+      end
+      alias_method :to_a, :to_ary
+
+      def and(other)
+        Conjunction.new(self, other)
+      end
+      alias_method :&, :and
+
+      def or(other)
+        Disjunction.new(self, other)
+      end
+      alias_method :|, :or
+
+      def curry(*args)
+        self.class.new(name, predicate.curry(*args))
+      end
+    end
+  end
+end

data/lib/dry/validation/rule_compiler.rb

@@ -0,0 +1,57 @@
+require 'dry/validation/rule'
+
+module Dry
+  module Validation
+    class RuleCompiler
+      attr_reader :predicates
+
+      def initialize(predicates)
+        @predicates = predicates
+      end
+
+      def call(ast)
+        ast.map { |node| visit(node) }
+      end
+
+      def visit(node)
+        name, nodes = node
+        send(:"visit_#{name}", nodes)
+      end
+
+      def visit_key(node)
+        name, predicate = node
+        Rule::Key.new(name, visit(predicate))
+      end
+
+      def visit_val(node)
+        name, predicate = node
+        Rule::Value.new(name, visit(predicate))
+      end
+
+      def visit_set(node)
+        name, rules = node
+        Rule::Set.new(name, call(rules))
+      end
+
+      def visit_each(node)
+        name, rule = node
+        Rule::Each.new(name, visit(rule))
+      end
+
+      def visit_predicate(node)
+        name, args = node
+        predicates[name].curry(*args)
+      end
+
+      def visit_and(node)
+        left, right = node
+        visit(left) & visit(right)
+      end
+
+      def visit_or(node)
+        left, right = node
+        visit(left) | visit(right)
+      end
+    end
+  end
+end

data/lib/dry/validation/schema.rb

@@ -0,0 +1,74 @@
+require 'dry/validation/schema/definition'
+require 'dry/validation/predicates'
+require 'dry/validation/error'
+require 'dry/validation/rule_compiler'
+require 'dry/validation/messages'
+require 'dry/validation/error_compiler'
+
+module Dry
+  module Validation
+    class Schema
+      extend Dry::Configurable
+      extend Definition
+
+      setting :predicates, Predicates
+      setting :messages, Messages.default
+      setting :messages_file
+      setting :namespace
+
+      def self.predicates
+        config.predicates
+      end
+
+      def self.error_compiler
+        ErrorCompiler.new(messages)
+      end
+
+      def self.messages
+        default = config.messages
+
+        if config.messages_file && config.namespace
+          default.merge(config.messages_file).namespaced(config.namespace)
+        elsif config.messages_file
+          default.merge(config.messages_file)
+        elsif config.namespace
+          default.namespaced(config.namespace)
+        else
+          default
+        end
+      end
+
+      def self.rules
+        @__rules__ ||= []
+      end
+
+      attr_reader :rules
+
+      attr_reader :error_compiler
+
+      def initialize(error_compiler = self.class.error_compiler)
+        @rules = RuleCompiler.new(self).(self.class.rules.map(&:to_ary))
+        @error_compiler = error_compiler
+      end
+
+      def call(input)
+        rules.each_with_object(Error::Set.new) do |rule, errors|
+          result = rule.(input)
+          errors << Error.new(result) if result.failure?
+        end
+      end
+
+      def messages(input)
+        error_compiler.call(call(input).map(&:to_ary))
+      end
+
+      def [](name)
+        if methods.include?(name)
+          Predicate.new(name, &method(name))
+        else
+          self.class.predicates[name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Dry
+  module Validation
+    class Schema
+      module Definition
+        def key(name, &block)
+          Key.new(name, rules).key?(&block)
+        end
+      end
+    end
+  end
+end
+
+require 'dry/validation/schema/rule'
+require 'dry/validation/schema/value'
+require 'dry/validation/schema/key'

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

@@ -0,0 +1,39 @@
+require 'dry/validation/rule'
+
+module Dry
+  module Validation
+    class Schema
+      class Key
+        attr_reader :name, :rules
+
+        def initialize(name, rules, &block)
+          @name = name
+          @rules = rules
+        end
+
+        private
+
+        def method_missing(meth, *args, &block)
+          key_rule = [:key, [name, [:predicate, [meth, args]]]]
+
+          if block
+            val_rule = yield(Value.new(name))
+
+            rules <<
+              if val_rule.is_a?(Array)
+                Definition::Rule.new([:and, [key_rule, [:set, [name, val_rule.map(&:to_ary)]]]])
+              else
+                Definition::Rule.new([:and, [key_rule, val_rule.to_ary]])
+              end
+          else
+            Definition::Rule.new(key_rule)
+          end
+        end
+
+        def respond_to_missing?(meth, _include_private = false)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Dry
+  module Validation
+    class Schema
+      module Definition
+        class Rule
+          attr_reader :node
+
+          def initialize(node)
+            @node = node
+          end
+
+          def to_ary
+            node
+          end
+          alias_method :to_a, :to_ary
+
+          def &(other)
+            self.class.new([:and, [node, other.to_ary]])
+          end
+
+          def |(other)
+            self.class.new([:or, [node, other.to_ary]])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Dry
+  module Validation
+    class Schema
+      class Value
+        include Schema::Definition
+
+        attr_reader :name, :rules
+
+        def initialize(name)
+          @name = name
+          @rules = []
+        end
+
+        def each(&block)
+          rule = yield(self).to_ary
+          Definition::Rule.new([:each, [name, rule]])
+        end
+
+        private
+
+        def method_missing(meth, *args, &block)
+          Definition::Rule.new([:val, [name, [:predicate, [meth, args]]]])
+        end
+
+        def respond_to_missing?(meth, _include_private = false)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/version.rb

@@ -0,0 +1,5 @@
+module Dry
+  module Validation
+    VERSION = '0.1.0'.freeze
+  end
+end