dry-validation 0.1.0

data/dry-validation.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+require File.expand_path('../lib/dry/validation/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dry-validation'
+  spec.version       = Dry::Validation::VERSION
+  spec.authors       = ['Andy Holland', 'Piotr Solnica']
+  spec.email         = ['andyholland1991@aol.com', 'piotr.solnica@gmail.com']
+  spec.summary       = 'A simple validation library'
+  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.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-equalizer', '~> 0.2'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/examples/basic.rb

@@ -0,0 +1,21 @@
+require 'dry-validation'
+
+class Schema < Dry::Validation::Schema
+  key(:email) { |email| email.filled? }
+
+  key(:age) do |age|
+    age.int? & age.gt?(18)
+  end
+end
+
+schema = Schema.new
+
+errors = schema.messages(email: 'jane@doe.org', age: 19)
+
+puts errors.inspect
+# []
+
+errors = schema.messages(email: nil, age: 19)
+
+puts errors.inspect
+# [[:email, ["email must be filled"]]]

data/examples/nested.rb

@@ -0,0 +1,30 @@
+require 'dry-validation'
+
+class Schema < Dry::Validation::Schema
+  key(:address) do |address|
+    address.key(:city) do |city|
+      city.min_size?(3)
+    end
+
+    address.key(:street) do |street|
+      street.filled?
+    end
+
+    address.key(:country) do |country|
+      country.key(:name, &:filled?)
+      country.key(:code, &:filled?)
+    end
+  end
+end
+
+schema = Schema.new
+
+errors = schema.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' })
+
+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

@@ -0,0 +1,33 @@
+require 'dry-validation'
+
+ast = [
+  [
+    :and,
+    [
+      [:key, [:age, [:predicate, [:key?, []]]]],
+      [
+        :and,
+        [
+          [:val, [:age, [:predicate, [:filled?, []]]]],
+          [:val, [:age, [:predicate, [:gt?, [18]]]]]
+        ]
+      ]
+    ]
+  ]
+]
+
+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

@@ -0,0 +1 @@
+require 'dry/validation'

data/lib/dry/validation.rb

@@ -0,0 +1,12 @@
+require 'dry-equalizer'
+require 'dry-configurable'
+require 'dry-container'
+
+# A collection of micro-libraries, each intended to encapsulate
+# a common task in Ruby
+module Dry
+  module Validation
+  end
+end
+
+require 'dry/validation/schema'

data/lib/dry/validation/error.rb

@@ -0,0 +1,43 @@
+module Dry
+  module Validation
+    class Error
+      class Set
+        include Enumerable
+
+        attr_reader :errors
+
+        def initialize
+          @errors = []
+        end
+
+        def each(&block)
+          errors.each(&block)
+        end
+
+        def empty?
+          errors.empty?
+        end
+
+        def <<(error)
+          errors << error
+        end
+
+        def to_ary
+          errors.map { |error| error.to_ary }
+        end
+        alias_method :to_a, :to_ary
+      end
+
+      attr_reader :result
+
+      def initialize(result)
+        @result = result
+      end
+
+      def to_ary
+        [:error, result.to_ary]
+      end
+      alias_method :to_a, :to_ary
+    end
+  end
+end

data/lib/dry/validation/error_compiler.rb

@@ -0,0 +1,116 @@
+module Dry
+  module Validation
+    class ErrorCompiler
+      attr_reader :messages
+
+      def initialize(messages)
+        @messages = messages
+      end
+
+      def call(ast)
+        ast.map { |node| visit(node) }
+      end
+
+      def visit(node, *args)
+        __send__(:"visit_#{node[0]}", node[1], *args)
+      end
+
+      def visit_error(error)
+        visit(error)
+      end
+
+      def visit_input(input, *args)
+        name, value, rules = input
+        [name, rules.map { |rule| visit(rule, name, value) }]
+      end
+
+      def visit_key(rule, name, value)
+        _, predicate = rule
+        visit(predicate, value, name)
+      end
+
+      def visit_val(rule, name, value)
+        name, predicate = rule
+        visit(predicate, value, name)
+      end
+
+      def visit_predicate(predicate, value, name)
+        messages.lookup(predicate[0], name, predicate[1][0]) % visit(predicate, value).merge(name: name)
+      end
+
+      def visit_key?(*args, value)
+        { name: args[0][0] }
+      end
+
+      def visit_empty?(*args, value)
+        { value: value }
+      end
+
+      def visit_exclusion?(*args, value)
+        { list: args[0][0].join(', ') }
+      end
+
+      def visit_inclusion?(*args, value)
+        { list: args[0][0].join(', ') }
+      end
+
+      def visit_gt?(*args, value)
+        { num: args[0][0], value: value }
+      end
+
+      def visit_gteq?(*args, value)
+        { num: args[0][0], value: value }
+      end
+
+      def visit_lt?(*args, value)
+        { num: args[0][0], value: value }
+      end
+
+      def visit_lteq?(*args, value)
+        { num: args[0][0], value: value }
+      end
+
+      def visit_int?(*args, value)
+        { num: args[0][0], value: value }
+      end
+
+      def visit_max_size?(*args, value)
+        { num: args[0][0], value: value }
+      end
+
+      def visit_min_size?(*args, value)
+        { num: args[0][0], value: value }
+      end
+
+      def visit_eql?(*args, value)
+        { eql_value: args[0][0], value: value }
+      end
+
+      def visit_size?(*args, value)
+        num = args[0][0]
+
+        if num.is_a?(Range)
+          { left: num.first, right: num.last, value: value }
+        else
+          { num: args[0][0], value: value }
+        end
+      end
+
+      def visit_str?(*args, value)
+        { value: value }
+      end
+
+      def visit_format?(*args, value)
+        {}
+      end
+
+      def visit_nil?(*args, value)
+        {}
+      end
+
+      def visit_filled?(*args)
+        {}
+      end
+    end
+  end
+end

data/lib/dry/validation/messages.rb

@@ -0,0 +1,71 @@
+require 'yaml'
+require 'pathname'
+
+module Dry
+  module Validation
+    class Messages
+      DEFAULT_PATH = Pathname(__dir__).join('../../../config/errors.yml').freeze
+
+      attr_reader :data
+
+      def self.default
+        load(DEFAULT_PATH)
+      end
+
+      def self.load(path)
+        new(load_yaml(path))
+      end
+
+      def self.load_yaml(path)
+        symbolize_keys(YAML.load_file(path))
+      end
+
+      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
+
+      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
+      end
+    end
+  end
+end

data/lib/dry/validation/predicate.rb

@@ -0,0 +1,39 @@
+module Dry
+  module Validation
+    def self.Predicate(block)
+      case block
+      when Method then Predicate.new(block.name, &block)
+      else raise ArgumentError, 'predicate needs an :id'
+      end
+    end
+
+    class Predicate
+      include Dry::Equalizer(:id)
+
+      attr_reader :id, :args, :fn
+
+      def initialize(id, *args, &block)
+        @id = id
+        @fn = block
+        @args = args
+      end
+
+      def call(*args)
+        fn.(*args)
+      end
+
+      def negation
+        self.class.new(:"not_#{id}") { |input| !fn.(input) }
+      end
+
+      def curry(*args)
+        self.class.new(id, *args, &fn.curry.(*args))
+      end
+
+      def to_ary
+        [:predicate, [id, args]]
+      end
+      alias_method :to_a, :to_ary
+    end
+  end
+end

data/lib/dry/validation/predicate_set.rb

@@ -0,0 +1,22 @@
+require 'dry/validation/predicate'
+
+module Dry
+  module Validation
+    module PredicateSet
+      module Methods
+        def predicate(name, &block)
+          register(name) { Predicate.new(name, &block) }
+        end
+
+        def import(predicate_set)
+          merge(predicate_set)
+        end
+      end
+
+      def self.extended(other)
+        super
+        other.extend(Methods, Dry::Container::Mixin)
+      end
+    end
+  end
+end

data/lib/dry/validation/predicates.rb

@@ -0,0 +1,88 @@
+require 'dry/validation/predicate_set'
+
+module Dry
+  module Validation
+    module Predicates
+      extend PredicateSet
+
+      def self.included(other)
+        super
+        other.extend(PredicateSet)
+        other.import(self)
+      end
+
+      predicate(:nil?) do |input|
+        input.nil?
+      end
+
+      predicate(:key?) do |name, input|
+        input.key?(name)
+      end
+
+      predicate(:empty?) do |input|
+        case input
+        when String, Array, Hash then input.empty?
+        when nil then true
+        else
+          false
+        end
+      end
+
+      predicate(:filled?) do |input|
+        !self[:empty?].(input)
+      end
+
+      predicate(:int?) do |input|
+        input.is_a?(Fixnum)
+      end
+
+      predicate(:str?) do |input|
+        input.is_a?(String)
+      end
+
+      predicate(:lt?) do |num, input|
+        input < num
+      end
+
+      predicate(:gt?) do |num, input|
+        input > num
+      end
+
+      predicate(:lteq?) do |num, input|
+        !self[:gt?].(num, input)
+      end
+
+      predicate(:gteq?) do |num, input|
+        !self[:lt?].(num, input)
+      end
+
+      predicate(:size?) do |num, input|
+        input.size == num
+      end
+
+      predicate(:min_size?) do |num, input|
+        input.size >= num
+      end
+
+      predicate(:max_size?) do |num, input|
+        input.size <= num
+      end
+
+      predicate(:inclusion?) do |list, input|
+        list.include?(input)
+      end
+
+      predicate(:exclusion?) do |list, input|
+        !self[:inclusion?].(list, input)
+      end
+
+      predicate(:eql?) do |left, right|
+        left.eql?(right)
+      end
+
+      predicate(:format?) do |regex, input|
+        !regex.match(input).nil?
+      end
+    end
+  end
+end