activesupport 4.1.15 → 4.2.11.3

data/lib/active_support/message_verifier.rb

@@ -1,5 +1,6 @@
 require 'base64'
 require 'active_support/core_ext/object/blank'
+require 'active_support/security_utils'
 
 module ActiveSupport
   # +MessageVerifier+ makes it easy to generate and verify messages which are
@@ -27,18 +28,19 @@ module ActiveSupport
     class InvalidSignature < StandardError; end
 
     def initialize(secret, options = {})
+      raise ArgumentError, 'Secret should not be nil.' unless secret
       @secret = secret
       @digest = options[:digest] || 'SHA1'
       @serializer = options[:serializer] || Marshal
     end
 
     def verify(signed_message)
-      raise InvalidSignature if signed_message.blank?
+      raise InvalidSignature if signed_message.nil? || !signed_message.valid_encoding? || signed_message.blank?
 
       data, digest = signed_message.split("--")
-      if data.present? && digest.present? && secure_compare(digest, generate_digest(data))
+      if data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
         begin
-          @serializer.load(::Base64.strict_decode64(data))
+          @serializer.load(decode(data))
         rescue ArgumentError => argument_error
           raise InvalidSignature if argument_error.message =~ %r{invalid base64}
           raise
@@ -49,20 +51,17 @@ module ActiveSupport
     end
 
     def generate(value)
-      data = ::Base64.strict_encode64(@serializer.dump(value))
+      data = encode(@serializer.dump(value))
       "#{data}--#{generate_digest(data)}"
     end
 
     private
-      # constant-time comparison algorithm to prevent timing attacks
-      def secure_compare(a, b)
-        return false unless a.bytesize == b.bytesize
-
-        l = a.unpack "C#{a.bytesize}"
+      def encode(data)
+        ::Base64.strict_encode64(data)
+      end
 
-        res = 0
-        b.each_byte { |byte| res |= byte ^ l.shift }
-        res == 0
+      def decode(data)
+        ::Base64.strict_decode64(data)
       end
 
       def generate_digest(data)

data/lib/active_support/multibyte/chars.rb

@@ -86,7 +86,7 @@ module ActiveSupport #:nodoc:
         @wrapped_string.split(*args).map { |i| self.class.new(i) }
       end
 
-      # Works like like <tt>String#slice!</tt>, but returns an instance of
+      # Works like <tt>String#slice!</tt>, but returns an instance of
       # Chars, or nil if the string was not modified.
       def slice!(*args)
         chars(@wrapped_string.slice!(*args))

data/lib/active_support/multibyte/unicode.rb

@@ -11,7 +11,7 @@ module ActiveSupport
       NORMALIZATION_FORMS = [:c, :kc, :d, :kd]
 
       # The Unicode version that is supported by the implementation
-      UNICODE_VERSION = '6.3.0'
+      UNICODE_VERSION = '7.0.0'
 
       # The default normalization used for operations that require
       # normalization. It can be set to any of the normalizations
@@ -212,7 +212,8 @@ module ActiveSupport
       end
 
       # Ruby >= 2.1 has String#scrub, which is faster than the workaround used for < 2.1.
-      if '<3'.respond_to?(:scrub)
+      # Rubinius' String#scrub, however, doesn't support ASCII-incompatible chars.
+      if '<3'.respond_to?(:scrub) && !defined?(Rubinius)
         # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
         # resulting in a valid UTF-8 string.
         #
@@ -334,7 +335,7 @@ module ActiveSupport
           begin
             @codepoints, @composition_exclusion, @composition_map, @boundary, @cp1252 = File.open(self.class.filename, 'rb') { |f| Marshal.load f.read }
           rescue => e
-              raise IOError.new("Couldn't load the Unicode tables for UTF8Handler (#{e.message}), ActiveSupport::Multibyte is unusable")
+            raise IOError.new("Couldn't load the Unicode tables for UTF8Handler (#{e.message}), ActiveSupport::Multibyte is unusable")
           end
 
           # Redefine the === method so we can write shorter rules for grapheme cluster breaks
@@ -366,6 +367,7 @@ module ActiveSupport
       private
 
       def apply_mapping(string, mapping) #:nodoc:
+        database.codepoints
         string.each_codepoint.map do |codepoint|
           cp = database.codepoints[codepoint]
           if cp and (ncp = cp.send(mapping)) and ncp > 0
@@ -383,7 +385,6 @@ module ActiveSupport
       def database
         @database ||= UnicodeDatabase.new
       end
