dry-schema 1.8.0 → 1.9.0

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

@@ -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/i18n.rb

@@ -5,125 +5,127 @@ require "dry/schema/messages/abstract"
 
 module Dry
   module Schema
-    # I18n message backend
-    #
-    # @api public
-    class Messages::I18n < Messages::Abstract
-      # Translation function
-      #
-      # @return [Method]
-      attr_reader :t
-
-      # @api private
-      def initialize
-        super
-        @t = I18n.method(:t)
-      end
-
-      # Get a message for the given key and its options
-      #
-      # @param [Symbol] key
-      # @param [Hash] options
-      #
-      # @return [String]
+    module Messages
+      # I18n message backend
       #
       # @api public
-      def get(key, options = EMPTY_HASH)
-        return unless key
+      class I18n < Abstract
+        # Translation function
+        #
+        # @return [Method]
+        attr_reader :t
+
+        # @api private
+        def initialize
+          super
+          @t = ::I18n.method(:t)
+        end
 
-        result = t.(key, locale: options.fetch(:locale, default_locale))
+        # Get a message for the given key and its options
+        #
+        # @param [Symbol] key
+        # @param [Hash] options
+        #
+        # @return [String]
+        #
+        # @api public
+        def get(key, options = EMPTY_HASH)
+          return unless key
+
+          result = t.(key, locale: options.fetch(:locale, default_locale))
+
+          if result.is_a?(Hash)
+            text = result[:text]
+            meta = result.dup.tap { |h| h.delete(:text) }
+          else
+            text = result
+            meta = EMPTY_HASH.dup
+          end
 
-        if result.is_a?(Hash)
-          text = result[:text]
-          meta = result.dup.tap { |h| h.delete(:text) }
-        else
-          text = result
-          meta = EMPTY_HASH.dup
+          {
+            text: text,
+            meta: meta
+          }
         end
 
-        {
-          text: text,
-          meta: meta
-        }
-      end
-
-      # Check if given key is defined
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def key?(key, options)
-        I18n.exists?(key, options.fetch(:locale, default_locale)) ||
-          I18n.exists?(key, I18n.default_locale)
-      end
+        # Check if given key is defined
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def key?(key, options)
+          ::I18n.exists?(key, options.fetch(:locale, default_locale)) ||
+            ::I18n.exists?(key, ::I18n.default_locale)
+        end
 
-      # Merge messages from an additional path
-      #
-      # @param [String, Array<String>] paths
-      #
-      # @return [Messages::I18n]
-      #
-      # @api public
-      def merge(paths)
-        prepare(paths)
-      end
+        # Merge messages from an additional path
+        #
+        # @param [String, Array<String>] paths
+        #
+        # @return [Messages::I18n]
+        #
+        # @api public
+        def merge(paths)
+          prepare(paths)
+        end
 
-      # @api private
-      def default_locale
-        super || I18n.locale || I18n.default_locale
-      end
+        # @api private
+        def default_locale
+          super || ::I18n.locale || ::I18n.default_locale
+        end
 
-      # @api private
-      def prepare(paths = config.load_paths)
-        paths.each do |path|
-          data = YAML.load_file(path)
+        # @api private
+        def prepare(paths = config.load_paths)
+          paths.each do |path|
+            data = ::YAML.load_file(path)
 
-          if custom_top_namespace?(path)
-            top_namespace = config.top_namespace
+            if custom_top_namespace?(path)
+              top_namespace = config.top_namespace
 
-            mapped_data = data
-              .map { |k, v| [k, {top_namespace => v[DEFAULT_MESSAGES_ROOT]}] }
-              .to_h
+              mapped_data = data.transform_values { |v|
+                {top_namespace => v[DEFAULT_MESSAGES_ROOT]}
+              }
 
-            store_translations(mapped_data)
-          else
-            store_translations(data)
+              store_translations(mapped_data)
+            else
+              store_translations(data)
+            end
           end
-        end
 
-        self
-      end
+          self
+        end
 
-      # @api private
-      def interpolatable_data(_key, _options, **data)
-        data
-      end
+        # @api private
+        def interpolatable_data(_key, _options, **data)
+          data
+        end
 
-      # @api private
-      def interpolate(key, options, **data)
-        text_key = "#{key}.text"
+        # @api private
+        def interpolate(key, options, **data)
+          text_key = "#{key}.text"
 
-        opts = {
-          locale: default_locale,
-          **options,
-          **data
-        }
+          opts = {
+            locale: default_locale,
+            **options,
+            **data
+          }
 
-        resolved_key = key?(text_key, opts) ? text_key : key
+          resolved_key = key?(text_key, opts) ? text_key : key
 
-        t.(resolved_key, **opts)
-      end
+          t.(resolved_key, **opts)
+        end
 
-      private
+        private
 
-      # @api private
-      def store_translations(data)
-        locales = data.keys.map(&:to_sym)
+        # @api private
+        def store_translations(data)
+          locales = data.keys.map(&:to_sym)
 
-        I18n.available_locales |= locales
+          ::I18n.available_locales |= locales
 
-        locales.each do |locale|
-          I18n.backend.store_translations(locale, data[locale.to_s])
+          locales.each do |locale|
+            ::I18n.backend.store_translations(locale, data[locale.to_s])
+          end
         end
       end
     end

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

@@ -21,6 +21,7 @@ module Dry
 
         # @api private
         def initialize(namespace, messages)
+          super()
           @config = messages.config
           @namespace = namespace
           @messages = messages