activesupport 3.1.0 → 5.0.0

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

@@ -1,9 +1,15 @@
 class Hash
-  # Slice a hash to include only the given keys. This is useful for
-  # limiting an options hash to valid keys before passing to a method:
+  # Slices a hash to include only the given keys. Returns a hash containing 
+  # the given keys.
+  # 
+  #   { a: 1, b: 2, c: 3, d: 4 }.slice(:a, :b)
+  #   # => {:a=>1, :b=>2}
+  # 
+  # This is useful for limiting an options hash to valid keys before 
+  # passing to a method:
   #
   #   def search(criteria = {})
-  #     assert_valid_keys(:mass, :velocity, :time)
+  #     criteria.assert_valid_keys(:mass, :velocity, :time)
   #   end
   #
   #   search(options.slice(:mass, :velocity, :time))
@@ -13,28 +19,30 @@ class Hash
   #   valid_keys = [:mass, :velocity, :time]
   #   search(options.slice(*valid_keys))
   def slice(*keys)
-    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
-    hash = self.class.new
-    keys.each { |k| hash[k] = self[k] if has_key?(k) }
-    hash
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
   end
 
   # Replaces the hash with only the given keys.
-  # Returns a hash contained the removed key/value pairs
-  #   {:a => 1, :b => 2, :c => 3, :d => 4}.slice!(:a, :b) # => {:c => 3, :d => 4}
+  # Returns a hash containing the removed key/value pairs.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.slice!(:a, :b)
+  #   # => {:c=>3, :d=>4}
   def slice!(*keys)
-    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
     omit = slice(*self.keys - keys)
     hash = slice(*keys)
+    hash.default      = default
+    hash.default_proc = default_proc if default_proc
     replace(hash)
     omit
   end
 
   # Removes and returns the key/value pairs matching the given keys.
-  #   {:a => 1, :b => 2, :c => 3, :d => 4}.extract!(:a, :b) # => {:a => 1, :b => 2}
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.extract!(:a, :b) # => {:a=>1, :b=>2}
+  #   { a: 1, b: 2 }.extract!(:a, :x)             # => {:a=>1}
   def extract!(*keys)
-    result = {}
-    keys.each {|key| result[key] = delete(key) }
-    result
+    keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
   end
 end

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

@@ -0,0 +1,29 @@
+class Hash
+  # Returns a new hash with the results of running +block+ once for every value.
+  # The keys are unchanged.
+  #
+  #   { a: 1, b: 2, c: 3 }.transform_values { |x| x * 2 } # => { a: 2, b: 4, c: 6 }
+  #
+  # If you do not provide a +block+, it will return an Enumerator
+  # for chaining with other methods:
+  #
+  #   { a: 1, b: 2 }.transform_values.with_index { |v, i| [v, i].join.to_i } # => { a: 10, b: 21 }
+  def transform_values
+    return enum_for(:transform_values) { size } unless block_given?
+    return {} if empty?
+    result = self.class.new
+    each do |key, value|
+      result[key] = yield(value)
+    end
+    result
+  end
+
+  # Destructively converts all values using the +block+ operations.
+  # Same as +transform_values+ but modifies +self+.
+  def transform_values!
+    return enum_for(:transform_values!) { size } unless block_given?
+    each do |key, value|
+      self[key] = yield(value)
+    end
+  end
+end

data/lib/active_support/core_ext/hash.rb

@@ -1,9 +1,9 @@
+require 'active_support/core_ext/hash/compact'
 require 'active_support/core_ext/hash/conversions'
 require 'active_support/core_ext/hash/deep_merge'
-require 'active_support/core_ext/hash/deep_dup'
-require 'active_support/core_ext/hash/diff'
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/hash/transform_values'

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

@@ -10,8 +10,20 @@ class Integer
   #  1003.ordinalize  # => "1003rd"
   #  -11.ordinalize   # => "-11th"
   #  -1001.ordinalize # => "-1001st"
-  #
   def ordinalize
     ActiveSupport::Inflector.ordinalize(self)
   end
+
+  # 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"
+  def ordinal
+    ActiveSupport::Inflector.ordinal(self)
+  end
 end

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

@@ -1,5 +1,9 @@
 class Integer
   # Check whether the integer is evenly divisible by the argument.
+  #
+  #   0.multiple_of?(0)  # => true
+  #   6.multiple_of?(5)  # => false
+  #   10.multiple_of?(2) # => true
   def multiple_of?(number)
     number != 0 ? self % number == 0 : zero?
   end

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

