dry-schema 1.4.2 → 1.5.3

data/lib/dry/schema/message.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'dry/initializer'
-require 'dry/equalizer'
+require "dry/initializer"
+require "dry/equalizer"
 
-require 'dry/schema/path'
-require 'dry/schema/message/or'
+require "dry/schema/path"
+require "dry/schema/message/or"
 
 module Dry
   module Schema
@@ -52,9 +52,22 @@ module Dry
       #
       # @api public
       def dump
-        @dump ||= meta.empty? ? text : { text: text, **meta }
+        @dump ||= meta.empty? ? text : {text: text, **meta}
+      end
+      alias_method :to_s, :dump
+
+      # Dump the message into a hash
+      #
+      # The hash will be deeply nested if the path's size is greater than 1
+      #
+      # @see Message#to_h
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_h
+        @to_h ||= _path.to_h(dump)
       end
-      alias to_s dump
 
       # See if another message is the same
       #
@@ -69,19 +82,32 @@ module Dry
         other.is_a?(String) ? text == other : super
       end
 
+      # @api private
+      def to_or(root)
+        clone = dup
+        clone.instance_variable_set("@path", path - root.to_a)
+        clone.instance_variable_set("@_path", nil)
+        clone
+      end
+
       # See which message is higher in the hierarchy
       #
       # @api private
       def <=>(other)
-        l_path = Path[path]
-        r_path = Path[other.path]
+        l_path = _path
+        r_path = other._path
 
         unless l_path.same_root?(r_path)
-          raise ArgumentError, 'Cannot compare messages from different root paths'
+          raise ArgumentError, "Cannot compare messages from different root paths"
         end
 
         l_path <=> r_path
       end
+
+      # @api private
+      def _path
+        @_path ||= Path[path]
+      end
     end
   end
 end

data/lib/dry/schema/message/or.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
+require "dry/schema/message/or/single_path"
+require "dry/schema/message/or/multi_path"
 
 module Dry
   module Schema
@@ -8,45 +9,23 @@ module Dry
     #
     # @api public
     class Message
-      # A message sub-type used by OR operations
-      #
-      # @api public
-      class Or
+      module Or
         # @api private
-        attr_reader :left
-
-        # @api private
-        attr_reader :right
-
-        # @api private
-        attr_reader :path
-
-        # @api private
-        attr_reader :messages
-
-        # @api private
-        def initialize(left, right, messages)
-          @left = left
-          @right = right
-          @messages = messages
-          @path = left.path
-        end
-
-        # Dump a message into a string
-        #
-        # @see Message#dump
-        #
-        # @return [String]
-        #
-        # @api public
-        def dump
-          to_a.map(&:dump).join(" #{messages[:or][:text]} ")
-        end
-        alias to_s dump
-
-        # @api private
-        def to_a
-          [left, right]
+        def self.[](left, right, messages)
+          msgs = [left, right].flatten
+          paths = msgs.map(&:path)
+
+          if paths.uniq.size == 1
+            SinglePath.new(left, right, messages)
+          elsif right.is_a?(Array)
+            if left.is_a?(Array) && paths.uniq.size > 1
+              MultiPath.new(left, right)
+            else
+              right
+            end
+          else
+            msgs.max
+          end
         end
       end
     end

