activesupport 4.1.16 → 4.2.0.beta1

data/lib/active_support/inflector/methods.rb

@@ -89,6 +89,7 @@ module ActiveSupport
     #
     #   'SSLError'.underscore.camelize # => "SslError"
     def underscore(camel_cased_word)
+      return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
       word = camel_cased_word.to_s.gsub('::', '/')
       word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
       word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
@@ -98,26 +99,46 @@ module ActiveSupport
       word
     end
 
-    # Capitalizes the first word, turns underscores into spaces, and strips a
-    # trailing '_id' if present.
-    # Like +titleize+, this is meant for creating pretty output.
+    # Tweaks an attribute name for display to end users.
+    #
+    # Specifically, +humanize+ performs these transformations:
+    #
+    #   * Applies human inflection rules to the argument.
+    #   * Deletes leading underscores, if any.
+    #   * Removes a "_id" suffix if present.
+    #   * Replaces underscores with spaces, if any.
+    #   * Downcases all words except acronyms.
+    #   * Capitalizes the first word.
     #
     # The capitalization of the first word can be turned off by setting the
-    # optional parameter +capitalize+ to false.
-    # By default, this parameter is true.
+    # +:capitalize+ option to false (default is true).
     #
     #   humanize('employee_salary')              # => "Employee salary"
     #   humanize('author_id')                    # => "Author"
     #   humanize('author_id', capitalize: false) # => "author"
+    #   humanize('_id')                          # => "Id"
+    #
+    # If "SSL" was defined to be an acronym:
+    #
+    #   humanize('ssl_error') # => "SSL error"
+    #
     def humanize(lower_case_and_underscored_word, options = {})
       result = lower_case_and_underscored_word.to_s.dup
+
       inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
-      result.gsub!(/_id$/, "")
+
+      result.sub!(/\A_+/, '')
+      result.sub!(/_id\z/, '')
       result.tr!('_', ' ')
-      result.gsub!(/([a-z\d]*)/i) { |match|
+
+      result.gsub!(/([a-z\d]*)/i) do |match|
         "#{inflections.acronyms[match] || match.downcase}"
-      }
-      result.gsub!(/^\w/) { |match| match.upcase } if options.fetch(:capitalize, true)
+      end
+
+      if options.fetch(:capitalize, true)
+        result.sub!(/\A\w/) { |match| match.upcase }
+      end
+
       result
     end
 
@@ -171,6 +192,8 @@ module ActiveSupport
     #
     #   'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
     #   'Inflections'.demodulize                                       # => "Inflections"
+    #   '::Inflections'.demodulize                                     # => "Inflections"
+    #   ''.demodulize                                                  # => ""
     #
     # See also +deconstantize+.
     def demodulize(path)
@@ -227,7 +250,7 @@ module ActiveSupport
     def constantize(camel_cased_word)
       names = camel_cased_word.split('::')
 
-      # Trigger a builtin NameError exception including the ill-formed constant in the message.
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
       Object.const_get(camel_cased_word) if names.empty?
 
       # Remove the first blank element in case of '::ClassName' notation.
@@ -241,8 +264,8 @@ module ActiveSupport
           next candidate if constant.const_defined?(name, false)
           next candidate unless Object.const_defined?(name)
 
-          # Go down the ancestors to check it it's owned
-          # directly before we reach Object or the end of ancestors.
+          # Go down the ancestors to check if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
           constant = constant.ancestors.inject do |const, ancestor|
             break const    if ancestor == Object
             break ancestor if ancestor.const_defined?(name, false)
@@ -325,10 +348,11 @@ module ActiveSupport
 
     private
 
-    # Mount a regular expression that will match part by part of the constant.
+    # Mounts a regular expression, returned as a string to ease interpolation,
+    # that will match part by part the given constant.
     #
-    #   const_regexp("Foo::Bar::Baz") # => /Foo(::Bar(::Baz)?)?/
-    #   const_regexp("::")            # => /::/
+    #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
+    #   const_regexp("::")            # => "::"
     def const_regexp(camel_cased_word) #:nodoc:
       parts = camel_cased_word.split("::")
 

data/lib/active_support/json/encoding.rb

@@ -58,10 +58,6 @@ module ActiveSupport
                 super.gsub ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, ESCAPED_CHARS
               end
             end
-
-            def to_s
-              self
-            end
           end
 
           # Mark these as private so we don't leak encoding-specific constructs

data/lib/active_support/logger.rb

@@ -44,20 +44,6 @@ module ActiveSupport
     def initialize(*args)
       super
       @formatter = SimpleFormatter.new
