dry-validation 0.1.0 → 1.8.0

data/lib/dry/validation/messages.rb

@@ -1,71 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

data/lib/dry/validation/rule_compiler.rb

@@ -1,57 +0,0 @@
-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/definition.rb

@@ -1,15 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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/schema.rb

@@ -1,74 +0,0 @@
-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/rakelib/rubocop.rake

@@ -1,18 +0,0 @@
-begin
-  require 'rubocop/rake_task'
-
-  Rake::Task[:default].enhance [:rubocop]
-
-  RuboCop::RakeTask.new do |task|
-    task.options << '--display-cop-names'
-  end
-
-  namespace :rubocop do
-    desc 'Generate a configuration file acting as a TODO list.'
-    task :auto_gen_config do
-      exec 'bundle exec rubocop --auto-gen-config'
-    end
-  end
-
-rescue LoadError
-end

data/spec/fixtures/errors.yml

@@ -1,4 +0,0 @@
-user:
-  attributes:
-    email:
-      filled?: "%{name} can't be blank"

data/spec/integration/custom_error_messages_spec.rb

@@ -1,35 +0,0 @@
-RSpec.describe Dry::Validation, 'with custom messages' do
-  subject(:validation) { schema.new }
-
-  describe 'defining schema' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        configure do |config|
-          config.messages_file = SPEC_ROOT.join('fixtures/errors.yml')
-          config.namespace = :user
-        end
-
-        key(:email) { |email| email.filled? }
-      end
-    end
-
-    let(:attrs) do
-      {
-        email: 'jane@doe.org',
-        age: 19,
-        address: { city: 'NYC', street: 'Street 1/2', country: { code: 'US', name: 'USA' } },
-        phone_numbers: [
-          '123456', '234567'
-        ]
-      }.freeze
-    end
-
-    describe '#messages' do
-      it 'returns compiled error messages' do
-        expect(validation.messages(attrs.merge(email: ''))).to eql([
-          [:email, ["email can't be blank"]]
-        ])
-      end
-    end
-  end
-end

data/spec/integration/custom_predicates_spec.rb

@@ -1,57 +0,0 @@
-RSpec.describe Dry::Validation do
-  subject(:validation) { schema.new }
-
-  shared_context 'uses custom predicates' do
-    it 'uses provided custom predicates' do
-      expect(validation.(email: 'jane@doe')).to be_empty
-
-      expect(validation.(email: nil)).to match_array([
-        [:error, [:input, [:email, nil, [[:val, [:email, [:predicate, [:filled?, []]]]]]]]]
-      ])
-
-      expect(validation.(email: 'jane')).to match_array([
-        [:error, [:input, [:email, 'jane', [[:val, [:email, [:predicate, [:email?, []]]]]]]]]
-      ])
-    end
-  end
-
-  describe 'defining schema with custom predicates container' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        configure do |config|
-          config.predicates = Test::Predicates
-        end
-
-        key(:email) { |value| value.filled? & value.email? }
-      end
-    end
-
-    before do
-      module Test
-        module Predicates
-          include Dry::Validation::Predicates
-
-          predicate(:email?) do |input|
-            input.include?('@') # for the lols
-          end
-        end
-      end
-    end
-
-    include_context 'uses custom predicates'
-  end
-
-  describe 'defining schema with custom predicate methods' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        key(:email) { |value| value.filled? & value.email? }
-
-        def email?(value)
-          value.include?('@')
-        end
-      end
-    end
-
-    include_context 'uses custom predicates'
-  end
-end