dry-schema 1.8.0 → 1.9.3

data/lib/dry/schema/key.rb

@@ -85,98 +85,99 @@ module Dry
       def coerced_name
         @__coerced_name__ ||= coercer[name]
       end
-    end
-
-    # A specialized key type which handles nested hashes
-    #
-    # @api private
-    class Key::Hash < Key
-      include Dry.Equalizer(:name, :members, :coercer)
 
+      # A specialized key type which handles nested hashes
+      #
       # @api private
-      attr_reader :members
+      class Hash < self
+        include Dry.Equalizer(:name, :members, :coercer)
 
-      # @api private
-      def initialize(id, members:, **opts)
-        super(id, **opts)
-        @members = members
-      end
+        # @api private
+        attr_reader :members
 
-      # @api private
-      def read(source)
-        super if source.is_a?(::Hash)
-      end
+        # @api private
+        def initialize(id, members:, **opts)
+          super(id, **opts)
+          @members = members
+        end
 
-      def write(source, target)
-        read(source) { |value|
-          target[coerced_name] = value.is_a?(::Hash) ? members.write(value) : value
-        }
-      end
+        # @api private
+        def read(source)
+          super if source.is_a?(::Hash)
+        end
 
-      # @api private
-      def coercible(&coercer)
-        new(coercer: coercer, members: members.coercible(&coercer))
-      end
+        def write(source, target)
+          read(source) { |value|
+            target[coerced_name] = value.is_a?(::Hash) ? members.write(value) : value
+          }
+        end
 
-      # @api private
-      def stringified
-        new(name: name.to_s, members: members.stringified)
-      end
+        # @api private
+        def coercible(&coercer)
+          new(coercer: coercer, members: members.coercible(&coercer))
+        end
 
-      # @api private
-      def to_dot_notation
-        [name].product(members.flat_map(&:to_dot_notation)).map { |e| e.join(DOT) }
-      end
+        # @api private
+        def stringified
+          new(name: name.to_s, members: members.stringified)
+        end
 
-      # @api private
-      def dump
-        {name => members.map(&:dump)}
+        # @api private
+        def to_dot_notation
+          [name].product(members.flat_map(&:to_dot_notation)).map { |e| e.join(DOT) }
+        end
+
+        # @api private
+        def dump
+          {name => members.map(&:dump)}
+        end
       end
-    end
 
-    # A specialized key type which handles nested arrays
-    #
-    # @api private
-    class Key::Array < Key
-      include Dry.Equalizer(:name, :member, :coercer)
+      # A specialized key type which handles nested arrays
+      #
+      # @api private
+      class Array < self
+        include Dry.Equalizer(:name, :member, :coercer)
 
-      attr_reader :member
+        attr_reader :member
 
-      # @api private
-      def initialize(id, member:, **opts)
-        super(id, **opts)
-        @member = member
-      end
+        # @api private
+        def initialize(id, member:, **opts)
+          super(id, **opts)
+          @member = member
+        end
 
-      # @api private
-      def write(source, target)
-        read(source) { |value|
-          target[coerced_name] = if value.is_a?(::Array)
-                                   value.map { |el| el.is_a?(::Hash) ? member.write(el) : el }
-                                 else
-                                   value
-                                 end
-        }
-      end
+        # @api private
+        def write(source, target)
+          read(source) { |value|
+            target[coerced_name] =
+              if value.is_a?(::Array)
+                value.map { |el| el.is_a?(::Hash) ? member.write(el) : el }
+              else
+                value
+              end
+          }
+        end
 
-      # @api private
-      def coercible(&coercer)
-        new(coercer: coercer, member: member.coercible(&coercer))
-      end
+        # @api private
+        def coercible(&coercer)
+          new(coercer: coercer, member: member.coercible(&coercer))
+        end
 
-      # @api private
-      def stringified
-        new(name: name.to_s, member: member.stringified)
-      end
+        # @api private
+        def stringified
+          new(name: name.to_s, member: member.stringified)
+        end
 
