dry-schema 1.4.3 → 1.5.0

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
@@ -44,7 +44,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 +100,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 +142,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,7 +200,7 @@ 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}"

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
@@ -18,12 +18,6 @@ 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

data/lib/dry/schema/messages.rb

@@ -7,8 +7,8 @@ module Dry
     # @api private
     module Messages
       BACKENDS = {
-        i18n: 'I18n',
-        yaml: 'YAML'
+        i18n: "I18n",
+        yaml: "YAML"
       }.freeze
 
       module_function
@@ -31,7 +31,7 @@ module Dry
   end
 end
 
-require 'dry/schema/messages/abstract'
-require 'dry/schema/messages/namespaced'
-require 'dry/schema/messages/yaml'
-require 'dry/schema/messages/i18n' if defined?(I18n)
+require "dry/schema/messages/abstract"
+require "dry/schema/messages/namespaced"
+require "dry/schema/messages/yaml"
+require "dry/schema/messages/i18n" if defined?(I18n)

data/lib/dry/schema/messages/abstract.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'set'
-require 'concurrent/map'
-require 'dry/equalizer'
-require 'dry/configurable'
+require "set"
+require "concurrent/map"
+require "dry/equalizer"
+require "dry/configurable"
 
-require 'dry/schema/constants'
-require 'dry/schema/messages/template'
+require "dry/schema/constants"
+require "dry/schema/messages/template"
 
 module Dry
   module Schema
@@ -21,36 +21,31 @@ module Dry
         setting :default_locale, nil
         setting :load_paths, Set[DEFAULT_MESSAGES_PATH]
         setting :top_namespace, DEFAULT_MESSAGES_ROOT
-        setting :root, 'errors'
+        setting :root, "errors"
         setting :lookup_options, %i[root predicate path val_type arg_type].freeze
 
         setting :lookup_paths, [
-          '%<root>s.rules.%<path>s.%<predicate>s.arg.%<arg_type>s',
-          '%<root>s.rules.%<path>s.%<predicate>s',
-          '%<root>s.%<predicate>s.%<message_type>s',
-          '%<root>s.%<predicate>s.value.%<path>s',
-          '%<root>s.%<predicate>s.value.%<val_type>s.arg.%<arg_type>s',
-          '%<root>s.%<predicate>s.value.%<val_type>s',
-          '%<root>s.%<predicate>s.arg.%<arg_type>s',
-          '%<root>s.%<predicate>s'
+          "%<root>s.rules.%<path>s.%<predicate>s.arg.%<arg_type>s",
+          "%<root>s.rules.%<path>s.%<predicate>s",
+          "%<root>s.%<predicate>s.%<message_type>s",
+          "%<root>s.%<predicate>s.value.%<path>s",
+          "%<root>s.%<predicate>s.value.%<val_type>s.arg.%<arg_type>s",
+          "%<root>s.%<predicate>s.value.%<val_type>s",
+          "%<root>s.%<predicate>s.arg.%<arg_type>s",
+          "%<root>s.%<predicate>s"
         ].freeze
 
-        setting :rule_lookup_paths, ['rules.%<name>s'].freeze
+        setting :rule_lookup_paths, ["rules.%<name>s"].freeze
 
-        setting :arg_types, Hash.new { |*| 'default' }.update(
-          Range => 'range'
+        setting :arg_types, Hash.new { |*| "default" }.update(
+          Range => "range"
         )
 
-        setting :val_types, Hash.new { |*| 'default' }.update(
-          Range => 'range',
-          String => 'string'
+        setting :val_types, Hash.new { |*| "default" }.update(
+          Range => "range",
+          String => "string"
         )
 
-        # @api private
-        def self.cache
-          @cache ||= Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
-        end
-
         # @api private
         def self.build(options = EMPTY_HASH)
           messages = new
@@ -79,7 +74,7 @@ module Dry
 
         # @api private
         def rule(name, options = {})
-          tokens = { name: name, locale: options.fetch(:locale, default_locale) }
+          tokens = {name: name, locale: options.fetch(:locale, default_locale)}
           path = rule_lookup_paths(tokens).detect { |key| key?(key, options) }
 
           rule = get(path, options) if path
@@ -92,13 +87,35 @@ module Dry
         #
         # @api public
         def call(predicate, options)
-          cache.fetch_or_store(cache_key(predicate, options)) do
-            text, meta = lookup(predicate, options)
-            [Template[text], meta] if text
-          end
+          options = {locale: default_locale, **options}
+          opts = options.reject { |k,| config.lookup_options.include?(k) }
+          path = lookup_paths(predicate, options).detect { |key| key?(key, opts) }
+
+          return unless path
+
+          result = get(path, opts)
+
+          [
+            Template.new(
+              messages: self,
+              key: path,
+              options: opts
+            ),
+            result[:meta]
+          ]
         end
+
         alias_method :[], :call
 
+        # Check if given key is defined
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def key?(_key, _options = EMPTY_HASH)
+          raise NotImplementedError
+        end
+
         # Retrieve an array of looked up paths
         #
         # @param [Symbol] predicate
@@ -112,21 +129,6 @@ module Dry
           filled_lookup_paths(tokens)
         end
 
-        # Try to find a message for the given predicate and its options
-        #
-        # @api private
-        #
-        # rubocop:disable Metrics/AbcSize
-        def lookup(predicate, options)
-          opts = options.reject { |k, _| config.lookup_options.include?(k) }
-          path = lookup_paths(predicate, options).detect { |key| key?(key, opts) }
-
-          return unless path
-
-          get(path, opts).values_at(:text, :meta)
-        end
-        # rubocop:enable Metrics/AbcSize
-
         # @api private
         def lookup_paths(predicate, options)
           tokens = lookup_tokens(predicate, options)
@@ -162,22 +164,18 @@ module Dry
         end
 
         # @api private
-        def cache
-          @cache ||= self.class.cache[self]
+        def default_locale
+          config.default_locale
         end
 
         # @api private
-        def default_locale
-          config.default_locale
+        def interpolatable_data(_key, _options, **_data)
+          raise NotImplementedError
         end
 
         # @api private
-        def cache_key(predicate, options)
-          if options.key?(:input)
-            [predicate, options.reject { |k,| k.equal?(:input) }]
-          else
-            [predicate, options]
-          end
+        def interpolate(_key, _options, **_data)
+          raise NotImplementedError
         end
 
         private