activesupport 6.1.0 → 7.1.5.1

data/lib/active_support/core_ext/hash/deep_transform_values.rb

@@ -5,10 +5,10 @@ class Hash
   # This includes the values from the root hash and from all
   # nested hashes and arrays.
   #
-  #  hash = { person: { name: 'Rob', age: '28' } }
+  #   hash = { person: { name: 'Rob', age: '28' } }
   #
-  #  hash.deep_transform_values{ |value| value.to_s.upcase }
-  #  # => {person: {name: "ROB", age: "28"}}
+  #   hash.deep_transform_values{ |value| value.to_s.upcase }
+  #   # => {person: {name: "ROB", age: "28"}}
   def deep_transform_values(&block)
     _deep_transform_values_in_object(self, &block)
   end

data/lib/active_support/core_ext/hash/indifferent_access.rb

@@ -3,7 +3,7 @@
 require "active_support/hash_with_indifferent_access"
 
 class Hash
-  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
+  # Returns an ActiveSupport::HashWithIndifferentAccess out of its receiver:
   #
   #   { a: 1 }.with_indifferent_access['a'] # => 1
   def with_indifferent_access
@@ -13,8 +13,8 @@ class Hash
   # Called when object is nested under an object that receives
   # #with_indifferent_access. This method will be called on the current object
   # by the enclosing object and is aliased to #with_indifferent_access by
-  # default. Subclasses of Hash may overwrite this method to return +self+ if
-  # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
+  # default. Subclasses of Hash may override this method to return +self+ if
+  # converting to an ActiveSupport::HashWithIndifferentAccess would not be
   # desirable.
   #
   #   b = { b: 1 }

data/lib/active_support/core_ext/hash/keys.rb

@@ -58,10 +58,10 @@ class Hash
   # This includes the keys from the root hash and from all
   # nested hashes and arrays.
   #
-  #  hash = { person: { name: 'Rob', age: '28' } }
+  #   hash = { person: { name: 'Rob', age: '28' } }
   #
-  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
-  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  #   hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #   # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
   def deep_transform_keys(&block)
     _deep_transform_keys_in_object(self, &block)
   end
@@ -116,7 +116,7 @@ class Hash
     def _deep_transform_keys_in_object(object, &block)
       case object
       when Hash
-        object.each_with_object({}) do |(key, value), result|
+        object.each_with_object(self.class.new) do |(key, value), result|
           result[yield(key)] = _deep_transform_keys_in_object(value, &block)
         end
       when Array

data/lib/active_support/core_ext/integer/inflections.rb

@@ -6,12 +6,12 @@ class Integer
   # Ordinalize turns a number into an ordinal string used to denote the
   # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
   #
-  #  1.ordinalize     # => "1st"
-  #  2.ordinalize     # => "2nd"
-  #  1002.ordinalize  # => "1002nd"
-  #  1003.ordinalize  # => "1003rd"
-  #  -11.ordinalize   # => "-11th"
-  #  -1001.ordinalize # => "-1001st"
+  #   1.ordinalize     # => "1st"
+  #   2.ordinalize     # => "2nd"
+  #   1002.ordinalize  # => "1002nd"
+  #   1003.ordinalize  # => "1003rd"
+  #   -11.ordinalize   # => "-11th"
+  #   -1001.ordinalize # => "-1001st"
   def ordinalize
     ActiveSupport::Inflector.ordinalize(self)
   end
@@ -19,12 +19,12 @@ class Integer
   # Ordinal returns the suffix used to denote the position
   # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
   #
-  #  1.ordinal     # => "st"
-  #  2.ordinal     # => "nd"
-  #  1002.ordinal  # => "nd"
-  #  1003.ordinal  # => "rd"
-  #  -11.ordinal   # => "th"
-  #  -1001.ordinal # => "st"
+  #   1.ordinal     # => "st"
+  #   2.ordinal     # => "nd"
+  #   1002.ordinal  # => "nd"
+  #   1003.ordinal  # => "rd"
+  #   -11.ordinal   # => "th"
+  #   -1001.ordinal # => "st"
   def ordinal
     ActiveSupport::Inflector.ordinal(self)
   end

data/lib/active_support/core_ext/kernel/reporting.rb

@@ -11,14 +11,14 @@ module Kernel
   #   end
   #
   #   noisy_call # warning voiced
-  def silence_warnings
-    with_warnings(nil) { yield }
+  def silence_warnings(&block)
+    with_warnings(nil, &block)
   end
 
   # Sets $VERBOSE to +true+ for the duration of the block and back to its
   # original value afterwards.