@@ -1,39 +1,29 @@
+require 'active_support/duration'
+require 'active_support/core_ext/numeric/time'
+
 class Integer
-  # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
+  # Enables the use of time calculations and declarations, like <tt>45.minutes +
+  # 2.hours + 4.years</tt>.
   #
-  # These methods use Time#advance for precise date calculations when using from_now, ago, etc.
-  # as well as adding or subtracting their results from a Time object. For example:
+  # These methods use Time#advance for precise date calculations when using
+  # <tt>from_now</tt>, +ago+, etc. as well as adding or subtracting their
+  # results from a Time object.
   #
-  #   # equivalent to Time.now.advance(:months => 1)
+  #   # equivalent to Time.now.advance(months: 1)
   #   1.month.from_now
   #
-  #   # equivalent to Time.now.advance(:years => 2)
+  #   # equivalent to Time.now.advance(years: 2)
   #   2.years.from_now
   #
-  #   # equivalent to Time.now.advance(:months => 4, :years => 5)
+  #   # equivalent to Time.now.advance(months: 4, years: 5)
   #   (4.months + 5.years).from_now
-  #
-  # While these methods provide precise calculation when used as in the examples above, care
-  # should be taken to note that this is not true if the result of `months', `years', etc is
-  # converted before use:
-  #
-  #   # equivalent to 30.days.to_i.from_now
-  #   1.month.to_i.from_now
-  #
-  #   # equivalent to 365.25.days.to_f.from_now
-  #   1.year.to_f.from_now
-  #
-  # In such cases, Ruby's core
-  # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and
-  # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
-  # date and time arithmetic
   def months
     ActiveSupport::Duration.new(self * 30.days, [[:months, self]])
   end
   alias :month :months
 
   def years
-    ActiveSupport::Duration.new(self * 365.25.days, [[:years, self]])
+    ActiveSupport::Duration.new(self * 365.25.days.to_i, [[:years, self]])
   end
   alias :year :years
 end

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

@@ -1,11 +1,11 @@
 class Object
   # Makes backticks behave (somewhat more) similarly on all platforms.
   # On win32 `nonexistent_command` raises Errno::ENOENT; on Unix, the