-      # @api private
-      def to_dot_notation
-        [:"#{name}[]"].product(member.to_dot_notation).map { |el| el.join(DOT) }
-      end
+        # @api private
+        def to_dot_notation
+          [:"#{name}[]"].product(member.to_dot_notation).map { |el| el.join(DOT) }
+        end
 
-      # @api private
-      def dump
-        [name, member.dump]
+        # @api private
+        def dump
+          [name, member.dump]
+        end
       end
     end
   end

data/lib/dry/schema/key_coercer.rb

@@ -17,8 +17,8 @@ module Dry
       attr_reader :key_map, :coercer
 
       # @api private
-      def self.new(*args, &coercer)
-        fetch_or_store(*args, coercer) { super(*args, &coercer) }
+      def self.new(*args)
+        fetch_or_store(*args) { super }
       end
 
       # @api private

data/lib/dry/schema/key_validator.rb

@@ -24,17 +24,7 @@ module Dry
         key_paths = key_map.to_dot_notation
 
         input_paths.each do |path|
-          error_path =
-            if path[INDEX_REGEX]
-              key = path.gsub(INDEX_REGEX, BRACKETS)
-
-              if key_paths.none? { |key_path| key_path.include?(key) }
-                arr = path.gsub(INDEX_REGEX) { |m| ".#{m[1]}" }
-                arr.split(DOT).map { |s| DIGIT_REGEX.match?(s) ? s.to_i : s.to_sym }
-              end
-            elsif key_paths.none? { |key_path| key_path.include?(path) }
-              path
-            end
+          error_path = validate_path(key_paths, path)
 
           next unless error_path
 
@@ -47,26 +37,57 @@ module Dry
       private
 
       # @api private