-  def enable_warnings
-    with_warnings(true) { yield }
+  def enable_warnings(&block)
+    with_warnings(true, &block)
   end
 
   # Sets $VERBOSE for the duration of the block and back to its original

data/lib/active_support/core_ext/kernel/singleton_class.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Kernel
-  # class_eval on an object acts like singleton_class.class_eval.
+  # class_eval on an object acts like +singleton_class.class_eval+.
   def class_eval(*args, &block)
     singleton_class.class_eval(*args, &block)
   end

data/lib/active_support/core_ext/module/attribute_accessors.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# == Attribute Accessors
+#
 # Extends the module object with class/module and instance accessors for
 # class/module attributes, just like the native attr* accessors for instance
 # attributes.
@@ -41,6 +43,7 @@ class Module
   #
   #   module HairColors
   #     mattr_reader :hair_colors, default: [:brown, :black, :blonde, :red]
+  #     mattr_reader(:hair_styles) { [:long, :short] }
   #   end
   #
   #   class Person
@@ -48,6 +51,7 @@ class Module
   #   end
   #
   #   Person.new.hair_colors # => [:brown, :black, :blonde, :red]
+  #   Person.new.hair_styles # => [:long, :short]
   def mattr_reader(*syms, instance_reader: true, instance_accessor: true, default: nil, location: nil)
     raise TypeError, "module attributes should be defined directly on class, not singleton" if singleton_class?
     location ||= caller_locations(1, 1).first
@@ -105,6 +109,7 @@ class Module
   #
   #   module HairColors
   #     mattr_writer :hair_colors, default: [:brown, :black, :blonde, :red]
+  #     mattr_writer(:hair_styles) { [:long, :short] }
   #   end
   #
   #   class Person
@@ -112,6 +117,7 @@ class Module
   #   end
   #
   #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
+  #   Person.class_variable_get("@@hair_styles") # => [:long, :short]
   def mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil, location: nil)
     raise TypeError, "module attributes should be defined directly on class, not singleton" if singleton_class?
     location ||= caller_locations(1, 1).first
@@ -190,6 +196,7 @@ class Module
   #
   #   module HairColors
   #     mattr_accessor :hair_colors, default: [:brown, :black, :blonde, :red]
+  #     mattr_accessor(:hair_styles) { [:long, :short] }
   #   end
   #
   #   class Person
@@ -197,6 +204,7 @@ class Module
   #   end
   #
   #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
+  #   Person.class_variable_get("@@hair_styles") # => [:long, :short]
   def mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil, &blk)
     location = caller_locations(1, 1).first
     mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default, location: location, &blk)

data/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
+# == Attribute Accessors per Thread
+#
 # Extends the module object with class/module and instance accessors for
 # class/module attributes, just like the native attr* accessors for instance
 # attributes, but does so on a per-thread basis.
 #
 # So the values are scoped within the Thread.current space under the class name
 # of the module.
+#
+# Note that it can also be scoped per-fiber if +Rails.application.config.active_support.isolation_level+
+# is set to +:fiber+.
 class Module
   # Defines a per-thread class attribute and creates class and instance reader methods.
   # The underlying per-thread class variable is set to +nil+, if it is not previously defined.
@@ -14,9 +19,9 @@ class Module
   #     thread_mattr_reader :user
   #   end
   #
-  #   Current.user # => nil
-  #   Thread.current[:attr_Current_user] = "DHH"
+  #   Current.user = "DHH"
   #   Current.user # => "DHH"
+  #   Thread.new { Current.user }.value # => nil
   #
   # The attribute name must be a valid method name in Ruby.
   #
@@ -37,13 +42,32 @@ class Module
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
 
-      # The following generated method concatenates `name` because we want it
-      # to work with inheritance via polymorphism.
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}
-          Thread.current["attr_" + name + "_#{sym}"]
-        end
-      EOS
+      # The following generated method concatenates `object_id` because we want
+      # subclasses to maintain independent values.
+      if default.nil?
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def self.#{sym}
+            @__thread_mattr_#{sym} ||= "attr_#{sym}_\#{object_id}"
+            ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}]
+          end
+        EOS
+      else
+        default = default.dup.freeze unless default.frozen?
+        singleton_class.define_method("#{sym}_default_value") { default }
+
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def self.#{sym}
+            @__thread_mattr_#{sym} ||= "attr_#{sym}_\#{object_id}"
+            value = ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}]
+
+            if value.nil? && !::ActiveSupport::IsolatedExecutionState.key?(@__thread_mattr_#{sym})
+              ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}] = #{sym}_default_value
+            else
+              value
+            end
+          end
+        EOS
+      end
 
       if instance_reader && instance_accessor
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
@@ -52,8 +76,6 @@ class Module
           end
         EOS
       end
