dry-schema 1.4.1 → 1.5.2

data/lib/dry/schema/macros/schema.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/value'
+require "dry/schema/macros/value"
 
 module Dry
   module Schema
@@ -13,8 +13,13 @@ module Dry
         def call(*args, &block)
           super(*args, &nil) unless args.empty?
 
+          if args.size.equal?(1) && (op = args.first).is_a?(Dry::Logic::Operations::Abstract)
+            process_operation(op)
+          end
+
           if block
             schema = define(*args, &block)
+            import_steps(schema)
             trace << schema.to_rule
           end
 
@@ -23,9 +28,25 @@ module Dry
 
         private
 
+        # @api private
+        def process_operation(op)
+          schemas = op.rules.select { |rule| rule.is_a?(Processor) }
+
+          hash_schema = hash_type.schema(
+            schemas.map(&:schema_dsl).map(&:types).reduce(:merge)
+          )
+
+          type(hash_schema)
+        end
+
+        # @api private
+        def hash_type
+          schema_dsl.resolve_type(:hash)
+        end
+
         # @api private
         def define(*args, &block)
-          definition = schema_dsl.new(&block)
+          definition = schema_dsl.new(path: schema_dsl.path, &block)
           schema = definition.call
           type_schema =
             if array_type?(parent_type)

data/lib/dry/schema/macros/value.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/dsl'
+require "dry/schema/path"
+require "dry/schema/macros/dsl"
 
 module Dry
   module Schema
@@ -13,6 +14,8 @@ module Dry
         def call(*predicates, **opts, &block)
           schema = predicates.detect { |predicate| predicate.is_a?(Processor) }
 
+          type_spec = opts[:type_spec]
+
           if schema
             current_type = schema_dsl.types[name]
 
@@ -23,17 +26,32 @@ module Dry
                 schema.type_schema
               end
 
-            schema_dsl.set_type(name, updated_type)
+            import_steps(schema)
+
+            type(updated_type) unless custom_type? && !current_type.respond_to?(:of)
           end
 
-          trace.evaluate(*predicates, **opts)
-          trace.append(new(chain: false).instance_exec(&block)) if block
+          trace_opts = opts.reject { |key, _| key == :type_spec || key == :type_rule }
+
+          if (type_rule = opts[:type_rule])
+            trace.append(type_rule).evaluate(*predicates, **trace_opts)
+            trace.append(new(chain: false).instance_exec(&block)) if block
+          else
+            trace.evaluate(*predicates, **trace_opts)
+
+            if block && type_spec.equal?(:hash)
+              hash(&block)
+            elsif type_spec.is_a?(::Dry::Types::Type) && hash_type?(type_spec)
+              hash(type_spec)
+            elsif block
+              trace.append(new(chain: false).instance_exec(&block))
+            end
+          end
 
           if trace.captures.empty?
-            raise ArgumentError, 'wrong number of arguments (given 0, expected at least 1)'
+            raise ArgumentError, "wrong number of arguments (given 0, expected at least 1)"
           end
 
-          type_spec = opts[:type_spec]
           each(type_spec.type.member) if type_spec.respond_to?(:member)
 
           self
@@ -44,12 +62,16 @@ module Dry
           primitive_inferrer[type].eql?([::Array])
         end
 
+        def hash_type?(type)
+          primitive_inferrer[type].eql?([::Hash])
+        end
+
         # @api private
         def build_array_type(array_type, member)
           if array_type.respond_to?(:of)
             array_type.of(member)
           else
-            raise ArgumentError, <<~ERROR.split("\n").join(' ')
+            raise ArgumentError, <<~ERROR.split("\n").join(" ")
               Cannot define schema for a nominal array type.
               Array types must be instances of Dry::Types::Array,
               usually constructed with Types::Constructor(Array) { ... } or
@@ -58,6 +80,11 @@ module Dry
           end
         end
 
+        # @api private
+        def import_steps(schema)
+          schema_dsl.steps.import_callbacks(Path[[*path, name]], schema.steps)
+        end
+
         # @api private
         def respond_to_missing?(meth, include_private = false)
           super || meth.to_s.end_with?(QUESTION_MARK)

data/lib/dry/schema/message.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'dry/initializer'
-require 'dry/equalizer'
+require "dry/initializer"
+require "dry/equalizer"
 
-require 'dry/schema/path'
-require 'dry/schema/message/or'
+require "dry/schema/path"
+require "dry/schema/message/or"
 
 module Dry
   module Schema
@@ -52,9 +52,22 @@ module Dry
       #
       # @api public
       def dump
-        @dump ||= meta.empty? ? text : { text: text, **meta }
+        @dump ||= meta.empty? ? text : {text: text, **meta}
+      end
+      alias_method :to_s, :dump
+
+      # Dump the message into a hash
+      #
+      # The hash will be deeply nested if the path's size is greater than 1
+      #
+      # @see Message#to_h
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_h
+        @to_h ||= _path.to_h(dump)
       end
