activesupport 4.2.11.1 → 6.1.7.3

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

@@ -1,4 +1,6 @@
-require 'date'
+# frozen_string_literal: true
+
+require "date"
 
 class DateTime
   class << self
@@ -10,7 +12,11 @@ class DateTime
     end
   end
 
-  # Seconds since midnight: DateTime.now.seconds_since_midnight.
+  # Returns the number of seconds since 00:00:00.
+  #
+  #   DateTime.new(2012, 8, 29,  0,  0,  0).seconds_since_midnight # => 0
+  #   DateTime.new(2012, 8, 29, 12, 34, 56).seconds_since_midnight # => 45296
+  #   DateTime.new(2012, 8, 29, 23, 59, 59).seconds_since_midnight # => 86399
   def seconds_since_midnight
     sec + (min * 60) + (hour * 3600)
   end
@@ -43,13 +49,23 @@ class DateTime
   #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => DateTime.new(1981, 8, 1, 22, 35, 0)
   #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => DateTime.new(1981, 8, 29, 0, 0, 0)
   def change(options)
+    if new_nsec = options[:nsec]
+      raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
+      new_fraction = Rational(new_nsec, 1000000000)
+    else
+      new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
+      new_fraction = Rational(new_usec, 1000000)
+    end
+
+    raise ArgumentError, "argument out of range" if new_fraction >= 1
+
     ::DateTime.civil(
       options.fetch(:year, year),
       options.fetch(:month, month),
       options.fetch(:day, day),
       options.fetch(:hour, hour),
       options.fetch(:min, options[:hour] ? 0 : min),
-      options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec + sec_fraction),
+      options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec) + new_fraction,
       options.fetch(:offset, offset),
       options.fetch(:start, start)
     )
@@ -71,7 +87,7 @@ class DateTime
     end
 
     d = to_date.advance(options)
-    datetime_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
+    datetime_advanced_by_date = change(year: d.year, month: d.month, day: d.day)
     seconds_to_advance = \
       options.fetch(:seconds, 0) +
       options.fetch(:minutes, 0) * 60 +
@@ -94,13 +110,13 @@ class DateTime
   # instance time. Do not use this method in combination with x.months, use
   # months_since instead!
   def since(seconds)
-    self + Rational(seconds.round, 86400)
+    self + Rational(seconds, 86400)
   end
   alias :in :since
 
   # Returns a new DateTime representing the start of the day (0:00).
   def beginning_of_day
-    change(:hour => 0)
+    change(hour: 0)
   end
   alias :midnight :beginning_of_day
   alias :at_midnight :beginning_of_day
@@ -108,7 +124,7 @@ class DateTime
 
   # Returns a new DateTime representing the middle of the day (12:00)
   def middle_of_day
-    change(:hour => 12)
+    change(hour: 12)
   end
   alias :midday :middle_of_day
   alias :noon :middle_of_day
@@ -118,31 +134,31 @@ class DateTime
 
   # Returns a new DateTime representing the end of the day (23:59:59).
   def end_of_day
-    change(:hour => 23, :min => 59, :sec => 59)
+    change(hour: 23, min: 59, sec: 59, usec: Rational(999999999, 1000))
   end
   alias :at_end_of_day :end_of_day
 
   # Returns a new DateTime representing the start of the hour (hh:00:00).
   def beginning_of_hour
-    change(:min => 0)
+    change(min: 0)
   end
   alias :at_beginning_of_hour :beginning_of_hour
 
   # Returns a new DateTime representing the end of the hour (hh:59:59).
   def end_of_hour
-    change(:min => 59, :sec => 59)
+    change(min: 59, sec: 59, usec: Rational(999999999, 1000))
   end
   alias :at_end_of_hour :end_of_hour
 
   # Returns a new DateTime representing the start of the minute (hh:mm:00).
   def beginning_of_minute
-    change(:sec => 0)
+    change(sec: 0)
   end
   alias :at_beginning_of_minute :beginning_of_minute
 
   # Returns a new DateTime representing the end of the minute (hh:mm:59).
   def end_of_minute
-    change(:sec => 59)
+    change(sec: 59, usec: Rational(999999999, 1000))
   end
   alias :at_end_of_minute :end_of_minute
 
