dry-schema 1.6.2 → 1.9.0

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

@@ -5,125 +5,127 @@ require "dry/schema/messages/abstract"
 
 module Dry
   module Schema
-    # I18n message backend
-    #
-    # @api public
-    class Messages::I18n < Messages::Abstract
-      # Translation function
-      #
-      # @return [Method]
-      attr_reader :t
-
-      # @api private
-      def initialize
-        super
-        @t = I18n.method(:t)
-      end
-
-      # Get a message for the given key and its options
-      #
-      # @param [Symbol] key
-      # @param [Hash] options
-      #
-      # @return [String]
+    module Messages
+      # I18n message backend
       #
       # @api public
-      def get(key, options = EMPTY_HASH)
-        return unless key
+      class I18n < Abstract
+        # Translation function
+        #
+        # @return [Method]
+        attr_reader :t
+
+        # @api private
+        def initialize
+          super
+          @t = ::I18n.method(:t)
+        end
 
-        result = t.(key, locale: options.fetch(:locale, default_locale))
+        # Get a message for the given key and its options
+        #
+        # @param [Symbol] key
+        # @param [Hash] options
+        #
+        # @return [String]
+        #
+        # @api public
+        def get(key, options = EMPTY_HASH)
+          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
 
-        if result.is_a?(Hash)
-          text = result[:text]
-          meta = result.dup.tap { |h| h.delete(:text) }
-        else
-          text = result
-          meta = EMPTY_HASH.dup
+          {
+            text: text,
+            meta: meta
+          }
         end
 
-        {
-          text: text,
-          meta: meta
-        }
-      end
-
-      # Check if given key is defined
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def key?(key, options)
-        I18n.exists?(key, options.fetch(:locale, default_locale)) ||
-          I18n.exists?(key, I18n.default_locale)
-      end
+        # Check if given key is defined
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def key?(key, options)
+          ::I18n.exists?(key, options.fetch(:locale, default_locale)) ||
+            ::I18n.exists?(key, ::I18n.default_locale)
+        end
 
-      # Merge messages from an additional path
-      #
-      # @param [String, Array<String>] paths
-      #
-      # @return [Messages::I18n]
-      #
-      # @api public
-      def merge(paths)
-        prepare(paths)
-      end
+        # Merge messages from an additional path
+        #
+        # @param [String, Array<String>] paths
+        #
+        # @return [Messages::I18n]
+        #
+        # @api public
+        def merge(paths)
+          prepare(paths)
+        end
 
-      # @api private
-      def default_locale
-        super || I18n.locale || I18n.default_locale
-      end
+        # @api private
+        def default_locale
+          super || ::I18n.locale || ::I18n.default_locale
+        end
 
-      # @api private
-      def prepare(paths = config.load_paths)
-        paths.each do |path|
-          data = YAML.load_file(path)
+        # @api private
+        def prepare(paths = config.load_paths)
+          paths.each do |path|
+            data = ::YAML.load_file(path)
 
-          if custom_top_namespace?(path)
-            top_namespace = config.top_namespace
+            if custom_top_namespace?(path)
+              top_namespace = config.top_namespace
 
-            mapped_data = data
-              .map { |k, v| [k, {top_namespace => v[DEFAULT_MESSAGES_ROOT]}] }
-              .to_h
+              mapped_data = data.transform_values { |v|
+                {top_namespace => v[DEFAULT_MESSAGES_ROOT]}
+              }
 
-            store_translations(mapped_data)
-          else
-            store_translations(data)
+              store_translations(mapped_data)
+            else
+              store_translations(data)
+            end
           end
-        end
 
-        self
-      end
+          self
+        end
 
-      # @api private
-      def interpolatable_data(_key, _options, **data)
-        data
-      end
+        # @api private
+        def interpolatable_data(_key, _options, **data)
+          data
+        end
 
-      # @api private
-      def interpolate(key, options, **data)
-        text_key = "#{key}.text"
+        # @api private
+        def interpolate(key, options, **data)
+          text_key = "#{key}.text"
 
-        opts = {
-          locale: default_locale,
-          **options,
-          **data
-        }
+          opts = {
+            locale: default_locale,
+            **options,
+            **data
+          }
 
-        resolved_key = key?(text_key, opts) ? text_key : key
+          resolved_key = key?(text_key, opts) ? text_key : key
 
-        t.(resolved_key, **opts)
-      end
+          t.(resolved_key, **opts)
+        end
 
-      private
+        private
 
