dry-validation 0.8.0 → 0.9.0

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

@@ -0,0 +1,193 @@
+require 'dry/validation/messages/yaml'
+require 'dry/validation/messages/i18n'
+
+require 'dry/validation/type_specs'
+
+module Dry
+  module Validation
+    class Schema
+      extend Dry::Configurable
+      extend TypeSpecs
+
+      NOOP_INPUT_PROCESSOR = -> input { input }
+
+      setting :path
+      setting :predicates, Logic::Predicates
+      setting :registry
+      setting :messages, :yaml
+      setting :messages_file
+      setting :namespace
+      setting :rules, []
+      setting :checks, []
+      setting :options, {}
+      setting :input, nil
+      setting :input_rule, nil
+      setting :dsl_extensions, nil
+
+      setting :input_processor_map, {
+        sanitizer: InputProcessorCompiler::Sanitizer.new,
+        json: InputProcessorCompiler::JSON.new,
+        form: InputProcessorCompiler::Form.new,
+      }.freeze
+
+      setting :type_specs, false
+
+      def self.new(rules = config.rules, **options)
+        super(rules, default_options.merge(options))
+      end
+
+      def self.define(options = {}, &block)
+        source = options.fetch(:schema_class)
+        config = source.config
+
+        dsl_ext = config.dsl_extensions
+
+        dsl = Schema::Value.new(options.merge(registry: source.registry))
+        dsl_ext.__send__(:extend_object, dsl) if dsl_ext
+        dsl.predicates(options[:predicates]) if options.key?(:predicates)
+        dsl.instance_exec(&block) if block
+
+        target = dsl.schema_class
+
+        if config.input
+          config.input_rule = dsl.__send__(:infer_predicates, Array(target.config.input))
+        end
+
+        rules = target.config.rules + (options.fetch(:rules, []) + dsl.rules)
+
+        target.configure do |cfg|
+          cfg.rules = rules
+          cfg.checks = cfg.checks + dsl.checks
+          cfg.path = dsl.path
+          cfg.type_map = target.build_type_map(dsl.type_map) if cfg.type_specs
+        end
+
+        target
+      end
+
+      def self.define!(options = {}, &block)
+        define(schema_class: self, &block)
+      end
+
+      def self.predicates(predicate_set = nil)
+        if predicate_set
+          config.predicates = predicate_set
+          set_registry!
+        else
+          config.predicates
+        end
+      end
+
+      def self.option(name, default = nil)
+        attr_reader(*name)
+        options.update(name => default)
+      end
+
+      def self.create_class(target, other = nil, &block)
+        klass =
+          if other.is_a?(self)
+            Class.new(other.class)
+          elsif other.is_a?(Class) && other < Types::Struct
+            Validation.Schema(parent: target, build: false) do
+              other.schema.each { |attr, type| required(attr).filled(type) }
+            end
+          elsif other.respond_to?(:schema) && other.schema.is_a?(self)
+            Class.new(other.schema.class)
+          else
+            Validation.Schema(target.schema_class, parent: target, build: false, &block)
+          end
+
+        klass.config.path = target.path if other
+        klass.config.input_processor = :noop
+
+        klass
+      end
+
+      def self.clone
+        klass = Class.new(self)
+        klass.config.rules = []
+        klass.config.registry = registry
+        klass
+      end
+
+      def self.to_ast
+        [:schema, self]
+      end
+
+      def self.registry
+        config.registry
+      end
+
+      def self.type_map
+        config.type_map
+      end
+
+      def self.rules
+        config.rules
+      end
+
+      def self.options
+        config.options
+      end
+
+      def self.messages
+        default = default_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.default_messages
+        case config.messages
+        when :yaml then Messages.default
+        when :i18n then Messages::I18n.new
+        else
+          raise "+#{config.messages}+ is not a valid messages identifier"
+        end
+      end
+
+      def self.error_compiler
+        @error_compiler ||= ErrorCompiler.new(messages)
+      end
+
+      def self.hint_compiler
+        @hint_compiler ||= HintCompiler.new(messages, rules: rule_ast)
+      end
+
+      def self.rule_ast
+        @rule_ast ||= config.rules.map(&:to_ast)
+      end
+
+      def self.default_options
+        @default_options ||= { predicate_registry: registry,
+          error_compiler: error_compiler,
+          hint_compiler: hint_compiler,
+          input_processor: input_processor,
+          checks: config.checks }
+      end
+
+      def self.inherited(klass)
+        super
+
+        klass.config.options = klass.config.options.dup
+
+        if registry && self != Schema
+          klass.config.registry = registry.new(self)
+        else
+          klass.set_registry!
+        end
+      end
+
+      def self.set_registry!
+        config.registry = PredicateRegistry[self, config.predicates]
+      end
+    end
+  end
+end

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

