dry-validation 0.13.3 → 1.0.0.alpha1

data/lib/dry/validation/schema_compiler.rb

@@ -1,81 +0,0 @@
-require 'dry/logic/rule_compiler'
-
-module Dry
-  module Validation
-    class Guard
-      attr_reader :rule, :deps
-
-      def initialize(rule, deps)
-        @rule = rule
-        @deps = deps
-      end
-
-      def call(input, results)
-        rule.(input) if deps_valid?(results)
-      end
-
-      def with(options)
-        self.class.new(rule.with(options), deps)
-      end
-
-      private
-
-      def deps_valid?(results)
-        deps.all? do |path|
-          result = nil
-          Array(path).each do |name|
-            curr = results[name]
-            if curr
-              result = curr.is_a?(Array) ? curr.first.success? : curr.success?
-            end
-          end
-          result
-        end
-      end
-    end
-
-    class SchemaCompiler < Logic::RuleCompiler
-      attr_reader :schema, :options
-
-      def initialize(*args, options)
-        super(*args)
-        @options = options
-        @schema = predicates.schema
-      end
-
-      def visit_rule(node)
-        id, other = node
-        visit(other).with(id: id)
-      end
-
-      def visit_predicate(node)
-        super.eval_args(schema)
-      end
-
-      def visit_custom(node)
-        id, predicate = node
-        Logic::Rule.new(predicate).with(id: id).bind(schema)
-      end
-
-      def visit_schema(klass)
-        opt_keys = klass.config.options.keys
-        opt_vals = options.values_at(*opt_keys).compact
-
-        if opt_vals.empty?
-          klass.new
-        else
-          klass.new(klass.config.rules, Hash[opt_keys.zip(opt_vals)])
-        end
-      end
-
-      def visit_guard(node)
-        deps, other = node
-        Guard.new(visit(other), deps)
-      end
-
-      def visit_type(type)
-        type.rule
-      end
-    end
-  end
-end

data/lib/dry/validation/template.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/equalizer'
-
-module Dry
-  module Validation
-    module Messages
-      # Template wraps a string with interpolation tokens and defines evaluator function
-      # dynamically
-      #
-      # @api private
-      class Template
-        include Dry::Equalizer(:text)
-
-        TOKEN_REGEXP = /%{(\w*)}/
-
-        # !@attribute [r] text
-        # @return [String]
-        attr_reader :text
-
-        # !@attribute [r] tokens
-        # @return [Hash]
-        attr_reader :tokens
-
-        # !@attribute [r] evaluator
-        # @return [Proc]
-        attr_reader :evaluator
-
-        # @api private
-        def self.[](input)
-          new(*parse(input))
-        end
-
-        # @api private
-        def self.parse(input)
-          tokens = input.scan(TOKEN_REGEXP).flatten(1).map(&:to_sym)
-          text = input.gsub('%', '#')
-
-          evaluator = <<-RUBY.strip
-            -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
-          RUBY
-
-          [text, tokens, eval(evaluator, binding, __FILE__, __LINE__ - 3)]
-        end
-
-        # @api private
-        def initialize(text, tokens, evaluator)
-          @text = text
-          @tokens = tokens
-          @evaluator = evaluator
-        end
-
-        # @api private
-        def data(input)
-          tokens.each_with_object({}) { |k, h| h[k] = input[k] }
-        end
-
-        # @api private
-        def call(data = EMPTY_HASH)
-          data.empty? ? evaluator.() : evaluator.(data)
-        end
-        alias_method :[], :call
-      end
-    end
-  end
-end

data/lib/dry/validation/type_specs.rb

