activesupport 4.1.15 → 4.2.11.3

data/lib/active_support/concern.rb

@@ -26,7 +26,7 @@ module ActiveSupport
   #       scope :disabled, -> { where(disabled: true) }
   #     end
   #
-  #     module ClassMethods
+  #     class_methods do
   #       ...
   #     end
   #   end
@@ -95,7 +95,7 @@ module ActiveSupport
   #   end
   #
   #   class Host
-  #     include Bar # works, Bar takes care now of its dependencies
+  #     include Bar # It works, now Bar takes care of its dependencies
   #   end
   module Concern
     class MultipleIncludedBlocks < StandardError #:nodoc:
@@ -130,5 +130,13 @@ module ActiveSupport
         super
       end
     end
+
+    def class_methods(&class_methods_module_definition)
+      mod = const_defined?(:ClassMethods, false) ?
+        const_get(:ClassMethods) :
+        const_set(:ClassMethods, Module.new)
+
+      mod.module_eval(&class_methods_module_definition)
+    end
   end
 end

data/lib/active_support/core_ext/array/access.rb

@@ -5,6 +5,8 @@ class Array
   #   %w( a b c d ).from(2)  # => ["c", "d"]
   #   %w( a b c d ).from(10) # => []
   #   %w().from(0)           # => []
+  #   %w( a b c d ).from(-2) # => ["c", "d"]
+  #   %w( a b c ).from(-10)  # => []
   def from(position)
     self[position, length] || []
   end
@@ -15,8 +17,14 @@ class Array
   #   %w( a b c d ).to(2)  # => ["a", "b", "c"]
   #   %w( a b c d ).to(10) # => ["a", "b", "c", "d"]
   #   %w().to(0)           # => []
+  #   %w( a b c d ).to(-2) # => ["a", "b", "c"]
+  #   %w( a b c ).to(-10)  # => []
   def to(position)
-    first position + 1
+    if position >= 0
+      first position + 1
+    else
+      self[0..position]
+    end
   end
 
   # Equal to <tt>self[1]</tt>.

data/lib/active_support/core_ext/array/grouping.rb

@@ -18,6 +18,11 @@ class Array
   #   ["3", "4"]
   #   ["5"]
   def in_groups_of(number, fill_with = nil)
+    if number.to_i <= 0
+      raise ArgumentError,
+        "Group size must be a positive integer, was #{number.inspect}"
+    end
+
     if fill_with == false
       collection = self
     else

data/lib/active_support/core_ext/big_decimal/yaml_conversions.rb

@@ -1,3 +1,5 @@
+require 'active_support/deprecation'
+
 ActiveSupport::Deprecation.warn 'core_ext/big_decimal/yaml_conversions is deprecated and will be removed in the future.'
 
 require 'bigdecimal'

data/lib/active_support/core_ext/class/delegating_attributes.rb

@@ -1,5 +1,7 @@
 require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/module/deprecation'
+
 
 class Class
   def superclass_delegating_accessor(name, options = {})
@@ -21,6 +23,8 @@ class Class
     end
   end
 
+  deprecate superclass_delegating_accessor: :class_attribute
+
   private
     # Take the object being set and store it in a method. This gives us automatic
     # inheritance behavior, without having to store the object in an instance

data/lib/active_support/core_ext/class/subclasses.rb

@@ -25,8 +25,6 @@ class Class
 
   # Returns an array with the direct children of +self+.
   #
-  #   Integer.subclasses # => [Fixnum, Bignum]
-  #
   #   class Foo; end
   #   class Bar < Foo; end
   #   class Baz < Bar; end

data/lib/active_support/core_ext/date/conversions.rb

@@ -35,6 +35,7 @@ class Date
   #   date.to_s(:db)                      # => "2007-11-10"
   #
   #   date.to_formatted_s(:short)         # => "10 Nov"
+  #   date.to_formatted_s(:number)        # => "20071110"
   #   date.to_formatted_s(:long)          # => "November 10, 2007"
   #   date.to_formatted_s(:long_ordinal)  # => "November 10th, 2007"
   #   date.to_formatted_s(:rfc822)        # => "10 Nov 2007"
@@ -82,6 +83,11 @@ class Date
     ::Time.send(form, year, month, day)
   end
 
+  # Returns a string which represents the time in used time zone as DateTime
+  # defined by XML Schema:
+  #
+  #   date = Date.new(2015, 05, 23)  # => Sat, 23 May 2015
+  #   date.xmlschema                 # => "2015-05-23T00:00:00+04:00"
   def xmlschema
     in_time_zone.xmlschema
   end

