dry-schema 1.13.4 → 1.14.1

data/lib/dry/schema/message.rb

@@ -8,9 +8,9 @@ module Dry
     #
     # @api public
     class Message
-      include Dry::Equalizer(:text, :path, :predicate, :input)
+      include ::Dry::Equalizer(:text, :path, :predicate, :input)
 
-      extend Dry::Initializer
+      extend ::Dry::Initializer
 
       # @!attribute [r] text
       #   Message text representation created from a localized template
@@ -75,7 +75,7 @@ module Dry
       #
       # @api private
       def eql?(other)
-        other.is_a?(String) ? text == other : super
+        other.is_a?(::String) ? text == other : super
       end
 
       # @api private
@@ -94,7 +94,7 @@ module Dry
         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

data/lib/dry/schema/message_compiler.rb

@@ -9,7 +9,7 @@ module Dry
     #
     # @api private
     class MessageCompiler
-      extend Dry::Initializer
+      extend ::Dry::Initializer
 
       resolve_key_predicate = proc { |node, opts|
         *arg_vals, val = node.map(&:last)
@@ -20,12 +20,12 @@ module Dry
         [Array(opts.path), *node.map(&:last)]
       }
 
-      DEFAULT_PREDICATE_RESOLVERS = Hash
+      DEFAULT_PREDICATE_RESOLVERS = ::Hash
         .new(resolve_predicate).update(key?: resolve_key_predicate).freeze
 
       EMPTY_OPTS = VisitorOpts.new
       EMPTY_MESSAGE_SET = MessageSet.new(EMPTY_ARRAY).freeze
