dry-schema 0.1.0

data/lib/dry/schema/message_compiler.rb

@@ -0,0 +1,193 @@
+require 'dry/schema/constants'
+require 'dry/schema/message'
+require 'dry/schema/message_set'
+require 'dry/schema/message_compiler/visitor_opts'
+
+module Dry
+  module Schema
+    # Compiles rule results AST into human-readable format
+    #
+    # @api private
+    class MessageCompiler
+      attr_reader :messages, :options, :locale, :default_lookup_options
+
+      EMPTY_OPTS = VisitorOpts.new
+      LIST_SEPARATOR = ', '.freeze
+
+      # @api private
+      def initialize(messages, options = {})
+        @messages = messages
+        @options = options
+        @full = @options.fetch(:full, false)
+        @hints = @options.fetch(:hints, true)
+        @locale = @options.fetch(:locale, messages.default_locale)
+        @default_lookup_options = { locale: locale }
+      end
+
+      # @api private
+      def full?
+        @full
+      end
+
+      # @api private
+      def hints?
+        @hints
+      end
+
+      # @api private
+      def with(new_options)
+        return self if new_options.empty?
+        self.class.new(messages, options.merge(new_options))
+      end
+
+      # @api private
+      def call(ast)
+        MessageSet[ast.map { |node| visit(node) }, failures: options.fetch(:failures, true)]
+      end
+
+      # @api private
+      def visit(node, *args)
+        __send__(:"visit_#{node[0]}", node[1], *args)
+      end
+
+      # @api private
+      def visit_failure(node, opts = EMPTY_OPTS.dup)
+        rule, other = node
+        visit(other, opts.(rule: rule))
+      end
+
+      # @api private
+      def visit_hint(node, opts = EMPTY_OPTS.dup)
+        if hints?
+          visit(node, opts.(message_type: :hint))
+        end
+      end
+
+      # @api private
+      def visit_each(node, opts = EMPTY_OPTS.dup)
+        # TODO: we can still generate a hint for elements here!
+        []
+      end
+
+      # @api private
+      def visit_not(node, opts = EMPTY_OPTS.dup)
+        visit(node, opts.(not: true))
+      end
+
+      # @api private
+      def visit_and(node, opts = EMPTY_OPTS.dup)
+        left, right = node.map { |n| visit(n, opts) }
+
+        if right
+          [left, right]
+        else
+          left
+        end
+      end
+
+      # @api private
+      def visit_or(node, opts = EMPTY_OPTS.dup)
+        left, right = node.map { |n| visit(n, opts) }
+
+        if [left, right].flatten.map(&:path).uniq.size == 1
+          Message::Or.new(left, right, -> k { messages[k, default_lookup_options] })
+        elsif right.is_a?(Array)
+          right
+        else
+          [left, right]
+        end
+      end
+
+      # @api private
+      def visit_predicate(node, base_opts = EMPTY_OPTS.dup)
+        predicate, args = node
+
+        *arg_vals, val = args.map(&:last)
+        tokens = message_tokens(args)
+
+        input = val != Undefined ? val : nil
+
+        options = base_opts.update(lookup_options(arg_vals: arg_vals, input: input))
+        msg_opts = options.update(tokens)
+
+        rule = msg_opts[:rule]
+        path = msg_opts[:path]
+
+        template = messages[rule] || messages[predicate, msg_opts]
+
+        unless template
+          raise MissingMessageError, "message for #{predicate} was not found"
+        end
+
+        text = message_text(rule, template, tokens, options)
+
+        message_class = options[:message_type] == :hint ? Hint : Message
+
+        message_class[
+          predicate, path, text,
+          args: arg_vals,
+          input: input,
+          rule: rule || msg_opts[:name]
+        ]
+      end
+
+      # @api private
+      def visit_key(node, opts = EMPTY_OPTS.dup)
+        name, other = node
+        visit(other, opts.(path: name))
+      end
+
+      # @api private
+      def visit_set(node, opts = EMPTY_OPTS.dup)
+        node.map { |el| visit(el, opts) }
+      end
+
+      # @api private
+      def visit_implication(node, *args)
+        _, right = node
+        visit(right, *args)
+      end
+
+      # @api private
+      def visit_xor(node, opts = EMPTY_OPTS.dup)
+        left, right = node
+        [visit(left, opts), visit(right, opts)].uniq
+      end
+
+      # @api private
+      def lookup_options(arg_vals: [], input: nil)
+        default_lookup_options.merge(
+          arg_type: arg_vals.size == 1 && arg_vals[0].class,
+          val_type: input.class
+        )
+      end
+
+      # @api private
+      def message_text(rule, template, tokens, opts)
+        text = template % tokens
+
+        if full?
+          rule_name = rule ? (messages.rule(rule, opts) || rule) : (opts[:name] || opts[:path].last)
+          "#{rule_name} #{text}"
+        else
+          text
+        end
+      end
+
+      # @api private
+      def message_tokens(args)
+        args.each_with_object({}) { |arg, hash|
+          case arg[1]
+          when Array
+            hash[arg[0]] = arg[1].join(LIST_SEPARATOR)
+          when Range
+            hash["#{arg[0]}_left".to_sym] = arg[1].first
+            hash["#{arg[0]}_right".to_sym] = arg[1].last
+          else
+            hash[arg[0]] = arg[1]
+          end
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Dry
+  module Schema
+    # @api private
+    class MessageCompiler
+      # Optimized option hash used by visitor methods in message compiler
+      #
+      # @api private
+      class VisitorOpts < Hash
+        # @api private
+        def self.new
+          opts = super
+          opts[:path] = EMPTY_ARRAY
+          opts[:rule] = nil
+          opts[:message_type] = :failure
+          opts
+        end
+
+        # @api private
+        def path
+          self[:path]
+        end
+
+        # @api private
+        def call(other)
+          merge(other.update(path: [*path, *other[:path]]))
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/message_set.rb

@@ -0,0 +1,123 @@
+module Dry
+  module Schema
+    # A set of messages used to generate errors
+    #
+    # @see Result#message_set
+    #
+    # @api public
+    class MessageSet
+      include Enumerable
+
+      HINT_EXCLUSION = %i(
+        key? filled? nil? bool?
+        str? int? float? decimal?
+        date? date_time? time? hash?
+        array? format?
+      ).freeze
+
+      attr_reader :messages, :failures, :hints, :paths, :placeholders, :options
+
+      # @api private
+      def self.[](messages, options = EMPTY_HASH)
+        new(messages.flatten, options)
+      end
+
+      # @api private
+      def initialize(messages, options = EMPTY_HASH)
+        @messages = messages
+        @hints = messages.select(&:hint?)
+        @failures = messages - hints
+        @paths = failures.map(&:path).uniq
+        @options = options
+
+        initialize_hints!
+        initialize_placeholders!
+      end
+
+      # @api public
+      def each(&block)
+        return to_enum unless block
+        messages.each(&block)
+      end
+
+      # @api public
+      def to_h
+        failures? ? messages_map : hints_map
+      end
+      alias_method :to_hash, :to_h
+      alias_method :dump, :to_h
+
+      # @api private
+      def failures?
+        options[:failures].equal?(true)
+      end
+
+      # @api private
+      def empty?
+        messages.empty?
+      end
+
+      private
+
+      # @api private
+      def messages_map
+        failures.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
+          node = path.reduce(hash) { |a, e| a[e] }
+
+          msgs.each do |msg|
+            node << msg
+          end
+
+          msg_hints = hint_groups[path]
+          node.concat(msg_hints) if msg_hints
+
+          node.map!(&:to_s)
+
+          hash
+        end
+      end
+
+      # @api private
+      def hints_map
+        hints.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
+          node = path.reduce(hash) { |a, e| a[e] }
+
+          msgs.each do |msg|
+            node << msg
+          end
+
+          node.map!(&:to_s)
+
+          hash
+        end
+      end
+
+      # @api private
+      def hint_groups
+        @hint_groups ||= hints.group_by(&:path)
+      end
+
+      # @api private
+      def initialize_hints!
+        hints.reject! { |hint| HINT_EXCLUSION.include?(hint.predicate) }
+      end
+
+      # @api private
+      def initialize_placeholders!
+        @placeholders = paths.reduce({}) do |hash, path|
+          curr_idx = 0
+          last_idx = path.size - 1
+          node = hash
+
+          while curr_idx <= last_idx do
+            key = path[curr_idx]
+            node = (node[key] || node[key] = curr_idx < last_idx ? {} : [])
+            curr_idx += 1
+          end
+
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/messages.rb

@@ -0,0 +1,42 @@
+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
+
+      # @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"
+        end
+      end
+
+      # @api private
+      def self.default
+        Messages::YAML.load
+      end
+    end
+  end
+end
+
+require 'dry/schema/messages/abstract'
+require 'dry/schema/messages/namespaced'
+require 'dry/schema/messages/yaml'
+require 'dry/schema/messages/i18n' if defined?(I18n)

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

@@ -0,0 +1,143 @@
+require 'pathname'
+require 'concurrent/map'
+require 'dry/equalizer'
+require 'dry/configurable'
+
+require 'dry/schema/constants'
+
+module Dry
+  module Schema
+    module Messages
+      # Abstract class for message backends
+      #
+      # @api public
+      class Abstract
+        extend 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(
+          Range => 'range'
+        )
+
+        setting :val_types, Hash.new { |*| config.val_type_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
+        attr_reader :config
+
+        # @api private
+        def initialize
+          @config = self.class.config
+        end
+
+        # @api private
+        def hash
+          @hash ||= config.hash
+        end
+
+        # @api private
+        def rule(name, options = {})
+          path = "%{locale}.rules.#{name}"
+          get(path, options) if key?(path, options)
+        end
+
+        # Retrieve a message
+        #
+        # @return [String]
+        #
+        # @api public
+        def call(*args)
+          cache.fetch_or_store(args.hash) do
+            path, opts = lookup(*args)
+            get(path, opts) if path
+          end
+        end
+        alias_method :[], :call
+
+        # Try to find a message for the given predicate and its options
+        #
+        # @api private
+        def lookup(predicate, options = {})
+          tokens = options.merge(
+            root: options[:not] ? "#{root}.not" : root,
+            predicate: predicate,
+            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, opts]
+        end
+
+        # @api private
+        def lookup_paths(tokens)
+          config.lookup_paths.map { |path| path % 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)
+        end
+
+        # Return root path to messages file
+        #
+        # @return [Pathname]
+        #
+        # @api public
+        def root
+          config.root
+        end
+
+        # @api private
+        def cache
+          @cache ||= self.class.cache[self]
+        end
+
+        # @api private
+        def default_locale
+          :en
+        end
+      end
+    end
+  end
+end