@@ -9,8 +9,7 @@ module Dry
             if type_map.is_a?(Dry::Types::Safe) && config.input_processor != :noop
               type_map
             elsif type_map.size > 0 && config.input_processor != :noop
-              lookup_type("hash", config.input_processor)
-                .public_send(config.hash_type, type_map)
+              build_hash_type(type_map)
             elsif input_processor_compiler
               input_processor_compiler.(rule_ast)
             else

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

@@ -26,6 +26,10 @@ module Dry
           create_rule([type, [name, value.each(*predicates, &block).to_ast]])
         end
 
+        def schema(other = nil, &block)
+          create_rule([type, [name, value.schema(other, &block).to_ast]])
+        end
+
         def hash?(&block)
           predicate = registry[:hash?]
 

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

@@ -18,8 +18,8 @@ module Dry
           @registry = options[:registry] = schema_class.predicates(mod)
         end
 
-        def input(type)
-          schema_class.config.input = type
+        def input(*predicates)
+          schema_class.config.input = predicates
           self
         end
 
@@ -115,9 +115,8 @@ module Dry
         end
 
         def configure(&block)
-          klass = ::Class.new(schema_class, &block)
-          @schema_class = klass
-          @registry = klass.registry
+          schema_class.class_eval(&block)
+          @registry = schema_class.registry
           self
         end
 
@@ -146,7 +145,7 @@ module Dry
         end
 
         def predicate(name, *args)
-          registry.ensure_valid_predicate(name, args)
+          registry.ensure_valid_predicate(name, args, schema_class)
           registry[name].curry(*args)
         end
 
@@ -164,9 +163,13 @@ module Dry
           end
         end
 
+        def dyn_arg?(name)
+          schema_class.instance_methods.include?(name)
+        end
+
         private
 
-        def infer_predicates(predicates, infer_on)
+        def infer_predicates(predicates, infer_on = self)
           predicates.map { |predicate|
             name, *args = ::Kernel.Array(predicate).first
 
@@ -179,6 +182,8 @@ module Dry
         end
 
         def method_missing(meth, *args, &block)
+          return schema_class.instance_method(meth) if dyn_arg?(meth)
+
           val_rule = create_rule([:val, predicate(meth, *args).to_ast])
 
           if block

data/lib/dry/validation/schema_compiler.rb

@@ -29,8 +29,27 @@ module Dry
     end
 
     class SchemaCompiler < Logic::RuleCompiler
+      attr_reader :schema, :options
+
+      def initialize(*args, options)
+        super(*args)
+        @options = options
+        @schema = predicates.schema
+      end
+
+      def visit_predicate(node)
+        super.evaluate_args!(schema)
+      end
+
       def visit_schema(klass)
-        klass.new
+        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)

data/lib/dry/validation/type_specs.rb

@@ -0,0 +1,70 @@
+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).member(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).member(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/lib/dry/validation/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Validation
-    VERSION = '0.8.0'.freeze
+    VERSION = '0.9.0'.freeze
   end
 end

data/spec/fixtures/locales/pl.yml

@@ -4,7 +4,7 @@ pl:
     size?:
       arg:
         default: "wielkość musi być równa %{size}"
-        range: "wielkość musi być między %{left} a %{right}"
+        range: "wielkość musi być między %{size_left} a %{size_right}"
     rules:
       email:
         filled?: "Proszę podać adres email"

data/spec/integration/custom_predicates_spec.rb

@@ -187,4 +187,41 @@ RSpec.describe Dry::Validation do
 
     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

data/spec/integration/error_compiler_spec.rb

@@ -48,7 +48,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
     end
 
     it 'converts error ast into another format' do
-      expect(error_compiler.(ast)).to eql(
+      expect(error_compiler.(ast).to_h).to eql(
         name: ["+name+ key is missing in the hash"],
         gender: ["Please provide your gender"],
         age: ["must be greater than 18"],
@@ -80,7 +80,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
     end
 
     it 'converts error ast into another format' do
-      expect(error_compiler.(ast)).to eql(
+      expect(error_compiler.(ast).to_h).to eql(
         settings: { newsletter: ['must be false'] }
       )
     end
@@ -103,7 +103,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
     end
 
     it 'converts error ast into another format' do
-      expect(error_compiler.(ast)).to eql(
+      expect(error_compiler.(ast).to_h).to eql(
         payments: { 1 => { method: ['+method+ key is missing in the hash'] } }
       )
     end
@@ -116,7 +116,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['2', [:val, p(:int?)]]]]]
         )
 
-        expect(msg).to eql(num: ['num must be an integer'])
+        expect(msg).to eql('num must be an integer')
       end
     end
 
@@ -126,7 +126,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:email, [:result, ['oops', [:val, p(:email?)]]]]]
         )
 
