activesupport 6.0.0 → 6.1.3

data/lib/active_support/concurrency/load_interlock_aware_monitor.rb

@@ -7,11 +7,29 @@ module ActiveSupport
     # A monitor that will permit dependency loading while blocked waiting for
     # the lock.
     class LoadInterlockAwareMonitor < Monitor
+      EXCEPTION_NEVER = { Exception => :never }.freeze
+      EXCEPTION_IMMEDIATE = { Exception => :immediate }.freeze
+      private_constant :EXCEPTION_NEVER, :EXCEPTION_IMMEDIATE
+
       # Enters an exclusive section, but allows dependency loading while blocked
       def mon_enter
         mon_try_enter ||
           ActiveSupport::Dependencies.interlock.permit_concurrent_loads { super }
       end
+
+      def synchronize
+        Thread.handle_interrupt(EXCEPTION_NEVER) do
+          mon_enter
+
+          begin
+            Thread.handle_interrupt(EXCEPTION_IMMEDIATE) do
+              yield
+            end
+          ensure
+            mon_exit
+          end
+        end
+      end
     end
   end
 end

data/lib/active_support/concurrency/share_lock.rb

@@ -200,7 +200,6 @@ module ActiveSupport
       end
 
       private
-
         # Must be called within synchronize
         def busy_for_exclusive?(purpose)
           busy_for_sharing?(purpose) ||

data/lib/active_support/configurable.rb

@@ -5,7 +5,7 @@ require "active_support/ordered_options"
 
 module ActiveSupport
   # Configurable provides a <tt>config</tt> method to store and retrieve
-  # configuration options as an <tt>OrderedHash</tt>.
+  # configuration options as an <tt>OrderedOptions</tt>.
   module Configurable
     extend ActiveSupport::Concern
 
@@ -124,9 +124,9 @@ module ActiveSupport
       private :config_accessor
     end
 
-    # Reads and writes attributes from a configuration <tt>OrderedHash</tt>.
+    # Reads and writes attributes from a configuration <tt>OrderedOptions</tt>.
     #
-    #   require 'active_support/configurable'
+    #   require "active_support/configurable"
     #
     #   class User
     #     include ActiveSupport::Configurable

data/lib/active_support/configuration_file.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Reads a YAML configuration file, evaluating any ERB, then
+  # parsing the resulting YAML.
+  #
+  # Warns in case of YAML confusing characters, like invisible
+  # non-breaking spaces.
+  class ConfigurationFile # :nodoc:
+    class FormatError < StandardError; end
+
+    def initialize(content_path)
+      @content_path = content_path.to_s
+      @content = read content_path
+    end
+
+    def self.parse(content_path, **options)
+      new(content_path).parse(**options)
+    end
+
+    def parse(context: nil, **options)
+      YAML.load(render(context), **options) || {}
+    rescue Psych::SyntaxError => error
+      raise "YAML syntax error occurred while parsing #{@content_path}. " \
+            "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
+            "Error: #{error.message}"
+    end
+
+    private
+      def read(content_path)
+        require "yaml"
+        require "erb"
+
+        File.read(content_path).tap do |content|
+          if content.include?("\u00A0")
+            warn "File contains invisible non-breaking spaces, you may want to remove those"
+          end
+        end
+      end
+
+      def render(context)
+        erb = ERB.new(@content).tap { |e| e.filename = @content_path }
+        context ? erb.result(context) : erb.result
+      end
+  end
+end

data/lib/active_support/core_ext.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).each do |path|
+Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort.each do |path|
   require path
 end

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

@@ -74,13 +74,13 @@ class Array
 
     case length
     when 0
-      ""
+      +""
     when 1
-      "#{self[0]}"
+      +"#{self[0]}"
     when 2
-      "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+      +"#{self[0]}#{options[:two_words_connector]}#{self[1]}"
     else
-      "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+      +"#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
     end
   end
 
@@ -181,7 +181,7 @@ class Array
   #   </messages>
   #
   def to_xml(options = {})
-    require "active_support/builder" unless defined?(Builder)
+    require "active_support/builder" unless defined?(Builder::XmlMarkup)
 
     options = options.dup
     options[:indent]  ||= 2

data/lib/active_support/core_ext/benchmark.rb

@@ -10,7 +10,7 @@ class << Benchmark
   #
   #   Benchmark.ms { User.all }
   #   # => 0.074
