dry-schema 1.13.1 → 1.14.1

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

@@ -7,7 +7,7 @@ module Dry
       #
       # @api public
       class DSL < Core
-        include Dry::Logic::Operators
+        include ::Dry::Logic::Operators
 
         undef :eql?
         undef :nil?

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

@@ -13,8 +13,7 @@ module Dry
 
           append_macro(Macros::Value) do |macro|
             if opts[:type_spec] && !filter_empty_string?
-              macro.call(predicates[0], :filled?, *predicates[1..predicates.size - 1], **opts,
-                         &block)
+              macro.call(predicates[0], :filled?, *predicates.drop(1), **opts, &block)
             elsif opts[:type_rule]
               macro.call(:filled?).value(*predicates, **opts, &block)
             else

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

@@ -21,7 +21,7 @@ module Dry
                 else
                   optional(key.name).value(key.type)
                 end
-                instance_exec(&block) if block
+                instance_exec(&block) if block_given?
               end
             end
           else

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

@@ -11,7 +11,7 @@ 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)
+          if args.size.equal?(1) && (op = args.first).is_a?(::Dry::Logic::Operations::Abstract)
             process_operation(op)
           end
 
@@ -55,8 +55,8 @@ module Dry
 
         # @api private
         # rubocop: disable Metrics/AbcSize
-        def define(*args, &block)
-          definition = schema_dsl.new(path: schema_dsl.path, &block)
+        def define(*args, &)
+          definition = schema_dsl.new(path: schema_dsl.path, &)
           schema = definition.call
           type_schema =
             if array_type?(parent_type)

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

@@ -12,11 +12,11 @@ module Dry
         # 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) }
+        def call(*args, **opts, &)
+          types, predicates = args.partition { _1.is_a?(::Dry::Types::Type) }
 
-          constructor = types.select { |type| type.is_a?(Dry::Types::Constructor) }.reduce(:>>)
-          schema = predicates.detect { |predicate| predicate.is_a?(Processor) }
+          constructor = types.select { _1.is_a?(::Dry::Types::Constructor) }.reduce(:>>)
+          schema = predicates.detect { _1.is_a?(Processor) }
 
           schema_dsl.set_type(name, constructor) if constructor
 
@@ -41,20 +41,20 @@ module Dry
             end
           end
 
-          trace_opts = opts.reject { |key, _| %i[type_spec type_rule].include?(key) }
+          trace_opts = opts.except(:type_spec, :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
+            trace.append(new(chain: false).instance_exec(&)) if block_given?
           else
             trace.evaluate(*predicates, **trace_opts)
 
-            if block && type_spec.equal?(:hash)
-              hash(&block)
+            if block_given? && type_spec.equal?(:hash)
+              hash(&)
             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))
+            elsif block_given?
+              trace.append(new(chain: false).instance_exec(&))
             end
           end
 
@@ -112,9 +112,9 @@ module Dry
         private
 
         # @api private
-        def method_missing(meth, *args, &block)
+        def method_missing(meth, ...)
           if meth.to_s.end_with?(QUESTION_MARK)
-            trace.__send__(meth, *args, &block)
+            trace.__send__(meth, ...)
           else
             super
           end

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