-        expect(msg).to eql(email: ['adres email nie jest poprawny'])
+        expect(msg).to eql('adres email nie jest poprawny')
       end
     end
 
@@ -136,7 +136,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:tags, [:result, [nil, [:val, p(:empty?)]]]]]
         )
 
-        expect(msg).to eql(tags: ['must be empty'])
+        expect(msg).to eql('must be empty')
       end
     end
 
@@ -146,7 +146,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, [2, [:val, p(:excluded_from?, [1, 2, 3])]]]]]
         )
 
-        expect(msg).to eql(num: ['must not be one of: 1, 2, 3'])
+        expect(msg).to eql('must not be one of: 1, 2, 3')
       end
     end
 
@@ -156,7 +156,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:array, [:result, [[1, 2, 3], [:val, p(:excludes?, 2)]]]]]
         )
 
-        expect(msg).to eql(array: ['must not include 2'])
+        expect(msg).to eql('must not include 2')
       end
     end
 
@@ -166,7 +166,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, [2, [:val, p(:included_in?, [1, 2, 3])]]]]]
         )
 
-        expect(msg).to eql(num: ['must be one of: 1, 2, 3'])
+        expect(msg).to eql('must be one of: 1, 2, 3')
       end
     end
 
@@ -176,7 +176,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, [[1, 2, 3], [:val, p(:includes?, 2)]]]]]
         )
 
-        expect(msg).to eql(num: ['must include 2'])
+        expect(msg).to eql('must include 2')
       end
     end
 
@@ -186,7 +186,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, [2, [:val, p(:gt?, 3)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be greater than 3'])
+        expect(msg).to eql('must be greater than 3')
       end
     end
 
@@ -196,7 +196,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, [2, [:val, p(:gteq?, 3)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be greater than or equal to 3'])
+        expect(msg).to eql('must be greater than or equal to 3')
       end
     end
 
@@ -206,7 +206,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, [2, [:val, p(:lt?, 3)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be less than 3'])
+        expect(msg).to eql('must be less than 3')
       end
     end
 
@@ -216,7 +216,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, [2, [:val, p(:lteq?, 3)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be less than or equal to 3'])
+        expect(msg).to eql('must be less than or equal to 3')
       end
     end
 
@@ -226,7 +226,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:address, [:result, ['', [:val, p(:hash?, [])]]]]]
         )
 
-        expect(msg).to eql(address: ['must be a hash'])
+        expect(msg).to eql('must be a hash')
       end
     end
 
@@ -236,7 +236,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:phone_numbers, [:result, ['', [:val, p(:array?)]]]]]
         )
 
-        expect(msg).to eql(phone_numbers: ['must be an array'])
+        expect(msg).to eql('must be an array')
       end
     end
 
@@ -246,7 +246,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['2', [:val, p(:int?)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be an integer'])
+        expect(msg).to eql('must be an integer')
       end
     end
 
@@ -256,7 +256,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['2', [:val, p(:float?)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be a float'])
+        expect(msg).to eql('must be a float')
       end
     end
 
@@ -266,7 +266,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['2', [:val, p(:decimal?)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be a decimal'])
+        expect(msg).to eql('must be a decimal')
       end
     end
 
@@ -276,7 +276,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['2', [:val, p(:date?)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be a date'])
+        expect(msg).to eql('must be a date')
       end
     end
 
@@ -286,7 +286,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['2', [:val, p(:date_time?)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be a date time'])
+        expect(msg).to eql('must be a date time')
       end
     end
 
@@ -296,7 +296,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['2', [:val, p(:time?)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be a time'])
+        expect(msg).to eql('must be a time')
       end
     end
 
@@ -306,7 +306,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['abcd', [:val, p(:max_size?, 3)]]]]]
         )
 
-        expect(msg).to eql(num: ['size cannot be greater than 3'])
+        expect(msg).to eql('size cannot be greater than 3')
       end
     end
 
@@ -316,7 +316,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['ab', [:val, p(:min_size?, 3)]]]]]
         )
 
-        expect(msg).to eql(num: ['size cannot be less than 3'])
+        expect(msg).to eql('size cannot be less than 3')
       end
     end
 
@@ -326,7 +326,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, [nil, [:val, p(:none?)]]]]]
         )
 
-        expect(msg).to eql(num: ['cannot be defined'])
+        expect(msg).to eql('cannot be defined')
       end
     end
 
@@ -336,7 +336,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:numbers, [:result, [[1], [:val, p(:size?, 3)]]]]]
         )
 
