activesupport 4.2.11.1 → 5.2.4

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

@@ -1,28 +1,34 @@
+# frozen_string_literal: true
+
 class Hash
-  # Returns a new hash with all keys converted using the block operation.
+  # Returns a new hash with all keys converted using the +block+ operation.
   #
   #  hash = { name: 'Rob', age: '28' }
   #
-  #  hash.transform_keys{ |key| key.to_s.upcase }
-  #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+  #  hash.transform_keys { |key| key.to_s.upcase } # => {"NAME"=>"Rob", "AGE"=>"28"}
+  #
+  # If you do not provide a +block+, it will return an Enumerator
+  # for chaining with other methods:
+  #
+  #  hash.transform_keys.with_index { |k, i| [k, i].join } # => {"name0"=>"Rob", "age1"=>"28"}
   def transform_keys
-    return enum_for(:transform_keys) unless block_given?
-    result = self.class.new
+    return enum_for(:transform_keys) { size } unless block_given?
+    result = {}
     each_key do |key|
       result[yield(key)] = self[key]
     end
     result
-  end
+  end unless method_defined? :transform_keys
 
-  # Destructively convert all keys using the block operations.
-  # Same as transform_keys but modifies +self+.
+  # Destructively converts all keys using the +block+ operations.
+  # Same as +transform_keys+ but modifies +self+.
   def transform_keys!
-    return enum_for(:transform_keys!) unless block_given?
+    return enum_for(:transform_keys!) { size } unless block_given?
     keys.each do |key|
       self[yield(key)] = delete(key)
     end
     self
-  end
+  end unless method_defined? :transform_keys!
 
   # Returns a new hash with all keys converted to strings.
   #
@@ -31,13 +37,13 @@ class Hash
   #   hash.stringify_keys
   #   # => {"name"=>"Rob", "age"=>"28"}
   def stringify_keys
-    transform_keys{ |key| key.to_s }
+    transform_keys(&:to_s)
   end
 
-  # Destructively convert all keys to strings. Same as
+  # Destructively converts all keys to strings. Same as
   # +stringify_keys+, but modifies +self+.
   def stringify_keys!
-    transform_keys!{ |key| key.to_s }
+    transform_keys!(&:to_s)
   end
 
   # Returns a new hash with all keys converted to symbols, as long as
@@ -48,19 +54,19 @@ class Hash
   #   hash.symbolize_keys
   #   # => {:name=>"Rob", :age=>"28"}
   def symbolize_keys
-    transform_keys{ |key| key.to_sym rescue key }
+    transform_keys { |key| key.to_sym rescue key }
   end
   alias_method :to_options,  :symbolize_keys
 
-  # Destructively convert all keys to symbols, as long as they respond
+  # Destructively converts all keys to symbols, as long as they respond
   # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
   def symbolize_keys!
-    transform_keys!{ |key| key.to_sym rescue key }
+    transform_keys! { |key| key.to_sym rescue key }
   end
   alias_method :to_options!, :symbolize_keys!
 
-  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising
-  # ArgumentError on a mismatch.
+  # Validates all keys in a hash match <tt>*valid_keys</tt>, raising
+  # +ArgumentError+ on a mismatch.
   #
   # Note that keys are treated differently than HashWithIndifferentAccess,
   # meaning that string and symbol keys will not match.
@@ -89,7 +95,7 @@ class Hash
     _deep_transform_keys_in_object(self, &block)
   end
 
-  # Destructively convert all keys by using the block operation.
+  # Destructively converts all keys by using the block operation.
   # This includes the keys from the root hash and from all
   # nested hashes and arrays.
   def deep_transform_keys!(&block)
@@ -105,14 +111,14 @@ class Hash
   #   hash.deep_stringify_keys
   #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
   def deep_stringify_keys
-    deep_transform_keys{ |key| key.to_s }
+    deep_transform_keys(&:to_s)
   end
 
-  # Destructively convert all keys to strings.
+  # Destructively converts all keys to strings.
   # This includes the keys from the root hash and from all
   # nested hashes and arrays.
   def deep_stringify_keys!