-
     end
   end
 end

data/lib/active_support/notifications.rb

@@ -16,7 +16,7 @@ module ActiveSupport
   #     render text: 'Foo'
   #   end
   #
-  # That executes the block first and notifies all subscribers once done.
+  # That first executes the block and then notifies all subscribers once done.
   #
   # In the example above +render+ is the name of the event, and the rest is called
   # the _payload_. The payload is a mechanism that allows instrumenters to pass
@@ -141,6 +141,11 @@ module ActiveSupport
   #
   #   ActiveSupport::Notifications.unsubscribe(subscriber)
   #
+  # You can also unsubscribe by passing the name of the subscriber object. Note
+  # that this will unsubscribe all subscriptions with the given name:
+  #
+  #   ActiveSupport::Notifications.unsubscribe("render")
+  #
   # == Default Queue
   #
   # Notifications ships with a queue implementation that consumes and publishes events
@@ -173,8 +178,8 @@ module ActiveSupport
         unsubscribe(subscriber)
       end
 
-      def unsubscribe(args)
-        notifier.unsubscribe(args)
+      def unsubscribe(subscriber_or_name)
+        notifier.unsubscribe(subscriber_or_name)
       end
 
       def instrumenter

data/lib/active_support/notifications/fanout.rb

@@ -25,9 +25,15 @@ module ActiveSupport
         subscriber
       end
 
-      def unsubscribe(subscriber)
+      def unsubscribe(subscriber_or_name)
         synchronize do
-          @subscribers.reject! { |s| s.matches?(subscriber) }
+          case subscriber_or_name
+          when String
+            @subscribers.reject! { |s| s.matches?(subscriber_or_name) }
+          else
+            @subscribers.delete(subscriber_or_name)
+          end
+
           @listeners_for.clear
         end
       end
@@ -97,16 +103,15 @@ module ActiveSupport
           end
 
           def subscribed_to?(name)
-            @pattern === name.to_s
+            @pattern === name
           end
 
-          def matches?(subscriber_or_name)
-            self === subscriber_or_name ||
-              @pattern && @pattern === subscriber_or_name
+          def matches?(name)
+            @pattern && @pattern === name
           end
         end
 
-        class Timed < Evented
+        class Timed < Evented # :nodoc:
           def publish(name, *args)
             @delegate.call name, *args
           end

data/lib/active_support/number_helper.rb

@@ -232,12 +232,8 @@ module ActiveSupport
     #   number_to_human_size(1234567, precision: 2)                  # => 1.2 MB
     #   number_to_human_size(483989, precision: 2)                   # => 470 KB
     #   number_to_human_size(1234567, precision: 2, separator: ',')  # => 1,2 MB
-    #
-    # Non-significant zeros after the fractional separator are stripped out by
-    # default (set <tt>:strip_insignificant_zeros</tt> to +false+ to change that):
-    #
-    #   number_to_human_size(1234567890123, precision: 5) # => "1.1229 TB"
-    #   number_to_human_size(524288000, precision: 5)     # => "500 MB"
+    #   number_to_human_size(1234567890123, precision: 5)            # => "1.1228 TB"
+    #   number_to_human_size(524288000, precision: 5)                # => "500 MB"
     def number_to_human_size(number, options = {})
       NumberToHumanSizeConverter.convert(number, options)
     end
@@ -276,12 +272,12 @@ module ActiveSupport
     #   string containing an i18n scope where to find this hash. It
     #   might have the following keys:
     #   * *integers*: <tt>:unit</tt>, <tt>:ten</tt>,
-    #     *<tt>:hundred</tt>, <tt>:thousand</tt>, <tt>:million</tt>,
-    #     *<tt>:billion</tt>, <tt>:trillion</tt>,
-    #     *<tt>:quadrillion</tt>
+    #     <tt>:hundred</tt>, <tt>:thousand</tt>, <tt>:million</tt>,
+    #     <tt>:billion</tt>, <tt>:trillion</tt>,
+    #     <tt>:quadrillion</tt>
     #   * *fractionals*: <tt>:deci</tt>, <tt>:centi</tt>,
-    #     *<tt>:mili</tt>, <tt>:micro</tt>, <tt>:nano</tt>,
-    #     *<tt>:pico</tt>, <tt>:femto</tt>
+    #     <tt>:mili</tt>, <tt>:micro</tt>, <tt>:nano</tt>,
+    #     <tt>:pico</tt>, <tt>:femto</tt>
     # * <tt>:format</tt> - Sets the format of the output string
     #   (defaults to "%n %u"). The field types are:
     #   * %u - The quantifier (ex.: 'thousand')
