dry-schema 0.1.0 → 1.0.0

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

@@ -1,9 +1,12 @@
-require 'pathname'
+# frozen_string_literal: true
+
+require 'set'
 require 'concurrent/map'
 require 'dry/equalizer'
 require 'dry/configurable'
 
 require 'dry/schema/constants'
+require 'dry/schema/messages/template'
 
 module Dry
   module Schema
@@ -12,35 +15,32 @@ 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 :root, 'errors'.freeze
-        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 :arg_type_default, 'default'.freeze
-        setting :val_type_default, 'default'.freeze
-
-        setting :arg_types, Hash.new { |*| config.arg_type_default }.update(
+        setting :load_paths, Set[DEFAULT_MESSAGES_PATH]
+        setting :top_namespace, DEFAULT_MESSAGES_ROOT
+        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'
+        ].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'
         )
@@ -51,11 +51,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
@@ -63,21 +76,29 @@ 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 = {})
-          path = "%{locale}.rules.#{name}"
-          get(path, options) if key?(path, options)
+          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
+          rule.is_a?(Hash) ? rule[:text] : rule
         end
 
-        # Retrieve a message
+        # Retrieve a message template
         #
-        # @return [String]
+        # @return [Template]
         #
         # @api public
         def call(*args)
           cache.fetch_or_store(args.hash) do
-            path, opts = lookup(*args)
-            get(path, opts) if path
+            text, meta = lookup(*args)
+            [Template[text], meta] if text
           end
         end
         alias_method :[], :call
@@ -85,38 +106,50 @@ module Dry
         # Try to find a message for the given predicate and its options
         #
         # @api private
-        def lookup(predicate, options = {})
+        #
+        # rubocop:disable Metrics/AbcSize
+        def lookup(predicate, options)
           tokens = options.merge(
-            root: options[:not] ? "#{root}.not" : root,
             predicate: predicate,
+            root: options[:not] ? "#{root}.not" : root,
             arg_type: config.arg_types[options[:arg_type]],
             val_type: config.val_types[options[:val_type]],
             message_type: options[:message_type] || :failure
           )
 
-          tokens[:path] = options[:rule] || Array(options[:path]).join(DOT)
-
           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)
-          end
+          path = lookup_paths(tokens).detect { |key| key?(key, opts) }
+
+          return unless path
 
-          [path, opts]
+          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(tokens)
           config.lookup_paths.map { |path| path % tokens }
         end
 
+        # @api private
+        def rule_lookup_paths(tokens)
+          config.rule_lookup_paths.map { |key| key % tokens }
+        end
+
         # Return a new message backend that will look for messages under provided namespace
         #
         # @param [Symbol,String] namespace
         #
         # @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
@@ -137,6 +170,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'i18n'
 require 'dry/schema/messages/abstract'
 
@@ -7,10 +9,11 @@ module Dry
     #
     # @api public
     class Messages::I18n < Messages::Abstract
+      # Translation function
+      #
+      # @return [Method]
       attr_reader :t
 
-      ::I18n.load_path.concat(config.paths)
-
       # @api private
       def initialize
         super
@@ -25,7 +28,7 @@ module Dry
       # @return [String]
       #
       # @api public
-      def get(key, options = {})
+      def get(key, options = EMPTY_HASH)
         t.(key, options) if key
       end
 
@@ -35,26 +38,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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Dry
   module Schema
     module Messages
       # Namespaced messages backend
       #
       # @api public
-      class Namespaced <Dry::Schema::Messages::Abstract
+      class Namespaced < Dry::Schema::Messages::Abstract
         # @api private
         attr_reader :namespace
 
@@ -12,14 +14,17 @@ 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
 
         # Get a message for the given key and its options
@@ -34,6 +39,12 @@ module Dry
           messages.get(key, options)
         end
 
+        # @api public
+        def call(key, options = {})
+          super(key, options.empty? ? call_opts : options.merge(call_opts))
+        end
+        alias_method :[], :call
+
         # Check if given key is defined
         #
         # @return [Boolean]
@@ -45,7 +56,13 @@ module Dry
 
         # @api private
         def lookup_paths(tokens)
-          super(tokens.merge(root: "#{root}.rules.#{namespace}")) + super
+          super(tokens.merge(root: "#{tokens[:root]}.#{namespace}")) + super
+        end
+
+        # @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
         end
       end
     end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'dry/equalizer'
