dry-schema 0.1.0 → 1.0.0

data/lib/dry/schema/message.rb

@@ -1,102 +1,86 @@
+# frozen_string_literal: true
+
+require 'dry/initializer'
 require 'dry/equalizer'
 
+require 'dry/schema/path'
+require 'dry/schema/message/or'
+
 module Dry
   module Schema
     # Message objects used by message sets
     #
     # @api public
     class Message
-      include Dry::Equalizer(:predicate, :path, :text, :options)
+      include Dry::Equalizer(:text, :path, :predicate, :input)
 
-      attr_reader :predicate, :path, :text, :rule, :args, :options
-
-      # A message sub-type used by OR operations
-      #
-      # @api public
-      class Or
-        # @api private
-        attr_reader :left
+      extend Dry::Initializer
 
-        # @api private
-        attr_reader :right
+      # @!attribute [r] text
+      #   Message text representation created from a localized template
+      #   @return [String]
+      option :text
 
-        # @api private
-        attr_reader :path
+      # @!attribute [r] path
+      #   Path to the value
+      #   @return [String]
+      option :path
 
-        # @api private
-        attr_reader :messages
+      # @!attribute [r] predicate
+      #   Predicate identifier that was used to produce a message
+      #   @return [Symbol]
+      option :predicate
 
-        # @api private
-        def initialize(left, right, messages)
-          @left = left
-          @right = right
-          @messages = messages
-          @path = left.path
-        end
+      # @!attribute [r] args
+      #   Optional list of arguments used by the predicate
+      #   @return [Array]
+      option :args, default: proc { EMPTY_ARRAY }
 
-        # @api private
-        def hint?
-          false
-        end
+      # @!attribute [r] input
+      #   The input value
+      #   @return [Object]
+      option :input
 
-        # Return a string representation of the message
-        #
-        # @api public
-        def to_s
-          [left, right].uniq.join(" #{messages[:or]} ")
-        end
-      end
+      # @!attribute [r] meta
+      #   Arbitrary meta data
+      #   @return [Hash]
+      option :meta, optional: true, default: proc { EMPTY_HASH }
 
-      # Build a new message object
+      # Dump the message to a representation suitable for the message set hash
       #
-      # @api private
-      def self.[](predicate, path, text, options)
-        Message.new(predicate, path, text, options)
-      end
-
-      # @api private
-      def initialize(predicate, path, text, options)
-        @predicate = predicate
-        @path = path.dup
-        @text = text
-        @options = options
-        @rule = options[:rule]
-        @args = options[:args] || EMPTY_ARRAY
-
-        if predicate == :key?
-          @path << rule
-        end
-      end
-
-      # Return a string representation of the message
+      # @return [String,Hash]
       #
       # @api public
-      def to_s
-        text
-      end
-
-      # @api private
-      def hint?
-        false
+      def dump
+        @dump ||= meta.empty? ? text : { text: text, **meta }
       end
+      alias to_s dump
 
+      # See if another message is the same
+      #
+      # If a string is passed, it will be compared with the text
+      #
+      # @param [Message,String]
+      #
+      # @return [Boolean]
+      #
       # @api private
       def eql?(other)
         other.is_a?(String) ? text == other : super
       end
-    end
-
-    # A hint message sub-type
-    #
-    # @api private
-    class Hint < Message
-      def self.[](predicate, path, text, options)
-        Hint.new(predicate, path, text, options)
-      end
 
+      # See which message is higher in the hierarchy
+      #
       # @api private
-      def hint?
-        true
+      def <=>(other)
+        l_path = Path[path]
+        r_path = Path[other.path]
+
+        unless l_path.same_root?(r_path)
+          raise ArgumentError, 'Cannot compare messages from different root paths'
+        end
+
+        l_path <=> r_path
       end
     end
   end

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

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+require 'dry/schema/constants'
+require 'dry/schema/message'
+
 module Dry
   module Schema
     # @api private
@@ -10,8 +15,8 @@ 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
         end
 
@@ -24,6 +29,28 @@ module Dry
         def call(other)
           merge(other.update(path: [*path, *other[:path]]))
         end
+
+        def dup(current_messages = EMPTY_ARRAY.dup)
+          opts = super()
+          opts[:current_messages] = current_messages
+          opts
+        end
+
+        def key_failure?(path)
+          failures.any? { |f| f.path == path && f.predicate.equal?(:key?) }
+        end
+
+        def failures
+          current_messages.reject(&:hint?)
+        end
+
+        def hints
+          current_messages.select(&:hint?)
+        end
+
+        def current_messages
+          self[:current_messages]
+        end
       end
     end
   end

data/lib/dry/schema/message_compiler.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'dry/initializer'
+
 require 'dry/schema/constants'
 require 'dry/schema/message'
 require 'dry/schema/message_set'
@@ -9,73 +13,84 @@ module Dry
     #
     # @api private
     class MessageCompiler