-
-      Thread.current["attr_" + name + "_#{sym}"] = default unless default.nil?
     end
   end
   alias :thread_cattr_reader :thread_mattr_reader
@@ -76,15 +98,16 @@ class Module
   #   end
   #
   #   Current.new.user = "DHH" # => NoMethodError
-  def thread_mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil) # :nodoc:
+  def thread_mattr_writer(*syms, instance_writer: true, instance_accessor: true) # :nodoc:
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
 
-      # The following generated method concatenates `name` because we want it
-      # to work with inheritance via polymorphism.
+      # The following generated method concatenates `object_id` because we want
+      # subclasses to maintain independent values.
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{sym}=(obj)
-          Thread.current["attr_" + name + "_#{sym}"] = obj
+          @__thread_mattr_#{sym} ||= "attr_#{sym}_\#{object_id}"
+          ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}] = obj
         end
       EOS
 
@@ -95,8 +118,6 @@ class Module
           end
         EOS
       end
-
-      public_send("#{sym}=", default) unless default.nil?
     end
   end
   alias :thread_cattr_writer :thread_mattr_writer
@@ -111,16 +132,18 @@ class Module
   #   Account.user     # => "DHH"
   #   Account.new.user # => "DHH"
   #
+  # Unlike +mattr_accessor+, values are *not* shared with subclasses or parent classes.
   # If a subclass changes the value, the parent class' value is not changed.
-  # Similarly, if the parent class changes the value, the value of subclasses
-  # is not changed.
+  # If the parent class changes the value, the value of subclasses is not changed.
   #
   #   class Customer < Account
   #   end
   #
-  #   Customer.user = "Rafael"
-  #   Customer.user # => "Rafael"
-  #   Account.user  # => "DHH"
+  #   Account.user   # => "DHH"
+  #   Customer.user  # => nil
+  #   Customer.user  = "Rafael"
+  #   Customer.user  # => "Rafael"
+  #   Account.user   # => "DHH"
   #
   # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
   # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
@@ -140,6 +163,10 @@ class Module
   #
   #   Current.new.user = "DHH"  # => NoMethodError
   #   Current.new.user          # => NoMethodError
+  #
+  # A default value may be specified using the +:default+ option. Because
+  # multiple threads can access the default value, non-frozen default values
+  # will be <tt>dup</tt>ed and frozen.
   def thread_mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil)
     thread_mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default)
     thread_mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor)

data/lib/active_support/core_ext/module/concerning.rb

@@ -3,7 +3,7 @@
 require "active_support/concern"
 
 class Module
-  # = Bite-sized separation of concerns
+  # == Bite-sized separation of concerns
   #
   # We often find ourselves with a medium-sized chunk of behavior that we'd
   # like to extract, but only mix in to a single class.
@@ -18,9 +18,9 @@ class Module
   # with a comment, as a least-bad alternative. Using modules in separate files
   # means tedious sifting to get a big-picture view.
   #
-  # = Dissatisfying ways to separate small concerns
+  # == Dissatisfying ways to separate small concerns
   #
-  # == Using comments:
+  # === Using comments:
   #
   #   class Todo < ApplicationRecord
   #     # Other todo implementation
@@ -37,7 +37,7 @@ class Module
   #       end
   #   end
   #
-  # == With an inline module:
+  # === With an inline module:
   #
   # Noisy syntax.
   #
@@ -61,7 +61,7 @@ class Module
   #     include EventTracking
   #   end
   #
-  # == Mix-in noise exiled to its own file:
+  # === Mix-in noise exiled to its own file:
   #
   # Once our chunk of behavior starts pushing the scroll-to-understand-it
   # boundary, we give in and move it to a separate file. At this size, the
@@ -75,7 +75,7 @@ class Module
   #     include TodoEventTracking
   #   end
   #
-  # = Introducing Module#concerning
+  # == Introducing Module#concerning
   #
   # By quieting the mix-in noise, we arrive at a natural, low-ceremony way to
   # separate bite-sized concerns.

data/lib/active_support/core_ext/module/delegation.rb

@@ -7,9 +7,9 @@ class Module
   # option is not used.
   class DelegationError < NoMethodError; end
 
