dry-schema 1.6.2 → 1.9.0

data/lib/dry/schema/key.rb

@@ -85,94 +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] = value.is_a?(::Array) ? value.map { |el| member.write(el) } : value
-        }
-      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
 
@@ -46,22 +36,58 @@ module Dry
 
       private
 
+      # @api private
+      def validate_path(key_paths, path)
+        if path[INDEX_REGEX]
+          key = path.gsub(INDEX_REGEX, BRACKETS)
+
+          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
+
+      # @api private
+      def paths_match?(input_path, key_path)
+        residue = key_path.sub(input_path, "")
+        residue.empty? || residue.start_with?(DOT, BRACKETS)
+      end
+
       # @api private
       def key_paths(hash)
-        hash.flat_map { |key, _|
-          case (value = hash[key])
-          when Hash
-            [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) }
-            hashes_or_arrays.flat_map.with_index { |el, idx|
-              key_paths(el).map { |path| ["#{key}[#{idx}]", *path].join(DOT) }
-            }
+        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,9 +11,18 @@ module Dry
       # @api private
       class Value < DSL
         # @api private
-        def call(*predicates, **opts, &block)
+        #
+        # 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) }
+
+          constructor = types.select { |type| type.is_a?(Dry::Types::Constructor) }.reduce(:>>)
           schema = predicates.detect { |predicate| predicate.is_a?(Processor) }
 
+          schema_dsl.set_type(name, constructor) if constructor
+
           type_spec = opts[:type_spec]
 
           if schema
@@ -60,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

@@ -17,17 +17,19 @@ module Dry
           attr_reader :root
 
           # @api private
-          def initialize(*args)
+          def initialize(...)
             super
-            @root = [left, right].flatten.map(&:_path).reduce(:&)
-            @left = left.map { |msg| msg.to_or(root) }
-            @right = right.map { |msg| msg.to_or(root) }
+            flat_left = left.flatten
+            flat_right = right.flatten
+            @root = [*flat_left, *flat_right].map(&:_path).reduce(:&)
+            @left = flat_left.map { _1.to_or(root) }
+            @right = flat_right.map { _1.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)]
+              [MessageSet.new(left).to_h, MessageSet.new(right).to_h]
             )
           end
         end

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

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

@@ -18,13 +18,13 @@ module Dry
         include Dry::Configurable
         include Dry::Equalizer(:config)
 
-        setting :default_locale, nil
-        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 :default_locale
+        setting :load_paths, default: Set[DEFAULT_MESSAGES_PATH]
+        setting :top_namespace, default: DEFAULT_MESSAGES_ROOT
+        setting :root, default: "errors"
+        setting :lookup_options, default: %i[root predicate path val_type arg_type].freeze
 
-        setting :lookup_paths, [
+        setting :lookup_paths, default: [
           "%<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",
@@ -35,13 +35,13 @@ module Dry
           "%<root>s.%<predicate>s"
         ].freeze
 
-        setting :rule_lookup_paths, ["rules.%<name>s"].freeze
+        setting :rule_lookup_paths, default: ["rules.%<name>s"].freeze
 
-        setting :arg_types, Hash.new { |*| "default" }.update(
+        setting :arg_types, default: Hash.new { |*| "default" }.update(
           Range => "range"
         )
 
-        setting :val_types, Hash.new { |*| "default" }.update(
+        setting :val_types, default: Hash.new { |*| "default" }.update(
           Range => "range",
           String => "string"
         )