-      def key_paths(hash)
-        hash.flat_map { |key, _|
-          case (value = hash[key])
-          when Hash
-            next key.to_s if value.empty?
+      def validate_path(key_paths, path)
+        if path[INDEX_REGEX]
+          key = path.gsub(INDEX_REGEX, BRACKETS)
 
-            [key].product(key_paths(hash[key])).map { |keys| keys.join(DOT) }
-          when Array
-            hashes_or_arrays = value.select { |e| (e.is_a?(Array) || e.is_a?(Hash)) && !e.empty? }
+          if key_paths.none? { paths_match?(key, _1) }
+            arr = path.gsub(INDEX_REGEX) { ".#{_1[1]}" }
+            arr.split(DOT).map { DIGIT_REGEX.match?(_1) ? Integer(_1, 10) : _1.to_sym }
+          end
+        elsif key_paths.none? { paths_match?(path, _1) }
+          path
+        end
+      end
 
-            next key.to_s if hashes_or_arrays.empty?
+      # @api private
+      def paths_match?(input_path, key_path)
+        residue = key_path.sub(input_path, "")
+        residue.empty? || residue.start_with?(DOT, BRACKETS)
+      end
 
-            hashes_or_arrays.flat_map.with_index { |el, idx|
-              key_paths(el).map { |path| ["#{key}[#{idx}]", *path].join(DOT) }
-            }
+      # @api private
+      def key_paths(hash)
+        hash.flat_map { |key, value|
+          case value
+          when ::Hash
+            if value.empty?
+              [key.to_s]
+            else
+              [key].product(key_paths(hash[key])).map { _1.join(DOT) }
+            end
+          when ::Array
+            hashes_or_arrays = hashes_or_arrays(value)
+
+            if hashes_or_arrays.empty?
+              [key.to_s]
+            else
+              hashes_or_arrays.flat_map.with_index { |el, idx|
+                key_paths(el).map { ["#{key}[#{idx}]", *_1].join(DOT) }
+              }
+            end
           else
             key.to_s
           end
         }
       end
+
+      # @api private
+      def hashes_or_arrays(xs)
+        xs.select { |x|
+          (x.is_a?(::Array) || x.is_a?(::Hash)) && !x.empty?
+        }
+      end
     end
   end
 end

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

@@ -10,6 +10,8 @@ module Dry
       # @api private
       class Array < DSL
         # @api private
+        # rubocop: disable Metrics/PerceivedComplexity
+        # rubocop: disable Metrics/AbcSize
         def value(*args, **opts, &block)
           type(:array)
 
@@ -40,6 +42,8 @@ module Dry
 
           self
         end
+        # rubocop: enable Metrics/AbcSize
+        # rubocop: enable Metrics/PerceivedComplexity
 
         # @api private
         def to_ast(*)

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

@@ -16,7 +16,7 @@ module Dry
         extend Dry::Initializer
 
         # @api private
-        option :name, default: proc { nil }, optional: true
+        option :name, default: proc {}, optional: true
 
         # @api private
         option :compiler, default: proc { Compiler.new }

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

@@ -58,9 +58,9 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def value(*predicates, &block)
+        def value(...)
           append_macro(Macros::Value) do |macro|
-            macro.call(*predicates, &block)
+            macro.call(...)
           end
         end
         ruby2_keywords :value if respond_to?(:ruby2_keywords, true)
@@ -76,9 +76,9 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def filled(*args, &block)
+        def filled(...)
           append_macro(Macros::Filled) do |macro|
-            macro.call(*args, &block)
+            macro.call(...)
           end
         end
         ruby2_keywords :filled if respond_to?(:ruby2_keywords, true)
@@ -97,9 +97,9 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def schema(*args, &block)
+        def schema(...)
           append_macro(Macros::Schema) do |macro|
-            macro.call(*args, &block)
+            macro.call(...)
           end
         end
         ruby2_keywords :schema if respond_to?(:ruby2_keywords, true)
@@ -112,9 +112,9 @@ module Dry
         #   end
         #
         # @api public
-        def hash(*args, &block)
+        def hash(...)
           append_macro(Macros::Hash) do |macro|
-            macro.call(*args, &block)
+            macro.call(...)
           end
         end
         ruby2_keywords :hash if respond_to?(:ruby2_keywords, true)
@@ -136,9 +136,9 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def each(*args, &block)
+        def each(...)
           append_macro(Macros::Each) do |macro|
-            macro.value(*args, &block)
+            macro.value(...)
           end
         end
         ruby2_keywords :each if respond_to?(:ruby2_keywords, true)
@@ -156,9 +156,9 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def array(*args, &block)
+        def array(...)
           append_macro(Macros::Array) do |macro|
-            macro.value(*args, &block)
+            macro.value(...)
           end
         end
         ruby2_keywords :array if respond_to?(:ruby2_keywords, true)
@@ -200,10 +200,11 @@ module Dry
         end
 
         # @api private
+        # rubocop: disable Metrics/PerceivedComplexity
         def extract_type_spec(*args, nullable: false, set_type: true)
           type_spec = args[0] unless schema_or_predicate?(args[0])
 
-          predicates = Array(type_spec ? args[1..-1] : args)
+          predicates = Array(type_spec ? args[1..] : args)
           type_rule = nil
 
           if type_spec
@@ -228,6 +229,7 @@ module Dry
             yield(*predicates, type_spec: type_spec, type_rule: nil)
           end
         end
+        # rubocop: enable Metrics/PerceivedComplexity
 
         # @api private
         def resolve_type(type_spec, nullable)
@@ -243,8 +245,8 @@ module Dry
         # @api private
         def schema_or_predicate?(arg)
           arg.is_a?(Dry::Schema::Processor) ||
-            arg.is_a?(Symbol) &&
-              arg.to_s.end_with?(QUESTION_MARK)
+            (arg.is_a?(Symbol) &&
+              arg.to_s.end_with?(QUESTION_MARK))
         end
       end
     end

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

@@ -29,7 +29,7 @@ module Dry
           else
             trace << hash?
 
-            super(*args, &block)
+            super
           end
         end
       end

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

@@ -26,8 +26,8 @@ module Dry
         # @return [Macros::Key]
         #
         # @api public
-        def filter(*args, &block)
-          (filter_schema_dsl[name] || filter_schema_dsl.optional(name)).value(*args, &block)
+        def filter(...)
+          (filter_schema_dsl[name] || filter_schema_dsl.optional(name)).value(...)
           self
         end
         ruby2_keywords(:filter) if respond_to?(:ruby2_keywords, true)

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

@@ -45,6 +45,7 @@ module Dry
         end
 
         # @api private
+        # rubocop: disable Metrics/AbcSize
         def define(*args, &block)
           definition = schema_dsl.new(path: schema_dsl.path, &block)
           schema = definition.call
@@ -66,6 +67,7 @@ module Dry
 
           schema
         end
+        # rubocop: enable Metrics/AbcSize
 
         # @api private
         def parent_type

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

@@ -11,6 +11,10 @@ module Dry
       # @api private
       class Value < DSL
         # @api private
+        #
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
         def call(*args, **opts, &block)
           types, predicates = args.partition { |arg| arg.is_a?(Dry::Types::Type) }
 
@@ -65,6 +69,9 @@ module Dry
 
           self
         end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/PerceivedComplexity
 
         # @api private
         def array_type?(type)

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/equalizer"
-
 require "dry/schema/message/or/abstract"
 require "dry/schema/path"
 
@@ -14,21 +12,85 @@ module Dry
         # @api public
         class MultiPath < Abstract
           # @api private
-          attr_reader :root
+          class MessageArray
+            # @api private
+            def initialize(messages)
+              @messages = messages.flatten
+            end
+
+            # @api private
+            def _paths
+              @messages.map(&:_path)
+            end
+
+            # @api private
+            def to_or(root)
+              self.class.new(@messages.map { _1.to_or(root) })
+            end
+
+            # @api private
+            def to_h
+              MessageSet.new(@messages).to_h
+            end
+          end
+
+          # @api private
+          def self.handler(message)
+            handlers.find { |k,| message.is_a?(k) }&.last
+          end
 
           # @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) }
+          private_class_method def self.handlers
+            @handlers ||= {
+              self => -> { _1 },
+              Array => -> { MessageArray.new(_1) }
+            }.freeze
           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)]
