dry-schema 0.3.0 → 0.4.0

data/lib/dry/schema/message_compiler/visitor_opts.rb

@@ -15,7 +15,6 @@ module Dry
         def self.new
           opts = super
           opts[:path] = EMPTY_ARRAY
-          opts[:rule] = nil
           opts[:message_type] = :failure
           opts[:current_messages] = EMPTY_ARRAY.dup
           opts

data/lib/dry/schema/message_set.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'dry/equalizer'
+
 module Dry
   module Schema
     # A set of messages used to generate errors
@@ -9,6 +11,7 @@ module Dry
     # @api public
     class MessageSet
       include Enumerable
+      include Dry::Equalizer(:messages, :options)
 
       attr_reader :messages, :placeholders, :options
 
@@ -35,7 +38,16 @@ module Dry
         messages_map
       end
       alias_method :to_hash, :to_h
-      alias_method :dump, :to_h
+
+      # @api public
+      def [](key)
+        to_h[key]
+      end
+
+      # @api public
+      def fetch(key)
+        self[key] || raise(KeyError, "+#{key}+ message was not found")
+      end
 
       # @api private
       def empty?

data/lib/dry/schema/messages.rb

@@ -6,35 +6,26 @@ module Dry
     #
     # @api private
     module Messages
-      def self.setup(config)
-        messages = build(config)
-
-        if config.messages_file && config.namespace
-          messages.merge(config.messages_file).namespaced(config.namespace)
-        elsif config.messages_file
-          messages.merge(config.messages_file)
-        elsif config.namespace
-          messages.namespaced(config.namespace)
-        else
-          messages
-        end
-      end
+      BACKENDS = {
+        i18n: 'I18n',
+        yaml: 'YAML'
+      }.freeze
+
+      module_function
 
-      # @api private
-      def self.build(config)
-        klass = case config.messages
-        when :yaml then default
-        when :i18n then Messages::I18n
-        else
-          raise "+#{config.messages}+ is not a valid messages identifier"
+      public def setup(config)
+        backend_class = BACKENDS.fetch(config.backend) do
+          raise "+#{config.backend}+ is not a valid messages identifier"
         end
 
-        klass.build
-      end
+        namespace = config.namespace
+        options = config.to_h.select { |k, _| Abstract.settings.include?(k) }
+
+        messages = Messages.const_get(backend_class).build(options)
+
+        return messages.namespaced(namespace) if namespace
 
-      # @api private
-      def self.default
-        Messages::YAML
+        messages
       end
     end
   end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'pathname'
+require 'set'
 require 'concurrent/map'
 require 'dry/equalizer'
 require 'dry/configurable'
@@ -15,39 +15,33 @@ module Dry
       #
       # @api public
       class Abstract
-        extend Dry::Configurable
+        include Dry::Configurable
         include Dry::Equalizer(:config)
 
-        DEFAULT_PATH = Pathname(__dir__).join('../../../../config/errors.yml').realpath.freeze
-
-        setting :paths, [DEFAULT_PATH]
+        setting :load_paths, Set[DEFAULT_MESSAGES_PATH]
+        setting :top_namespace, DEFAULT_MESSAGES_ROOT
         setting :root, 'errors'
-        setting :lookup_options, [:root, :predicate, :path, :val_type, :arg_type].freeze
-
-        setting :lookup_paths, %w(
-          %{root}.rules.%{path}.%{predicate}.arg.%{arg_type}
-          %{root}.rules.%{path}.%{predicate}
-          %{root}.%{predicate}.%{message_type}
-          %{root}.%{predicate}.value.%{path}.arg.%{arg_type}
-          %{root}.%{predicate}.value.%{path}
-          %{root}.%{predicate}.value.%{val_type}.arg.%{arg_type}
-          %{root}.%{predicate}.value.%{val_type}
-          %{root}.%{predicate}.arg.%{arg_type}
-          %{root}.%{predicate}
-        ).freeze
-
-        setting :rule_lookup_paths, %w(
-          rules.%{name}
-        ).freeze
-
-        setting :arg_type_default, 'default'
-        setting :val_type_default, 'default'
-
-        setting :arg_types, Hash.new { |*| config.arg_type_default }.update(
+        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.arg.%<arg_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 :arg_types, Hash.new { |*| 'default' }.update(
           Range => 'range'
         )
 
-        setting :val_types, Hash.new { |*| config.val_type_default }.update(
+        setting :val_types, Hash.new { |*| 'default' }.update(
           Range => 'range',
           String => 'string'
         )
@@ -58,11 +52,24 @@ module Dry
         end
 
         # @api private
-        attr_reader :config
+        def self.build(options = EMPTY_HASH)
+          messages = new
 
-        # @api private
-        def initialize
-          @config = self.class.config
+          messages.configure do |config|
+            options.each do |key, value|
+              config.public_send(:"#{key}=", value)
+            end
+
+            config.root = "#{config.top_namespace}.#{config.root}"
+
+            config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
+              "#{config.top_namespace}.#{path}"
+            }
+
+            yield(config) if block_given?
+          end
+
+          messages.prepare
         end
 
         # @api private
@@ -70,6 +77,11 @@ module Dry
           @hash ||= config.hash
         end
 
+        # @api private
+        def translate(key, locale: default_locale)
+          t["#{config.top_namespace}.#{key}", locale: locale]
+        end
+
         # @api private
         def rule(name, options = {})
           tokens = { name: name, locale: options.fetch(:locale, default_locale) }
@@ -103,9 +115,7 @@ module Dry
             message_type: options[:message_type] || :failure
           )
 