@@ -305,12 +301,15 @@ module ActiveSupport
     #                            separator: ',',
     #                            significant: false) # => "1,2 Million"
     #
+    #   number_to_human(500000000, precision: 5)           # => "500 Million"
+    #   number_to_human(12345012345, significant: false)   # => "12.345 Billion"
+    #
     # Non-significant zeros after the decimal separator are stripped
     # out by default (set <tt>:strip_insignificant_zeros</tt> to
     # +false+ to change that):
     #
-    #   number_to_human(12345012345, significant_digits: 6) # => "12.345 Billion"
-    #   number_to_human(500000000, precision: 5)            # => "500 Million"
+    # number_to_human(12.00001)                                       # => "12"
+    # number_to_human(12.00001, strip_insignificant_zeros: false)     # => "12.0"
     #
     # ==== Custom Unit Quantifiers
     #

data/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -13,7 +13,7 @@ module ActiveSupport
         end
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub('%n', rounded_number).gsub('%u', options[:unit])
+        format.gsub(/%n/, rounded_number).gsub(/%u/, options[:unit])
       end
 
       private

data/lib/active_support/number_helper/number_to_percentage_converter.rb

@@ -5,7 +5,7 @@ module ActiveSupport
 
       def convert
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        options[:format].gsub('%n', rounded_number)
+        options[:format].gsub(/%n/, rounded_number)
       end
     end
   end

data/lib/active_support/number_helper/number_to_rounded_converter.rb

@@ -33,7 +33,7 @@ module ActiveSupport
             a, b = s.split('.', 2)
             a + '.' + b[0, precision]
           else
-            "%01.#{precision}f" % rounded_number
+            "%00.#{precision}f" % rounded_number
           end
 
         delimited_number = NumberToDelimitedConverter.convert(formatted_string, options)

data/lib/active_support/per_thread_registry.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/module/delegation'
+
 module ActiveSupport
   # This module is used to encapsulate access to thread local variables.
   #
@@ -43,9 +45,9 @@ module ActiveSupport
     protected
       def method_missing(name, *args, &block) # :nodoc:
         # Caches the method definition as a singleton method of the receiver.
-        define_singleton_method(name) do |*a, &b|
-          instance.public_send(name, *a, &b)
-        end
+        #
+        # By letting #delegate handle it, we avoid an enclosure that'll capture args.
+        singleton_class.delegate name, to: :instance
 
         send(name, *args, &block)
       end

data/lib/active_support/test_case.rb

@@ -11,25 +11,59 @@ require 'active_support/testing/time_helpers'
 require 'active_support/core_ext/kernel/reporting'
 require 'active_support/deprecation'
 
-begin
-  silence_warnings { require 'mocha/setup' }
-rescue LoadError
-end
-
 module ActiveSupport
   class TestCase < ::Minitest::Test
     Assertion = Minitest::Assertion
 
-    alias_method :method_name, :name
+    class << self
+      # Sets the order in which test cases are run.
+      #
+      #   ActiveSupport::TestCase.test_order = :random # => :random
+      #
+      # Valid values are:
+      # * +:random+   (to run tests in random order)
+      # * +:parallel+ (to run tests in parallel)
+      # * +:sorted+   (to run tests alphabetically by method name)
+      # * +:alpha+    (equivalent to +:sorted+)
+      def test_order=(new_order)
+        ActiveSupport.test_order = new_order
+      end
+
+      # Returns the order in which test cases are run.
+      #
+      #   ActiveSupport::TestCase.test_order # => :sorted
+      #
+      # Possible values are +:random+, +:parallel+, +:alpha+, +:sorted+.
+      # Defaults to +:sorted+.
+      def test_order
+        test_order = ActiveSupport.test_order
 
-    $tags = {}
-    def self.for_tag(tag)
-      yield if $tags[tag]
+        if test_order.nil?
+          ActiveSupport::Deprecation.warn "You did not specify a value for the " \
+            "configuration option `active_support.test_order`. In Rails 5, " \
+            "the default value of this option will change from `:sorted` to " \
+            "`:random`.\n" \
+            "To disable this warning and keep the current behavior, you can add " \
+            "the following line to your `config/environments/test.rb`:\n" \
+            "\n" \
+            "  Rails.application.configure do\n" \
+            "    config.active_support.test_order = :sorted\n" \
+            "  end\n" \
+            "\n" \
+            "Alternatively, you can opt into the future behavior by setting this " \
+            "option to `:random`."
+
+          test_order = :sorted
+          self.test_order = test_order
+        end
+
+        test_order
+      end
+
+      alias :my_tests_are_order_dependent! :i_suck_and_my_tests_are_order_dependent!
     end
 