data/lib/dry/schema/message/or/abstract.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    class Message
+      module Or
+        # A message type used by OR operations
+        #
+        # @abstract
+        #
+        # @api private
+        class Abstract
+          # @api private
+          attr_reader :left
+
+          # @api private
+          attr_reader :right
+
+          # @api private
+          def initialize(left, right)
+            @left = left
+            @right = right
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/message/or/multi_path.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "dry/equalizer"
+
+require "dry/schema/message/or/abstract"
+require "dry/schema/path"
+
+module Dry
+  module Schema
+    class Message
+      module Or
+        # A message type used by OR operations with different paths
+        #
+        # @api public
+        class MultiPath < Abstract
+          # @api private
+          attr_reader :root
+
+          # @api private
+          def initialize(*args)
+            super
+            @root = [left, right].flatten.map(&:_path).reduce(:&)
+            @left = left.map { |msg| msg.to_or(root) }
+            @right = right.map { |msg| msg.to_or(root) }
+          end
+
+          # @api public
+          def to_h
+            @to_h ||= Path[[*root, :or]].to_h(
+              [left.map(&:to_h).reduce(:merge), right.map(&:to_h).reduce(:merge)]
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/message/or/single_path.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "dry/schema/message/or/abstract"
+
+module Dry
+  module Schema
+    class Message
+      module Or
+        # A message type used by OR operations with the same path
+        #
+        # @api public
+        class SinglePath < Abstract
+          # @api private
+          attr_reader :path
+
+          # @api private
+          attr_reader :_path
+
+          # @api private
+          attr_reader :messages
+
+          # @api private
+          def initialize(*args, messages)
+            super(*args)
+            @messages = messages
+            @path = left.path
+            @_path = left._path
+          end
+
+          # Dump a message into a string
+          #
+          # Both sides of the message will be joined using translated
+          # value under `dry_schema.or` message key
+          #
+          # @see Message#dump
+          #
+          # @return [String]
+          #
+          # @api public
+          def dump
+            @dump ||= "#{left.dump} #{messages[:or][:text]} #{right.dump}"
+          end
+          alias_method :to_s, :dump
+
+          # Dump an `or` message into a hash
+          #
+          # @see Message#to_h
+          #
+          # @return [String]
+          #
+          # @api public
+          def to_h
+            @to_h ||= _path.to_h(dump)
+          end
+
+          # @api private
+          def to_a
+            @to_a ||= [left, right]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/message_compiler.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'dry/initializer'
+require "dry/initializer"
 
-require 'dry/schema/constants'
-require 'dry/schema/message'
-require 'dry/schema/message_set'
-require 'dry/schema/message_compiler/visitor_opts'
+require "dry/schema/constants"
+require "dry/schema/message"
+require "dry/schema/message_set"
+require "dry/schema/message_compiler/visitor_opts"
 
 module Dry
   module Schema
@@ -29,6 +29,14 @@ module Dry
 
       EMPTY_OPTS = VisitorOpts.new
       EMPTY_MESSAGE_SET = MessageSet.new(EMPTY_ARRAY).freeze
+      FULL_MESSAGE_WHITESPACE = Hash.new(' ').merge(
+            ja: '',
+            zh: '',
+            bn: '',
+            th: '',
+            lo: '',
+            my: '',
+          )
 
       param :messages
 
@@ -44,7 +52,7 @@ module Dry
       def initialize(messages, **options)
         super
         @options = options
-        @default_lookup_options = options[:locale] ? { locale: locale } : EMPTY_HASH
+        @default_lookup_options = options[:locale] ? {locale: locale} : EMPTY_HASH
       end
 
       # @api private
@@ -100,17 +108,29 @@ module Dry
         end
       end
 
+      # @api private
+      def visit_unexpected_key(node, _opts)
+        path, input = node
+
+        msg = messages.translate("errors.unexpected_key")
+
+        Message.new(
+          path: path,
+          text: msg[:text],
+          predicate: nil,
+          input: input
+        )
+      end
+
       # @api private
       def visit_or(node, opts)
         left, right = node.map { |n| visit(n, opts) }
+        Message::Or[left, right, or_translator]
+      end
 
-        if [left, right].flatten.map(&:path).uniq.size == 1
-          Message::Or.new(left, right, proc { |k| messages.translate(k, **default_lookup_options) })
-        elsif right.is_a?(Array)
-          right
-        else
-          [left, right].flatten.max
-        end
+      # @api private
+      def or_translator
+        @or_translator ||= proc { |k| messages.translate(k, **default_lookup_options) }
       end
 
       # @api private
@@ -130,13 +150,21 @@ module Dry
           path: path.last, **tokens, **lookup_options(arg_vals: arg_vals, input: input)
         ).to_h
 
-        template, meta = messages[predicate, options] ||
-          raise(MissingMessageError.new(path, messages.looked_up_paths(predicate, options)))
+        template, meta = messages[predicate, options]
+
+        unless template
+          raise MissingMessageError.new(path, messages.looked_up_paths(predicate, options))
+        end
 
         text = message_text(template, tokens, options)
 
         message_type(options).new(
-          text: text, path: path, predicate: predicate, args: arg_vals, input: input, meta: meta
+          text: text,
+          meta: meta,
+          path: path,
+          predicate: predicate,
+          args: arg_vals,
+          input: input
         )
       end
 