-      after_initialize if respond_to? :after_initialize
-    end
-
-    def add(severity, message = nil, progname = nil, &block)
-      return true if @logdev.nil? || (severity || UNKNOWN) < level
-      super
-    end
-
-    Logger::Severity.constants.each do |severity|
-      class_eval(<<-EOT, __FILE__, __LINE__ + 1)
-        def #{severity.downcase}?                # def debug?
-          Logger::#{severity} >= level           #   DEBUG >= level
-        end                                      # end
-      EOT
     end
 
     # Simple formatter which only displays the message.

data/lib/active_support/logger_silence.rb

@@ -1,45 +1,24 @@
 require 'active_support/concern'
-require 'thread_safe'
 
 module LoggerSilence
   extend ActiveSupport::Concern
   
   included do
     cattr_accessor :silencer
-    attr_reader :local_levels
     self.silencer = true
   end
 
-
-  def after_initialize
-    @local_levels = ThreadSafe::Cache.new(:initial_capacity => 2)
-  end
-
-  def local_log_id
-    Thread.current.__id__
-  end
-
-  def level
-    local_levels[local_log_id] || super
-  end
-
   # Silences the logger for the duration of the block.
   def silence(temporary_level = Logger::ERROR)
     if silencer
       begin
-        old_local_level            = local_levels[local_log_id]
-        local_levels[local_log_id] = temporary_level
-
+        old_logger_level, self.level = level, temporary_level
         yield self
       ensure
-        if old_local_level
-          local_levels[local_log_id] = old_local_level
-        else
-          local_levels.delete(local_log_id)
-        end
+        self.level = old_logger_level
       end
     else
       yield self
     end
   end
-end
+end

data/lib/active_support/message_encryptor.rb

@@ -40,6 +40,7 @@ module ActiveSupport
     # Options:
     # * <tt>:cipher</tt>     - Cipher to use. Can be any cipher returned by
     #   <tt>OpenSSL::Cipher.ciphers</tt>. Default is 'aes-256-cbc'.
+    # * <tt>:digest</tt> - String of digest to use for signing. Default is +SHA1+.
     # * <tt>:serializer</tt> - Object serializer to use. Default is +Marshal+.
     def initialize(secret, *signature_key_or_options)
       options = signature_key_or_options.extract_options!
@@ -47,7 +48,7 @@ module ActiveSupport
       @secret = secret
       @sign_secret = sign_secret
       @cipher = options[:cipher] || 'aes-256-cbc'
-      @verifier = MessageVerifier.new(@sign_secret || @secret, :serializer => NullSerializer)
+      @verifier = MessageVerifier.new(@sign_secret || @secret, digest: options[:digest] || 'SHA1', serializer: NullSerializer)
       @serializer = options[:serializer] || Marshal
     end
 

data/lib/active_support/multibyte/unicode.rb

@@ -42,6 +42,7 @@ module ActiveSupport
         0x0085,                # White_Space # Cc       <control-0085>
         0x00A0,                # White_Space # Zs       NO-BREAK SPACE
         0x1680,                # White_Space # Zs       OGHAM SPACE MARK
+        0x180E,                # White_Space # Zs       MONGOLIAN VOWEL SEPARATOR
         (0x2000..0x200A).to_a, # White_Space # Zs  [11] EN QUAD..HAIR SPACE
         0x2028,                # White_Space # Zl       LINE SEPARATOR
         0x2029,                # White_Space # Zp       PARAGRAPH SEPARATOR
@@ -212,7 +213,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 +336,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 +368,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 +386,6 @@ module ActiveSupport
       def database
         @database ||= UnicodeDatabase.new
       end
-
     end
   end
 end

data/lib/active_support/notifications.rb

@@ -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,12 +103,11 @@ 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
 

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
@@ -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_rounded_converter.rb

@@ -23,7 +23,7 @@ module ActiveSupport
           precision = 0 if precision < 0 # don't let it be negative
         else
           rounded_number = number.round(precision)
-          rounded_number = rounded_number.to_i if precision == 0 && rounded_number.finite?
+          rounded_number = rounded_number.to_i if precision == 0
           rounded_number = rounded_number.abs if rounded_number.zero? # prevent showing negative zeros
         end
 
@@ -59,7 +59,7 @@ module ActiveSupport
         end
 
         def digit_count(number)
-          number.zero? ? 1 : (Math.log10(absolute_number(number)) + 1).floor
+          (Math.log10(absolute_number(number)) + 1).floor
         end
 
         def strip_insignificant_zeros

data/lib/active_support/test_case.rb

@@ -11,25 +11,15 @@ 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
-
-    $tags = {}
-    def self.for_tag(tag)
-      yield if $tags[tag]
+    class << self
+      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/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