-  def ms
-    1000 * realtime { yield }
+  def ms(&block)
+    1000 * realtime(&block)
   end
 end

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/kernel/singleton_class"
 require "active_support/core_ext/module/redefine_method"
-require "active_support/core_ext/array/extract_options"
 
 class Class
   # Declare a class-level attribute whose value is inheritable by subclasses.
@@ -84,58 +82,50 @@ class Class
   # To set a default value for the attribute, pass <tt>default:</tt>, like so:
   #
   #   class_attribute :settings, default: {}
-  def class_attribute(
-    *attrs,
-    instance_accessor: true,
-    instance_reader: instance_accessor,
-    instance_writer: instance_accessor,
-    instance_predicate: true,
-    default: nil
-  )
-    attrs.each do |name|
-      singleton_class.silence_redefinition_of_method(name)
-      define_singleton_method(name) { default }
-
-      singleton_class.silence_redefinition_of_method("#{name}?")
-      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+  def class_attribute(*attrs, instance_accessor: true,
+    instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil)
 
-      ivar = "@#{name}".to_sym
+    class_methods, methods = [], []
+    attrs.each do |name|
+      unless name.is_a?(Symbol) || name.is_a?(String)
+        raise TypeError, "#{name.inspect} is not a symbol nor a string"
+      end
 
-      singleton_class.silence_redefinition_of_method("#{name}=")
-      define_singleton_method("#{name}=") do |val|
-        redefine_singleton_method(name) { val }
+      class_methods << <<~RUBY # In case the method exists and is not public
+        silence_redefinition_of_method def #{name}
+        end
+      RUBY
 