-          tokens[:path] = options[:rule] || Array(options[:path]).last
-
-          opts = options.select { |k, _| !config.lookup_options.include?(k) }
+          opts = options.reject { |k, _| config.lookup_options.include?(k) }
 
           path = lookup_paths(tokens).detect do |key|
             key?(key, opts) && get(key, opts).is_a?(String)
@@ -130,7 +140,7 @@ module Dry
         #
         # @api public
         def namespaced(namespace)
-         Dry::Schema::Messages::Namespaced.new(namespace, self)
+          Dry::Schema::Messages::Namespaced.new(namespace, self)
         end
 
         # Return root path to messages file
@@ -151,6 +161,13 @@ module Dry
         def default_locale
           :en
         end
+
+        private
+
+        # @api private
+        def custom_top_namespace?(path)
+          path.to_s == DEFAULT_MESSAGES_PATH.to_s && config.top_namespace != DEFAULT_MESSAGES_ROOT
+        end
       end
     end
   end

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

@@ -11,22 +11,6 @@ module Dry
     class Messages::I18n < Messages::Abstract
       attr_reader :t
 
-      configure do |config|
-        config.root = 'dry_schema.errors'
-        config.rule_lookup_paths = config.rule_lookup_paths.map { |path| "dry_schema.#{path}" }
-      end
-
-      # @api private
-      def self.build(paths = config.paths)
-        set_load_paths(paths)
-        new
-      end
-
-      # @api private
-      def self.set_load_paths(paths)
-        ::I18n.load_path.concat(paths)
-      end
-
       # @api private
       def initialize
         super
@@ -41,7 +25,7 @@ module Dry
       # @return [String]
       #
       # @api public
-      def get(key, options = {})
+      def get(key, options = EMPTY_HASH)
         t.(key, options) if key
       end
 
@@ -51,26 +35,59 @@ module Dry
       #
       # @api public
       def key?(key, options)
-        ::I18n.exists?(key, options.fetch(:locale, default_locale)) ||
-          ::I18n.exists?(key, I18n.default_locale)
+        I18n.exists?(key, options.fetch(:locale, default_locale)) ||
+          I18n.exists?(key, I18n.default_locale)
       end
 
       # Merge messages from an additional path
       #
-      # @param [String] path
+      # @param [String, Array<String>] paths
       #
       # @return [Messages::I18n]
       #
       # @api public
-      def merge(path)
-        ::I18n.load_path << path
-        self
+      def merge(paths)
+        prepare(paths)
       end
 
       # @api private
       def default_locale
         I18n.locale || I18n.default_locale || super
       end
+
+      # @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
+
+            mapped_data = data
+              .map { |k, v| [k, { top_namespace => v[DEFAULT_MESSAGES_ROOT] }] }
+              .to_h
+
+            store_translations(mapped_data)
+          else
+            store_translations(data)
+          end
+        end
+
+        self
+      end
+
+      private
+
+      # @api private
+      def store_translations(data)
+        locales = data.keys.map(&:to_sym)
+
+        I18n.available_locales += locales
+
+        locales.each do |locale|
+          I18n.backend.store_translations(locale, data[locale.to_s])
+        end
+      end
     end
   end
 end

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

@@ -6,7 +6,7 @@ module Dry
       # Namespaced messages backend
       #
       # @api public