-      alias to_s dump
 
       # See if another message is the same
       #
@@ -69,19 +82,32 @@ module Dry
         other.is_a?(String) ? text == other : super
       end
 
+      # @api private
+      def to_or(root)
+        clone = dup
+        clone.instance_variable_set("@path", path - root.to_a)
+        clone.instance_variable_set("@_path", nil)
+        clone
+      end
+
       # See which message is higher in the hierarchy
       #
       # @api private
       def <=>(other)
-        l_path = Path[path]
-        r_path = Path[other.path]
+        l_path = _path
+        r_path = other._path
 
         unless l_path.same_root?(r_path)
-          raise ArgumentError, 'Cannot compare messages from different root paths'
+          raise ArgumentError, "Cannot compare messages from different root paths"
         end
 
         l_path <=> r_path
       end
+
+      # @api private
+      def _path
+        @_path ||= Path[path]
+      end
     end
   end
 end

data/lib/dry/schema/message/or.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
+require "dry/schema/message/or/single_path"
+require "dry/schema/message/or/multi_path"
 
 module Dry
   module Schema
@@ -8,45 +9,23 @@ module Dry
     #
     # @api public
     class Message
-      # A message sub-type used by OR operations
-      #
-      # @api public
-      class Or
+      module Or
         # @api private
-        attr_reader :left
-
-        # @api private
-        attr_reader :right
-
-        # @api private
-        attr_reader :path
-
-        # @api private
-        attr_reader :messages
-
-        # @api private
-        def initialize(left, right, messages)
-          @left = left
-          @right = right
-          @messages = messages
-          @path = left.path
-        end
-
-        # Dump a message into a string
-        #
-        # @see Message#dump
-        #
-        # @return [String]
-        #
-        # @api public
-        def dump
-          to_a.map(&:dump).join(" #{messages[:or][:text]} ")
-        end
-        alias to_s dump
-
-        # @api private
-        def to_a
-          [left, right]
+        def self.[](left, right, messages)
+          msgs = [left, right].flatten
+          paths = msgs.map(&:path)
+
+          if paths.uniq.size == 1
+            SinglePath.new(left, right, messages)
+          elsif right.is_a?(Array)
+            if left.is_a?(Array) && paths.uniq.size > 1
+              MultiPath.new(left, right)
+            else
+              right
+            end
+          else
+            msgs.max
+          end
         end
       end
     end