data/lib/active_support/core_ext/date_and_time/calculations.rb

@@ -109,9 +109,20 @@ module DateAndTime
     alias :at_beginning_of_year :beginning_of_year
 
     # Returns a new date/time representing the given day in the next week.
+    #
+    #   today = Date.today # => Thu, 07 May 2015
+    #   today.next_week    # => Mon, 11 May 2015
+    #
     # The +given_day_in_next_week+ defaults to the beginning of the week
     # which is determined by +Date.beginning_of_week+ or +config.beginning_of_week+
+    #
+    #   today = Date.today       # => Thu, 07 May 2015
+    #   today.next_week(:friday) # => Fri, 15 May 2015
+    #
     # when set. +DateTime+ objects have their time set to 0:00.
+    #
+    #   now = Time.current # => Thu, 07 May 2015 13:31:16 UTC +00:00
+    #   now.next_week      # => Mon, 11 May 2015 00:00:00 UTC +00:00
     def next_week(given_day_in_next_week = Date.beginning_of_week)
       first_hour(weeks_since(1).beginning_of_week.days_since(days_span(given_day_in_next_week)))
     end

data/lib/active_support/core_ext/date_and_time/compatibility.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/module/remove_method'
+
+module DateAndTime
+  module Compatibility
+    # If true, +to_time+ preserves the timezone offset of receiver.
+    #
+    # NOTE: With Ruby 2.4+ the default for +to_time+ changed from
+    # converting to the local system time, to preserving the offset
+    # of the receiver. For backwards compatibility we're overriding
+    # this behavior, but new apps will have an initializer that sets
+    # this to true, because the new behavior is preferred.
+    mattr_accessor(:preserve_timezone, instance_writer: false) { false }
+  end
+end

data/lib/active_support/core_ext/date_time.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/date_time/acts_like'
 require 'active_support/core_ext/date_time/calculations'
+require 'active_support/core_ext/date_time/compatibility'
 require 'active_support/core_ext/date_time/conversions'
 require 'active_support/core_ext/date_time/zones'

data/lib/active_support/core_ext/date_time/calculations.rb

@@ -24,6 +24,13 @@ class DateTime
     end_of_day.to_i - to_i
   end
 
+  # Returns the fraction of a second as a +Rational+
+  #
+  #   DateTime.new(2012, 8, 29, 0, 0, 0.5).subsec # => (1/2)
+  def subsec
+    sec_fraction
+  end
+
   # Returns a new DateTime where one or more of the elements have been changed
   # according to the +options+ parameter. The time options (<tt>:hour</tt>,
   # <tt>:min</tt>, <tt>:sec</tt>) reset cascadingly, so if only the hour is
@@ -53,6 +60,16 @@ class DateTime
   # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
   # <tt>:minutes</tt>, <tt>:seconds</tt>.
   def advance(options)
+    unless options[:weeks].nil?
+      options[:weeks], partial_weeks = options[:weeks].divmod(1)
+      options[:days] = options.fetch(:days, 0) + 7 * partial_weeks
+    end
+
+    unless options[:days].nil?
+      options[:days], partial_days = options[:days].divmod(1)
+      options[:hours] = options.fetch(:hours, 0) + 24 * partial_days
+    end
+
     d = to_date.advance(options)
     datetime_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
     seconds_to_advance = \
@@ -63,7 +80,7 @@ class DateTime
     if seconds_to_advance.zero?
       datetime_advanced_by_date
     else
-      datetime_advanced_by_date.since seconds_to_advance
+      datetime_advanced_by_date.since(seconds_to_advance)
     end
   end
 
@@ -129,14 +146,27 @@ class DateTime
   end
   alias :at_end_of_minute :end_of_minute
 
-  # Adjusts DateTime to UTC by adding its offset value; offset is set to 0.
+  # Returns a <tt>Time</tt> instance of the simultaneous time in the system timezone.
+  def localtime(utc_offset = nil)
+    utc = new_offset(0)
+
+    Time.utc(
+      utc.year, utc.month, utc.day,
+      utc.hour, utc.min, utc.sec + utc.sec_fraction
+    ).getlocal(utc_offset)
+  end
+  alias_method :getlocal, :localtime
+
+  # Returns a <tt>DateTime</tt> instance of the simultaneous time in the UTC timezone.
   #
   #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24))     # => Mon, 21 Feb 2005 10:11:12 -0600