-    deep_transform_keys!{ |key| key.to_s }
+    deep_transform_keys!(&:to_s)
   end
 
   # Returns a new hash with all keys converted to symbols, as long as
@@ -124,14 +130,14 @@ class Hash
   #   hash.deep_symbolize_keys
   #   # => {:person=>{:name=>"Rob", :age=>"28"}}
   def deep_symbolize_keys
-    deep_transform_keys{ |key| key.to_sym rescue key }
+    deep_transform_keys { |key| key.to_sym rescue key }
   end
 
-  # Destructively convert all keys to symbols, as long as they respond
+  # Destructively converts all keys to symbols, as long as they respond
   # to +to_sym+. This includes the keys from the root hash and from all
   # nested hashes and arrays.
   def deep_symbolize_keys!
-    deep_transform_keys!{ |key| key.to_sym rescue key }
+    deep_transform_keys! { |key| key.to_sym rescue key }
   end
 
   private
@@ -143,7 +149,7 @@ class Hash
           result[yield(key)] = _deep_transform_keys_in_object(value, &block)
         end
       when Array
-        object.map {|e| _deep_transform_keys_in_object(e, &block) }
+        object.map { |e| _deep_transform_keys_in_object(e, &block) }
       else
         object
       end
@@ -158,7 +164,7 @@ class Hash
         end
         object
       when Array
-        object.map! {|e| _deep_transform_keys_in_object!(e, &block)}
+        object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
       else
         object
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Hash
   # Merges the caller into +other_hash+. For example,
   #
@@ -12,11 +14,12 @@ class Hash
   def reverse_merge(other_hash)
     other_hash.merge(self)
   end
+  alias_method :with_defaults, :reverse_merge
 
   # Destructive +reverse_merge+.
   def reverse_merge!(other_hash)
-    # right wins if there is no left
-    merge!( other_hash ){|key,left,right| left }
+    replace(reverse_merge(other_hash))
   end
   alias_method :reverse_update, :reverse_merge!
+  alias_method :with_defaults!, :reverse_merge!
 end

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

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 class Hash
-  # Slice a hash to include only the given keys. Returns a hash containing 
+  # 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 
+  #
+  # This is useful for limiting an options hash to valid keys before
   # passing to a method:
   #
   #   def search(criteria = {})
@@ -19,9 +21,8 @@ class Hash
   #   valid_keys = [:mass, :velocity, :time]
   #   search(options.slice(*valid_keys))
   def slice(*keys)
-    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
+    keys.each_with_object(Hash.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
+  end unless method_defined?(:slice)
 
   # Replaces the hash with only the given keys.
   # Returns a hash containing the removed key/value pairs.
@@ -29,7 +30,6 @@ class Hash
   #   { a: 1, b: 2, c: 3, d: 4 }.slice!(:a, :b)
   #   # => {:c=>3, :d=>4}
   def slice!(*keys)
-    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
     omit = slice(*self.keys - keys)
     hash = slice(*keys)
     hash.default      = default

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

@@ -1,11 +1,18 @@
+# frozen_string_literal: true
+
 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 }
+  #   { 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) unless block_given?
+    return enum_for(:transform_values) { size } unless block_given?
+    return {} if empty?
     result = self.class.new
     each do |key, value|
       result[key] = yield(value)
@@ -13,11 +20,13 @@ class Hash
     result
   end unless method_defined? :transform_values
 
-  # Destructive +transform_values+
+  # Destructively converts all values using the +block+ operations.
+  # Same as +transform_values+ but modifies +self+.
   def transform_values!
-    return enum_for(:transform_values!) unless block_given?
+    return enum_for(:transform_values!) { size } unless block_given?
     each do |key, value|
       self[key] = yield(value)
     end
   end unless method_defined? :transform_values!
+  # TODO: Remove this file when supporting only Ruby 2.4+.
 end

data/lib/active_support/core_ext/hash.rb

@@ -1,9 +1,11 @@
-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/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'
+# frozen_string_literal: true
+
+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/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

@@ -1,4 +1,6 @@
-require 'active_support/inflector'
+# frozen_string_literal: true
+
+require "active_support/inflector"
 
 class Integer
   # Ordinalize turns a number into an ordinal string used to denote the

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Integer
   # Check whether the integer is evenly divisible by the argument.
   #

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