-        expect(msg).to eql(numbers: ['size must be 3'])
+        expect(msg).to eql('size must be 3')
       end
 
       it 'returns valid message when val is array and arg is range' do
@@ -344,7 +344,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:numbers, [:result, [[1], [:val, p(:size?, 3..4)]]]]]
         )
 
-        expect(msg).to eql(numbers: ['size must be within 3 - 4'])
+        expect(msg).to eql('size must be within 3 - 4')
       end
 
       it 'returns valid message when arg is int' do
@@ -352,7 +352,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['ab', [:val, p(:size?, 3)]]]]]
         )
 
-        expect(msg).to eql(num: ['length must be 3'])
+        expect(msg).to eql('length must be 3')
       end
 
       it 'returns valid message when arg is range' do
@@ -360,7 +360,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, ['ab', [:val, p(:size?, 3..4)]]]]]
         )
 
-        expect(msg).to eql(num: ['length must be within 3 - 4'])
+        expect(msg).to eql('length must be within 3 - 4')
       end
     end
 
@@ -370,7 +370,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, [3, [:val, p(:str?)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be a string'])
+        expect(msg).to eql('must be a string')
       end
     end
 
@@ -380,7 +380,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:num, [:result, [3, [:val, p(:bool?)]]]]]
         )
 
-        expect(msg).to eql(num: ['must be boolean'])
+        expect(msg).to eql('must be boolean')
       end
     end
 
@@ -390,7 +390,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:str, [:result, ['Bar', [:val, p(:format?, /^F/)]]]]]
         )
 
-        expect(msg).to eql(str: ['is in invalid format'])
+        expect(msg).to eql('is in invalid format')
       end
     end
 
@@ -400,7 +400,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:str, [:result, ["not a number", [:val, p(:number?)]]]]]
         )
 
-        expect(msg).to eql(str: ['must be a number'])
+        expect(msg).to eql('must be a number')
       end
     end
 
@@ -410,7 +410,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:str, [:result, [1, [:val, p(:odd?)]]]]]
         )
 
-        expect(msg).to eql(str: ['must be odd'])
+        expect(msg).to eql('must be odd')
       end
     end
 
@@ -420,7 +420,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:str, [:result, [2, [:val, p(:even?)]]]]]
         )
 
-        expect(msg).to eql(str: ['must be even'])
+        expect(msg).to eql('must be even')
       end
     end
 
@@ -430,7 +430,7 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:str, [:result, ['Foo', [:val, p(:eql?, 'Bar')]]]]]
         )
 
-        expect(msg).to eql(str: ['must be equal to Bar'])
+        expect(msg).to eql('must be equal to Bar')
       end
     end
 
@@ -440,17 +440,17 @@ RSpec.describe Dry::Validation::ErrorCompiler do
           [:input, [:str, [:result, ['Foo', [:val, p(:not_eql?, 'Foo')]]]]]
         )
 
-        expect(msg).to eql(str: ['must not be equal to Foo'])
+        expect(msg).to eql('must not be equal to Foo')
       end
     end
 
-    describe ':type??' do
+    describe ':type?' do
       it 'returns valid message' do
         msg = error_compiler.visit(
           [:input, [:age, [:result, ['1', [:val, p(:type?, Integer)]]]]]
         )
 
-        expect(msg).to eql(age: ['must be Integer'])
+        expect(msg).to eql('must be Integer')
       end
     end
   end