-        if singleton_class?
-          class_eval do
-            redefine_method(name) do
-              if instance_variable_defined? ivar
-                instance_variable_get ivar
-              else
-                singleton_class.send name
-              end
-            end
-          end
+      methods << <<~RUBY if instance_reader
+        silence_redefinition_of_method def #{name}
+          defined?(@#{name}) ? @#{name} : self.class.#{name}
         end
-        val
-      end
+      RUBY
 
-      if instance_reader
-        redefine_method(name) do
-          if instance_variable_defined?(ivar)
-            instance_variable_get ivar
-          else
-            self.class.public_send name
-          end
+      class_methods << <<~RUBY
+        silence_redefinition_of_method def #{name}=(value)
+          redefine_method(:#{name}) { value } if singleton_class?
+          redefine_singleton_method(:#{name}) { value }
+          value
         end
+      RUBY
 
-        redefine_method("#{name}?") { !!public_send(name) } if instance_predicate
-      end
+      methods << <<~RUBY if instance_writer
+        silence_redefinition_of_method(:#{name}=)
+        attr_writer :#{name}
+      RUBY
 
-      if instance_writer
-        redefine_method("#{name}=") do |val|
-          instance_variable_set ivar, val
+      if instance_predicate
+        class_methods << "silence_redefinition_of_method def #{name}?; !!self.#{name}; end"
+        if instance_reader
+          methods << "silence_redefinition_of_method def #{name}?; !!self.#{name}; end"
         end
       end
     end
+
+    location = caller_locations(1, 1).first
+    class_eval(["class << self", *class_methods, "end", *methods].join(";").tr("\n", ";"), location.path, location.lineno)
+
+    attrs.each { |name| public_send("#{name}=", default) }
   end
 end

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

@@ -1,39 +1,22 @@
 # frozen_string_literal: true
 
 class Class
-  begin
-    # Test if this Ruby supports each_object against singleton_class
-    ObjectSpace.each_object(Numeric.singleton_class) { }
-
-    # Returns an array with all classes that are < than its receiver.
-    #
-    #   class C; end
-    #   C.descendants # => []
-    #
-    #   class B < C; end
-    #   C.descendants # => [B]
-    #
-    #   class A < B; end
-    #   C.descendants # => [B, A]
-    #
-    #   class D < C; end
-    #   C.descendants # => [B, A, D]
-    def descendants
-      descendants = []
-      ObjectSpace.each_object(singleton_class) do |k|
-        next if k.singleton_class?
-        descendants.unshift k unless k == self
-      end
-      descendants
-    end
-  rescue StandardError # JRuby 9.0.4.0 and earlier
-    def descendants
-      descendants = []
-      ObjectSpace.each_object(Class) do |k|
-        descendants.unshift k if k < self
-      end
-      descendants.uniq!
-      descendants
+  # Returns an array with all classes that are < than its receiver.
+  #
+  #   class C; end
+  #   C.descendants # => []
+  #
+  #   class B < C; end
+  #   C.descendants # => [B]
+  #
+  #   class A < B; end
+  #   C.descendants # => [B, A]
+  #
+  #   class D < C; end
+  #   C.descendants # => [B, A, D]
+  def descendants
+    ObjectSpace.each_object(singleton_class).reject do |k|
+      k.singleton_class? || k == self
     end
   end
 
@@ -45,10 +28,6 @@ class Class
   #
   #   Foo.subclasses # => [Bar]
   def subclasses
-    subclasses, chain = [], descendants
-    chain.each do |k|
-      subclasses << k unless chain.any? { |c| c > k }
-    end
-    subclasses
+    descendants.select { |descendant| descendant.superclass == self }
   end
 end

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

@@ -10,6 +10,7 @@ class Date
     short: "%d %b",
     long: "%B %d, %Y",
     db: "%Y-%m-%d",
+    inspect: "%Y-%m-%d",
     number: "%Y%m%d",
     long_ordinal: lambda { |date|
       day_format = ActiveSupport::Inflector.ordinalize(date.day)
@@ -80,7 +81,7 @@ class Date
   #       If the *application's* timezone is needed, then use +in_time_zone+ instead.
   def to_time(form = :local)
     raise ArgumentError, "Expected :local or :utc, got #{form.inspect}." unless [:local, :utc].include?(form)
-    ::Time.send(form, year, month, day)
+    ::Time.public_send(form, year, month, day)
   end
 
   silence_redefinition_of_method :xmlschema

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/try"
+require "active_support/core_ext/date_time/conversions"
 
 module DateAndTime
   module Calculations
@@ -30,6 +31,18 @@ module DateAndTime
       to_date == ::Date.current
     end
 
+    # Returns true if the date/time is tomorrow.
+    def tomorrow?
+      to_date == ::Date.current.tomorrow
+    end
+    alias :next_day? :tomorrow?
+
+    # Returns true if the date/time is yesterday.
+    def yesterday?
+      to_date == ::Date.current.yesterday
+    end
+    alias :prev_day? :yesterday?
+
     # Returns true if the date/time is in the past.
     def past?
       self < self.class.current

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

@@ -12,5 +12,20 @@ module DateAndTime
     # 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, default: false
+
+    # Change the output of <tt>ActiveSupport::TimeZone.utc_to_local</tt>.
+    #
+    # When `true`, it returns local times with an UTC offset, with `false` local
+    # times are returned as UTC.
+    #
+    #   # Given this zone:
+    #   zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
+    #
+    #   # With `utc_to_local_returns_utc_offset_times = false`, local time is converted to UTC:
+    #   zone.utc_to_local(Time.utc(2000, 1)) # => 1999-12-31 19:00:00 UTC
+    #
+    #   # With `utc_to_local_returns_utc_offset_times = true`, local time is returned with UTC offset:
+    #   zone.utc_to_local(Time.utc(2000, 1)) # => 1999-12-31 19:00:00 -0500
+    mattr_accessor :utc_to_local_returns_utc_offset_times, instance_writer: false, default: false
   end
 end

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

@@ -29,7 +29,6 @@ module DateAndTime
     end
 
     private
-
       def time_with_zone(time, zone)
         if time
           ActiveSupport::TimeWithZone.new(time.utc? ? time : time.getutc, zone)

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

@@ -96,7 +96,6 @@ class DateTime
   end
 
   private
-
     def offset_in_seconds
       (offset * 86400).to_i
     end

data/lib/active_support/core_ext/enumerable.rb

@@ -44,7 +44,8 @@ module Enumerable
     end
   end
 
-  # Convert an enumerable to a hash keying it by the block return value.
+  # 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 ...>, ...}
@@ -61,12 +62,19 @@ module Enumerable
     end
   end
 
-  # Convert an enumerable to a hash keying it with the enumerable items and with the values returned in the block.
+  # 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 = {}
@@ -134,7 +142,7 @@ module Enumerable
     excluding(*elements)
   end
 
-  # Convert an enumerable to an array based on the given key.
+  # Extract the given key from each element in the enumerable.
   #
   #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name)
   #   # => ["David", "Rafael", "Aaron"]
@@ -145,9 +153,62 @@ module Enumerable
     if keys.many?
       map { |element| keys.map { |key| element[key] } }
     else
-      map { |element| element[keys.first] }
+      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:
@@ -185,4 +246,15 @@ class Array #:nodoc:
       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