-  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc # => Mon, 21 Feb 2005 16:11:12 +0000
+  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc # => Mon, 21 Feb 2005 16:11:12 UTC
   def utc
     new_offset(0)
   end
+  alias_method :getgm, :utc
   alias_method :getutc, :utc
+  alias_method :gmtime, :utc
 
   # Returns +true+ if <tt>offset == 0</tt>.
   def utc?
@@ -154,7 +184,7 @@ class DateTime
     if other.kind_of?(Infinity)
       super
     elsif other.respond_to? :to_datetime
-      super other.to_datetime
+      super other.to_datetime rescue nil
     else
       nil
     end

data/lib/active_support/core_ext/date_time/compatibility.rb

@@ -0,0 +1,16 @@
+require 'active_support/core_ext/date_and_time/compatibility'
+require 'active_support/core_ext/module/remove_method'
+
+class DateTime
+  include DateAndTime::Compatibility
+
+  remove_possible_method :to_time
+
+  # Either return an instance of `Time` with the same UTC offset
+  # as +self+ or an instance of `Time` representing the same time
+  # in the the local system timezone depending on the setting of
+  # on the setting of +ActiveSupport.to_time_preserves_timezone+.
+  def to_time
+    preserve_timezone ? getlocal(utc_offset) : getlocal
+  end
+end

data/lib/active_support/core_ext/date_time/conversions.rb

@@ -71,9 +71,9 @@ class DateTime
     civil(year, month, day, hour, min, sec, offset)
   end
 
-  # Converts +self+ to a floating-point number of seconds since the Unix epoch.
+  # Converts +self+ to a floating-point number of seconds, including fractional microseconds, since the Unix epoch.
   def to_f
-    seconds_since_unix_epoch.to_f
+    seconds_since_unix_epoch.to_f + sec_fraction
   end
 
   # Converts +self+ to an integer number of seconds since the Unix epoch.

data/lib/active_support/core_ext/digest/uuid.rb

@@ -0,0 +1,51 @@
+require 'securerandom'
+
+module Digest
+  module UUID
+    DNS_NAMESPACE  = "k\xA7\xB8\x10\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+    URL_NAMESPACE  = "k\xA7\xB8\x11\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+    OID_NAMESPACE  = "k\xA7\xB8\x12\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+    X500_NAMESPACE = "k\xA7\xB8\x14\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+
+    # Generates a v5 non-random UUID (Universally Unique IDentifier).
+    #
+    # Using Digest::MD5 generates version 3 UUIDs; Digest::SHA1 generates version 5 UUIDs.
+    # uuid_from_hash always generates the same UUID for a given name and namespace combination.
+    #
+    # See RFC 4122 for details of UUID at: http://www.ietf.org/rfc/rfc4122.txt
+    def self.uuid_from_hash(hash_class, uuid_namespace, name)
+      if hash_class == Digest::MD5
+        version = 3
+      elsif hash_class == Digest::SHA1
+        version = 5
+      else
+        raise ArgumentError, "Expected Digest::SHA1 or Digest::MD5, got #{hash_class.name}."
+      end
+
+      hash = hash_class.new
+      hash.update(uuid_namespace)
+      hash.update(name)
+
+      ary = hash.digest.unpack('NnnnnN')
+      ary[2] = (ary[2] & 0x0FFF) | (version << 12)
+      ary[3] = (ary[3] & 0x3FFF) | 0x8000
+
+      "%08x-%04x-%04x-%04x-%04x%08x" % ary
+    end
+
+    # Convenience method for uuid_from_hash using Digest::MD5.
+    def self.uuid_v3(uuid_namespace, name)
+      self.uuid_from_hash(Digest::MD5, uuid_namespace, name)
+    end
+
+    # Convenience method for uuid_from_hash using Digest::SHA1.
+    def self.uuid_v5(uuid_namespace, name)
+      self.uuid_from_hash(Digest::SHA1, uuid_namespace, name)
+    end
+
+    # Convenience method for SecureRandom.uuid.
+    def self.uuid_v4
+      SecureRandom.uuid
+    end
+  end
+end

data/lib/active_support/core_ext/enumerable.rb

@@ -78,3 +78,19 @@ class Range #:nodoc:
     end
   end
 end
+
+# Array#sum was added in Ruby 2.4 but it only works with Numeric elements.
+#
+# We tried shimming it to attempt the fast native method, rescue TypeError,
+# and fall back to the compatible implementation, but that's much slower than
+# just calling the compat method in the first place.
+if Array.instance_methods(false).include?(:sum) && !(%w[a].sum rescue false)
+  class Array
+    remove_method :sum
+
+    def sum(*args) #:nodoc:
+      # Use Enumerable#sum instead.
+      super
+    end
+  end
+end