-      FULL_MESSAGE_WHITESPACE = Hash.new(" ").merge(
+      FULL_MESSAGE_WHITESPACE = ::Hash.new(" ").merge(
         ja: "",
         zh: "",
         bn: "",
@@ -190,7 +190,7 @@ module Dry
       def lookup_options(arg_vals:, input:)
         default_lookup_options.merge(
           arg_type: arg_vals.size == 1 && arg_vals[0].class,
-          val_type: input.equal?(Undefined) ? NilClass : input.class
+          val_type: input.equal?(Undefined) ? ::NilClass : input.class
         )
       end
 
@@ -209,11 +209,11 @@ module Dry
       def message_tokens(args)
         tokens = args.each_with_object({}) do |arg, hash|
           case arg[1]
-          when Array
+          when ::Array, ::Set
             hash[arg[0]] = arg[1].join(LIST_SEPARATOR)
-          when Range
-            hash["#{arg[0]}_left".to_sym] = arg[1].first
-            hash["#{arg[0]}_right".to_sym] = arg[1].last
+          when ::Range
+            hash[:"#{arg[0]}_left"] = arg[1].first
+            hash[:"#{arg[0]}_right"] = arg[1].last
           else
             hash[arg[0]] = arg[1]
           end

data/lib/dry/schema/message_set.rb

@@ -10,8 +10,8 @@ module Dry
     #
     # @api public
     class MessageSet
-      include Enumerable
-      include Dry::Equalizer(:messages, :options)
+      include ::Enumerable
+      include ::Dry::Equalizer(:messages, :options)
 
       # A list of compiled message objects
       #
@@ -44,11 +44,11 @@ module Dry
       # @return [Array]
       #
       # @api public
-      def each(&block)
+      def each(&)
         return self if empty?
-        return to_enum unless block
+        return to_enum unless block_given?
 
-        messages.each(&block)
+        messages.each(&)
       end
 
       # Dump message set to a hash
@@ -82,7 +82,7 @@ module Dry
       #
       # @api public
       def fetch(key)
-        self[key] || raise(KeyError, "+#{key}+ message was not found")
+        self[key] || raise(::KeyError, "+#{key}+ message was not found")
       end
 
       # Check if a message set is empty
@@ -135,9 +135,9 @@ module Dry
       # @api private
       def partition_message_values(values)
         values
-          .map { |value| value.is_a?(Array) ? value : [value] }
+          .map { |value| value.is_a?(::Array) ? value : [value] }
           .reduce(EMPTY_ARRAY.dup, :+)
-          .partition { |value| value.is_a?(Hash) && !value[:text].is_a?(String) }
+          .partition { |value| value.is_a?(::Hash) && !value[:text].is_a?(::String) }
       end
     end
   end

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

@@ -12,11 +12,11 @@ module Dry
       #
       # @api public
       class Abstract
-        include Dry::Configurable
-        include Dry::Equalizer(:config)
+        include ::Dry::Configurable
+        include ::Dry::Equalizer(:config)
 
         setting :default_locale
-        setting :load_paths, default: Set[DEFAULT_MESSAGES_PATH]
+        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
@@ -34,13 +34,13 @@ module Dry
 
         setting :rule_lookup_paths, default: ["rules.%<name>s"].freeze
 
-        setting :arg_types, default: Hash.new { |*| "default" }.update(
-          Range => "range"
+        setting :arg_types, default: ::Hash.new { |*| "default" }.update(
+          ::Range => "range"
         )
 
-        setting :val_types, default: Hash.new { |*| "default" }.update(
-          Range => "range",
-          String => "string"
+        setting :val_types, default: ::Hash.new { |*| "default" }.update(
+          ::Range => "range",
+          ::String => "string"
         )
 
         # @api private
@@ -80,7 +80,7 @@ module Dry
           path = rule_lookup_paths(tokens).detect { |key| key?(key, options) }
 
           rule = get(path, options) if path
-          rule.is_a?(Hash) ? rule[:text] : rule
+          rule.is_a?(::Hash) ? rule[:text] : rule
         end
 
         # Retrieve a message template
@@ -115,7 +115,7 @@ module Dry
         #
         # @api public
         def key?(_key, _options = EMPTY_HASH)
-          raise NotImplementedError
+          raise ::NotImplementedError
         end
 
         # Retrieve an array of looked up paths
@@ -172,12 +172,12 @@ module Dry
 
         # @api private
         def interpolatable_data(_key, _options, **_data)
-          raise NotImplementedError
+          raise ::NotImplementedError
         end
 
         # @api private
         def interpolate(_key, _options, **_data)
-          raise NotImplementedError
+          raise ::NotImplementedError
         end
 
         private

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

@@ -6,7 +6,7 @@ module Dry
       # Namespaced messages backend
       #
       # @api public
-      class Namespaced < Dry::Schema::Messages::Abstract
+      class Namespaced < ::Dry::Schema::Messages::Abstract
         # @api private
         attr_reader :namespace
 

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

@@ -10,8 +10,8 @@ module Dry
     module Messages
       # @api private
       class Template
-        extend Dry::Initializer
-        include Dry::Equalizer(:messages, :key, :options)
+        extend ::Dry::Initializer
+        include ::Dry::Equalizer(:messages, :key, :options)
 
         option :messages
         option :key

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

@@ -14,7 +14,7 @@ module Dry
       class YAML < Abstract
         LOCALE_TOKEN = "%<locale>s"
         TOKEN_REGEXP = /%{(\w*)}/
-        EMPTY_CONTEXT = Object.new.tap { |ctx|
+        EMPTY_CONTEXT = ::Object.new.tap { |ctx|
           def ctx.context
             binding
           end
@@ -165,12 +165,12 @@ module Dry
         # @api private
         def evaluation_context(key, options)
           cache.fetch_or_store(get(key, options).fetch(:text)) do |input|
-            tokens = input.scan(TOKEN_REGEXP).flatten(1).map(&:to_sym).to_set
+            tokens = input.scan(TOKEN_REGEXP).flatten(1).to_set(&:to_sym)
             text = input.gsub("%", "#")
 
             # rubocop:disable Security/Eval
             evaluator = eval(<<~RUBY, EMPTY_CONTEXT, __FILE__, __LINE__ + 1)
-              -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
+              -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }  # -> (a:, b:) { "Translation #\{a} #\{b}" }
             RUBY
             # rubocop:enable Security/Eval
 

data/lib/dry/schema/path.rb

@@ -8,9 +8,9 @@ module Dry
     #
     # @api private
     class Path
-      include Dry.Equalizer(:keys)
-      include Comparable
-      include Enumerable
+      include ::Dry.Equalizer(:keys)
+      include ::Comparable
+      include ::Enumerable
 
       # @return [Array<Symbol>]
       attr_reader :keys
@@ -26,16 +26,16 @@ module Dry
       # @api private
       def self.call(spec)
         case spec
-        when Symbol, Array
-          new(Array[*spec])
-        when String
+        when ::Symbol, ::Array
+          new([*spec])
+        when ::String
           new(spec.split(DOT).map(&:to_sym))
-        when Hash
+        when ::Hash
           new(keys_from_hash(spec))
         when self
           spec
         else
-          raise ArgumentError, "+spec+ must be either a Symbol, Array, Hash or a #{name}"
+          raise ::ArgumentError, "+spec+ must be either a Symbol, Array, Hash or a #{name}"
         end
       end
 
@@ -49,7 +49,7 @@ module Dry
       # @api private
       def self.keys_from_hash(hash)
         hash.inject([]) { |a, (k, v)|
-          v.is_a?(Hash) ? a.concat([k, *keys_from_hash(v)]) : a.concat([k, v])
+          v.is_a?(::Hash) ? a.push(k, *keys_from_hash(v)) : a.push(k, v)
         }
       end
 
@@ -60,14 +60,14 @@ module Dry
 
       # @api private
       def to_h(value = EMPTY_ARRAY.dup)
-        value = [value] unless value.is_a?(Array)
+        value = [value] unless value.is_a?(::Array)
 
         keys.reverse_each.reduce(value) { |result, key| {key => result} }
       end
 
       # @api private
-      def each(&block)
-        keys.each(&block)
+      def each(&)
+        keys.each(&)
       end
 
       # @api private

data/lib/dry/schema/predicate.rb

@@ -13,7 +13,7 @@ module Dry
       #
       # @api private
       class Negation
-        include Dry::Logic::Operators
+        include ::Dry::Logic::Operators
 
         # @api private
         attr_reader :predicate
@@ -34,8 +34,8 @@ module Dry
         alias_method :ast, :to_ast
       end
 
-      include Dry::Logic::Operators
-      include Dry::Equalizer(:name, :args, :block)
+      include ::Dry::Logic::Operators
+      include ::Dry::Equalizer(:name, :args, :block)
 
       # @api private
       attr_reader :compiler
@@ -77,7 +77,7 @@ module Dry
       # @api private
       def ensure_valid
         if arity - 1 != args.size
-          raise ArgumentError, "#{name} predicate arity is invalid"
+          raise ::ArgumentError, "#{name} predicate arity is invalid"
         end
       end
 

data/lib/dry/schema/predicate_registry.rb

@@ -5,7 +5,7 @@ module Dry
     # A registry with predicate objects from `Dry::Logic::Predicates`
     #
     # @api private
-    class PredicateRegistry < Dry::Types::PredicateRegistry
+    class PredicateRegistry < ::Dry::Types::PredicateRegistry
       # @api private
       def arg_list(name, *values)
         predicate = self[name]
@@ -15,7 +15,7 @@ module Dry
         predicate
           .parameters
           .map(&:last)
-          .zip(values + Array.new(arity - values.size, Undefined))
+          .zip(values + ::Array.new(arity - values.size, Undefined))
       end
     end
   end

data/lib/dry/schema/processor.rb

@@ -13,10 +13,10 @@ module Dry
     #
     # @api public
     class Processor
-      extend Dry::Initializer
-      extend Dry::Configurable
+      extend ::Dry::Initializer
+      extend ::Dry::Configurable
 
-      include Dry::Logic::Operators
+      include ::Dry::Logic::Operators
 
       setting :key_map_type
       setting :type_registry_namespace, default: :strict
@@ -42,9 +42,9 @@ module Dry
         # @return [Class]
         #
         # @api public
-        def define(&block)
+        def define(&)
           @definition ||= DSL.new(
-            processor_type: self, parent: superclass.definition, **config.to_h, &block
+            processor_type: self, parent: superclass.definition, **config.to_h, &
           )
           self
         end
@@ -54,15 +54,15 @@ module Dry
         # @return [Processor]
         #
         # @api public
-        def new(options = nil, &block)
-          if options || block
+        def new(options = nil)
+          if options || block_given?
             processor = super(**(options || EMPTY_HASH))
-            yield(processor) if block
+            yield(processor) if block_given?
             processor
           elsif definition
             definition.call
           else
-            raise ArgumentError, "Cannot create a schema without a definition"
+            raise ::ArgumentError, "Cannot create a schema without a definition"
           end
         end
       end
@@ -83,7 +83,7 @@ module Dry
 
       # @api public
       def xor(_other)
-        raise NotImplementedError, "composing schemas using `xor` operator is not supported yet"
+        raise ::NotImplementedError, "composing schemas using `xor` operator is not supported yet"
       end
       alias_method :^, :xor
 

data/lib/dry/schema/processor_steps.rb

@@ -19,7 +19,7 @@ module Dry
     #
     # @api public
     class ProcessorSteps
-      extend Dry::Initializer
+      extend ::Dry::Initializer
 
       option :steps, default: -> { EMPTY_HASH.dup }
       option :before_steps, default: -> { EMPTY_HASH.dup }

data/lib/dry/schema/result.rb

@@ -11,9 +11,9 @@ module Dry
     #
     # @api public
     class Result
-      include Dry::Equalizer(:output, :errors)
+      include ::Dry::Equalizer(:output, :errors)
 
-      extend Dry::Initializer[undefined: false]
+      extend ::Dry::Initializer[undefined: false]
 
       # @api private
       param :output, reader: false
@@ -43,18 +43,18 @@ module Dry
       # @return [Result]
       #
       # @api private
-      def at(at_path, &block)
-        new(@output, path: Path.new([*path, *Path[at_path]]), &block)
+      def at(at_path, &)
+        new(@output, path: Path.new([*path, *Path[at_path]]), &)
       end
 
       # @api private
-      def new(output, **opts, &block)
+      def new(output, **opts, &)
         self.class.new(
           output,
           message_compiler: message_compiler,
           result_ast: result_ast,
           **opts,
-          &block
+          &
         )
       end
 

data/lib/dry/schema/rule_applier.rb

@@ -9,7 +9,7 @@ module Dry
     #
     # @api private
     class RuleApplier
-      extend Dry::Initializer
+      extend ::Dry::Initializer
 
       # @api private
       param :rules

data/lib/dry/schema/trace.rb

@@ -5,7 +5,7 @@ module Dry
     # Captures predicates defined within the DSL
     #
     # @api private
-    class Trace < BasicObject
+    class Trace < ::BasicObject
       INVALID_PREDICATES = %i[key?].freeze
 
       include ::Dry::Equalizer(:compiler, :captures)

data/lib/dry/schema/type_container.rb

@@ -13,9 +13,9 @@ module Dry
     #
     # @api public
     class TypeContainer
-      include Dry::Core::Container::Mixin
+      include ::Dry::Core::Container::Mixin
 
-      def initialize(types_container = Dry::Types.container)
+      def initialize(types_container = ::Dry::Types.container)
         super()
 
         merge(types_container)

data/lib/dry/schema/type_registry.rb

@@ -18,7 +18,7 @@ module Dry
       attr_reader :namespace
 
       # @api private
-      def self.new(types = Dry::Types, namespace = :strict)
+      def self.new(types = ::Dry::Types, namespace = :strict)
         super
       end
 

data/lib/dry/schema/types.rb

@@ -8,7 +8,7 @@ module Dry
     #
     # @api public
     module Types
-      include Dry.Types
+      include ::Dry.Types
     end
   end
 end

data/lib/dry/schema/types_merger.rb

@@ -27,14 +27,14 @@ module Dry
 
         # @api private
         def call
-          if op_class <= Dry::Logic::Operations::Or
+          if op_class <= ::Dry::Logic::Operations::Or
             merge_or
-          elsif op_class <= Dry::Logic::Operations::And
+          elsif op_class <= ::Dry::Logic::Operations::And
             merge_and
-          elsif op_class <= Dry::Logic::Operations::Implication
+          elsif op_class <= ::Dry::Logic::Operations::Implication
             merge_implication
           else
-            raise ArgumentError, <<~MESSAGE
+            raise ::ArgumentError, <<~MESSAGE
               Can't merge operations, op_class=#{op_class}
             MESSAGE
           end
@@ -58,7 +58,7 @@ module Dry
 
           rule = [old_rule, new_rule].compact.reduce { op_class.new(_1, _2) }
 
-          type = Dry::Types::Constrained.new(type, rule: rule) if rule
+          type = ::Dry::Types::Constrained.new(type, rule: rule) if rule
 
           type
         end
@@ -66,61 +66,17 @@ module Dry
         alias_method :merge_and, :merge_ordered
         alias_method :merge_implication, :merge_ordered
 
-        if RUBY_VERSION >= "3.0"
-          class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            # @api private
-            def merge_unwrapped_types(unwrapped_old, unwrapped_new)
-              case [unwrapped_old, unwrapped_new]
-              in Dry::Types::Schema, Dry::Types::Schema
-                merge_schemas(unwrapped_old, unwrapped_new)
-              in [Dry::Types::AnyClass, _] | [Dry::Types::Hash, Dry::Types::Schema]
-                unwrapped_new
-              in [Dry::Types::Schema, Dry::Types::Hash] | [_, Dry::Types::AnyClass]
-                unwrapped_old
-              else
-                merge_equivalent_types(unwrapped_old, unwrapped_new)
-              end
-            end
-          RUBY
-        else
-          # @api private
-          def merge_unwrapped_types(unwrapped_old, unwrapped_new)
-            if change_from_schema_to_schema?(unwrapped_old, unwrapped_new)
-              merge_schemas(unwrapped_old, unwrapped_new)
-            elsif change_from_any?(unwrapped_old) || change_from_hash_to_schema?(unwrapped_old,
-                                                                                 unwrapped_new)
-              unwrapped_new
-            elsif change_from_schema_to_hash?(unwrapped_old,
-                                              unwrapped_new) || change_to_any?(unwrapped_new)
-              unwrapped_old
-            else
-              merge_equivalent_types(unwrapped_old, unwrapped_new)
-            end
-          end
-
-          # @api private
-          def change_from_any?(unwrapped_old)
-            unwrapped_old.is_a?(Dry::Types::AnyClass)
-          end
-
-          # @api private
-          def change_to_any?(unwrapped_new)
-            unwrapped_new.is_a?(Dry::Types::AnyClass)
-          end
-
-          # @api private
-          def change_from_hash_to_schema?(unwrapped_old, unwrapped_new)
-            unwrapped_old.is_a?(Dry::Types::Hash) && unwrapped_new.is_a?(Dry::Types::Schema)
-          end
-
-          # @api private
-          def change_from_schema_to_hash?(unwrapped_old, unwrapped_new)
-            unwrapped_old.is_a?(Dry::Types::Schema) && unwrapped_new.is_a?(Dry::Types::Hash)
-          end
-
-          # @api private
-          def change_from_schema_to_schema?(unwrapped_old, unwrapped_new)
-            unwrapped_old.is_a?(Dry::Types::Schema) && unwrapped_new.is_a?(Dry::Types::Schema)
+        # @api private
+        def merge_unwrapped_types(unwrapped_old, unwrapped_new)
+          case [unwrapped_old, unwrapped_new]
+          in ::Dry::Types::Schema, ::Dry::Types::Schema
+            merge_schemas(unwrapped_old, unwrapped_new)
+          in [::Dry::Types::AnyClass, _] | [::Dry::Types::Hash, ::Dry::Types::Schema]
+            unwrapped_new
+          in [::Dry::Types::Schema, ::Dry::Types::Hash] | [_, ::Dry::Types::AnyClass]
+            unwrapped_old
+          else
+            merge_equivalent_types(unwrapped_old, unwrapped_new)
           end
         end
 
@@ -142,7 +98,7 @@ module Dry
           elsif unwrapped_new.primitive <= unwrapped_old.primitive
             unwrapped_old
           else
-            raise ArgumentError, <<~MESSAGE
+            raise ::ArgumentError, <<~MESSAGE
               Can't merge types, unwrapped_old=#{unwrapped_old.inspect}, unwrapped_new=#{unwrapped_new.inspect}
             MESSAGE
           end
@@ -157,7 +113,7 @@ module Dry
 
             if type.optional?
               type = type.left.primitive?(nil) ? type.right : type.left
-            elsif type.is_a?(Dry::Types::Decorator)
+            elsif type.is_a?(::Dry::Types::Decorator)
               type = type.type
             else
               break

data/lib/dry/schema/value_coercer.rb

@@ -9,7 +9,7 @@ module Dry
     #
     # @api private
     class ValueCoercer
-      extend Dry::Initializer
+      extend ::Dry::Initializer
       include ::Dry::Equalizer(:type_schema)
 
       # @api private

data/lib/dry/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module Schema
-    VERSION = "1.13.4"
+    VERSION = "1.14.1"
   end
 end