dry-schema 1.4.3 → 1.5.0

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

data/lib/dry/schema/params.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/processor'
+require "dry/schema/processor"
 
 module Dry
   module Schema

data/lib/dry/schema/path.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/constants'
+require "dry/schema/constants"
 
 module Dry
   module Schema
@@ -8,6 +8,7 @@ module Dry
     #
     # @api private
     class Path
+      include Dry.Equalizer(:keys)
       include Comparable
       include Enumerable
 
@@ -23,7 +24,7 @@ module Dry
       # @return [Path]
       #
       # @api private
-      def self.[](spec)
+      def self.call(spec)
         case spec
         when Symbol, Array
           new(Array[*spec])
@@ -34,10 +35,15 @@ module Dry
         when Path
           spec
         else
-          raise ArgumentError, '+spec+ must be either a Symbol, Array, Hash or a Path'
+          raise ArgumentError, "+spec+ must be either a Symbol, Array, Hash or a Path"
         end
       end
 
+      # @api private
+      def self.[](spec)
+        call(spec)
+      end
+
       # Extract a list of keys from a hash
       #
       # @api private
@@ -52,6 +58,28 @@ module Dry
         @keys = keys
       end
 
+      # @api private
+      def to_h(value = EMPTY_ARRAY.dup)
+        curr_idx = 0
+        last_idx = keys.size - 1
+        hash = EMPTY_HASH.dup
+        node = hash
+
+        while curr_idx <= last_idx
+          node =
+            node[keys[curr_idx]] =
+              if curr_idx == last_idx
+                value.is_a?(Array) ? value : [value]
+              else
+                EMPTY_HASH.dup
+              end
+
+          curr_idx += 1
+        end
+
+        hash
+      end
+
       # @api private
       def each(&block)
         keys.each(&block)
@@ -83,8 +111,19 @@ module Dry
       end
 
       # @api private
-      def key_matches(other)
-        map { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
+      def &(other)
+        unless same_root?(other)
+          raise ArgumentError, "#{other.inspect} doesn't have the same root #{inspect}"
+        end
+
+        self.class.new(
+          key_matches(other, :select).compact.reject { |value| value.equal?(false) }
+        )
+      end
+
+      # @api private
+      def key_matches(other, meth = :map)
+        public_send(meth) { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
       end
 
       # @api private

data/lib/dry/schema/predicate.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
-require 'dry/logic/operators'
+require "dry/equalizer"
+require "dry/logic/operators"
 
 module Dry
   module Schema