-      attr_reader :messages, :options, :locale, :default_lookup_options
+      extend Dry::Initializer
+
+      resolve_key_predicate = proc { |node, opts|
+        *arg_vals, val = node.map(&:last)
+        [[*opts.path, arg_vals[0]], arg_vals[1..arg_vals.size - 1], val]
+      }
+
+      resolve_predicate = proc { |node, opts|
+        [Array(opts.path), *node.map(&:last)]
+      }
+
+      DEFAULT_PREDICATE_RESOLVERS = Hash
+        .new(resolve_predicate).update(key?: resolve_key_predicate).freeze
 
       EMPTY_OPTS = VisitorOpts.new
-      LIST_SEPARATOR = ', '.freeze
+      EMPTY_MESSAGE_SET = MessageSet.new(EMPTY_ARRAY).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
+      param :messages
 
-      # @api private
-      def full?
-        @full
-      end
+      option :full, default: -> { false }
+      option :locale, default: -> { :en }
+      option :predicate_resolvers, default: -> { DEFAULT_PREDICATE_RESOLVERS }
+
+      attr_reader :options
+
+      attr_reader :default_lookup_options
 
       # @api private
-      def hints?
-        @hints
+      def initialize(messages, options = EMPTY_HASH)
+        super
+        @options = options
+        @default_lookup_options = options[:locale] ? { locale: locale } : EMPTY_HASH
       end
 
       # @api private
       def with(new_options)
         return self if new_options.empty?
-        self.class.new(messages, options.merge(new_options))
+
+        updated_opts = options.merge(new_options)
+
+        return self if updated_opts.eql?(options)
+
+        self.class.new(messages, updated_opts)
       end
 
       # @api private
       def call(ast)
-        MessageSet[ast.map { |node| visit(node) }, failures: options.fetch(:failures, true)]
+        return EMPTY_MESSAGE_SET if ast.empty?
+
+        current_messages = EMPTY_ARRAY.dup
+        compiled_messages = ast.map { |node| visit(node, EMPTY_OPTS.dup(current_messages)) }
+
+        MessageSet[compiled_messages, failures: options.fetch(:failures, true)]
       end
 
       # @api private
-      def visit(node, *args)
-        __send__(:"visit_#{node[0]}", node[1], *args)
+      def visit(node, opts = EMPTY_OPTS.dup)
+        __send__(:"visit_#{node[0]}", node[1], opts)
       end
 
       # @api private
-      def visit_failure(node, opts = EMPTY_OPTS.dup)
+      def visit_failure(node, opts)
         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
+      def visit_hint(*)
+        nil
       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)
+      def visit_not(node, opts)
         visit(node, opts.(not: true))
       end
 
       # @api private
-      def visit_and(node, opts = EMPTY_OPTS.dup)
+      def visit_and(node, opts)
         left, right = node.map { |n| visit(n, opts) }
 
         if right
@@ -86,59 +101,57 @@ module Dry
       end
 
       # @api private
-      def visit_or(node, opts = EMPTY_OPTS.dup)
+      def visit_or(node, opts)
         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] })
+          Message::Or.new(left, right, proc { |k| messages.translate(k, default_lookup_options) })
         elsif right.is_a?(Array)
           right
         else
-          [left, right]
+          [left, right].flatten.max
         end
       end
 
       # @api private
-      def visit_predicate(node, base_opts = EMPTY_OPTS.dup)
+      def visit_namespace(node, opts)
+        ns, rest = node
+        self.class.new(messages.namespaced(ns), options).visit(rest, opts)
+      end
+
+      # @api private
+      def visit_predicate(node, opts)
         predicate, args = node
 
-        *arg_vals, val = args.map(&:last)
         tokens = message_tokens(args)
+        path, *arg_vals, input = predicate_resolvers[predicate].(args, opts)
 
-        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]
+        options = opts.dup.update(
+          path: path.last, **tokens, **lookup_options(arg_vals: arg_vals, input: input)
+        ).to_h
 
-        template = messages[rule] || messages[predicate, msg_opts]
+        template, meta = messages[predicate, options] || raise(MissingMessageError, path)
 
-        unless template
-          raise MissingMessageError, "message for #{predicate} was not found"
-        end
-
-        text = message_text(rule, template, tokens, options)
+        text = message_text(template, tokens, options)
 
-        message_class = options[:message_type] == :hint ? Hint : Message
+        message_type(options).new(
+          text: text, path: path, predicate: predicate, args: arg_vals, input: input, meta: meta
+        )
+      end
 
-        message_class[
-          predicate, path, text,
-          args: arg_vals,
-          input: input,
-          rule: rule || msg_opts[:name]
-        ]
+      # @api private
+      def message_type(*)
+        Message
       end
 
       # @api private
-      def visit_key(node, opts = EMPTY_OPTS.dup)
+      def visit_key(node, opts)
         name, other = node
         visit(other, opts.(path: name))
       end
 
       # @api private
