dry-validation 0.12.0 → 1.6.0

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

@@ -1,211 +0,0 @@
-require 'dry/validation/schema/dsl'
-
-module Dry
-  module Validation
-    class Schema
-      class Value < DSL
-        attr_reader :type, :schema_class, :schema, :type_map
-
-        def initialize(options = {})
-          super
-          @type = options.fetch(:type, :key)
-          @schema_class = options.fetch(:schema_class, ::Class.new(Schema))
-          @options = options.merge(type: @type, schema_class: @schema_class)
-          @type_map = parent && parent.root? ? parent.type_map : {}
-        end
-
-        def predicates(mod)
-          @registry = options[:registry] = schema_class.predicates(mod)
-        end
-
-        def input(*predicates)
-          schema_class.config.input = predicates
-          self
-        end
-
-        def key(name, &block)
-          warn 'key is deprecated - use required instead.'
-
-          required(name, &block)
-        end
-
-        def required(name, type_spec = nil, &block)
-          rule = define(name, Key, &block)
-
-          if type_spec
-            type_map[name] = type_spec
-          end
-
-          rule
-        end
-
-        def schema(other = nil, &block)
-          @schema = Schema.create_class(self, other, &block)
-          type_map.update(@schema.type_map)
-          hash?.and(@schema)
-        end
-
-        def each(*predicates, &block)
-          left = array?
-
-          right =
-            if predicates.size > 0
-              create_rule([:each, infer_predicates(predicates, new).to_ast])
-            else
-              val = Value[
-                name, registry: registry, schema_class: schema_class.clone
-              ].instance_eval(&block)
-
-              if val.type_map?
-                if root?
-                  @type_map = [val.type_map]
-                else
-                  type_map[name] = [val.type_map]
-                end
-              end
-
-              create_rule([:each, val.to_ast])
-            end
-
-          rule = left.and(right)
-
-          add_rule(rule) if root?
-
-          rule
-        end
-
-        def when(*predicates, &block)
-          left = infer_predicates(predicates, Check[path, type: type, registry: registry])
-          right = Value.new(type: type, registry: registry).instance_eval(&block)
-
-          add_check(left.then(right.to_rule))
-
-          self
-        end
-
-        def rule(id = nil, **options, &block)
-          if id
-            val = Value[id, registry: registry, schema_class: schema_class]
-            res = val.instance_exec(&block)
-          else
-            id, deps = options.to_a.first
-            val = Value[id, registry: registry, schema_class: schema_class]
-            res = val.instance_exec(*deps.map { |path| val.value(id, path: path) }, &block)
-          end
-
-          add_check(val.with(rules: [res.with(name: id, deps: deps || [])]))
-        end
-
-        def confirmation
-          conf = :"#{name}_confirmation"
-
-          parent.optional(conf).maybe
-
-          rule(conf => [conf, name]) do |left, right|
-            left.eql?(right)
-          end
-        end
-
-        def value(path, opts = {})
-          check(name || path, { registry: registry, rules: rules, path: path }.merge(opts))
-        end
-
-        def check(name, options = {})
-          Check[name, options.merge(type: type)]
-        end
-
-        def validate(**opts, &block)
-          id, *deps = opts.to_a.flatten
-          name = deps.size > 1 ? id : deps.first
-          rule = create_rule([:check, [deps, [:custom, [id, block]]]], name).with(deps: deps)
-          add_check(rule)
-        end
-
-        def configure(&block)
-          schema_class.class_eval(&block)
-          @registry = schema_class.registry
-          self
-        end
-
-        def root?
-          name.nil?
-        end
-
-        def type_map?
-          ! type_map.empty?
-        end
-
-        def schema?
-          ! @schema.nil?
-        end
-
-        def class
-          Value
-        end
-
-        def new
-          self.class.new(registry: registry, schema_class: schema_class.clone)
-        end
-
-        def key?(name)
-          create_rule(predicate(:key?, name))
-        end
-
-        def node(input, *args)
-          if input.is_a?(::Symbol)
-            registry.ensure_valid_predicate(input, args, schema_class)
-            [type, [name, predicate(input, args)]]
-          elsif input.respond_to?(:rule)
-            [type, [name, [:type, input]]]
-          elsif input.is_a?(Schema)
-            [type, [name, schema(input).to_ast]]
-          else
-            [type, [name, input.to_ast]]
-          end
-        end
-
-        def dyn_arg?(name)
-          !name.to_s.end_with?('?') && schema_class.instance_methods.include?(name)
-        end
-
-        def respond_to?(name)
-          self.class.public_methods.include?(name)
-        end
-
-        def infer_predicates(predicates, infer_on = self)
-          predicates.flat_map(&::Kernel.method(:Array)).map { |predicate|
-            name, *args = ::Kernel.Array(predicate)
-
-            if name.is_a?(Schema)
-              infer_on.schema(name)
-            elsif name.respond_to?(:rule)
-              create_rule(name.rule.to_ast)
-            else
-              infer_on.__send__(name, *args)
-            end
-          }.reduce(:and)
-        end
-
-        private
-
-        def method_missing(meth, *args, &block)
-          return schema_class.instance_method(meth) if dyn_arg?(meth)
-
-          val_rule = create_rule(predicate(meth, args))
-
-          if block
-            val = new.instance_eval(&block)
-
-            type_map.update(val.type_map) if val.type_map?
-
-            new_rule = create_rule([:and, [val_rule.to_ast, val.to_ast]])
-
-            add_rule(new_rule)
-          else
-            val_rule
-          end
-        end
-      end
-    end
-  end
-end

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/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,6 +0,0 @@
-en:
-  errors:
-    rules:
-      email:
-        filled?: "Please provide your email"
-    email?: "must be an email"