@@ -157,12 +173,17 @@ class DateTime
   end
   alias_method :getlocal, :localtime
 
-  # Returns a <tt>DateTime</tt> instance of the simultaneous time in the UTC timezone.
+  # Returns a <tt>Time</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 UTC
   def utc
-    new_offset(0)
+    utc = new_offset(0)
+
+    Time.utc(
+      utc.year, utc.month, utc.day,
+      utc.hour, utc.min, utc.sec + utc.sec_fraction
+    )
   end
   alias_method :getgm, :utc
   alias_method :getutc, :utc
@@ -181,13 +202,10 @@ class DateTime
   # Layers additional behavior on DateTime#<=> so that Time and
   # ActiveSupport::TimeWithZone instances can be compared with a DateTime.
   def <=>(other)
-    if other.kind_of?(Infinity)
-      super
-    elsif other.respond_to? :to_datetime
+    if other.respond_to? :to_datetime
       super other.to_datetime rescue nil
     else
-      nil
+      super
     end
   end
-
 end

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

@@ -1,14 +1,16 @@
-require 'active_support/core_ext/date_and_time/compatibility'
-require 'active_support/core_ext/module/remove_method'
+# frozen_string_literal: true
+
+require "active_support/core_ext/date_and_time/compatibility"
+require "active_support/core_ext/module/redefine_method"
 
 class DateTime
   include DateAndTime::Compatibility
 
-  remove_possible_method :to_time
+  silence_redefinition_of_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
+  # Either return an instance of +Time+ with the same UTC offset
+  # as +self+ or an instance of +Time+ representing the same time
+  # in 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

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

@@ -1,8 +1,10 @@
-require 'date'
-require 'active_support/inflector/methods'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/date_time/calculations'
-require 'active_support/values/time_zone'
+# frozen_string_literal: true
+
+require "date"
+require "active_support/inflector/methods"
+require "active_support/core_ext/time/conversions"
+require "active_support/core_ext/date_time/calculations"
+require "active_support/values/time_zone"
 
 class DateTime
   # Convert to a formatted string. See Time::DATE_FORMATS for predefined formats.
@@ -40,6 +42,8 @@ class DateTime
   alias_method :to_default_s, :to_s if instance_methods(false).include?(:to_s)
   alias_method :to_s, :to_formatted_s
 
+  # Returns a formatted string of the offset from UTC, or an alternative
+  # string if the time zone is already UTC.
   #
   #   datetime = DateTime.civil(2000, 1, 1, 0, 0, 0, Rational(-6, 24))
   #   datetime.formatted_offset         # => "-06:00"
@@ -62,7 +66,7 @@ class DateTime
   #   # => Sun, 01 Jan 2012 00:00:00 +0300
   #   DateTime.civil_from_format :local, 2012, 12, 17
   #   # => Mon, 17 Dec 2012 00:00:00 +0000
-  def self.civil_from_format(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0)
+  def self.civil_from_format(utc_or_local, year, month = 1, day = 1, hour = 0, min = 0, sec = 0)
     if utc_or_local.to_sym == :local
       offset = ::Time.local(year, month, day).utc_offset.to_r / 86400
     else
@@ -92,12 +96,11 @@ class DateTime
   end
 
   private
+    def offset_in_seconds
+      (offset * 86400).to_i
+    end
 
-  def offset_in_seconds
-    (offset * 86400).to_i
-  end
-
-  def seconds_since_unix_epoch
-    (jd - 2440588) * 86400 - offset_in_seconds + seconds_since_midnight
-  end
+    def seconds_since_unix_epoch
+      (jd - 2440588) * 86400 - offset_in_seconds + seconds_since_midnight
+    end
 end

data/lib/active_support/core_ext/date_time.rb

@@ -1,5 +1,7 @@
-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'
+# frozen_string_literal: true
+
+require "active_support/core_ext/date_time/acts_like"
+require "active_support/core_ext/date_time/blank"
+require "active_support/core_ext/date_time/calculations"
+require "active_support/core_ext/date_time/compatibility"
+require "active_support/core_ext/date_time/conversions"

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

@@ -1,4 +1,7 @@
-require 'securerandom'
+# frozen_string_literal: true
+
+require "securerandom"
+require "digest"
 
 module Digest
   module UUID