@@ -1,29 +1,22 @@
-require 'active_support/duration'
-require 'active_support/core_ext/numeric/time'
+# frozen_string_literal: true
+
+require "active_support/duration"
+require "active_support/core_ext/numeric/time"
 
 class Integer
-  # 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
-  # <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)
-  #   1.month.from_now
+  # Returns a Duration instance matching the number of months provided.
   #
-  #   # equivalent to Time.now.advance(years: 2)
-  #   2.years.from_now
-  #
-  #   # equivalent to Time.now.advance(months: 4, years: 5)
-  #   (4.months + 5.years).from_now
+  #   2.months # => 2 months
   def months
-    ActiveSupport::Duration.new(self * 30.days, [[:months, self]])
+    ActiveSupport::Duration.months(self)
   end
   alias :month :months
 
+  # Returns a Duration instance matching the number of years provided.
+  #
+  #   2.years # => 2 years
   def years
-    ActiveSupport::Duration.new(self * 365.25.days, [[:years, self]])
+    ActiveSupport::Duration.years(self)
   end
   alias :year :years
 end

data/lib/active_support/core_ext/integer.rb

@@ -1,3 +1,5 @@
-require 'active_support/core_ext/integer/multiple'
-require 'active_support/core_ext/integer/inflections'
-require 'active_support/core_ext/integer/time'
+# frozen_string_literal: true
+
+require "active_support/core_ext/integer/multiple"
+require "active_support/core_ext/integer/inflections"
+require "active_support/core_ext/integer/time"

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Object
   # Makes backticks behave (somewhat more) similarly on all platforms.
   # On win32 `nonexistent_command` raises Errno::ENOENT; on Unix, the

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

@@ -1,6 +1,10 @@
-require 'active_support/core_ext/module/concerning'
+# frozen_string_literal: true
+
+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.

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

@@ -1,9 +1,9 @@
-require 'rbconfig'
-require 'tempfile'
-require 'active_support/deprecation'
+# frozen_string_literal: true
 
 module Kernel
-  # Sets $VERBOSE to nil for the duration of the block and back to its original
+  module_function
+
+  # Sets $VERBOSE to +nil+ for the duration of the block and back to its original
   # value afterwards.
   #
   #   silence_warnings do
@@ -30,34 +30,6 @@ module Kernel
     $VERBOSE = old_verbose
   end
 
-  # For compatibility
-  def silence_stderr #:nodoc:
-    ActiveSupport::Deprecation.warn(
-      "`#silence_stderr` is deprecated and will be removed in the next release."
-    ) #not thread-safe
-    silence_stream(STDERR) { yield }
-  end
-
-  # Deprecated : this method is not thread safe
-  # Silences any stream for the duration of the block.
-  #
-  #   silence_stream(STDOUT) do
-  #     puts 'This will never be seen'
-  #   end
-  #
-  #   puts 'But this will'
-  #
-  # This method is not thread-safe.
-  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)
-    old_stream.close
-  end
-
   # Blocks and ignores any exception passed as argument if raised within the block.
   #
   #   suppress(ZeroDivisionError) do
@@ -70,56 +42,4 @@ module Kernel
     yield
   rescue *exception_classes
   end
-
-  # Captures the given stream and returns it:
-  #
-  #   stream = capture(:stdout) { puts 'notice' }
-  #   stream # => "notice\n"
-  #
-  #   stream = capture(:stderr) { warn 'error' }
-  #   stream # => "error\n"
-  #
-  # even for subprocesses:
-  #
-  #   stream = capture(:stdout) { system('echo notice') }
-  #   stream # => "notice\n"
-  #
-  #   stream = capture(:stderr) { system('echo error 1>&2') }
-  #   stream # => "error\n"
-  def capture(stream)
-    ActiveSupport::Deprecation.warn(
-      "`#capture(stream)` is deprecated and will be removed in the next release."
-    ) #not thread-safe
-    stream = stream.to_s
-    captured_stream = Tempfile.new(stream)
-    stream_io = eval("$#{stream}")
-    origin_stream = stream_io.dup
-    stream_io.reopen(captured_stream)
-
-    yield
-
-    stream_io.rewind
-    return captured_stream.read
-  ensure
-    captured_stream.close
-    captured_stream.unlink
-    stream_io.reopen(origin_stream)
-  end
-  alias :silence :capture
-
-  # Silences both STDOUT and STDERR, even for subprocesses.
-  #
-  #   quietly { system 'bundle install' }
-  #
-  # This method is not thread-safe.
-  def quietly
-    ActiveSupport::Deprecation.warn(
-      "`#quietly` is deprecated and will be removed in the next release."
-    ) #not thread-safe
-    silence_stream(STDOUT) do
-      silence_stream(STDERR) do
-        yield
-      end
-    end
-  end
 end

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

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

