dry-validation 0.12.0 → 1.6.0

data/benchmarks/suite.rb

@@ -1,5 +0,0 @@
-require 'i18n'
-require 'dry-validation'
-
-I18n.locale = :en
-I18n.backend.load_translations

data/examples/basic.rb

@@ -1,15 +0,0 @@
-require 'dry-validation'
-
-schema = Dry::Validation.Schema do
-  required(:email).filled
-
-  required(:age).filled(:int?, gt?: 18)
-end
-
-errors = schema.call(email: 'jane@doe.org', age: 19).messages
-
-puts errors.inspect
-
-errors = schema.call(email: nil, age: 19).messages
-
-puts errors.inspect

data/examples/each.rb

@@ -1,14 +0,0 @@
-require 'byebug'
-require 'dry-validation'
-
-schema = Dry::Validation.Schema do
-  key(:phone_numbers).each(:str?)
-end
-
-errors = schema.call(phone_numbers: '').messages
-
-puts errors.inspect
-
-errors = schema.call(phone_numbers: ['123456789', 123456789]).messages
-
-puts errors.inspect

data/examples/json.rb

@@ -1,12 +0,0 @@
-require 'json'
-require 'dry-validation'
-
-schema = Dry::Validation.JSON do
-  required(:email).filled
-
-  required(:age).filled(:int?, gt?: 18)
-end
-
-errors = schema.call(JSON.parse('{"email": "", "age": "18"}')).messages
-
-puts errors.inspect

data/examples/multiple.rb

@@ -1,27 +0,0 @@
-require 'dry-validation'
-
-schema = Dry::Validation.Schema do
-  configure do
-    def self.messages
-      super.merge(en: {
-        errors: {
-          john_email?: '%{value} is not a john email',
-          example_email?: '%{value} is not a example email'
-        } })
-    end
-  end
-
-  required(:email).filled
-
-  validate(example_email?: :email) do |value|
-    value.end_with?('@example.com')
-  end
-
-  validate(john_email?: :email) do |value|
-    value.start_with?('john')
-  end
-end
-
-errors = schema.call(email: 'jane@doe.org').messages
-
-puts errors.inspect

data/examples/nested.rb

@@ -1,22 +0,0 @@
-require 'dry-validation'
-
-schema = Dry::Validation.Schema do
-  required(:address).schema do
-    required(:city).filled(min_size?: 3)
-
-    required(:street).filled
-
-    required(:country).schema do
-      required(:name).filled
-      required(:code).filled
-    end
-  end
-end
-
-errors = schema.call({}).messages
-
-puts errors.inspect
-
-errors = schema.call(address: { city: 'NYC' }).messages
-
-puts errors.inspect

data/examples/params.rb

@@ -1,11 +0,0 @@
-require 'dry-validation'
-
-schema = Dry::Validation.Params do
-  required(:email).filled
-
-  required(:age).filled(:int?, gt?: 18)
-end
-
-errors = schema.call('email' => '', 'age' => '18').messages
-
-puts errors.inspect

data/lib/dry/validation/compat/form.rb

@@ -1,67 +0,0 @@
-require 'dry/core/deprecations'
-
-Dry::Core::Deprecations.warn('Form was renamed to Params and will be removed in the next version', tag: :'dry-validation')
-
-require 'dry/types/compat/int'
-require 'dry/types/compat/form_types'
-require 'dry/validation/input_processor_compiler/params'
-require 'dry/validation/schema/params'
-
-
-module Dry
-  module Validation
-    class InputProcessorCompiler::Form < InputProcessorCompiler
-      PREDICATE_MAP = {
-        default: 'string',
-        none?: 'form.nil',
-        bool?: 'form.bool',
-        true?: 'form.true',
-        false?: 'form.false',
-        str?: 'string',
-        int?: 'form.integer',
-        float?: 'form.float',
-        decimal?: 'form.decimal',
-        date?: 'form.date',
-        date_time?: 'form.date_time',
-        time?: 'form.time',
-        hash?: 'form.hash',
-        array?: 'form.array'
-      }.freeze
-
-      CONST_MAP = {
-        NilClass => 'form.nil',
-        String => 'string',
-        Integer => 'form.integer',
-        Float => 'form.float',
-        BigDecimal => 'form.decimal',
-        Array => 'form.array',
-        Hash => 'form.hash',
-        Date => 'form.date',
-        DateTime => 'form.date_time',
-        Time => 'form.time',
-        TrueClass => 'form.true',
-        FalseClass => 'form.false'
-      }.freeze
-
-      def identifier
-        :form
-      end
-
-      def hash_node(schema)
-        [:form_hash, [schema, {}]]
-      end
-
-      def array_node(members)
-        [:form_array, [members, {}]]
-      end
-    end
-
-    class << self
-      alias_method :Form, :Params
-    end
-
-    Schema::Form = Schema::Params
-
-    Schema::DEFAULT_PROCESSOR_MAP[:form] = InputProcessorCompiler::Form.new
-  end
-end