-  RUBY_RESERVED_KEYWORDS = %w(alias and BEGIN begin break case class def defined? do
-  else elsif END end ensure false for if in module next nil not or redo rescue retry
-  return self super then true undef unless until when while yield)
+  RUBY_RESERVED_KEYWORDS = %w(__ENCODING__ __LINE__ __FILE__ alias and BEGIN begin break
+  case class def defined? do else elsif END end ensure false for if in module next nil
+  not or redo rescue retry return self super then true undef unless until when while yield)
   DELEGATION_RESERVED_KEYWORDS = %w(_ arg args block)
   DELEGATION_RESERVED_METHOD_NAMES = Set.new(
     RUBY_RESERVED_KEYWORDS + DELEGATION_RESERVED_KEYWORDS
@@ -187,25 +187,49 @@ class Module
     location = caller_locations(1, 1).first
     file, line = location.path, location.lineno
 
-    to = to.to_s
-    to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)
+    receiver = to.to_s
+    receiver = "self.#{receiver}" if DELEGATION_RESERVED_METHOD_NAMES.include?(receiver)
 
     method_def = []
     method_names = []
 
-    methods.map do |method|
+    method_def << "self.private" if private
+
+    methods.each do |method|
       method_name = prefix ? "#{method_prefix}#{method}" : method
       method_names << method_name.to_sym
 
       # Attribute writer methods only accept one argument. Makes sure []=
       # methods still accept two arguments.
-      definition = if /[^\]]=$/.match?(method)
-        "arg"
-      elsif RUBY_VERSION >= "2.7"
-        "..."
-      else
-        "*args, &block"
-      end
+      definition = \
+        if /[^\]]=\z/.match?(method)
+          "arg"
+        else
+          method_object =
+            begin
+              if to.is_a?(Module)
+                to.method(method)
+              elsif receiver == "self.class"
+                method(method)
+              end
+            rescue NameError
+              # Do nothing. Fall back to `"..."`
+            end
+
+          if method_object
+            parameters = method_object.parameters
+
+            if (parameters.map(&:first) & [:opt, :rest, :keyreq, :key, :keyrest]).any?
+              "..."
+            else
+              defn = parameters.filter_map { |type, arg| arg if type == :req }
+              defn << "&block"
+              defn.join(", ")
+            end
+          else
+            "..."
+          end
+        end
 
       # The following generated method calls the target exactly once, storing
       # the returned value in a dummy variable.
@@ -219,7 +243,7 @@ class Module
 
         method_def <<
           "def #{method_name}(#{definition})" <<
-          "  _ = #{to}" <<
+          "  _ = #{receiver}" <<
           "  if !_.nil? || nil.respond_to?(:#{method})" <<
           "    _.#{method}(#{definition})" <<
           "  end" <<
@@ -230,11 +254,11 @@ class Module
 
         method_def <<
           "def #{method_name}(#{definition})" <<
-          "  _ = #{to}" <<
+          "  _ = #{receiver}" <<
           "  _.#{method}(#{definition})" <<
           "rescue NoMethodError => e" <<
           "  if _.nil? && e.name == :#{method}" <<
-          %(   raise DelegationError, "#{self}##{method_name} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}") <<
+          %(   raise DelegationError, "#{self}##{method_name} delegated to #{receiver}.#{method}, but #{receiver} is nil: \#{self.inspect}") <<
           "  else" <<
           "    raise" <<
           "  end" <<
@@ -242,7 +266,6 @@ class Module
       end
     end
     module_eval(method_def.join(";"), file, line)
-    private(*method_names) if private
     method_names
   end
 
@@ -294,37 +317,52 @@ class Module
   # of <tt>object</tt> add or remove instance variables.
   def delegate_missing_to(target, allow_nil: nil)
     target = target.to_s
-    target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)
+    target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target) || target == "__target"
 
-    module_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def respond_to_missing?(name, include_private = false)
-        # It may look like an oversight, but we deliberately do not pass
-        # +include_private+, because they do not get delegated.
+    if allow_nil
+      module_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def respond_to_missing?(name, include_private = false)
+          # It may look like an oversight, but we deliberately do not pass
+          # +include_private+, because they do not get delegated.
 
-        return false if name == :marshal_dump || name == :_dump
-        #{target}.respond_to?(name) || super
-      end
+          return false if name == :marshal_dump || name == :_dump
+          #{target}.respond_to?(name) || super
+        end
 
-      def method_missing(method, *args, &block)
-        if #{target}.respond_to?(method)
-          #{target}.public_send(method, *args, &block)
-        else
-          begin
+        def method_missing(method, *args, &block)
+          __target = #{target}
+          if __target.nil? && !nil.respond_to?(method)
+            nil
+          elsif __target.respond_to?(method)
+            __target.public_send(method, *args, &block)
+          else
             super