@@ -1,70 +0,0 @@
-module Dry
-  module Validation
-    module TypeSpecs
-      def self.extended(klass)
-        super
-        klass.class_eval do
-          setting :input_processor, :noop
-          setting :hash_type, :weak
-          setting :type_map, {}
-        end
-      end
-
-      def build_type_map(type_specs, category = config.input_processor)
-        if type_specs.is_a?(Array)
-          build_array_type(type_specs[0], category)
-        else
-          type_specs.reduce({}) { |res, (name, spec)|
-            res.update(name => resolve_spec(spec, category))
-          }
-        end
-      end
-
-      def build_hash_type(spec = type_map)
-        lookup_type("hash", config.input_processor)
-          .public_send(config.hash_type, spec)
-      end
-
-      def build_array_type(spec, category)
-        member_schema = build_type_map(spec, category)
-        member_type = lookup_type("hash", category)
-          .public_send(config.hash_type, member_schema)
-
-        lookup_type("array", category).of(member_type)
-      end
-
-      def build_sum_type(spec, category)
-        spec
-          .map { |id| id.is_a?(Symbol) ? lookup_type(id, category) : id }
-          .reduce(:|)
-      end
-
-      def resolve_spec(spec, category)
-        case spec
-        when Symbol
-          lookup_type(spec, category)
-        when Hash
-          build_hash_type(spec)
-        when Array
-          if spec.size == 1
-            if spec[0].is_a?(Hash)
-              build_array_type(spec[0], category)
-            else
-              array_member = lookup_type(spec[0], category)
-              lookup_type("array", category).of(array_member)
-            end
-          else
-            build_sum_type(spec, category)
-          end
-        else
-          spec
-        end
-      end
-
-      def lookup_type(name, category)
-        id = "#{category}.#{name}"
-        Types.type_keys.include?(id) ? Types[id] : Types[name.to_s]
-      end
-    end
-  end
-end

data/spec/extensions/monads/result_spec.rb

@@ -1,40 +0,0 @@
-RSpec.describe Dry::Validation::Result do
-  before { Dry::Validation.load_extensions(:monads) }
-
-  let(:schema) { Dry::Validation.Schema { required(:name).filled(:str?, size?: 2..4) } }
-
-  context 'with valid input' do
-    let(:input) { { name: 'Jane' } }
-
-    describe '#to_monad' do
-      it 'returns a Success value' do
-        monad = result.to_monad
-
-        expect(monad).to be_a Dry::Monads::Result
-        expect(monad).to be_a_success
-        expect(monad.value!).to eql(name: 'Jane')
-      end
-    end
-  end
-
-  context 'with invalid input' do
-    let(:input) { { name: '' } }
-
-    describe '#to_monad' do
-      it 'returns a Failure value' do
-        monad = result.to_monad
-
-        expect(monad).to be_a_failure
-        expect(monad.failure).to eql(name: ['must be filled', 'length must be within 2 - 4'])
-      end
-
-      it 'returns full messages' do
-        monad = result.to_monad(full: true)
-
-        expect(monad).to be_a Dry::Monads::Result
-        expect(monad).to be_a_failure
-        expect(monad.failure).to eql(name: ['name must be filled', 'name length must be within 2 - 4'])
-      end
-    end
-  end
-end

data/spec/extensions/struct/schema_spec.rb

@@ -1,32 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'defining schema using dry struct' do
-  before do
-    Dry::Validation.load_extensions(:struct)
-  end
-
-  subject(:schema) do
-    Dry::Validation.Schema do
-      required(:person).filled(Test::Person)
-    end
-  end
-
-  before do
-    class Test::Name < Dry::Struct::Value
-      attribute :given_name, Dry::Types['strict.string']
-      attribute :family_name, Dry::Types['strict.string']
-    end
-
-    class Test::Person < Dry::Struct::Value
-      attribute :name, Test::Name
-    end
-  end
-
-  it 'handles nested structs' do
-    expect(schema.call(person: { name: { given_name: 'Tim', family_name: 'Cooper' } })).to be_success
-  end
-
-  it 'fails when input is not valid' do
-    expect(schema.call(person: { name: { given_name: 'Tim' } }).messages).to eq(
-      person: { name: { family_name: ['is missing', 'must be String'] } }
-    )
-  end
-end