-  # spawned shell prints a message to stderr and sets $?.  We emulate
+  # spawned shell prints a message to stderr and sets $?. We emulate
   # Unix on the former but not the latter.
   def `(command) #:nodoc:
     super
   rescue Errno::ENOENT => e
     STDERR.puts "#$0: #{e}"
   end
-end
+end

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

@@ -0,0 +1,12 @@
+require 'active_support/core_ext/module/concerning'
+
+module Kernel
+  module_function
+
+  # A shortcut to define a toplevel concern, not within a module.
+  #
+  # See Module::Concerning for more.
+  def concern(topic, &module_definition)
+    Object.concern topic, &module_definition
+  end
+end

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

@@ -1,16 +1,3 @@
-module Kernel
-  unless respond_to?(:debugger)
-    # Starts a debugging session if ruby-debug has been loaded (call rails server --debugger to do load it).
-    def debugger
-      message = "\n***** Debugger requested, but was not available (ensure ruby-debug is listed in Gemfile/installed as gem): Start server with --debugger to enable *****\n"
-      defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)
-    end
-  end
+require 'active_support/deprecation'
 
-  undef :breakpoint if respond_to?(:breakpoint)
-  def breakpoint
-    message = "\n***** The 'breakpoint' command has been renamed 'debugger' -- please change *****\n"
-    defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)
-    debugger
-  end
-end
+ActiveSupport::Deprecation.warn("This file is deprecated and will be removed in Rails 5.1 with no replacement.")

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

@@ -1,6 +1,8 @@
-require 'rbconfig'
 module Kernel
-  # Sets $VERBOSE to nil for the duration of the block and back to its original value afterwards.
+  module_function
+
+  # Sets $VERBOSE to nil for the duration of the block and back to its original
+  # value afterwards.
   #
   #   silence_warnings do
   #     value = noisy_call # no warning voiced
@@ -11,12 +13,14 @@ module Kernel
     with_warnings(nil) { yield }
   end
 
-  # Sets $VERBOSE to true for the duration of the block and back to its original value afterwards.
+  # Sets $VERBOSE to +true+ for the duration of the block and back to its
+  # original value afterwards.
   def enable_warnings
     with_warnings(true) { yield }
   end
 
-  # Sets $VERBOSE for the duration of the block and back to its original value afterwards.
+  # Sets $VERBOSE for the duration of the block and back to its original
+  # value afterwards.
   def with_warnings(flag)
     old_verbose, $VERBOSE = $VERBOSE, flag
     yield
@@ -24,70 +28,16 @@ module Kernel
     $VERBOSE = old_verbose
   end
 
-  # For compatibility
-  def silence_stderr #:nodoc:
-    silence_stream(STDERR) { yield }
-  end
-
-  # Silences any stream for the duration of the block.
-  #
-  #   silence_stream(STDOUT) do
-  #     puts 'This will never be seen'
-  #   end
-  #
-  #   puts 'But this will'
-  def silence_stream(stream)
-    old_stream = stream.dup
-    stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
-    stream.sync = true
-    yield
-  ensure
-    stream.reopen(old_stream)
-  end
-
   # Blocks and ignores any exception passed as argument if raised within the block.
   #
   #   suppress(ZeroDivisionError) do
   #     1/0
-  #     puts "This code is NOT reached"
+  #     puts 'This code is NOT reached'
   #   end
   #
-  #   puts "This code gets executed and nothing related to ZeroDivisionError was seen"
+  #   puts 'This code gets executed and nothing related to ZeroDivisionError was seen'
   def suppress(*exception_classes)
-    begin yield
-    rescue Exception => e
-      raise unless exception_classes.any? { |cls| e.kind_of?(cls) }
-    end
-  end
-
-  # Captures the given stream and returns it:
-  #
-  #   stream = capture(:stdout) { puts "Cool" }
-  #   stream # => "Cool\n"
-  #
-  def capture(stream)
-    begin
-      stream = stream.to_s
-      eval "$#{stream} = StringIO.new"
-      yield
-      result = eval("$#{stream}").string
-    ensure
-      eval("$#{stream} = #{stream.upcase}")
-    end
-
-    result
-  end
-  alias :silence :capture
-
-  # Silences both STDOUT and STDERR, even for subprocesses.
-  #
-  #   quietly { system 'bundle install' }
-  #
-  def quietly
-    silence_stream(STDOUT) do
-      silence_stream(STDERR) do
-        yield
-      end
-    end
+    yield
+  rescue *exception_classes
   end
 end

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

@@ -1,11 +1,4 @@
 module Kernel
-  # Returns the object's singleton class.
-  def singleton_class
-    class << self
-      self
-    end
-  end unless respond_to?(:singleton_class) # exists in 1.9.2
-
   # class_eval on an object acts like singleton_class.class_eval.
   def class_eval(*args, &block)
     singleton_class.class_eval(*args, &block)

data/lib/active_support/core_ext/kernel.rb

@@ -1,5 +1,4 @@
-require 'active_support/core_ext/kernel/reporting'
 require 'active_support/core_ext/kernel/agnostics'
-require 'active_support/core_ext/kernel/requires'
-require 'active_support/core_ext/kernel/debugger'
+require 'active_support/core_ext/kernel/concern'
+require 'active_support/core_ext/kernel/reporting'
 require 'active_support/core_ext/kernel/singleton_class'

data/lib/active_support/core_ext/load_error.rb

@@ -1,3 +1,5 @@
+require 'active_support/deprecation/proxy_wrappers'
+
 class LoadError
   REGEXPS = [
     /^no such file to load -- (.+)$/i,
@@ -6,18 +8,23 @@ class LoadError
     /^cannot load such file -- (.+)$/i,
   ]
 
-  def path
-    @path ||= begin
-      REGEXPS.find do |regex|
-        message =~ regex
+  unless method_defined?(:path)
+    # Returns the path which was unable to be loaded.
+    def path
+      @path ||= begin
+        REGEXPS.find do |regex|
+          message =~ regex
+        end
+        $1
       end
-      $1
     end
   end
 
+  # Returns true if the given path name (except perhaps for the ".rb"
+  # extension) is the missing file which caused the exception to be raised.
   def is_missing?(location)
-    location.sub(/\.rb$/, '') == path.sub(/\.rb$/, '')
+    location.sub(/\.rb$/, ''.freeze) == path.sub(/\.rb$/, ''.freeze)
   end
 end
 
-MissingSourceFile = LoadError
+MissingSourceFile = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('MissingSourceFile', 'LoadError')

data/lib/active_support/core_ext/marshal.rb

@@ -0,0 +1,22 @@
+module ActiveSupport
+  module MarshalWithAutoloading # :nodoc:
+    def load(source)
+      super(source)
+    rescue ArgumentError, NameError => exc
+      if exc.message.match(%r|undefined class/module (.+?)(?:::)?\z|)
+        # try loading the class/module
+        loaded = $1.constantize
+
+        raise unless $1 == loaded.name
+
+        # if it is an IO we need to go back to read the object
+        source.rewind if source.respond_to?(:rewind)
+        retry
+      else
+        raise exc
+      end
+    end
+  end
+end
+
+Marshal.singleton_class.prepend(ActiveSupport::MarshalWithAutoloading)

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

@@ -1,4 +1,7 @@
 class Module
+  # NOTE: This method is deprecated. Please use <tt>Module#prepend</tt> that
+  # comes with Ruby 2.0 or newer instead.
+  #
   # Encapsulates the common pattern of:
   #
   #   alias_method :foo_without_feature, :foo
@@ -19,32 +22,33 @@ class Module
   #   alias_method :foo_without_feature?, :foo?
   #   alias_method :foo?, :foo_with_feature?
   #
-  # so you can safely chain foo, foo?, and foo! with the same feature.
+  # so you can safely chain foo, foo?, foo! and/or foo= with the same feature.
   def alias_method_chain(target, feature)
-    # Strip out punctuation on predicates or bang methods since
+    ActiveSupport::Deprecation.warn("alias_method_chain is deprecated. Please, use Module#prepend instead. From module, you can access the original method using super.")
+
+    # Strip out punctuation on predicates, bang or writer methods since
     # e.g. target?_without_feature is not a valid method name.
     aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
     yield(aliased_target, punctuation) if block_given?
 
-    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+    with_method = "#{aliased_target}_with_#{feature}#{punctuation}"
+    without_method = "#{aliased_target}_without_#{feature}#{punctuation}"
 
     alias_method without_method, target
     alias_method target, with_method
 
     case
-      when public_method_defined?(without_method)
-        public target
-      when protected_method_defined?(without_method)
-        protected target
-      when private_method_defined?(without_method)
-        private target
+    when public_method_defined?(without_method)
+      public target
+    when protected_method_defined?(without_method)
+      protected target
+    when private_method_defined?(without_method)
+      private target
     end
   end
 
   # Allows you to make aliases for attributes, which includes
-  # getter, setter, and query methods.
-  #
-  # Example:
+  # getter, setter, and a predicate.
   #
   #   class Content < ActiveRecord::Base
   #     # has a title attribute

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

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/object/blank'
-
 class Module
   # A module may or may not have a name.
   #
@@ -7,18 +5,24 @@ class Module
   #   M.name # => "M"
   #
   #   m = Module.new
-  #   m.name # => ""
+  #   m.name # => nil
+  #
+  # +anonymous?+ method returns true if module does not have a name, false otherwise:
+  #
+  #   Module.new.anonymous? # => true
+  #
+  #   module M; end
+  #   M.anonymous?          # => false
   #
   # A module gets a name when it is first assigned to a constant. Either
   # via the +module+ or +class+ keyword or by an explicit assignment:
   #
   #   m = Module.new # creates an anonymous module
-  #   M = m          # => m gets a name here as a side-effect
+  #   m.anonymous?   # => true
+  #   M = m          # m gets a name here as a side-effect
   #   m.name         # => "M"
-  #
+  #   m.anonymous?   # => false
   def anonymous?
-    # Uses blank? because the name of an anonymous class is an empty
-    # string in 1.8, and nil in 1.9.
-    name.blank?
+    name.nil?
   end
 end

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

@@ -15,7 +15,6 @@ class Module
     attr_internal_reader(*attrs)
     attr_internal_writer(*attrs)
   end
-
   alias_method :attr_internal, :attr_internal_accessor
 
   class << self; attr_accessor :attr_internal_naming_format end
@@ -28,10 +27,8 @@ class Module
 
     def attr_internal_define(attr_name, type)
       internal_name = attr_internal_ivar_name(attr_name).sub(/\A@/, '')
-      class_eval do # class_eval is necessary on 1.9 or else the methods a made private
-        # use native attr_* methods as they are faster on some Ruby implementations
-        send("attr_#{type}", internal_name)
-      end
+      # use native attr_* methods as they are faster on some Ruby implementations
+      send("attr_#{type}", internal_name)
       attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer
       alias_method attr_name, internal_name
       remove_method internal_name