@@ -12,7 +15,7 @@ module Digest
     # 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
+    # See RFC 4122 for details of UUID at: https://www.ietf.org/rfc/rfc4122.txt
     def self.uuid_from_hash(hash_class, uuid_namespace, name)
       if hash_class == Digest::MD5
         version = 3
@@ -26,7 +29,7 @@ module Digest
       hash.update(uuid_namespace)
       hash.update(name)
 
-      ary = hash.digest.unpack('NnnnnN')
+      ary = hash.digest.unpack("NnnnnN")
       ary[2] = (ary[2] & 0x0FFF) | (version << 12)
       ary[3] = (ary[3] & 0x3FFF) | 0x8000
 
@@ -35,12 +38,12 @@ module Digest
 
     # 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)
+      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)
+      uuid_from_hash(Digest::SHA1, uuid_namespace, name)
     end
 
     # Convenience method for SecureRandom.uuid.

data/lib/active_support/core_ext/digest.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/digest/uuid"

data/lib/active_support/core_ext/enumerable.rb

@@ -1,4 +1,21 @@
+# frozen_string_literal: true
+
 module Enumerable
+  INDEX_WITH_DEFAULT = Object.new
+  private_constant :INDEX_WITH_DEFAULT
+
+  # Enumerable#sum was added in Ruby 2.4, but it only works with Numeric elements
+  # when we omit an identity.
+
+  # :stopdoc:
+
+  # We can't use Refinements here because Refinements with Module which will be prepended
+  # doesn't work well https://bugs.ruby-lang.org/issues/13446
+  alias :_original_sum_with_required_identity :sum
+  private :_original_sum_with_required_identity
+
+  # :startdoc:
+
   # Calculates a sum from the elements.
   #
   #  payments.sum { |p| p.price * p.tax_rate }
@@ -12,33 +29,66 @@ module Enumerable
   #
   #  [5, 15, 10].sum # => 30
   #  ['foo', 'bar'].sum # => "foobar"
-  #  [[1, 2], [3, 1, 5]].sum => [1, 2, 3, 1, 5]
+  #  [[1, 2], [3, 1, 5]].sum # => [1, 2, 3, 1, 5]
   #
   # The default sum of an empty list is zero. You can override this default:
   #
   #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
-  def sum(identity = 0, &block)
-    if block_given?
+  def sum(identity = nil, &block)
+    if identity
+      _original_sum_with_required_identity(identity, &block)
+    elsif block_given?
       map(&block).sum(identity)
     else
-      inject { |sum, element| sum + element } || identity
+      inject(:+) || 0
     end
   end
 
-  # Convert an enumerable to a hash.
+  # Convert an enumerable to a hash, using the block result as the key and the
+  # element as the value.
   #
   #   people.index_by(&:login)
-  #     => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
+  #   # => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
+  #
   #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
-  #     => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
+  #   # => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
   def index_by
     if block_given?
-      Hash[map { |elem| [yield(elem), elem] }]
+      result = {}
+      each { |elem| result[yield(elem)] = elem }
+      result
     else
       to_enum(:index_by) { size if respond_to?(:size) }
     end
   end
 
+  # Convert an enumerable to a hash, using the element as the key and the block
+  # result as the value.
+  #
+  #   post = Post.new(title: "hey there", body: "what's up?")
+  #
+  #   %i( title body ).index_with { |attr_name| post.public_send(attr_name) }
+  #   # => { title: "hey there", body: "what's up?" }
+  #
+  # If an argument is passed instead of a block, it will be used as the value
+  # for all elements:
+  #
+  #   %i( created_at updated_at ).index_with(Time.now)
+  #   # => { created_at: 2020-03-09 22:31:47, updated_at: 2020-03-09 22:31:47 }
+  def index_with(default = INDEX_WITH_DEFAULT)
+    if block_given?
+      result = {}
+      each { |elem| result[elem] = yield(elem) }
+      result
+    elsif default != INDEX_WITH_DEFAULT
+      result = {}
+      each { |elem| result[elem] = default }
+      result
+    else
+      to_enum(:index_with) { size if respond_to?(:size) }
+    end
+  end
+
   # Returns +true+ if the enumerable has more than 1 element. Functionally
   # equivalent to <tt>enum.to_a.size > 1</tt>. Can be called with a block too,
   # much like any?, so <tt>people.many? { |p| p.age > 26 }</tt> returns +true+