-          rescue NoMethodError
-            if #{target}.nil?
-              if #{allow_nil == true}
-                nil
-              else
-                raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
-              end
-            else
-              raise
-            end
           end
         end
-      end
-      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
-    RUBY
+        ruby2_keywords(:method_missing)
+      RUBY
+    else
+      module_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def respond_to_missing?(name, include_private = false)
+          # It may look like an oversight, but we deliberately do not pass
+          # +include_private+, because they do not get delegated.
+
+          return false if name == :marshal_dump || name == :_dump
+          #{target}.respond_to?(name) || super
+        end
+
+        def method_missing(method, *args, &block)
+          __target = #{target}
+          if __target.nil? && !nil.respond_to?(method)
+            raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
+          elsif __target.respond_to?(method)
+            __target.public_send(method, *args, &block)
+          else
+            super
+          end
+        end
+        ruby2_keywords(:method_missing)
+      RUBY
+    end
   end
 end

data/lib/active_support/core_ext/module/deprecation.rb

@@ -1,17 +1,12 @@
 # frozen_string_literal: true
 
 class Module
-  #   deprecate :foo
-  #   deprecate bar: 'message'
-  #   deprecate :foo, :bar, baz: 'warning!', qux: 'gone!'
+  #   deprecate :foo, deprecator: MyLib.deprecator
+  #   deprecate :foo, bar: "warning!", deprecator: MyLib.deprecator
   #
-  # You can also use custom deprecator instance:
-  #
-  #   deprecate :foo, deprecator: MyLib::Deprecator.new
-  #   deprecate :foo, bar: "warning!", deprecator: MyLib::Deprecator.new
-  #
-  # \Custom deprecators must respond to <tt>deprecation_warning(deprecated_method_name, message, caller_backtrace)</tt>
-  # method where you can implement your custom warning behavior.
+  # A deprecator is typically an instance of ActiveSupport::Deprecation, but you can also pass any object that responds
+  # to <tt>deprecation_warning(deprecated_method_name, message, caller_backtrace)</tt> where you can implement your
+  # custom warning behavior.
   #
   #   class MyLib::Deprecator
   #     def deprecation_warning(deprecated_method_name, message, caller_backtrace = nil)
@@ -19,7 +14,15 @@ class Module
   #       Kernel.warn message
   #     end
   #   end
-  def deprecate(*method_names)
-    ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
+  def deprecate(*method_names, deprecator: nil, **options)
+    if deprecator.is_a?(ActiveSupport::Deprecation)
+      deprecator.deprecate_methods(self, *method_names, **options)
+    elsif deprecator
+      # we just need any instance to call deprecate_methods, but the deprecation will be emitted by deprecator
+      ActiveSupport.deprecator.deprecate_methods(self, *method_names, **options, deprecator: deprecator)
+    else
+      ActiveSupport.deprecator.warn("Module.deprecate without a deprecator is deprecated")
+      ActiveSupport::Deprecation._instance.deprecate_methods(self, *method_names, **options)
+    end
   end
 end

data/lib/active_support/core_ext/module/introspection.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string/filters"
 require "active_support/inflector"
 
 class Module

data/lib/active_support/core_ext/name_error.rb

@@ -53,13 +53,7 @@ class NameError
     UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
     private_constant :UNBOUND_METHOD_MODULE_NAME
 
-    if UnboundMethod.method_defined?(:bind_call)
-      def real_mod_name(mod)
-        UNBOUND_METHOD_MODULE_NAME.bind_call(mod)
-      end
-    else
-      def real_mod_name(mod)
-        UNBOUND_METHOD_MODULE_NAME.bind(mod).call
-      end
+    def real_mod_name(mod)
+      UNBOUND_METHOD_MODULE_NAME.bind_call(mod)
     end
 end

data/lib/active_support/core_ext/numeric/bytes.rb

@@ -7,6 +7,7 @@ class Numeric
   TERABYTE = GIGABYTE * 1024
   PETABYTE = TERABYTE * 1024
   EXABYTE  = PETABYTE * 1024
+  ZETTABYTE = EXABYTE * 1024
 
   # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
   #
@@ -63,4 +64,12 @@ class Numeric
     self * EXABYTE
   end
   alias :exabyte :exabytes
+
+  # Returns the number of bytes equivalent to the zettabytes provided.
+  #
+  #   2.zettabytes # => 2_361_183_241_434_822_606_848
+  def zettabytes
+    self * ZETTABYTE
+  end
+  alias :zettabyte :zettabytes
 end