+
+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)
+
+        TOKEN_REGEXP = /%{([\w\d]*)}/
+
+        # !@attribute [r] text
+        # @return [String]
+        attr_reader :text
+
+        # !@attribute [r] tokens
+        # @return [Hash]
+        attr_reader :tokens
+
+        # !@attribute [r] evaluator
+        # @return [Proc]
+        attr_reader :evaluator
+
+        # @api private
+        def self.[](input)
+          new(*parse(input))
+        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)]
+        end
+
+        # @api private
+        def initialize(text, tokens, evaluator)
+          @text = text
+          @tokens = tokens
+          @evaluator = evaluator
+        end
+
+        # @api private
+        def data(input)
+          tokens.each_with_object({}) { |k, h| h[k] = input[k] }
+        end
+
+        # @api private
+        def call(data = EMPTY_HASH)
+          data.empty? ? evaluator.() : evaluator.(data)
+        end
+        alias_method :[], :call
+      end
+    end
+  end
+end

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

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'pathname'
 
 require 'dry/equalizer'
+require 'dry/schema/constants'
 require 'dry/schema/messages/abstract'
 
 module Dry
@@ -10,36 +13,57 @@ module Dry
     #
     # @api public
     class Messages::YAML < Messages::Abstract
+      LOCALE_TOKEN = '%<locale>s'
+
       include Dry::Equalizer(:data)
 
+      # Loaded localized message templates
+      #
+      # @return [Hash]
       attr_reader :data
 
-      # @api private
-      configure do |config|
-        config.root = '%{locale}.errors'.freeze
-      end
+      # Translation function     
+      #
+      # @return [Proc]
+      attr_reader :t
 
       # @api private
-      def self.load(paths = config.paths)
-        new(paths.map { |path| load_file(path) }.reduce(:merge))
-      end
+      def self.build(options = EMPTY_HASH)
+        super do |config|
+          config.root = "%<locale>s.#{config.root}"
 
-      # @api private
-      def self.load_file(path)
-        flat_hash(YAML.load_file(path))
+          config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
+            "%<locale>s.#{path}"
+          }
+        end
       end
 
       # @api private
-      def self.flat_hash(h, f = [], g = {})
-        return g.update(f.join('.'.freeze) => h) unless h.is_a? Hash
-        h.each { |k, r| flat_hash(r, f + [k], g) }
-        g
+      def self.flat_hash(hash, path = [], 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.dup.delete_if { |k| k == 'text' }.map { |k, v| [k.to_sym, v] }.to_h
+            }
+          end
+        end
+        keys
       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
@@ -50,8 +74,8 @@ module Dry
       # @return [String]
       #
       # @api public
-      def get(key, options = {})
-        data[key % { locale: options.fetch(:locale, default_locale) }]
+      def get(key, options = EMPTY_HASH)
+        data[evaluated_key(key, options)]
       end
 
       # Check if given key is defined
@@ -59,24 +83,54 @@ module Dry
       # @return [Boolean]
       #
       # @api public
-      def key?(key, options = {})
-        data.key?(key % { locale: options.fetch(:locale, default_locale) })
+      def key?(key, options = EMPTY_HASH)
+        data.key?(evaluated_key(key, options))
       end
 
       # Merge messages from an additional path
       #
-      # @param [String] path
+      # @param [String] overrides
       #
       # @return [Messages::I18n]
       #
       # @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

data/lib/dry/schema/messages.rb

@@ -1,36 +1,31 @@
+# frozen_string_literal: true
+
 module Dry
   module Schema
     # An API for configuring message backends
     #
     # @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)
-        case config.messages
-        when :yaml then default
-        when :i18n then Messages::I18n.new
-        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
-      end
 
-      # @api private
-      def self.default
-        Messages::YAML.load
+        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
+
+        messages
       end
     end
   end

data/lib/dry/schema/namespaced_rule.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # A special rule type that is configured under a specified namespace
+    #
+    # This is used internally to create rules that can be properly handled
+    # by the message compiler in situations where a schema reuses another schema
+    # but it is configured to use a message namespace
+    #
+    # @api private
+    class NamespacedRule
+      # @api private
+      attr_reader :rule
+
+      # @api private
+      attr_reader :namespace
+
+      # @api private
+      def initialize(namespace, rule)
+        @namespace = namespace
+        @rule = rule
+      end
+
+      # @api private
+      def call(input)
+        result = rule.call(input)
+        Logic::Result.new(result.success?) { [:namespace, [namespace, result.to_ast]] }
+      end
+
+      # @api private
+      def ast(input=Undefined)
+        [:namespace, [namespace, rule.ast(input)]]
+      end
+    end
+  end
+end