data/lib/dry/validation/deprecations.rb

@@ -1,24 +0,0 @@
-require 'logger'
-require 'dry/configurable'
-
-module Dry
-  module Validation
-    module Deprecations
-      extend Dry::Configurable
-
-      setting :logger, Logger.new($stdout)
-
-      def self.format(msg, caller)
-        "#{msg} [#{caller[1].split(':')[0..1].join(' line ')}]"
-      end
-
-      def logger
-        @logger ||= Deprecations.config.logger
-      end
-
-      def warn(msg)
-        logger.warn(Deprecations.format(msg, ::Kernel.caller))
-      end
-    end
-  end
-end

data/lib/dry/validation/executor.rb

@@ -1,91 +0,0 @@
-module Dry
-  module Validation
-    class ProcessInput
-      attr_reader :processor
-
-      def initialize(processor)
-        @processor = processor
-      end
-
-      def call(input, *)
-        processor.(input)
-      end
-    end
-
-    class ApplyInputRule
-      attr_reader :rule
-
-      def initialize(rule)
-        @rule = rule
-      end
-
-      def call(input, result)
-        rule_res = rule.(input)
-        result.update(nil => rule_res) unless rule_res.success?
-        input
-      end
-    end
-
-    class ApplyRules
-      attr_reader :rules
-
-      def initialize(rules)
-        @rules = rules
-      end
-
-      def call(input, result)
-        rules.each_with_object(result) do |(name, rule), hash|
-          hash[name] = rule.(input)
-        end
-        input
-      end
-    end
-
-    class ApplyChecks < ApplyRules
-      def call(input, result)
-        rules.each_with_object(result) do |(name, checks), hash|
-          checks.each do |check|
-            check_res = check.is_a?(Guard) ? check.(input, result) : check.(input)
-            if hash.key?(name)
-              if hash[name].is_a?(Array)
-                hash[name] << check_res
-              else
-                hash[name] = [hash[name], check_res]
-              end
-            else
-              hash[name] = check_res if check_res
-            end
-          end
-        end
-        input
-      end
-    end
-
-    class BuildErrors
-      def call(result)
-        result.values.flatten.compact.select(&:failure?)
-      end
-    end
-
-    class Executor
-      attr_reader :steps, :final
-
-      def self.new(&block)
-        super(BuildErrors.new).tap { |executor| yield(executor.steps) }.freeze
-      end
-
-      def initialize(final)
-        @steps = []
-        @final = final
-      end
-
-      def call(input, result = {})
-        output = steps.reduce(input) do |a, e|
-          return [a, final.(result)] if result.key?(nil)
-          e.call(a, result)
-        end
-        [output, final.(result)]
-      end
-    end
-  end
-end

data/lib/dry/validation/extensions.rb

@@ -1,7 +0,0 @@
-Dry::Validation.register_extension(:monads) do
-  require 'dry/validation/extensions/monads'
-end
-
-Dry::Validation.register_extension(:struct) do
-  require 'dry/validation/extensions/struct'
-end

data/lib/dry/validation/extensions/struct.rb