data/lib/active_support/core_ext/file/atomic.rb

@@ -40,7 +40,7 @@ class File
       chown(old_stat.uid, old_stat.gid, file_name)
       # This operation will affect filesystem ACL's
       chmod(old_stat.mode, file_name)
-    rescue Errno::EPERM
+    rescue Errno::EPERM, Errno::EACCES
       # Changing file ownership failed, moving on.
     end
   end

data/lib/active_support/core_ext/hash.rb

@@ -6,3 +6,4 @@ 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/hash/compact.rb

@@ -1,20 +1,24 @@
 class Hash
-  # Returns a hash with non +nil+ values.
-  # 
-  #   hash = { a: true, b: false, c: nil}
-  #   hash.compact # => { a: true, b: false}
-  #   hash # => { a: true, b: false, c: nil}
-  #   { c: nil }.compact # => {}
-  def compact
-    self.select { |_, value| !value.nil? }
+  unless Hash.instance_methods(false).include?(:compact)
+    # Returns a hash with non +nil+ values.
+    #
+    #   hash = { a: true, b: false, c: nil}
+    #   hash.compact # => { a: true, b: false}
+    #   hash # => { a: true, b: false, c: nil}
+    #   { c: nil }.compact # => {}
+    def compact
+      self.select { |_, value| !value.nil? }
+    end
   end
-  
-  # Replaces current hash with non +nil+ values.
-  # 
-  #   hash = { a: true, b: false, c: nil}
-  #   hash.compact! # => { a: true, b: false}
-  #   hash # => { a: true, b: false}
-  def compact!
-    self.reject! { |_, value| value.nil? }
+
+  unless Hash.instance_methods(false).include?(:compact!)
+    # Replaces current hash with non +nil+ values.
+    #
+    #   hash = { a: true, b: false, c: nil}
+    #   hash.compact! # => { a: true, b: false}
+    #   hash # => { a: true, b: false}
+    def compact!
+      self.reject! { |_, value| value.nil? }
+    end
   end
 end

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

@@ -55,8 +55,7 @@ class Hash
   #
   #     XML_TYPE_NAMES = {
   #       "Symbol"     => "symbol",
-  #       "Fixnum"     => "integer",
-  #       "Bignum"     => "integer",
+  #       "Integer"    => "integer",
   #       "BigDecimal" => "decimal",
   #       "Float"      => "float",
   #       "TrueClass"  => "boolean",
@@ -105,7 +104,7 @@ class Hash
     #   hash = Hash.from_xml(xml)
     #   # => {"hash"=>{"foo"=>1, "bar"=>2}}
     #
-    # DisallowedType is raised if the XML contains attributes with <tt>type="yaml"</tt> or
+    # +DisallowedType+ is raised if the XML contains attributes with <tt>type="yaml"</tt> or
     # <tt>type="symbol"</tt>. Use <tt>Hash.from_trusted_xml</tt> to parse this XML.
     def from_xml(xml, disallowed_types = nil)
       ActiveSupport::XMLConverter.new(xml, disallowed_types).to_h
@@ -221,7 +220,7 @@ module ActiveSupport
       def garbage?(value)
         # If the type is the only element which makes it then
         # this still makes the value nil, except if type is
-        # a XML node(where type['value'] is a Hash)
+        # an XML node(where type['value'] is a Hash)
         value['type'] && !value['type'].is_a?(::Hash) && value.size == 1
       end
 
@@ -241,4 +240,3 @@ module ActiveSupport
 
   end
 end
-

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

@@ -1,13 +1,19 @@
 class Hash
-  # Returns a hash that includes everything but the given keys. This is useful for
-  # limiting a set of parameters to everything but a few known toggles:
+  # Returns a hash that includes everything but the given keys.
+  #   hash = { a: true, b: false, c: nil}
+  #   hash.except(:c) # => { a: true, b: false}
+  #   hash # => { a: true, b: false, c: nil}
   #
+  # This is useful for limiting a set of parameters to everything but a few known toggles:
   #   @person.update(params[:person].except(:admin))
   def except(*keys)
     dup.except!(*keys)
   end
 
   # Replaces the hash without the given keys.
+  #   hash = { a: true, b: false, c: nil}
+  #   hash.except!(:c) # => { a: true, b: false}
+  #   hash # => { a: true, b: false }
   def except!(*keys)
     keys.each { |key| delete(key) }
     self