data/spec/fixtures/locales/en.yml

@@ -1,8 +0,0 @@
-en:
-  errors:
-    rules:
-      email:
-        filled?: "Please provide your email"
-      age:
-        gt?: "%{input} must be greater than %{num}"
-    email?: "must be an email"

data/spec/fixtures/locales/pl.yml

@@ -1,22 +0,0 @@
-pl:
-  errors:
-    filled?: "nie może być pusty"
-    size?:
-      arg:
-        default: "wielkość musi być równa %{size}"
-        range: "wielkość musi być między %{size_left} a %{size_right}"
-      value:
-        string:
-          arg:
-            default: "wielkość musi być równa %{size}"
-    rules:
-      email:
-        filled?: "Proszę podać adres email"
-      user:
-        rules:
-          email:
-            filled?: "Hej user! Dawaj ten email no!"
-
-  rules:
-    email:
-      'Adres email'

data/spec/integration/custom_error_messages_spec.rb

@@ -1,54 +0,0 @@
-require 'dry/validation/messages/i18n'
-
-RSpec.describe Dry::Validation do
-  shared_context 'schema with customized messages' do
-    describe '#messages' do
-      it 'returns compiled error messages' do
-        expect(schema.(email: '', age: 12).messages).to eql(
-          email: ['Please provide your email'], age: ['12 must be greater than 18']
-        )
-
-        expect(schema.(email: '', age: 14).messages).to eql(
-          email: ['Please provide your email'], age: ['14 must be greater than 18']
-        )
-      end
-    end
-  end
-
-  context 'yaml' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          config.messages_file = SPEC_ROOT.join('fixtures/locales/en.yml')
-        end
-
-        required(:email).filled
-        required(:age).value(gt?: 18)
-      end
-    end
-
-    include_context 'schema with customized messages'
-  end
-
-  context 'i18n' do
-    context 'with custom messages set globally' do
-      before do
-        I18n.load_path << SPEC_ROOT.join('fixtures/locales/en.yml')
-        I18n.backend.load_translations
-      end
-
-      subject(:schema) do
-        Dry::Validation.Schema do
-          configure do
-            config.messages = :i18n
-          end
-
-          required(:email).filled
-          required(:age).value(gt?: 18)
-        end
-      end
-
-      include_context 'schema with customized messages'
-    end
-  end
-end

data/spec/integration/custom_predicates_spec.rb