-            )
+            @to_h ||= Path[[*root, :or]].to_h(messages.map(&:to_h))
+          end
+
+          # @api private
+          def messages
+            @messages ||= _messages.flat_map { _1.to_or(root) }
+          end
+
+          # @api private
+          def root
+            @root ||= _messages.flat_map(&:_paths).reduce(:&)
+          end
+
+          # @api private
+          def path
+            root
+          end
+
+          # @api private
+          def _paths
+            @paths ||= [Path[root]]
+          end
+
+          # @api private
+          def to_or(root)
+            self.root == root ? messages : [self]
+          end
+
+          private
+
+          # @api private
+          def _messages
+            @_messages ||= [left, right].map do |message|
+              handler = self.class.handler(message)
+
+              unless handler
+                raise ArgumentError,
+                      "#{message.inspect} is of unknown type #{message.class.inspect}"
+              end
+
+              handler.(message)
+            end
           end
         end
       end

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

@@ -17,8 +17,8 @@ module Dry
 
           if paths.uniq.size == 1
             SinglePath.new(left, right, messages)
-          elsif right.is_a?(Array)
-            if left.is_a?(Array) && paths.uniq.size > 1
+          elsif MultiPath.handler(right)
+            if MultiPath.handler(left) && paths.uniq.size > 1
               MultiPath.new(left, right)
             else
               right

data/lib/dry/schema/message_compiler.rb

@@ -30,14 +30,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: '',
-          )
+      FULL_MESSAGE_WHITESPACE = Hash.new(" ").merge(
+        ja: "",
+        zh: "",
+        bn: "",
+        th: "",
+        lo: "",
+        my: ""
+      )
 
       param :messages
 
@@ -206,7 +206,8 @@ module Dry
         return text if !text || !full
 
         rule = options[:path]
-        [messages.rule(rule, options) || rule, text].join(FULL_MESSAGE_WHITESPACE[template.options[:locale]])
+        [messages.rule(rule, options) || rule,
+         text].join(FULL_MESSAGE_WHITESPACE[template.options[:locale]])
       end
 
       # @api private
@@ -228,7 +229,9 @@ module Dry
       # @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 }
+        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