dry-schema 1.4.1 → 1.5.2

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

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,27 +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
-
-          text = get(path, opts)
-
-          if text.is_a?(Hash)
-            text.values_at(:text, :meta)
-          else
-            [text, EMPTY_HASH]
-          end
-        end
-        # rubocop:enable Metrics/AbcSize
-
         # @api private
         def lookup_paths(predicate, options)
           tokens = lookup_tokens(predicate, options)
@@ -168,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

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'i18n'
-require 'dry/schema/messages/abstract'
+require "i18n"
+require "dry/schema/messages/abstract"
 
 module Dry
   module Schema
@@ -29,7 +29,22 @@ module Dry
       #
       # @api public
       def get(key, options = EMPTY_HASH)
-        t.(key, locale: options.fetch(:locale, default_locale)) if key
+        return unless key
+
+        result = t.(key, locale: options.fetch(:locale, default_locale))
+
+        if result.is_a?(Hash)
+          text = result[:text]
+          meta = result.dup.tap { |h| h.delete(:text) }
+        else
+          text = result
+          meta = EMPTY_HASH.dup
+        end
+
+        {
+          text: text,
+          meta: meta
+        }
       end
 
       # Check if given key is defined
@@ -67,7 +82,7 @@ module Dry
             top_namespace = config.top_namespace
 
             mapped_data = data
-              .map { |k, v| [k, { top_namespace => v[DEFAULT_MESSAGES_ROOT] }] }
+              .map { |k, v| [k, {top_namespace => v[DEFAULT_MESSAGES_ROOT]}] }
               .to_h
 
             store_translations(mapped_data)
@@ -80,12 +95,23 @@ module Dry
       end
 
       # @api private
-      def cache_key(predicate, options)
-        if options[:locale]
-          super
-        else
-          [*super, I18n.locale]
-        end
+      def interpolatable_data(_key, _options, **data)
+        data
+      end
+
+      # @api private
+      def interpolate(key, options, **data)
+        text_key = "#{key}.text"
+
+        opts = {
+          locale: default_locale,
+          **options,
+          **data
+        }
+
+        resolved_key = key?(text_key, opts) ? text_key : key
+
+        t.(resolved_key, **opts)
       end
 
       private

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

@@ -24,7 +24,7 @@ module Dry
           @config = messages.config
           @namespace = namespace
           @messages = messages
-          @call_opts = { namespace: namespace }.freeze
+          @call_opts = {namespace: namespace}.freeze
         end
 
         # Get a message for the given key and its options
@@ -62,13 +62,23 @@ module Dry
         # @api private
         def rule_lookup_paths(tokens)
           base_paths = messages.rule_lookup_paths(tokens)
-          base_paths.map { |key| key.gsub('dry_schema', "dry_schema.#{namespace}") } + base_paths
+          base_paths.map { |key| key.gsub("dry_schema", "dry_schema.#{namespace}") } + base_paths
         end
 
         # @api private
         def cache_key(predicate, options)
           messages.cache_key(predicate, options)
         end
+
+        # @api private
+        def interpolatable_data(key, options, **data)
+          messages.interpolatable_data(key, options, **data)
+        end
+
+        # @api private
+        def interpolate(key, options, **data)
+          messages.interpolate(key, options, **data)
+        end
       end
     end
   end

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

@@ -1,67 +1,42 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
+require "dry/initializer"
+require "dry/equalizer"
 
-require 'dry/schema/constants'
+require "dry/schema/constants"
 
 module Dry
   module Schema
     module Messages
-      # Template wraps a string with interpolation tokens and defines evaluator function
-      # dynamically
-      #
       # @api private
       class Template
-        include Dry::Equalizer(:text)
+        extend Dry::Initializer
+        include Dry::Equalizer(:messages, :key, :options)
 
-        TOKEN_REGEXP = /%{(\w*)}/
-
-        # !@attribute [r] text
-        # @return [String]
-        attr_reader :text
-
-        # !@attribute [r] tokens
-        # @return [Hash]
-        attr_reader :tokens
-
-        # !@attribute [r] evaluator
-        # @return [Proc]
-        attr_reader :evaluator
+        option :messages
+        option :key
+        option :options
 
         # @api private
-        def self.[](input)
-          new(*parse(input))
+        def data(data = EMPTY_HASH)
+          ensure_message!
+          messages.interpolatable_data(key, options, **options, **data)
         end
 
         # @api private
-        def self.parse(input)
-          tokens = input.scan(TOKEN_REGEXP).flatten(1).map(&:to_sym)
-          text = input.gsub('%', '#')
-
-          evaluator = <<-RUBY.strip
-            -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
-          RUBY
-
-          [text, tokens, eval(evaluator, binding, __FILE__, __LINE__ - 3)]
+        def call(data = EMPTY_HASH)
+          ensure_message!
+          messages.interpolate(key, options, **data)
         end
+        alias_method :[], :call
 
-        # @api private
-        def initialize(text, tokens, evaluator)
-          @text = text
-          @tokens = tokens
-          @evaluator = evaluator
-        end
+        private
 
-        # @api private
-        def data(input)
-          tokens.each_with_object({}) { |k, h| h[k] = input[k] }
-        end
+        def ensure_message!
+          return if messages.key?(key, options)
 
-        # @api private
-        def call(data = EMPTY_HASH)
-          data.empty? ? evaluator.() : evaluator.(data)
+          raise KeyError, "No message found for template, template=#{inspect}"
         end
-        alias_method :[], :call
       end
     end
   end