-      def visit_set(node, opts = EMPTY_OPTS.dup)
+      def visit_set(node, opts)
         node.map { |el| visit(el, opts) }
       end
 
@@ -149,34 +162,32 @@ module Dry
       end
 
       # @api private
-      def visit_xor(node, opts = EMPTY_OPTS.dup)
+      def visit_xor(node, opts)
         left, right = node
         [visit(left, opts), visit(right, opts)].uniq
       end
 
       # @api private
-      def lookup_options(arg_vals: [], input: nil)
+      def lookup_options(arg_vals:, input:)
         default_lookup_options.merge(
           arg_type: arg_vals.size == 1 && arg_vals[0].class,
-          val_type: input.class
+          val_type: input.equal?(Undefined) ? NilClass : input.class
         )
       end
 
       # @api private
-      def message_text(rule, template, tokens, opts)
-        text = template % tokens
+      def message_text(template, tokens, options)
+        text = template[template.data(tokens)]
 
-        if full?
-          rule_name = rule ? (messages.rule(rule, opts) || rule) : (opts[:name] || opts[:path].last)
-          "#{rule_name} #{text}"
-        else
-          text
-        end
+        return text unless full
+
+        rule = options[:path]
+        "#{messages.rule(rule, options) || rule} #{text}"
       end
 
       # @api private
       def message_tokens(args)
-        args.each_with_object({}) { |arg, hash|
+        args.each_with_object({}) do |arg, hash|
           case arg[1]
           when Array
             hash[arg[0]] = arg[1].join(LIST_SEPARATOR)
@@ -186,7 +197,7 @@ module Dry
           else
             hash[arg[0]] = arg[1]
           end
-        }
+        end
       end
     end
   end

data/lib/dry/schema/message_set.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'dry/equalizer'
+
 module Dry
   module Schema
     # A set of messages used to generate errors
@@ -7,15 +11,23 @@ module Dry
     # @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
+      include Dry::Equalizer(:messages, :options)
+
+      # A list of compiled message objects
+      #
+      # @return [Array<Message>]
+      attr_reader :messages
+      
+      # An internal hash that is filled in with dumped messages
+      # when a message set is coerced to a hash
+      #
+      # @return [Hash<Symbol=>[Array,Hash]>]
+      attr_reader :placeholders
+      
+      # Options hash
+      #
+      # @return [Hash]
+      attr_reader :options
 
       # @api private
       def self.[](messages, options = EMPTY_HASH)
@@ -25,91 +37,111 @@ module Dry
       # @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
 
+      # Iterate over messages
+      #
+      # @example
+      #   result.errors.each do |message|
+      #     puts message.text
+      #   end
+      #
+      # @return [Array]
+      #
       # @api public
       def each(&block)
+        return self if empty?
         return to_enum unless block
+
         messages.each(&block)
       end
 
+      # Dump message set to a hash
+      #
+      # @return [Hash<Symbol=>Array<String>>]
+      #
       # @api public
       def to_h
-        failures? ? messages_map : hints_map
+        @to_h ||= messages_map
       end
       alias_method :to_hash, :to_h
-      alias_method :dump, :to_h
 
-      # @api private
-      def failures?
-        options[:failures].equal?(true)
+      # Get a list of message texts for the given key
+      #
+      # @param [Symbol] key
+      #
+      # @return [Array<String>]
+      #
+      # @api public
+      def [](key)
+        to_h[key]
       end
 
-      # @api private
-      def empty?
-        messages.empty?
+      # Get a list of message texts for the given key
+      #
+      # @param [Symbol] key
+      #
+      # @return [Array<String>]
+      #
+      # @raise KeyError
+      #
+      # @api public
+      def fetch(key)
+        self[key] || raise(KeyError, "+#{key}+ message was not found")
       end
 
-      private
+      # Check if a message set is empty
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def empty?
+        @empty ||= messages.empty?
+      end
 
       # @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
+      def freeze
+        to_h
+        empty?
+        super
       end
 
+      private
+
       # @api private
-      def hints_map
-        hints.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
+      def messages_map(messages = self.messages)
+        return EMPTY_HASH if empty?
+
+        messages.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)
+          node.map!(&:dump)
 
           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) }
+      def paths
+        @paths ||= messages.map(&:path).uniq
       end
 
       # @api private
       def initialize_placeholders!
-        @placeholders = paths.reduce({}) do |hash, path|
+        return @placeholders = EMPTY_HASH if empty?
+
+        @placeholders = paths.reduce(EMPTY_HASH.dup) do |hash, path|
           curr_idx = 0
           last_idx = path.size - 1
           node = hash
 
-          while curr_idx <= last_idx do
+          while curr_idx <= last_idx
             key = path[curr_idx]
             node = (node[key] || node[key] = curr_idx < last_idx ? {} : [])
             curr_idx += 1