dry-schema 1.4.3 → 1.5.4

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

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
@@ -31,21 +31,19 @@ module Dry
       def get(key, options = EMPTY_HASH)
         return unless key
 
-        opts = { locale: options.fetch(:locale, default_locale) }
+        result = t.(key, locale: options.fetch(:locale, default_locale))
 
-        translation = t.(key, **opts)
-        text_key = "#{key}.text"
-
-        if !translation.is_a?(Hash) || !key?(text_key, opts)
-          return {
-            text: translation,
-            meta: EMPTY_HASH
-          }
+        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: t.(text_key, **opts),
-          meta: extract_meta(key, translation, opts)
+          text: text,
+          meta: meta
         }
       end
 
@@ -84,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)
@@ -97,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
@@ -117,13 +126,6 @@ module Dry
           I18n.backend.store_translations(locale, data[locale.to_s])
         end
       end
-
-      def extract_meta(parent_key, translation, options)
-        translation.keys.each_with_object({}) do |k, meta|
-          meta_key = "#{parent_key}.#{k}"
-          meta[k] = t.(meta_key, **options) if k != :text && key?(meta_key, options)
-        end
-      end
     end
   end
 end

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

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'yaml'
-require 'pathname'
+require "yaml"
+require "pathname"
 
-require 'dry/equalizer'
-require 'dry/schema/constants'
-require 'dry/schema/messages/abstract'
+require "dry/equalizer"
+require "dry/schema/constants"
+require "dry/schema/messages/abstract"
 
 module Dry
   module Schema
@@ -13,7 +13,13 @@ module Dry
     #
     # @api public
     class Messages::YAML < Messages::Abstract
-      LOCALE_TOKEN = '%<locale>s'
+      LOCALE_TOKEN = "%<locale>s"
+      TOKEN_REGEXP = /%{(\w*)}/.freeze
+      EMPTY_CONTEXT = Object.new.tap { |ctx|
+        def ctx.context
+          binding
+        end
+      }.freeze.context
 
       include Dry::Equalizer(:data)
 
@@ -45,21 +51,26 @@ module Dry
         hash.each do |key, value|
           flat_hash(value, [*path, key], keys) if value.is_a?(Hash)
 
-          if value.is_a?(String) && hash['text'] != value
+          if value.is_a?(String) && hash["text"] != value
             keys[[*path, key].join(DOT)] = {
               text: value,
               meta: EMPTY_HASH
             }
-          elsif value.is_a?(Hash) && value['text'].is_a?(String)
+          elsif value.is_a?(Hash) && value["text"].is_a?(String)
             keys[[*path, key].join(DOT)] = {
-              text: value['text'],
-              meta: value.dup.delete_if { |k| k == 'text' }.map { |k, v| [k.to_sym, v] }.to_h
+              text: value["text"],
+              meta: value.dup.delete_if { |k| k == "text" }.map { |k, v| [k.to_sym, v] }.to_h
             }
           end
         end
         keys
       end
 
+      # @api private
+      def self.cache
+        @cache ||= Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
+      end
+
       # @api private
       def initialize(data: EMPTY_HASH, config: nil)
         super()
@@ -77,7 +88,7 @@ module Dry
       #
       # @api public
       def looked_up_paths(predicate, options)
-        super.map { |path| path % { locale: options[:locale] || default_locale } }
+        super.map { |path| path % {locale: options[:locale] || default_locale} }
       end
 
       # Get a message for the given key and its options
@@ -124,12 +135,48 @@ module Dry
 
       # @api private
       def prepare
-        @data = config.load_paths.map { |path| load_translations(path) }.reduce(:merge)
+        @data = config.load_paths.map { |path| load_translations(path) }.reduce({}, :merge)
         self
       end
 
+      # @api private
+      def interpolatable_data(key, options, **data)
+        tokens = evaluation_context(key, options).fetch(:tokens)
+        data.select { |k,| tokens.include?(k) }
+      end
+
+      # @api private
+      def interpolate(key, options, **data)
+        evaluator = evaluation_context(key, options).fetch(:evaluator)
+        data.empty? ? evaluator.() : evaluator.(**data)
+      end
+
       private
 
+      # @api private
+      def evaluation_context(key, options)
+        cache.fetch_or_store(get(key, options).fetch(:text)) do |input|
+          tokens = input.scan(TOKEN_REGEXP).flatten(1).map(&:to_sym).to_set
+          text = input.gsub("%", "#")
+
+          # rubocop:disable Security/Eval
+          evaluator = eval(<<~RUBY, EMPTY_CONTEXT, __FILE__, __LINE__ + 1)
+            -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
+          RUBY
+          # rubocop:enable Security/Eval
+
+          {
+            tokens: tokens,
+            evaluator: evaluator
+          }
+        end
+      end
+
+      # @api private
+      def cache
+        @cache ||= self.class.cache[self]
+      end
+
       # @api private
       def load_translations(path)
         data = self.class.flat_hash(YAML.load_file(path))
@@ -143,7 +190,7 @@ module Dry
       def evaluated_key(key, options)
         return key unless key.include?(LOCALE_TOKEN)
 
-        key % { locale: options[:locale] || default_locale }
+        key % {locale: options[:locale] || default_locale}
       end
     end
   end