-      # @api private
-      def store_translations(data)
-        locales = data.keys.map(&:to_sym)
+        # @api private
+        def store_translations(data)
+          locales = data.keys.map(&:to_sym)
 
-        I18n.available_locales |= locales
+          ::I18n.available_locales |= locales
 
-        locales.each do |locale|
-          I18n.backend.store_translations(locale, data[locale.to_s])
+          locales.each do |locale|
+            ::I18n.backend.store_translations(locale, data[locale.to_s])
+          end
         end
       end
     end

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

@@ -21,6 +21,7 @@ module Dry
 
         # @api private
         def initialize(namespace, messages)
+          super()
           @config = messages.config
           @namespace = namespace
           @messages = messages

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

@@ -9,188 +9,202 @@ require "dry/schema/messages/abstract"
 
 module Dry
   module Schema
-    # Plain YAML message backend
-    #
-    # @api public
-    class Messages::YAML < Messages::Abstract
-      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)
-
-      # Loaded localized message templates
+    module Messages
+      # Plain YAML message backend
       #
-      # @return [Hash]
-      attr_reader :data
+      # @api public
+      class YAML < Abstract
+        LOCALE_TOKEN = "%<locale>s"
+        TOKEN_REGEXP = /%{(\w*)}/.freeze
+        EMPTY_CONTEXT = Object.new.tap { |ctx|
+          def ctx.context
+            binding
+          end
+        }.freeze.context
 
-      # Translation function
-      #
-      # @return [Proc]
-      attr_reader :t
+        include ::Dry::Equalizer(:data)
 
-      # @api private
-      def self.build(options = EMPTY_HASH)
-        super do |config|
-          config.default_locale = :en unless config.default_locale
+        # Loaded localized message templates
+        #
+        # @return [Hash]
+        attr_reader :data
 
-          config.root = "%<locale>s.#{config.root}"
+        # Translation function
+        #
+        # @return [Proc]
+        attr_reader :t
 
-          config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
-            "%<locale>s.#{path}"
-          }
-        end
-      end
+        # @api private
+        def self.build(options = EMPTY_HASH)
+          super do |config|
+            config.default_locale = :en unless config.default_locale
 
-      # @api private
-      def self.flat_hash(hash, path = [], keys = {})
-        hash.each do |key, value|
-          flat_hash(value, [*path, key], keys) if value.is_a?(Hash)
+            config.root = "%<locale>s.#{config.root}"
 
-          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)
-            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
+            config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
+              "%<locale>s.#{path}"
             }
           end
         end
-        keys
-      end
 
-      # @api private
-      def self.cache
-        @cache ||= Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
-      end
+        # @api private
+        # rubocop: disable Metrics/PerceivedComplexity
+        def self.flat_hash(hash, path = EMPTY_ARRAY, keys = {})
+          hash.each do |key, value|
+            flat_hash(value, [*path, key], keys) if value.is_a?(Hash)
+
+            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)
+              keys[[*path, key].join(DOT)] = {
+                text: value["text"],
+                meta: value.reject { _1.eql?("text") }.transform_keys(&:to_sym)
+              }
+            end
+          end
 
-      # @api private
-      def initialize(data: EMPTY_HASH, config: nil)
-        super()
-        @data = data
-        @config = config if config
-        @t = proc { |key, locale: default_locale| get("%<locale>s.#{key}", locale: locale) }
-      end
+          keys
+        end
+        # rubocop: enable Metrics/PerceivedComplexity
 
-      # Get an array of looked up paths
-      #
-      # @param [Symbol] predicate
-      # @param [Hash] options
-      #
-      # @return [String]
-      #
-      # @api public
-      def looked_up_paths(predicate, options)
-        super.map { |path| path % {locale: options[:locale] || default_locale} }
-      end
+        # @api private
+        def self.cache
+          @cache ||= Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
+        end
 
-      # Get a message for the given key and its options
-      #
-      # @param [Symbol] key
-      # @param [Hash] options
-      #
-      # @return [String]
-      #
-      # @api public
-      def get(key, options = EMPTY_HASH)
-        data[evaluated_key(key, options)]
-      end
+        # @api private
+        def self.source_cache
+          @source_cache ||= Concurrent::Map.new
+        end
 
-      # Check if given key is defined
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def key?(key, options = EMPTY_HASH)
-        data.key?(evaluated_key(key, options))
-      end
+        # @api private
+        def initialize(data: EMPTY_HASH, config: nil)
+          super()
+          @data = data
+          @config = config if config
+          @t = proc { |key, locale: default_locale| get("%<locale>s.#{key}", locale: locale) }
+        end
 