@@ -1,228 +0,0 @@
-# -*- coding: utf-8 -*-
-RSpec.describe Dry::Validation do
-  shared_context 'uses custom predicates' do
-    it 'uses provided custom predicates' do
-      expect(schema.(email: 'jane@doe')).to be_success
-
-      expect(schema.(email: nil).messages).to eql(
-        email: ['must be filled', 'must be a valid email']
-      )
-
-      expect(schema.(email: 'jane').messages).to eql(
-        email: ['must be a valid email']
-      )
-    end
-  end
-
-  let(:base_class) do
-    Class.new(Dry::Validation::Schema) do
-      def self.messages
-        Dry::Validation::Messages.default.merge(
-          en: { errors: { email?: 'must be a valid email' } }
-        )
-      end
-    end
-  end
-
-  describe 'defining schema with custom predicates container' do
-    before do
-      module Test
-        module Predicates
-          include Dry::Logic::Predicates
-
-          def self.email?(input)
-            input.include?('@') # for the lols
-          end
-        end
-      end
-    end
-
-    context 'when configured globally' do
-      subject(:schema) do
-        Dry::Validation.Schema(base_class) do
-          required(:email) { filled? & email? }
-        end
-      end
-
-      before do
-        Dry::Validation::Schema.predicates(Test::Predicates)
-      end
-
-      after do
-        # HACK: reset global predicates configuration
-        Dry::Validation::Schema.configure do |config|
-          config.predicates = Dry::Logic::Predicates
-        end
-      end
-
-      include_context 'uses custom predicates'
-    end
-
-    context 'when configured locally' do
-      subject(:schema) do
-        Dry::Validation.Schema(base_class) do
-          configure do
-            predicates(Test::Predicates)
-          end
-
-          required(:email) { filled? & email? }
-        end
-      end
-
-      include_context 'uses custom predicates'
-    end
-  end
-
-  describe 'defining schema with custom predicate methods' do
-    subject(:schema) do
-      Dry::Validation.Schema(base_class) do
-        configure do
-          def email?(value)
-            value.include?('@')
-          end
-        end
-
-        required(:email) { filled? & email? }
-      end
-    end
-
-    include_context 'uses custom predicates'
-  end
-
-  describe 'custom predicate which requires an arbitrary dependency' do
-    subject(:schema) do
-      Dry::Validation.Schema(base_class) do
-        configure do
-          option :email_check
-
-          def email?(value)
-            email_check.(value)
-          end
-        end
-
-        required(:email).filled(:email?)
-      end
-    end
-
-    it 'uses injected dependency for the custom predicate' do
-      email_check = -> input { input.include?('@') }
-
-      expect(schema.with(email_check: email_check).(email: 'foo').messages).to eql(
-        email: ['must be a valid email']
-      )
-    end
-  end
-
-  it 'raises an error when message is missing' do
-    schema = Dry::Validation.Schema do
-      configure do
-        def email?(value)
-          false
-        end
-      end
-
-      required(:email).filled(:email?)
-    end
-
-    expect { schema.(email: 'foo').messages }.to raise_error(
-      Dry::Validation::MissingMessageError, /email/
-    )
-  end
-
-  it 'works with custom predicate args' do
-    schema = Dry::Validation.Schema do
-      configure do
-        def self.messages
-          Dry::Validation::Messages.default.merge(
-            en: { errors: { fav_number?: 'must be %{expected}' } }
-          )
-        end
-        def fav_number?(expected, current)
-          current == expected
-        end
-      end
-
-      required(:foo) { fav_number?(23) }
-    end
-
-    expect(schema.(foo: 20).messages).to eql(
-      foo: ['must be 23']
-    )
-
-  end
-
-  it 'works when no predicate args' do
-    schema = Dry::Validation.Schema do
-      configure do
-        def self.messages
-          Dry::Validation::Messages.default.merge(
-            en: { errors: { with_no_args?: 'is always false' } }
-          )
-        end
-
-        def with_no_args?
-          false
-        end
-      end
-
-      required(:email).filled(:with_no_args?)
-    end
-
-    expect(schema.(email: 'foo').messages).to eql(
-      email: ['is always false']
-    )
-  end
-
-  it 'works with nested schemas' do
-    schema = Dry::Validation.Schema do
-      configure do
-        def ok?(_value)
-          true
-        end
-      end
-
-      required(:foo).schema do
-        required(:bar).value(:ok?)
-      end
-    end
-
-    expect(schema.(foo: { bar: "1" })).to be_success
-  end
-
-  it 'works with interpolation of messages' do
-    schema = Dry::Validation.Schema do
-      configure do
-        option :categories, []
-
-        def self.messages
-          Dry::Validation::Messages.default.merge(
-            en: {
-              errors: {
-                valid_category?: 'must be one of the categories: %{categories}'
-              }
-            },
-            pl: {
-              errors: {
-                valid_category?: 'musi być jedną z: %{categories}'
-              }
-            }
-          )
-        end
-
-        def valid_category?(categories, value)
-          categories.include?(value)
-        end
-      end
-
-      required(:category).filled(valid_category?: categories)
-    end.with(categories: %w(foo bar))
-
-    expect(schema.(category: 'baz').messages).to eql(
-      category: ['must be one of the categories: foo, bar']
-    )
-
-    expect(schema.(category: 'baz').messages(locale: :pl)).to eql(
-      category: ['musi być jedną z: foo, bar']
-    )
-  end
-end