-      class Namespaced <Dry::Schema::Messages::Abstract
+      class Namespaced < Dry::Schema::Messages::Abstract
         # @api private
         attr_reader :namespace
 
@@ -14,17 +14,16 @@ module Dry
         attr_reader :messages
 
         # @api private
-        attr_reader :root
+        attr_reader :config
 
         # @api private
         attr_reader :call_opts
 
         # @api private
         def initialize(namespace, messages)
-          super()
+          @config = messages.config
           @namespace = namespace
           @messages = messages
-          @root = messages.root
           @call_opts = { namespace: namespace }.freeze
         end
 

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

@@ -4,6 +4,7 @@ require 'yaml'
 require 'pathname'
 
 require 'dry/equalizer'
+require 'dry/schema/constants'
 require 'dry/schema/messages/abstract'
 
 module Dry
@@ -12,39 +13,37 @@ module Dry
     #
     # @api public
     class Messages::YAML < Messages::Abstract
+      LOCALE_TOKEN = '%<locale>s'
+
       include Dry::Equalizer(:data)
 
-      attr_reader :data
+      attr_reader :data, :t
 
       # @api private
-      configure do |config|
-        config.root = '%{locale}.dry_schema.errors'
-        config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
-          "%{locale}.dry_schema.#{path}"
-        }
-      end
+      def self.build(options = EMPTY_HASH)
+        super do |config|
+          config.root = "%<locale>s.#{config.root}"
 
-      # @api private
-      def self.build(paths = config.paths)
-        new(paths.map { |path| load_file(path) }.reduce(:merge))
+          config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
+            "%<locale>s.#{path}"
+          }
+        end
       end
 
       # @api private
-      def self.load_file(path)
-        flat_hash(YAML.load_file(path))
-      end
+      def self.flat_hash(hash, acc = [], result = {})
+        return result.update(acc.join(DOT) => hash) unless hash.is_a?(Hash)
 
-      # @api private
-      def self.flat_hash(h, f = [], g = {})
-        return g.update(f.join('.') => h) unless h.is_a? Hash
-        h.each { |k, r| flat_hash(r, f + [k], g) }
-        g
+        hash.each { |k, v| flat_hash(v, acc + [k], result) }
+        result
       end
 
       # @api private
-      def initialize(data)
+      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
 
       # Get a message for the given key and its options
@@ -55,12 +54,8 @@ module Dry
       # @return [String]
       #
       # @api public
-      def get(key, options = {})
-        evaluated_key = key.include?('%{locale}') ?
-          key % { locale: options.fetch(:locale, default_locale) } :
-          key
-
-        data[evaluated_key]
+      def get(key, options = EMPTY_HASH)
+        data[evaluated_key(key, options)]
       end
 
       # Check if given key is defined
@@ -68,12 +63,8 @@ module Dry
       # @return [Boolean]
       #
       # @api public
-      def key?(key, options = {})
-        evaluated_key = key.include?('%{locale}') ?
-          key % { locale: options.fetch(:locale, default_locale) } :
-          key
-
-        data.key?(evaluated_key)
+      def key?(key, options = EMPTY_HASH)
+        data.key?(evaluated_key(key, options))
       end
 
       # Merge messages from an additional path
@@ -85,11 +76,41 @@ module Dry
       # @api public
       def merge(overrides)
         if overrides.is_a?(Hash)
-          self.class.new(data.merge(self.class.flat_hash(overrides)))
+          self.class.new(
+            data: data.merge(self.class.flat_hash(overrides)),
+            config: config
+          )
         else
-          self.class.new(data.merge(Messages::YAML.load_file(overrides)))
+          self.class.new(
+            data: Array(overrides).reduce(data) { |a, e| a.merge(load_translations(e)) },
+            config: config
+          )
         end
       end
+
+      # @api private
+      def prepare
+        @data = config.load_paths.map { |path| load_translations(path) }.reduce(:merge)
+        self
+      end
+
+      private
+
+      # @api private
+      def load_translations(path)
+        data = self.class.flat_hash(YAML.load_file(path))
+
+        return data unless custom_top_namespace?(path)
+
+        data.map { |k, v| [k.gsub(DEFAULT_MESSAGES_ROOT, config.top_namespace), v] }.to_h
+      end
+
+      # @api private
+      def evaluated_key(key, options)
+        return key unless key.include?(LOCALE_TOKEN)
+
+        key % { locale: options[:locale] || default_locale }
+      end
     end
   end
 end