@@ -1,32 +0,0 @@
-require 'dry-struct'
-
-module Dry
-  module Validation
-    class Schema
-      module StructClassBuilder
-        def create_class(target, other = nil)
-          if other.is_a?(Class) && other < Dry::Struct
-            super do
-              other.schema.each { |attr, type| required(attr).filled(type) }
-            end
-          else
-            super
-          end
-        end
-      end
-
-      module StructNode
-        def node(input, *)
-          if input.is_a?(::Class) && input < ::Dry::Struct
-            [type, [name, [:schema, Schema.create_class(self, input)]]]
-          else
-            super
-          end
-        end
-      end
-
-      singleton_class.prepend(StructClassBuilder)
-      Value.prepend(StructNode)
-    end
-  end
-end

data/lib/dry/validation/input_processor_compiler.rb

@@ -1,135 +0,0 @@
-require 'dry/types'
-require 'dry/types/compiler'
-require 'dry/types/compat'
-
-module Dry
-  module Validation
-    class InputProcessorCompiler
-      attr_reader :type_compiler
-
-      DEFAULT_TYPE_NODE = [:definition, [String, {}]].freeze
-
-      def initialize
-        @type_compiler = Dry::Types::Compiler.new(Dry::Types)
-      end
-
-      def call(ast)
-        type_compiler.(hash_node(schema_ast(ast)))
-      end
-
-      def schema_ast(ast)
-        ast.map { |node| visit(node) }
-      end
-
-      def visit(node, *args)
-        send(:"visit_#{node[0]}", node[1], *args)
-      end
-
-      def visit_rule(node, *args)
-        _, rule = node
-        visit(rule, *args)
-      end
-
-      def visit_type(type, *args)
-        if type.is_a?(Types::Constructor)
-          constructor(type)
-        elsif type.respond_to?(:rule)
-          visit(type.rule.to_ast, *args)
-        end
-      end
-
-      def constructor(type)
-        fn_id = type.__send__(:register_fn, type.fn)
-        [:constructor, [[:definition, [type.primitive, {}]], fn_id, {}]]
-      end
-
-      def visit_schema(schema, *args)
-        hash_node(schema.input_processor_ast(identifier))
-      end
-
-      def visit_or(node, *args)
-        left, right = node
-        [:sum, [visit(left, *args), visit(right, *args), {}]]
-      end
-
-      def visit_and(node, first = true)
-        if first
-          name, type = node.map { |n| visit(n, false) }.uniq
-
-          if name.is_a?(Array)
-            type
-          else
-            [:member, [name, type]]
-          end
-        else
-          result = node.map { |n| visit(n, first) }.uniq
-
-          if result.size == 1
-            result.first
-          else
-            result.select { |r| r != self.class::DEFAULT_TYPE_NODE }.last
-          end
-        end
-      end
-
-      def visit_implication(node, *args)
-        left, right = node
-
-        key = visit(left)
-
-        if key.is_a?(Symbol)
-          [:member, [key, visit(right, false)]]
-        else
-          [:sum, [key, visit(right, false), {}]]
-        end
-      end
-
-      def visit_not(node, *args)
-        visit(node, *args)
-      end
-
-      def visit_key(node, *args)
-        _, other = node
-        visit(other, *args)
-      end
-
-      def visit_val(node, *args)
-        visit(node, *args)
-      end
-
-      def visit_set(node, *)
-        hash_node(node.map { |n| visit(n) })
-      end
-
-      def visit_each(node, *args)
-        array_node(visit(node, *args))
-      end
-
-      def visit_predicate(node, *)
-        id, args = node
-
-        if id == :key?
-          args[0][1]
-        else
-          type(id, args.map(&:last))
-        end
-      end
-
-      def type(predicate, args)
-        default = self.class::PREDICATE_MAP[:default]
-
-        type_value = if predicate == :type?
-                       const = args[0]
-                       self.class::CONST_MAP[const] || Types.identifier(const)
-                     else
-                       self.class::PREDICATE_MAP[predicate] || default
-                     end
-        Types[type_value].to_ast
-      end
-    end
-  end
-end
-
-require 'dry/validation/input_processor_compiler/sanitizer'
-require 'dry/validation/input_processor_compiler/json'
-require 'dry/validation/input_processor_compiler/params'