@@ -180,15 +208,15 @@ module Dry
       def message_text(template, tokens, options)
         text = template[template.data(tokens)]
 
-        return text unless full
+        return text if !text || !full
 
         rule = options[:path]
-        "#{messages.rule(rule, options) || rule} #{text}"
+        [messages.rule(rule, options) || rule, text].join(FULL_MESSAGE_WHITESPACE[template.options[:locale]])
       end
 
       # @api private
       def message_tokens(args)
-        args.each_with_object({}) do |arg, hash|
+        tokens = args.each_with_object({}) do |arg, hash|
           case arg[1]
           when Array
             hash[arg[0]] = arg[1].join(LIST_SEPARATOR)
@@ -199,6 +227,14 @@ module Dry
             hash[arg[0]] = arg[1]
           end
         end
+        args.any? { |e| e.first == :size } ? append_mapped_size_tokens(tokens) : tokens
+      end
+
+      # @api private
+      def append_mapped_size_tokens(tokens)
+        # this is a temporary fix for the inconsistency in the "size" errors arguments
+        mapped_hash = tokens.each_with_object({}) { |(k, v), h| h[k.to_s.gsub("size", "num").to_sym] = v }
+        tokens.merge(mapped_hash)
       end
     end
   end

data/lib/dry/schema/message_compiler/visitor_opts.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/schema/constants'
-require 'dry/schema/message'
+require "dry/schema/constants"
+require "dry/schema/message"
 
 module Dry
   module Schema

data/lib/dry/schema/message_set.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
+require "dry/equalizer"
 
 module Dry
   module Schema
@@ -17,13 +17,7 @@ module Dry
       #
       # @return [Array<Message>]
       attr_reader :messages
-      
-      # An internal hash that is filled in with dumped messages
-      # when a message set is coerced to a hash
-      #
-      # @return [Hash<Symbol=>[Array,Hash]>]
-      attr_reader :placeholders
-      
+
       # Options hash
       #
       # @return [Hash]
@@ -38,7 +32,6 @@ module Dry
       def initialize(messages, options = EMPTY_HASH)
         @messages = messages
         @options = options
-        initialize_placeholders!
       end
 
       # Iterate over messages
@@ -112,43 +105,39 @@ module Dry
 
       # @api private
       def messages_map(messages = self.messages)
-        return EMPTY_HASH if empty?
-
-        messages.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
-          node = path.reduce(hash) { |a, e| a[e] }
+        combine_message_hashes(messages.map(&:to_h))
+      end
 
-          msgs.each do |msg|
-            node << msg
+      # @api private
+      def combine_message_hashes(hashes)
+        hashes.reduce(EMPTY_HASH.dup) do |a, e|
+          a.merge(e) do |_, *values|
+            combine_message_values(values)
           end
-
-          node.map!(&:dump)
-
-          hash
         end
       end
 
       # @api private
-      def paths
-        @paths ||= messages.map(&:path).uniq
+      def combine_message_values(values)
+        hashes, other = partition_message_values(values)
+        combined = combine_message_hashes(hashes)
+        flattened = other.flatten
+
+        if flattened.empty?
+          combined
+        elsif combined.empty?
+          flattened
+        else
+          [flattened, combined]
+        end
       end
 
       # @api private
-      def initialize_placeholders!
-        return @placeholders = EMPTY_HASH if empty?
-
-        @placeholders = paths.reduce(EMPTY_HASH.dup) do |hash, path|
-          curr_idx = 0
-          last_idx = path.size - 1
-          node = hash
-
-          while curr_idx <= last_idx
-            key = path[curr_idx]
-            node = (node[key] || node[key] = curr_idx < last_idx ? {} : [])
-            curr_idx += 1
-          end
-
-          hash
-        end
+      def partition_message_values(values)
+        values
+          .map { |value| value.is_a?(Array) ? value : [value] }
+          .reduce(EMPTY_ARRAY.dup, :+)
+          .partition { |value| value.is_a?(Hash) && !value[:text].is_a?(String) }
       end
     end
   end