@@ -55,42 +105,156 @@ module Enumerable
     end
   end
 
+  # Returns a new array that includes the passed elements.
+  #
+  #   [ 1, 2, 3 ].including(4, 5)
+  #   # => [ 1, 2, 3, 4, 5 ]
+  #
+  #   ["David", "Rafael"].including %w[ Aaron Todd ]
+  #   # => ["David", "Rafael", "Aaron", "Todd"]
+  def including(*elements)
+    to_a.including(*elements)
+  end
+
   # The negative of the <tt>Enumerable#include?</tt>. Returns +true+ if the
   # collection does not include the object.
   def exclude?(object)
     !include?(object)
   end
+
+  # Returns a copy of the enumerable excluding the specified elements.
+  #
+  #   ["David", "Rafael", "Aaron", "Todd"].excluding "Aaron", "Todd"
+  #   # => ["David", "Rafael"]
+  #
+  #   ["David", "Rafael", "Aaron", "Todd"].excluding %w[ Aaron Todd ]
+  #   # => ["David", "Rafael"]
+  #
+  #   {foo: 1, bar: 2, baz: 3}.excluding :bar
+  #   # => {foo: 1, baz: 3}
+  def excluding(*elements)
+    elements.flatten!(1)
+    reject { |element| elements.include?(element) }
+  end
+
+  # Alias for #excluding.
+  def without(*elements)
+    excluding(*elements)
+  end
+
+  # Extract the given key from each element in the enumerable.
+  #
+  #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name)
+  #   # => ["David", "Rafael", "Aaron"]
+  #
+  #   [{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pluck(:id, :name)
+  #   # => [[1, "David"], [2, "Rafael"]]
+  def pluck(*keys)
+    if keys.many?
+      map { |element| keys.map { |key| element[key] } }
+    else
+      key = keys.first
+      map { |element| element[key] }
+    end
+  end
+
+  # Extract the given key from the first element in the enumerable.
+  #
+  #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pick(:name)
+  #   # => "David"
+  #
+  #   [{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pick(:id, :name)
+  #   # => [1, "David"]
+  def pick(*keys)
+    return if none?
+
+    if keys.many?
+      keys.map { |key| first[key] }
+    else
+      first[keys.first]
+    end
+  end
+
+  # Returns a new +Array+ without the blank items.
+  # Uses Object#blank? for determining if an item is blank.
+  #
+  #    [1, "", nil, 2, " ", [], {}, false, true].compact_blank
+  #    # =>  [1, 2, true]
+  #
+  #    Set.new([nil, "", 1, 2])
+  #    # => [2, 1] (or [1, 2])
+  #
+  # When called on a +Hash+, returns a new +Hash+ without the blank values.
+  #
+  #    { a: "", b: 1, c: nil, d: [], e: false, f: true }.compact_blank
+  #    #=> { b: 1, f: true }
+  def compact_blank
+    reject(&:blank?)
+  end
+end
+
+class Hash
+  # Hash#reject has its own definition, so this needs one too.
+  def compact_blank #:nodoc:
+    reject { |_k, v| v.blank? }
+  end
+
+  # Removes all blank values from the +Hash+ in place and returns self.
+  # Uses Object#blank? for determining if a value is blank.
+  #
+  #    h = { a: "", b: 1, c: nil, d: [], e: false, f: true }
+  #    h.compact_blank!
+  #    # => { b: 1, f: true }
+  def compact_blank!
+    # use delete_if rather than reject! because it always returns self even if nothing changed
+    delete_if { |_k, v| v.blank? }
+  end
 end
 
 class Range #:nodoc:
   # Optimize range sum to use arithmetic progression if a block is not given and
   # we have a range of numeric values.
-  def sum(identity = 0)
+  def sum(identity = nil)
     if block_given? || !(first.is_a?(Integer) && last.is_a?(Integer))
       super
     else
       actual_last = exclude_end? ? (last - 1) : last
       if actual_last >= first
