dry-validation 1.0.0.alpha2 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 288a3f0d9af21271cfeb794d48752ba6bfa93c8e4fa088e8faa9f6eb9a05e083
-  data.tar.gz: 1949525da40fb528c5eda20c610a5c017c260600613ba4fc392f23cd6a84a8d7
+  metadata.gz: f6a47d27d49e9894cf283af7e4809cea07f45e5f8f3f52a180dd20d8c849b315
+  data.tar.gz: 83f1e9b5ff94c4db24769624dd1552f0876be541926ffd57d43c2490757ab662
 SHA512:
-  metadata.gz: f4884bb2c55f0b987b0aad70bceaedc0d1bc5adc5056bd47e9606e126a9ce9bcb450f5ec7c2035b35572eb4677c4ee0c1525856fe83866b07bf559a75b97a260
-  data.tar.gz: f8f79772a1950752dfa03204269df85d7480c52114c4369d2e895e1edd02b6f02ee3bc03049a2c4ed0994042b104b82dd0e22fcb1c31882b7b0c741d414c8ae1
+  metadata.gz: 67ab872380ecdc45fbe1efeb8cec95a03dff692aae2e74ca498483ceb7104b6a2d5cd78bdc23884d69d89665f110f79c3fa67285b97a40cc2c3625f9744bc34f
+  data.tar.gz: f306b9dc73085526c485a7b18f2e33c83d08dd72922f1640bbc9b3b6ea0164ad1fbda752da0bb9b5d1f55dbd47c6ca6aa9ebef297035fd7adb22bb18be879c4e

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+# v1.0.0.beta1 2019-03-26
+
+### Added
+
+* New API for setting failures `base.failure` for base errors and `key.failure` for key errors (solnic)
+* Support for `base` errors associated with a key even when child keys have errors too (solnic)
+* Support for `base` errors not associated with any key (solnic)
+* Result objects use `ErrorSet` object now for managing messages (solnic)
+* Nested keys are properly handled when generating messages hash (issue #489) (flash-gordon + solnic)
+* Result objects support `locale` and `full` options now (solnic)
+* Ability to configure `top_namespace` for messages, which will be used for both schema and rule localization (solnic)
+* Rule blocks receive a context object that you can use to share data between rules (solnic)
+
+### Changed
+
+* [BREAKING] `Result#errors` returns an instance of `ErrorSet` now, it's an enumerable, coerible to a hash (solnic)
+* [BREAKING] `failure` was removed in favor of `key.failure` or `key(:foo).failure` (solnic)
+* [BREAKING] `Result#to_hash` was removed (flash-gordon)
+
+[Compare v1.0.0.alpha2...v1.0.0.beta1](https://github.com/dry-rb/dry-validation/compare/v1.0.0.alpha2...v1.0.0.beta1)
+
 # v1.0.0.alpha2 2019-03-05
 
 First round of bug fixes. Thanks for testing <3!

data/lib/dry/validation/config.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'dry/schema/config'
+
+module Dry
+  module Validation
+    class Config < Schema::Config
+    end
+  end
+end

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

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require 'dry/schema'
-require 'dry/validation/messages'
+require 'dry/schema/messages'
+
 require 'dry/validation/constants'
 
 module Dry
@@ -11,6 +12,21 @@ module Dry
       #
       # @api public
       module ClassInterface
+        # @api private
+        def inherited(klass)
+          super
+          klass.instance_variable_set('@config', config.dup)
+        end
+
+        # Configuration
+        #
+        # @return [Config]
+        #
+        # @api public
+        def config
+          @config ||= Validation::Config.new
+        end
+
         # Define a params schema for your contract
         #
         # This type of schema is suitable for HTTP parameters
@@ -78,14 +94,14 @@ module Dry
 
         # @api private
         def rules
-          @__rules__ ||= EMPTY_ARRAY
-                         .dup
-                         .concat(superclass.respond_to?(:rules) ? superclass.rules : EMPTY_ARRAY)
+          @rules ||= EMPTY_ARRAY
+            .dup
+            .concat(superclass.respond_to?(:rules) ? superclass.rules : EMPTY_ARRAY)
         end
 
         # @api private
         def messages
-          @__messages__ ||= Messages.setup(config)
+          @messages ||= Schema::Messages.setup(config.messages)
         end
 
         private
@@ -97,7 +113,9 @@ module Dry
 
         # @api private
         def define(method_name, &block)
-          raise ::Dry::Validation::DuplicateSchemaError, 'Schema has already been defined' if defined?(@__schema__)
+          if defined?(@__schema__)
+            raise ::Dry::Validation::DuplicateSchemaError, 'Schema has already been defined'
+          end
 
           case method_name
           when :schema

data/lib/dry/validation/contract.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
+require 'concurrent/map'
+
 require 'dry/equalizer'
-require 'dry/configurable'
 require 'dry/initializer'
 
+require 'dry/validation/config'
 require 'dry/validation/constants'
 require 'dry/validation/rule'
 require 'dry/validation/evaluator'
+require 'dry/validation/messages/resolver'
 require 'dry/validation/result'
+require 'dry/validation/error'
 require 'dry/validation/contract/class_interface'
 
 module Dry
@@ -47,40 +51,20 @@ module Dry
     class Contract
       include Dry::Equalizer(:schema, :rules, :messages)
 
-      extend Dry::Configurable
       extend Dry::Initializer
       extend ClassInterface
 
-      # @!group Configuration
-
-      # @overload config.messages=(identifier)
-      #   Set message backend
-      #
-      #   @param identifier [Symbol] the backend identifier, either `:yaml` or `:i18n`
-      #
-      #   @api public
-      # @!scope class
-      setting :messages, :yaml
+      config.messages.top_namespace = 'dry_validation'
 
-      # @overload config.messages_file=(path)
-      #   Set additional path to messages file
-      #
-      #   @param path [String, Pathname] the path
-      #
+      # @!attribute [r] config
+      #   @return [Config]
       #   @api public
-      # @!scope class
-      setting :messages_file
+      option :config, default: -> { self.class.config }
 
-      # @overload config.namespace=(name)
-      #   Set namespace that will be used to override default messages
-      #
-      #   @param name [Symbol] the namespace
-      #
+      # @!attribute [r] locale
+      #   @return [Symbol]
       #   @api public
-      # @!scope class
-      setting :namespace
-
-      # @!endgroup
+      option :locale, default: -> { :en }
 
       # @!attribute [r] schema
       #   @return [Dry::Schema::Params, Dry::Schema::JSON, Dry::Schema::Processor]
@@ -92,10 +76,10 @@ module Dry
       #   @api private
       option :rules, default: -> { self.class.rules }
 
-      # @!attribute [r] messages
-      #   @return [Messages::I18n, Messages::YAML]
+      # @!attribute [r] message_resolver
+      #   @return [Messages::Resolver]
       #   @api private
-      option :messages, default: -> { self.class.messages }
+      option :message_resolver, default: -> { Messages::Resolver.new(self.class.messages, locale) }
 
       # Apply contract to an input
       #
@@ -103,36 +87,18 @@ module Dry
       #
       # @api public
       def call(input)
-        Result.new(schema.(input)) do |result|
+        Result.new(schema.(input), locale: locale) do |result|
+          context = Concurrent::Map.new
+
           rules.each do |rule|
             next if rule.keys.any? { |key| result.error?(key) }
 
-            rule_result = rule.(self, result)
-            result.add_error(*rule_result.message) if rule_result.failure?
+            rule.(self, result, context).failures.each do |failure|
+              result.add_error(message_resolver[failure])
+            end
           end
         end
       end
-
-      # Get message text for the given rule name and options
-      #
-      # @return [String]
-      #
-      # @api private
-      def message(key, tokens: EMPTY_HASH, **opts)
-        msg_opts = opts.merge(tokens)
-        rule_path = Array(opts.fetch(:rule)).flatten
-
-        template = messages[key, msg_opts.merge(rule: rule_path.join(DOT))]
-        template ||= messages[key, msg_opts.merge(rule: rule_path.last)]
-
-        unless template
-          raise MissingMessageError, <<~STR
-            Message template for #{key.inspect} under #{rule_path.join(DOT).inspect} was not found
-          STR
-        end
-
-        template.(template.data(tokens))
-      end
     end
   end
 end

data/lib/dry/validation/error.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'dry/equalizer'
+require 'dry/schema/message'
+
+module Dry
+  module Validation
+    # Error message
+    #
+    # @api public
+    class Error < Schema::Message
+      include Dry::Equalizer(:text, :path)
+
+      # @!attribute [r] text
+      #   @return [String] text The error message text
+      attr_reader :text
+
+      # @!attribute [r] path
+      #   @return [Array<Symbol, Integer>] path The path to the value with the error
+      attr_reader :path
+
+      # @api public
+      class Localized < Error
+        # @api public
+        def evaluate(**opts)
+          Error.new(text.(opts), path: path)
+        end
+      end
+
+      # Build an error
+      #
+      # @return [Error, Error::Localized]
+      #
+      # @api public
+      def self.[](text, path)
+        text.respond_to?(:call) ? Localized.new(text, path: path) : Error.new(text, path: path)
+      end
+
+      # Initialize a new error object
+      #
+      # @api private
+      def initialize(text, path:)
+        @text = text
+        @path = Array(path)
+      end
+
+      # Check if this is a base error not associated with any key
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def base?
+        @base ||= path.compact.empty?
+      end
+
+      # Dump error to a string
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_s
+        text
+      end
+    end
+  end
+end

data/lib/dry/validation/error_set.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'dry/schema/message_set'
+
+require 'dry/validation/constants'
+require 'dry/validation/error'
+
+module Dry
+  module Validation
+    # ErrorSet is a specialized message set for handling validation errors
+    #
+    # @api public
+    class ErrorSet < Schema::MessageSet
+      # @!attribute [r] source
+      #   Return the source set of messages used to produce final evaluated messages
+      #   @return [Array<Error, Error::Localized, Schema::Message>]
+      #   @api private
+      attr_reader :source_messages
+
+      # @!attribute [r] locale
+      #   @return [Symbol] locale
+      #   @api public
+      attr_reader :locale
+
+      # @api private
+      def initialize(messages, options = EMPTY_HASH)
+        @locale = options.fetch(:locale, :en)
+        @source_messages = options.fetch(:source, messages.dup)
+        super
+      end
+
+      # Return a new error set using updated options
+      #
+      # @return [ErrorSet]
+      #
+      # @api private
+      def with(other, new_options = EMPTY_HASH)
+        return self if new_options.empty?
+
+        self.class.new(
+          other + select { |err| err.is_a?(Error) },
+          options.merge(source: source_messages, **new_options)
+        ).freeze
+      end
+
+      # Add a new error
+      #
+      # This is used when result is being prepared
+      #
+      # @return [ErrorSet]
+      #
+      # @api private
+      def add(error)
+        source_messages << error
+        messages << error
+        initialize_placeholders!
+        self
+      end
+
+      # Filter error set using provided predicates
+      #
+      # This method is open to any predicate because errors can be anything that
+      # implements Message API, thus they can implement whatever predicates you
+      # may need.
+      #
+      # @example get a list of base errors
+      #   error_set = contract.(input).error_set
+      #   error_set.filter(:base?)
+      #
+      # @param [Array<Symbol>] *predicates
+      #
+      # @return [ErrorSet]
+      #
+      # @api public
+      def filter(*predicates)
+        errors = select { |e|
+          predicates.all? { |predicate| e.respond_to?(predicate) && e.public_send(predicate) }
+        }
+        self.class.new(errors)
+      end
+
+      # @api private
+      def freeze
+        source_messages.select { |err| err.respond_to?(:evaluate) }.each do |err|
+          idx = source_messages.index(err)
+          msg = err.evaluate(locale: locale, full: options[:full])
+          messages[idx] = msg
+        end
+        to_h
+        self
+      end
+
+      private
+
+      # @api private
+      def unique_paths
+        source_messages.uniq(&:path).map(&:path)
+      end
+
+      # @api private
+      def messages_map
+        @messages_map ||= reduce(placeholders) { |hash, msg|
+          node = msg.path.reduce(hash) { |a, e| a.is_a?(Hash) ? a[e] : a.last[e] }
+          (node.size > 1 ? node[0] : node) << msg.to_s
+          hash
+        }
+      end
+
+      # @api private
+      #
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/PerceivedComplexity
+      def initialize_placeholders!
+        @placeholders = unique_paths.each_with_object(EMPTY_HASH.dup) { |path, hash|
+          curr_idx = 0
+          last_idx = path.size - 1
+          node = hash
+
+          while curr_idx <= last_idx
+            key = path[curr_idx]
+
+            next_node =
+              if node.is_a?(Array) && key.is_a?(Symbol)
+                node_hash = (node << [] << {}).last
+                node_hash[key] || (node_hash[key] = curr_idx < last_idx ? {} : [])
+              else
+                node[key] || (node[key] = curr_idx < last_idx ? {} : [])
+              end
+
+            node = next_node
+            curr_idx += 1
+          end
+        }
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/PerceivedComplexity
+    end
+  end
+end

data/lib/dry/validation/evaluator.rb

@@ -15,103 +15,128 @@ module Dry
     class Evaluator
       extend Dry::Initializer
 
-      # @!attribute [r] _context
+      ROOT_PATH = [nil].freeze
+
+      # Failure accumulator object
+      #
+      # @api public
+      class Failures
+        # @api private
+        attr_reader :path
+
+        # @api private
+        attr_reader :opts
+
+        # @api private
+        def initialize(path = ROOT_PATH)
+          @path = Dry::Schema::Path[path]
+          @opts = []
+        end
+
+        # Set failure
+        #
+        # @overload failure(message)
+        #   Set message text explicitly
+        #   @param message [String] The message text
+        #   @example
+        #     failure('this failed')
+        #
+        # @overload failure(id)
+        #   Use message identifier (needs localized messages setup)
+        #   @param id [Symbol] The message id
+        #   @example
+        #     failure(:taken)
+        #
+        # @api public
+        def failure(message, tokens = EMPTY_HASH)
+          @opts << { message: message, tokens: tokens, path: path }
+          self
+        end
+      end
+
+      # @!attribute [r] _contract
       #   @return [Contract]
       #   @api private
-      param :_context
+      param :_contract
 
       # @!attribute [r] keys
       #   @return [Array<String, Symbol, Hash>]
       #   @api private
       option :keys
 
-      # @!attribute [r] default_id
-      #   @return [String, Symbol, Hash]
+      # @!attribute [r] _context
+      #   @return [Concurrent::Map]
+      #   @api public
+      option :_context
+
+      # @!attribute [r] path
+      #   @return [Dry::Schema::Path]
       #   @api private
-      option :default_id, default: proc { keys.first }
+      option :path, default: proc { Dry::Schema::Path[(key = keys.first) ? key : ROOT_PATH] }
 
       # @!attribute [r] values
       #   @return [Object]
       #   @api private
       option :values
 
-      # @!attribute [r] message
-      #   @return [String]
-      #   @api private
-      attr_reader :message
-
       # Initialize a new evaluator
       #
       # @api private
       def initialize(*args, &block)
         super(*args)
-        @failure = false
-        instance_eval(&block)
+        instance_exec(_context, &block)
       end
 
-      # Set failure message
+      # Get failures object for the default or provided path
       #
-      # @overload failure(message)
-      #   Set message text explicitly
-      #   @param message [String] The message text
-      #   @example
-      #     failure('this failed')
+      # @param [Symbol,String,Hash,Array<Symbol>] path
       #
-      # @overload failure(id)
-      #   Use message identifier (needs localized messages setup)
-      #   @param id [Symbol] The message id
-      #   @example
-      #     failure(:taken)
+      # @return [Failures]
+      #
+      # @see Failures#failure
+      #
+      # @api public
+      def key(path = self.path)
+        (@key ||= EMPTY_HASH.dup)[path] ||= Failures.new(path)
+      end
+
+      # Get failures object for base errors
       #
-      # @overload failure(key, message)
-      #   Set message under specified key (overrides rule's default key)
-      #   @param id [Symbol] The message key
-      #   @example
-      #     failure(:my_error, 'this failed')
+      # @return [Failures]
       #
-      # @return [Evaluator]
+      # @see Failures#failure
       #
       # @api public
-      def failure(*args, **tokens)
-        id, text =
-          if args.size.equal?(1)
-            case (msg = args[0])
-            when Symbol
-              [default_id, _context.message(msg, rule: default_id, tokens: tokens)]
-            when String
-              [default_id, msg]
-            end
-          else
-            args
-          end
-        @failure = true
-        @message = [id, text]
-        self
+      def base
+        @base ||= Failures.new
       end
 
-      # Check if evaluation resulted in a failure message
+      # Return aggregated failures
       #
-      # @return [Boolean]
+      # @return [Array<Hash>]
       #
       # @api private
-      def failure?
-        @failure.equal?(true)
+      def failures
+        failures = []
+        failures += @base.opts if defined?(@base)
+        failures.concat(@key.values.flat_map(&:opts)) if defined?(@key)
+        failures
       end
 
       # @api private
       def respond_to_missing?(meth, include_private = false)
-        super || _context.respond_to?(meth, true)
+        super || _contract.respond_to?(meth, true)
       end
 
       private
 
-      # Forward to the underlying context
+      # Forward to the underlying contract
       #
       # @api private
       def method_missing(meth, *args, &block)
         # yes, we do want to delegate to private methods too
-        if _context.respond_to?(meth, true)
-          _context.__send__(meth, *args, &block)
+        if _contract.respond_to?(meth, true)
+          _contract.__send__(meth, *args, &block)
         else
           super
         end

data/lib/dry/validation/messages/resolver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    module Messages
+      # Resolve translated messages from failure arguments
+      #
+      # @api public
+      class Resolver
+        # @!attribute [r] messages
+        #   @return [Messages::I18n, Messages::YAML] messages backend
+        #   @api private
+        attr_reader :messages
+
+        # @!attribute [r] locale
+        #   @return [Symbol] current locale
+        #   @api private
+        attr_reader :locale
+
+        # @api private
+        def initialize(messages, locale = :en)
+          @messages = messages
+          @locale = locale
+        end
+
+        # Resolve Error object from provided args and path
+        #
+        # This is used internally by contracts when rules are applied
+        #
+        # @return [Error, Error::Localized]
+        #
+        # @api public
+        def call(message:, tokens:, path:)
+          case message
+          when Symbol
+            Error[->(**opts) { message(message, path: path, tokens: tokens, **opts) }, path]
+          when String
+            Error[message, path]
+          end
+        end
+        alias_method :[], :call
+
+        # Resolve a message
+        #
+        # @return [String]
+        #
+        # @api public
+        def message(rule, tokens: EMPTY_HASH, path:, locale: self.locale, full: false)
+          keys = path.to_a.compact
+          msg_opts = tokens.merge(path: keys, locale: locale)
+
+          if keys.empty?
+            template = messages["rules.#{rule}", msg_opts]
+          else
+            template = messages[rule, msg_opts.merge(path: keys.join(DOT))]
+            template ||= messages[rule, msg_opts.merge(path: keys.last)]
+          end
+
+          unless template
+            raise MissingMessageError, <<~STR
+              Message template for #{rule.inspect} under #{keys.join(DOT).inspect} was not found
+            STR
+          end
+
+          text = template.(template.data(tokens))
+
+          full ? "#{messages.rule(keys.last, msg_opts)} #{text}" : text
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/result.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'dry/equalizer'
+
 require 'dry/validation/constants'
+require 'dry/validation/error_set'
 
 module Dry
   module Validation
@@ -13,8 +15,10 @@ module Dry
 
       # Build a new result
       #
+      # @param [Dry::Schema::Result]
+      #
       # @api private
-      def self.new(params, errors = EMPTY_HASH.dup)
+      def self.new(values, options = EMPTY_HASH)
         result = super
         yield(result) if block_given?
         result.freeze
@@ -25,25 +29,29 @@ module Dry
       #   @api private
       attr_reader :values
 
-      # @!attribute [r] errors
-      #   @return [Hash<Symbol=>Array<String>>]
-      #   @api public
-      attr_reader :errors
+      # @!attribute [r] options
+      #   @return [Hash]
+      #   @api private
+      attr_reader :options
 
       # Initialize a new result
       #
       # @api private
-      def initialize(values, errors)
+      def initialize(values, options)
         @values = values
-        @errors = errors.update(values.errors)
+        @options = options
+        @errors = initialize_errors
       end
 
-      # Return all messages including hints from schema
+      # Get error set
+      #
+      # @return [ErrorSet]
       #
       # @api public
-      def messages
-        values.messages
+      def errors(new_options = EMPTY_HASH)
+        new_options.empty? ? @errors : @errors.with(schema_errors(new_options), new_options)
       end
+      alias_method :messages, :errors
 
       # Check if result is successful
       #
@@ -51,7 +59,7 @@ module Dry
       #
       # @api public
       def success?
-        errors.empty?
+        @errors.empty?
       end
 
       # Check if result is not successful
@@ -73,8 +81,8 @@ module Dry
       # Add a new error for the provided key
       #
       # @api private
-      def add_error(key, message)
-        add_to(errors, key, message)
+      def add_error(error)
+        errors.add(error)
         self
       end
 
@@ -86,27 +94,7 @@ module Dry
       #
       # @api public
       def [](key)
-        if values.key?(key)
-          values[key]
-        elsif storage.key?(key)
-          storage[key]
-        else
-          nil
-        end
-      end
-
-      # Store value under specified key
-      #
-      # @param [Symbol] key
-      # @param [Object] value
-      #
-      # @return [Object]
-      #
-      # @api public
-      def []=(key, value)
-        raise ArgumentError, "Key +#{key}+ was already set" if key?(key)
-
-        storage[key] = value
+        values[key]
       end
 
       # Check if a key was set
@@ -117,7 +105,7 @@ module Dry
       #
       # @api public
       def key?(key)
-        values.key?(key) || storage.key?(key)
+        values.key?(key)
       end
 
       # Coerce to a hash
@@ -126,38 +114,32 @@ module Dry
       def to_h
         values.to_h
       end
-      alias_method :to_hash, :to_h
-
-      # Add new errors
-      #
-      # @api private
-      def update(new_errors)
-        errors.update(new_errors)
-      end
 
       # Return a string representation
       #
       # @api public
       def inspect
-        "#<#{self.class}#{to_h.inspect} errors=#{errors.inspect}>"
+        "#<#{self.class}#{to_h.inspect} errors=#{errors.to_h.inspect}>"
+      end
+
+      # Freeze result and its error set
+      #
+      # @api private
+      def freeze
+        errors.freeze
+        super
       end
 
       private
 
       # @api private
-      def storage
-        @storage ||= EMPTY_HASH.dup
+      def initialize_errors(options = self.options)
+        ErrorSet.new(schema_errors(options), options)
       end
 
       # @api private
-      def add_to(hash, path, value)
-        if path.is_a?(Hash)
-          key = path.keys[0]
-          messages = (hash[key] ||= EMPTY_HASH.dup)
-          add_to(messages, path[key], value)
-        else
-          (hash[path] ||= EMPTY_ARRAY.dup) << value
-        end
+      def schema_errors(options)
+        values.message_set(options).to_a
       end
     end
   end

data/lib/dry/validation/rule.rb

@@ -25,12 +25,13 @@ module Dry
 
       # Evaluate the rule within the provided context
       #
-      # @param [Contract] context
-      # @param [Object] values
+      # @param [Contract] contract
+      # @param [Result] result
+      # @param [Concurrent::Map] context
       #
       # @api private
-      def call(context, values)
-        Evaluator.new(context, values: values, keys: keys, &block)
+      def call(contract, result, context)
+        Evaluator.new(contract, values: result, keys: keys, _context: context, &block)
       end
     end
   end

data/lib/dry/validation/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module Validation
-    VERSION = '1.0.0.alpha2'
+    VERSION = '1.0.0.beta1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-validation
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha2
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-05 00:00:00.000000000 Z
+date: 2019-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -24,26 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: dry-configurable
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: dry-core
   requirement: !ruby/object:Gem::Requirement
@@ -96,22 +76,22 @@ dependencies:
   name: dry-schema
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.3'
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.3'
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -166,12 +146,15 @@ files:
 - README.md
 - lib/dry-validation.rb
 - lib/dry/validation.rb
+- lib/dry/validation/config.rb
 - lib/dry/validation/constants.rb
 - lib/dry/validation/contract.rb
 - lib/dry/validation/contract/class_interface.rb
+- lib/dry/validation/error.rb
+- lib/dry/validation/error_set.rb
 - lib/dry/validation/evaluator.rb
 - lib/dry/validation/extensions/monads.rb
-- lib/dry/validation/messages.rb
+- lib/dry/validation/messages/resolver.rb
 - lib/dry/validation/result.rb
 - lib/dry/validation/rule.rb
 - lib/dry/validation/version.rb
@@ -194,7 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Validation library

data/lib/dry/validation/messages.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/schema/messages'
-
-module Dry
-  module Validation
-    module Messages
-      class YAML < Schema::Messages::YAML
-        config.root = config.root.gsub('dry_schema', 'dry_validation')
-        config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
-          path.gsub('dry_schema', 'dry_validation')
-        }
-      end
-
-      if defined?(::I18n)
-        class I18n < Schema::Messages::I18n
-          config.root = config.root.gsub('dry_schema', 'dry_validation')
-          config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
-            path.gsub('dry_schema', 'dry_validation')
-          }
-        end
-      end
-
-      # @api private
-      def self.setup(config)
-        messages = build(config)
-
-        if config.messages_file && config.namespace
-          messages.merge(config.messages_file).namespaced(config.namespace)
-        elsif config.messages_file
-          messages.merge(config.messages_file)
-        elsif config.namespace
-          messages.namespaced(config.namespace)
-        else
-          messages
-        end
-      end
-
-      # @api private
-      def self.build(config)
-        klass =
-          case config.messages
-          when :yaml then default
-          when :i18n then Messages::I18n
-          else
-            raise "+#{config.messages}+ is not a valid messages identifier"
-          end
-
-        klass.build
-      end
-
-      # @api private
-      def self.default
-        Messages::YAML
-      end
-    end
-  end
-end