data/lib/active_support/core_ext/kernel.rb

@@ -1,5 +1,6 @@
-require 'active_support/core_ext/kernel/agnostics'
-require 'active_support/core_ext/kernel/concern'
-require 'active_support/core_ext/kernel/debugger' if RUBY_VERSION < '2.0.0'
-require 'active_support/core_ext/kernel/reporting'
-require 'active_support/core_ext/kernel/singleton_class'
+# frozen_string_literal: true
+
+require "active_support/core_ext/kernel/agnostics"
+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,28 +1,9 @@
-class LoadError
-  REGEXPS = [
-    /^no such file to load -- (.+)$/i,
-    /^Missing \w+ (?:file\s*)?([^\s]+.rb)$/i,
-    /^Missing API definition file in (.+)$/i,
-    /^cannot load such file -- (.+)$/i,
-  ]
-
-  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
-    end
-  end
+# frozen_string_literal: true
 
+class LoadError
   # 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

data/lib/active_support/core_ext/marshal.rb

@@ -1,11 +1,11 @@
-require 'active_support/core_ext/module/aliasing'
+# frozen_string_literal: true
 
-module Marshal
-  class << self
-    def load_with_autoloading(source, proc = nil)
-      load_without_autoloading(source, proc)
+module ActiveSupport
+  module MarshalWithAutoloading # :nodoc:
+    def load(source, proc = nil)
+      super(source, proc)
     rescue ArgumentError, NameError => exc
-      if exc.message.match(%r|undefined class/module (.+?)(::)?\z|)
+      if exc.message.match(%r|undefined class/module (.+?)(?:::)?\z|)
         # try loading the class/module
         loaded = $1.constantize
 
@@ -18,7 +18,7 @@ module Marshal
         raise exc
       end
     end
-
-    alias_method_chain :load, :autoloading
   end
 end
+
+Marshal.singleton_class.prepend(ActiveSupport::MarshalWithAutoloading)

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

@@ -1,49 +1,8 @@
-class Module
-  # Encapsulates the common pattern of:
-  #
-  #   alias_method :foo_without_feature, :foo
-  #   alias_method :foo, :foo_with_feature
-  #
-  # With this, you simply do:
-  #
-  #   alias_method_chain :foo, :feature
-  #
-  # And both aliases are set up for you.
-  #
-  # Query and bang methods (foo?, foo!) keep the same punctuation:
-  #
-  #   alias_method_chain :foo?, :feature
-  #
-  # is equivalent to
-  #
-  #   alias_method :foo_without_feature?, :foo?
-  #   alias_method :foo?, :foo_with_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, 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 = "#{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
-    end
-  end
+# frozen_string_literal: true
 
+class Module
   # Allows you to make aliases for attributes, which includes
-  # getter, setter, and query methods.
+  # getter, setter, and a predicate.
   #
   #   class Content < ActiveRecord::Base
   #     # has a title attribute
@@ -60,6 +19,9 @@ class Module
   #   e.subject = "Megastars"
   #   e.title    # => "Megastars"
   def alias_attribute(new_name, old_name)
+    # The following reader methods use an explicit `self` receiver in order to
+    # support aliases that start with an uppercase letter. Otherwise, they would
+    # be resolved as constants instead.
     module_eval <<-STR, __FILE__, __LINE__ + 1
       def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
       def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Module
   # A module may or may not have a name.
   #
@@ -7,12 +9,21 @@ class Module
   #   m = Module.new
   #   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?
     name.nil?
   end