-        (actual_last - first + 1) * (actual_last + first) / 2
+        sum = identity || 0
+        sum + (actual_last - first + 1) * (actual_last + first) / 2
       else
-        identity
+        identity || 0
       end
     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.
+# Using Refinements here in order not to expose our internal method
+using Module.new {
+  refine Array do
+    alias :orig_sum :sum
+  end
+}
+
+class Array #:nodoc:
+  # Array#sum was added in Ruby 2.4 but it only works with Numeric elements.
+  def sum(init = nil, &block)
+    if init.is_a?(Numeric) || first.is_a?(Numeric)
+      init ||= 0
+      orig_sum(init, &block)
+    else
       super
     end
   end
+
+  # Removes all blank elements from the +Array+ in place and returns self.
+  # Uses Object#blank? for determining if an item is blank.
+  #
+  #    a = [1, "", nil, 2, " ", [], {}, false, true]
+  #    a.compact_blank!
+  #    # =>  [1, 2, true]
+  def compact_blank!
+    # use delete_if rather than reject! because it always returns self even if nothing changed
+    delete_if(&:blank?)
+  end
 end

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

@@ -1,4 +1,6 @@
-require 'fileutils'
+# frozen_string_literal: true
+
+require "fileutils"
 
 class File
   # Write to a file atomically. Useful for situations where you don't
@@ -8,51 +10,56 @@ class File
   #     file.write('hello')
   #   end
   #
-  # If your temp directory is not on the same filesystem as the file you're
-  # trying to write, you can provide a different temporary directory.
+  # This method needs to create a temporary file. By default it will create it
+  # in the same directory as the destination file. If you don't like this
+  # behavior you can provide a different directory but it must be on the
+  # same physical filesystem as the file you're trying to write.
   #
   #   File.atomic_write('/data/something.important', '/data/tmp') do |file|
   #     file.write('hello')
   #   end
-  def self.atomic_write(file_name, temp_dir = Dir.tmpdir)
-    require 'tempfile' unless defined?(Tempfile)
-    require 'fileutils' unless defined?(FileUtils)
-
-    temp_file = Tempfile.new(basename(file_name), temp_dir)
-    temp_file.binmode
-    yield temp_file
-    temp_file.close
-
-    if File.exist?(file_name)
-      # Get original file permissions
-      old_stat = stat(file_name)
-    else
-      # If not possible, probe which are the default permissions in the
-      # destination directory.
-      old_stat = probe_stat_in(dirname(file_name))
-    end
+  def self.atomic_write(file_name, temp_dir = dirname(file_name))
+    require "tempfile" unless defined?(Tempfile)
+
+    Tempfile.open(".#{basename(file_name)}", temp_dir) do |temp_file|
+      temp_file.binmode
+      return_val = yield temp_file
+      temp_file.close
+
+      old_stat = if exist?(file_name)
+        # Get original file permissions
+        stat(file_name)
+      else
+        # If not possible, probe which are the default permissions in the
+        # destination directory.
+        probe_stat_in(dirname(file_name))
+      end
 
-    # Overwrite original file with temp file
-    FileUtils.mv(temp_file.path, file_name)
+      if old_stat
+        # Set correct permissions on new file
+        begin
+          chown(old_stat.uid, old_stat.gid, temp_file.path)
+          # This operation will affect filesystem ACL's
+          chmod(old_stat.mode, temp_file.path)
+        rescue Errno::EPERM, Errno::EACCES
+          # Changing file ownership failed, moving on.
+        end
+      end
 
-    # Set correct permissions on new file
-    begin
-      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, Errno::EACCES
-      # Changing file ownership failed, moving on.
+      # Overwrite original file with temp file
+      rename(temp_file.path, file_name)
+      return_val
     end
   end
 
   # Private utility method.
   def self.probe_stat_in(dir) #:nodoc:
     basename = [
-      '.permissions_check',
+      ".permissions_check",
       Thread.current.object_id,
       Process.pid,
       rand(1000000)
-    ].join('.')
+    ].join(".")
 
     file_name = join(dir, basename)
     FileUtils.touch(file_name)

data/lib/active_support/core_ext/file.rb

@@ -1 +1,3 @@
-require 'active_support/core_ext/file/atomic'
+# frozen_string_literal: true
+
+require "active_support/core_ext/file/atomic"