data/lib/dry/schema/message/or/abstract.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    class Message
+      module Or
+        # A message type used by OR operations
+        #
+        # @abstract
+        #
+        # @api private
+        class Abstract
+          # @api private
+          attr_reader :left
+
+          # @api private
+          attr_reader :right
+
+          # @api private
+          def initialize(left, right)
+            @left = left
+            @right = right
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/message/or/multi_path.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "dry/equalizer"
+
+require "dry/schema/message/or/abstract"
+require "dry/schema/path"
+
+module Dry
+  module Schema
+    class Message
+      module Or
+        # A message type used by OR operations with different paths
+        #
+        # @api public
+        class MultiPath < Abstract
+          # @api private
+          attr_reader :root
+
+          # @api private
+          def initialize(*args)
+            super
+            @root = [left, right].flatten.map(&:_path).reduce(:&)
+            @left = left.map { |msg| msg.to_or(root) }
+            @right = right.map { |msg| msg.to_or(root) }
+          end
+
+          # @api public
+          def to_h
+            @to_h ||= Path[[*root, :or]].to_h(
+              [left.map(&:to_h).reduce(:merge), right.map(&:to_h).reduce(:merge)]
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/message/or/single_path.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "dry/schema/message/or/abstract"
+
+module Dry
+  module Schema
+    class Message
+      module Or
+        # A message type used by OR operations with the same path
+        #
+        # @api public
+        class SinglePath < Abstract
+          # @api private
+          attr_reader :path
+
+          # @api private
+          attr_reader :_path
+
+          # @api private
+          attr_reader :messages
+
+          # @api private
+          def initialize(*args, messages)
+            super(*args)
+            @messages = messages
+            @path = left.path
+            @_path = left._path
+          end
+
+          # Dump a message into a string
+          #
+          # Both sides of the message will be joined using translated
+          # value under `dry_schema.or` message key
+          #
+          # @see Message#dump
+          #
+          # @return [String]
+          #
+          # @api public
+          def dump
+            @dump ||= "#{left.dump} #{messages[:or][:text]} #{right.dump}"
+          end
+          alias_method :to_s, :dump
+
+          # Dump an `or` message into a hash
+          #
+          # @see Message#to_h
+          #
+          # @return [String]
+          #
+          # @api public
+          def to_h
+            @to_h ||= _path.to_h(dump)
+          end
+
+          # @api private
+          def to_a
+            @to_a ||= [left, right]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/message_compiler.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'dry/initializer'
+require "dry/initializer"
 
-require 'dry/schema/constants'
-require 'dry/schema/message'
-require 'dry/schema/message_set'
-require 'dry/schema/message_compiler/visitor_opts'
+require "dry/schema/constants"
+require "dry/schema/message"
+require "dry/schema/message_set"
+require "dry/schema/message_compiler/visitor_opts"
 
 module Dry
   module Schema
@@ -29,6 +29,14 @@ module Dry
 
       EMPTY_OPTS = VisitorOpts.new
       EMPTY_MESSAGE_SET = MessageSet.new(EMPTY_ARRAY).freeze
+      FULL_MESSAGE_WHITESPACE = Hash.new(' ').merge(
+            ja: '',
+            zh: '',
+            bn: '',
+            th: '',
+            lo: '',
+            my: '',
+          )
 
       param :messages
 
@@ -41,10 +49,10 @@ module Dry
       attr_reader :default_lookup_options
 
       # @api private
-      def initialize(messages, options = EMPTY_HASH)
+      def initialize(messages, **options)
         super
         @options = options
-        @default_lookup_options = options[:locale] ? { locale: locale } : EMPTY_HASH
+        @default_lookup_options = options[:locale] ? {locale: locale} : EMPTY_HASH
       end
 
       # @api private
@@ -55,7 +63,7 @@ module Dry
 
         return self if updated_opts.eql?(options)
 
-        self.class.new(messages, updated_opts)
+        self.class.new(messages, **updated_opts)
       end
 
       # @api private
@@ -100,23 +108,35 @@ module Dry
         end
       end
 
+      # @api private
+      def visit_unexpected_key(node, _opts)
+        path, input = node
+
+        msg = messages.translate("errors.unexpected_key")
+
+        Message.new(
+          path: path,
+          text: msg[:text],
+          predicate: nil,
+          input: input
+        )
+      end
+
       # @api private
       def visit_or(node, opts)
         left, right = node.map { |n| visit(n, opts) }
+        Message::Or[left, right, or_translator]
+      end
 
-        if [left, right].flatten.map(&:path).uniq.size == 1
-          Message::Or.new(left, right, proc { |k| messages.translate(k, default_lookup_options) })
-        elsif right.is_a?(Array)
-          right
-        else
-          [left, right].flatten.max
-        end
+      # @api private
+      def or_translator
+        @or_translator ||= proc { |k| messages.translate(k, **default_lookup_options) }
       end
 
       # @api private
       def visit_namespace(node, opts)
         ns, rest = node
-        self.class.new(messages.namespaced(ns), options).visit(rest, opts)
+        self.class.new(messages.namespaced(ns), **options).visit(rest, opts)
       end
 
       # @api private
@@ -130,13 +150,21 @@ module Dry
           path: path.last, **tokens, **lookup_options(arg_vals: arg_vals, input: input)
         ).to_h
 
-        template, meta = messages[predicate, options] ||
-          raise(MissingMessageError.new(path, messages.looked_up_paths(predicate, options)))
+        template, meta = messages[predicate, options]
+
+        unless template
+          raise MissingMessageError.new(path, messages.looked_up_paths(predicate, options))
+        end
 
         text = message_text(template, tokens, options)
 
         message_type(options).new(
-          text: text, path: path, predicate: predicate, args: arg_vals, input: input, meta: meta
+          text: text,
+          meta: meta,
+          path: path,
+          predicate: predicate,
+          args: arg_vals,
+          input: input
         )
       end
 
@@ -180,15 +208,15 @@ module Dry
       def message_text(template, tokens, options)
         text = template[template.data(tokens)]
 
-        return text unless full
+        return text if !text || !full
 
         rule = options[:path]
-        "#{messages.rule(rule, options) || rule} #{text}"
+        [messages.rule(rule, options) || rule, text].join(FULL_MESSAGE_WHITESPACE[template.options[:locale]])
       end
 
       # @api private
       def message_tokens(args)
-        args.each_with_object({}) do |arg, hash|
+        tokens = args.each_with_object({}) do |arg, hash|
           case arg[1]
           when Array
             hash[arg[0]] = arg[1].join(LIST_SEPARATOR)
@@ -199,6 +227,14 @@ module Dry
             hash[arg[0]] = arg[1]
           end
         end
+        args.any? { |e| e.first == :size } ? append_mapped_size_tokens(tokens) : tokens
+      end
+
+      # @api private
+      def append_mapped_size_tokens(tokens)
+        # this is a temporary fix for the inconsistency in the "size" errors arguments
+        mapped_hash = tokens.each_with_object({}) { |(k, v), h| h[k.to_s.gsub("size", "num").to_sym] = v }
+        tokens.merge(mapped_hash)
       end
     end
   end