-      # Merge messages from an additional path
-      #
-      # @param [String] overrides
-      #
-      # @return [Messages::I18n]
-      #
-      # @api public
-      def merge(overrides)
-        if overrides.is_a?(Hash)
-          self.class.new(
-            data: data.merge(self.class.flat_hash(overrides)),
-            config: config
-          )
-        else
-          self.class.new(
-            data: Array(overrides).reduce(data) { |a, e| a.merge(load_translations(e)) },
-            config: config
-          )
+        # Get an array of looked up paths
+        #
+        # @param [Symbol] predicate
+        # @param [Hash] options
+        #
+        # @return [String]
+        #
+        # @api public
+        def looked_up_paths(predicate, options)
+          super.map { |path| path % {locale: options[:locale] || default_locale} }
         end
-      end
 
-      # @api private
-      def prepare
-        @data = config.load_paths.map { |path| load_translations(path) }.reduce({}, :merge)
-        self
-      end
+        # Get a message for the given key and its options
+        #
+        # @param [Symbol] key
+        # @param [Hash] options
+        #
+        # @return [String]
+        #
+        # @api public
+        def get(key, options = EMPTY_HASH)
+          data[evaluated_key(key, options)]
+        end
 
-      # @api private
-      def interpolatable_data(key, options, **data)
-        tokens = evaluation_context(key, options).fetch(:tokens)
-        data.select { |k,| tokens.include?(k) }
-      end
+        # Check if given key is defined
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def key?(key, options = EMPTY_HASH)
+          data.key?(evaluated_key(key, options))
+        end
 
-      # @api private
-      def interpolate(key, options, **data)
-        evaluator = evaluation_context(key, options).fetch(:evaluator)
-        data.empty? ? evaluator.() : evaluator.(**data)
-      end
+        # Merge messages from an additional path
+        #
+        # @param [String] overrides
+        #
+        # @return [Messages::I18n]
+        #
+        # @api public
+        def merge(overrides)
+          if overrides.is_a?(Hash)
+            self.class.new(
+              data: data.merge(self.class.flat_hash(overrides)),
+              config: config
+            )
+          else
+            self.class.new(
+              data: Array(overrides).reduce(data) { |a, e| a.merge(load_translations(e)) },
+              config: config
+            )
+          end
+        end
 
-      private
+        # @api private
+        def prepare
+          @data = config.load_paths.map { |path| load_translations(path) }.reduce({}, :merge)
+          self
+        end
 
-      # @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("%", "#")
+        # @api private
+        def interpolatable_data(key, options, **data)
+          tokens = evaluation_context(key, options).fetch(:tokens)
+          data.select { |k,| tokens.include?(k) }
+        end
 
-          # rubocop:disable Security/Eval
-          evaluator = eval(<<~RUBY, EMPTY_CONTEXT, __FILE__, __LINE__ + 1)
-            -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
-          RUBY
-          # rubocop:enable Security/Eval
+        # @api private
+        def interpolate(key, options, **data)
+          evaluator = evaluation_context(key, options).fetch(:evaluator)
+          data.empty? ? evaluator.() : evaluator.(**data)
+        end
 
-          {
-            tokens: tokens,
-            evaluator: evaluator
-          }
+        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
+            # rubocop:disable Style/DocumentDynamicEvalDefinition
+            evaluator = eval(<<~RUBY, EMPTY_CONTEXT, __FILE__, __LINE__ + 1)
+              -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
+            RUBY
+            # rubocop:enable Style/DocumentDynamicEvalDefinition
+            # rubocop:enable Security/Eval
+
+            {
+              tokens: tokens,
+              evaluator: evaluator
+            }
+          end
         end
-      end
 
-      # @api private
-      def cache
-        @cache ||= self.class.cache[self]
-      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))
+        # @api private
+        def load_translations(path)
+          data = self.class.source_cache.fetch_or_store(path) do
+            self.class.flat_hash(::YAML.load_file(path)).freeze
+          end
 
-        return data unless custom_top_namespace?(path)
+          return data unless custom_top_namespace?(path)
 
-        data.map { |k, v| [k.gsub(DEFAULT_MESSAGES_ROOT, config.top_namespace), v] }.to_h
-      end
+          data.transform_keys { _1.gsub(DEFAULT_MESSAGES_ROOT, config.top_namespace) }
+        end
 
-      # @api private
-      def evaluated_key(key, options)
-        return key unless key.include?(LOCALE_TOKEN)
+        # @api private
+        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
   end