-    # FIXME: we have tests that depend on run order, we should fix that and
-    # remove this method call.
-    self.i_suck_and_my_tests_are_order_dependent!
+    alias_method :method_name, :name
 
     include ActiveSupport::Testing::TaggedLogging
     include ActiveSupport::Testing::SetupAndTeardown

data/lib/active_support/testing/assertions.rb

@@ -9,7 +9,7 @@ module ActiveSupport
       #
       #   assert_not nil    # => true
       #   assert_not false  # => true
-      #   assert_not 'foo'  # => 'foo' is not nil or false
+      #   assert_not 'foo'  # => Expected "foo" to be nil or false
       #
       # An error message can be specified.
       #

data/lib/active_support/testing/constant_lookup.rb

@@ -36,12 +36,8 @@ module ActiveSupport
           while names.size > 0 do
             names.last.sub!(/Test$/, "")
             begin
-              constant = names.join("::").constantize
+              constant = names.join("::").safe_constantize
               break(constant) if yield(constant)
-            rescue NoMethodError # subclass of NameError
-              raise
-            rescue NameError
-              # Constant wasn't found, move on
             ensure
               names.pop
             end

data/lib/active_support/testing/declarative.rb

@@ -1,30 +1,6 @@
 module ActiveSupport
   module Testing
     module Declarative
-
-      def self.extended(klass) #:nodoc:
-        klass.class_eval do
-
-          unless method_defined?(:describe)
-            def self.describe(text)
-              if block_given?
-                super
-              else
-                message = "`describe` without a block is deprecated, please switch to: `def self.name; #{text.inspect}; end`\n"
-                ActiveSupport::Deprecation.warn message
-
-                class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-                  def self.name
-                    "#{text}"
-                  end
-                RUBY_EVAL
-              end
-            end
-          end
-
-        end
-      end
-
       unless defined?(Spec)
         # Helper to define a test method using a String. Under the hood, it replaces
         # spaces with underscores and defines the test method.
@@ -34,7 +10,7 @@ module ActiveSupport
         #   end
         def test(name, &block)
           test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
-          defined = instance_method(test_name) rescue false
+          defined = method_defined? test_name
           raise "#{test_name} is already defined in #{self}" if defined
           if block_given?
             define_method(test_name, &block)

data/lib/active_support/testing/isolation.rb

@@ -70,14 +70,24 @@ module ActiveSupport
             exit!
           else
             Tempfile.open("isolation") do |tmpfile|
-              ENV["ISOLATION_TEST"]   = self.class.name
-              ENV["ISOLATION_OUTPUT"] = tmpfile.path
+              env = {
+                ISOLATION_TEST: self.class.name,
+                ISOLATION_OUTPUT: tmpfile.path
+              }
 
               load_paths = $-I.map {|p| "-I\"#{File.expand_path(p)}\"" }.join(" ")
-              `#{Gem.ruby} #{load_paths} #{$0} #{ORIG_ARGV.join(" ")}`
-
-              ENV.delete("ISOLATION_TEST")
-              ENV.delete("ISOLATION_OUTPUT")
+              orig_args = ORIG_ARGV.join(" ")
+              test_opts = "-n#{self.class.name}##{self.name}"
+              command = "#{Gem.ruby} #{load_paths} #{$0} #{orig_args} #{test_opts}"
+
+              # IO.popen lets us pass env in a cross-platform way
+              child = IO.popen([env, command])
+
+              begin
+                Process.wait(child.pid)
+              rescue Errno::ECHILD # The child process may exit before we wait
+                nil
+              end
 
               return tmpfile.read.unpack("m")[0]
             end

data/lib/active_support/testing/tagged_logging.rb

@@ -6,7 +6,7 @@ module ActiveSupport
       attr_writer :tagged_logger
 
       def before_setup
-        if tagged_logger
+        if tagged_logger && tagged_logger.info?
           heading = "#{self.class}: #{name}"
           divider = '-' * heading.size
           tagged_logger.info divider