activesupport 4.2.11.3 → 5.2.8.1

data/lib/active_support/concern.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   # A typical module looks like this:
   #
@@ -111,10 +113,10 @@ module ActiveSupport
     def append_features(base)
       if base.instance_variable_defined?(:@_dependencies)
         base.instance_variable_get(:@_dependencies) << self
-        return false
+        false
       else
         return false if base < self
-        @_dependencies.each { |dep| base.send(:include, dep) }
+        @_dependencies.each { |dep| base.include(dep) }
         super
         base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
         base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
@@ -123,9 +125,13 @@ module ActiveSupport
 
     def included(base = nil, &block)
       if base.nil?
-        raise MultipleIncludedBlocks if instance_variable_defined?(:@_included_block)
-
-        @_included_block = block
+        if instance_variable_defined?(:@_included_block)
+          if @_included_block.source_location != block.source_location
+            raise MultipleIncludedBlocks
+          end
+        else
+          @_included_block = block
+        end
       else
         super
       end

data/lib/active_support/concurrency/load_interlock_aware_monitor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module ActiveSupport
+  module Concurrency
+    # 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

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require "thread"
+require "monitor"
+
+module ActiveSupport
+  module Concurrency
+    # A share/exclusive lock, otherwise known as a read/write lock.
+    #
+    # https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock
+    class ShareLock
+      include MonitorMixin
+
+      # We track Thread objects, instead of just using counters, because
+      # we need exclusive locks to be reentrant, and we need to be able
+      # to upgrade share locks to exclusive.
+
+      def raw_state # :nodoc:
+        synchronize do
+          threads = @sleeping.keys | @sharing.keys | @waiting.keys
+          threads |= [@exclusive_thread] if @exclusive_thread
+
+          data = {}
+
+          threads.each do |thread|
+            purpose, compatible = @waiting[thread]
+
+            data[thread] = {
+              thread: thread,
+              sharing: @sharing[thread],
+              exclusive: @exclusive_thread == thread,
+              purpose: purpose,
+              compatible: compatible,
+              waiting: !!@waiting[thread],
+              sleeper: @sleeping[thread],
+            }
+          end
+
+          # NB: Yields while holding our *internal* synchronize lock,
+          # which is supposed to be used only for a few instructions at
+          # a time. This allows the caller to inspect additional state
+          # without things changing out from underneath, but would have
+          # disastrous effects upon normal operation. Fortunately, this
+          # method is only intended to be called when things have
+          # already gone wrong.
+          yield data
+        end
+      end
+
+      def initialize
+        super()
+
+        @cv = new_cond
+
+        @sharing = Hash.new(0)
+        @waiting = {}
+        @sleeping = {}
+        @exclusive_thread = nil
+        @exclusive_depth = 0
+      end
+
+      # Returns false if +no_wait+ is set and the lock is not
+      # immediately available. Otherwise, returns true after the lock
+      # has been acquired.
+      #
+      # +purpose+ and +compatible+ work together; while this thread is
+      # waiting for the exclusive lock, it will yield its share (if any)
+      # to any other attempt whose +purpose+ appears in this attempt's
+      # +compatible+ list. This allows a "loose" upgrade, which, being
+      # less strict, prevents some classes of deadlocks.
+      #
+      # For many resources, loose upgrades are sufficient: if a thread
+      # is awaiting a lock, it is not running any other code. With
+      # +purpose+ matching, it is possible to yield only to other
+      # threads whose activity will not interfere.
+      def start_exclusive(purpose: nil, compatible: [], no_wait: false)
+        synchronize do
+          unless @exclusive_thread == Thread.current
+            if busy_for_exclusive?(purpose)
+              return false if no_wait
+
+              yield_shares(purpose: purpose, compatible: compatible, block_share: true) do
+                wait_for(:start_exclusive) { busy_for_exclusive?(purpose) }
+              end
+            end
+            @exclusive_thread = Thread.current
+          end
+          @exclusive_depth += 1
+
+          true
+        end
+      end
+
+      # Relinquish the exclusive lock. Must only be called by the thread
+      # that called start_exclusive (and currently holds the lock).
+      def stop_exclusive(compatible: [])
+        synchronize do
+          raise "invalid unlock" if @exclusive_thread != Thread.current
+
+          @exclusive_depth -= 1
+          if @exclusive_depth == 0
+            @exclusive_thread = nil
+
+            if eligible_waiters?(compatible)
+              yield_shares(compatible: compatible, block_share: true) do
+                wait_for(:stop_exclusive) { @exclusive_thread || eligible_waiters?(compatible) }
+              end
+            end
+            @cv.broadcast
+          end
+        end
+      end
+
+      def start_sharing
+        synchronize do
+          if @sharing[Thread.current] > 0 || @exclusive_thread == Thread.current
+            # We already hold a lock; nothing to wait for
+          elsif @waiting[Thread.current]
+            # We're nested inside a +yield_shares+ call: we'll resume as
+            # soon as there isn't an exclusive lock in our way
+            wait_for(:start_sharing) { @exclusive_thread }
+          else
+            # This is an initial / outermost share call: any outstanding
+            # requests for an exclusive lock get to go first
+            wait_for(:start_sharing) { busy_for_sharing?(false) }
+          end
+          @sharing[Thread.current] += 1
+        end
+      end
+
+      def stop_sharing
+        synchronize do
+          if @sharing[Thread.current] > 1
+            @sharing[Thread.current] -= 1
+          else
+            @sharing.delete Thread.current
+            @cv.broadcast
+          end
+        end
+      end
+
+      # Execute the supplied block while holding the Exclusive lock. If
+      # +no_wait+ is set and the lock is not immediately available,
+      # returns +nil+ without yielding. Otherwise, returns the result of
+      # the block.
+      #
+      # See +start_exclusive+ for other options.
+      def exclusive(purpose: nil, compatible: [], after_compatible: [], no_wait: false)
+        if start_exclusive(purpose: purpose, compatible: compatible, no_wait: no_wait)
+          begin
+            yield
+          ensure
+            stop_exclusive(compatible: after_compatible)
+          end
+        end
+      end
+
+      # Execute the supplied block while holding the Share lock.
+      def sharing
+        start_sharing
+        begin
+          yield
+        ensure
+          stop_sharing
+        end
+      end
+
+      # Temporarily give up all held Share locks while executing the
+      # supplied block, allowing any +compatible+ exclusive lock request
+      # to proceed.
+      def yield_shares(purpose: nil, compatible: [], block_share: false)
+        loose_shares = previous_wait = nil
+        synchronize do
+          if loose_shares = @sharing.delete(Thread.current)
+            if previous_wait = @waiting[Thread.current]
+              purpose = nil unless purpose == previous_wait[0]
+              compatible &= previous_wait[1]
+            end
+            compatible |= [false] unless block_share
+            @waiting[Thread.current] = [purpose, compatible]
+          end
+
+          @cv.broadcast
+        end
+
+        begin
+          yield
+        ensure
+          synchronize do
+            wait_for(:yield_shares) { @exclusive_thread && @exclusive_thread != Thread.current }
+
+            if previous_wait
+              @waiting[Thread.current] = previous_wait
+            else
+              @waiting.delete Thread.current
+            end
+            @sharing[Thread.current] = loose_shares if loose_shares
+          end
+        end
+      end
+
+      private
+
+        # Must be called within synchronize
+        def busy_for_exclusive?(purpose)
+          busy_for_sharing?(purpose) ||
+            @sharing.size > (@sharing[Thread.current] > 0 ? 1 : 0)
+        end
+
+        def busy_for_sharing?(purpose)
+          (@exclusive_thread && @exclusive_thread != Thread.current) ||
+            @waiting.any? { |t, (_, c)| t != Thread.current && !c.include?(purpose) }
+        end
+
+        def eligible_waiters?(compatible)
+          @waiting.any? { |t, (p, _)| compatible.include?(p) && @waiting.all? { |t2, (_, c2)| t == t2 || c2.include?(p) } }
+        end
+
+        def wait_for(method)
+          @sleeping[Thread.current] = method
+          @cv.wait_while { yield }
+        ensure
+          @sleeping.delete Thread.current
+        end
+    end
+  end
+end

data/lib/active_support/configurable.rb

@@ -1,6 +1,9 @@
-require 'active_support/concern'
-require 'active_support/ordered_options'
-require 'active_support/core_ext/array/extract_options'
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/ordered_options"
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/regexp"
 
 module ActiveSupport
   # Configurable provides a <tt>config</tt> method to store and retrieve
@@ -107,7 +110,7 @@ module ActiveSupport
         options = names.extract_options!
 
         names.each do |name|
-          raise NameError.new('invalid config attribute name') unless name =~ /\A[_A-Za-z]\w*\z/
+          raise NameError.new("invalid config attribute name") unless /\A[_A-Za-z]\w*\z/.match?(name)
 
           reader, reader_line = "def #{name}; config.#{name}; end", __LINE__
           writer, writer_line = "def #{name}=(value); config.#{name} = value; end", __LINE__
@@ -122,6 +125,7 @@ module ActiveSupport
           send("#{name}=", yield) if block_given?
         end
       end
+      private :config_accessor
     end
 
     # Reads and writes attributes from a configuration <tt>OrderedHash</tt>.
@@ -144,4 +148,3 @@ module ActiveSupport
     end
   end
 end
-

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Array
   # Returns the tail of the array from +position+.
   #
@@ -21,12 +23,24 @@ class Array
   #   %w( a b c ).to(-10)  # => []
   def to(position)
     if position >= 0
-      first position + 1
+      take position + 1
     else
       self[0..position]
     end
   end
 
+  # Returns a copy of the Array without the specified elements.
+  #
+  #   people = ["David", "Rafael", "Aaron", "Todd"]
+  #   people.without "Aaron", "Todd"
+  #   # => ["David", "Rafael"]
+  #
+  # Note: This is an optimization of <tt>Enumerable#without</tt> that uses <tt>Array#-</tt>
+  # instead of <tt>Array#reject</tt> for performance reasons.
+  def without(*elements)
+    self - elements
+  end
+
   # Equal to <tt>self[1]</tt>.
   #
   #   %w( a b c d e ).second # => "b"
@@ -61,4 +75,18 @@ class Array
   def forty_two
     self[41]
   end
+
+  # Equal to <tt>self[-3]</tt>.
+  #
+  #   %w( a b c d e ).third_to_last # => "c"
+  def third_to_last
+    self[-3]
+  end
+
+  # Equal to <tt>self[-2]</tt>.
+  #
+  #   %w( a b c d e ).second_to_last # => "d"
+  def second_to_last
+    self[-2]
+  end
 end

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

@@ -1,8 +1,10 @@
-require 'active_support/xml_mini'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/object/to_param'
-require 'active_support/core_ext/object/to_query'
+# frozen_string_literal: true
+
+require "active_support/xml_mini"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/object/to_param"
+require "active_support/core_ext/object/to_query"
 
 class Array
   # Converts the array to a comma-separated sentence where the last element is
@@ -32,7 +34,7 @@ class Array
   #   ['one', 'two', 'three'].to_sentence # => "one, two, and three"
   #
   #   ['one', 'two'].to_sentence(passing: 'invalid option')
-  #   # => ArgumentError: Unknown key :passing
+  #   # => ArgumentError: Unknown key: :passing. Valid keys are: :words_connector, :two_words_connector, :last_word_connector, :locale
   #
   #   ['one', 'two'].to_sentence(two_words_connector: '-')
   #   # => "one-two"
@@ -60,9 +62,9 @@ class Array
     options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
 
     default_connectors = {
-      :words_connector     => ', ',
-      :two_words_connector => ' and ',
-      :last_word_connector => ', and '
+      words_connector: ", ",
+      two_words_connector: " and ",
+      last_word_connector: ", and "
     }
     if defined?(I18n)
       i18n_connectors = I18n.translate(:'support.array', locale: options[:locale], default: {})
@@ -72,9 +74,9 @@ class Array
 
     case length
     when 0
-      ''
+      ""
     when 1
-      self[0].to_s.dup
+      "#{self[0]}"
     when 2
       "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
     else
@@ -85,14 +87,16 @@ class Array
   # Extends <tt>Array#to_s</tt> to convert a collection of elements into a
   # comma separated id list if <tt>:db</tt> argument is given as the format.
   #
-  #   Blog.all.to_formatted_s(:db) # => "1,2,3"
+  #   Blog.all.to_formatted_s(:db)  # => "1,2,3"
+  #   Blog.none.to_formatted_s(:db) # => "null"
+  #   [1,2].to_formatted_s          # => "[1, 2]"
   def to_formatted_s(format = :default)
     case format
     when :db
       if empty?
-        'null'
+        "null"
       else
-        collect { |element| element.id }.join(',')
+        collect(&:id).join(",")
       end
     else
       to_default_s
@@ -177,7 +181,7 @@ class Array
   #   </messages>
   #
   def to_xml(options = {})
-    require 'active_support/builder' unless defined?(Builder)
+    require "active_support/builder" unless defined?(Builder)
 
     options = options.dup
     options[:indent]  ||= 2
@@ -185,9 +189,9 @@ class Array
     options[:root]    ||= \
       if first.class != Hash && all? { |e| e.is_a?(first.class) }
         underscored = ActiveSupport::Inflector.underscore(first.class.name)
-        ActiveSupport::Inflector.pluralize(underscored).tr('/', '_')
+        ActiveSupport::Inflector.pluralize(underscored).tr("/", "_")
       else
-        'objects'
+        "objects"
       end
 
     builder = options[:builder]
@@ -195,7 +199,7 @@ class Array
 
     root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
     children = options.delete(:children) || root.singularize
-    attributes = options[:skip_types] ? {} : { type: 'array' }
+    attributes = options[:skip_types] ? {} : { type: "array" }
 
     if empty?
       builder.tag!(root, attributes)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Hash
   # By default, only instances of Hash itself are extractable.
   # Subclasses of Hash may implement this method and return

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Array
   # Splits or iterates over the array in groups of size +number+,
   # padding any remaining slots with +fill_with+ unless it is +false+.
@@ -89,28 +91,19 @@ class Array
   #   [1, 2, 3, 4, 5].split(3)              # => [[1, 2], [4, 5]]
   #   (1..10).to_a.split { |i| i % 3 == 0 } # => [[1, 2], [4, 5], [7, 8], [10]]
   def split(value = nil)
+    arr = dup
+    result = []
     if block_given?
-      inject([[]]) do |results, element|
-        if yield(element)
-          results << []
-        else
-          results.last << element
-        end
-
-        results
+      while (idx = arr.index { |i| yield i })
+        result << arr.shift(idx)
+        arr.shift
       end
     else
-      results, arr = [[]], self.dup
-      until arr.empty?
-        if (idx = arr.index(value))
-          results.last.concat(arr.shift(idx))
-          arr.shift
-          results << []
-        else
-          results.last.concat(arr.shift(arr.size))
-        end
+      while (idx = arr.index(value))
+        result << arr.shift(idx)
+        arr.shift
       end
-      results
     end
+    result << arr
   end
 end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/array_inquirer"
+
+class Array
+  # Wraps the array in an +ArrayInquirer+ object, which gives a friendlier way
+  # to check its string-like contents.
+  #
+  #   pets = [:cat, :dog].inquiry
+  #
+  #   pets.cat?     # => true
+  #   pets.ferret?  # => false
+  #
+  #   pets.any?(:cat, :ferret)  # => true
+  #   pets.any?(:ferret, :alligator)  # => false
+  def inquiry
+    ActiveSupport::ArrayInquirer.new(self)
+  end
+end

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

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 class Array
   # The human way of thinking about adding stuff to the end of a list is with append.
-  alias_method :append,  :<<
+  alias_method :append,  :push unless [].respond_to?(:append)
 
   # The human way of thinking about adding stuff to the beginning of a list is with prepend.
-  alias_method :prepend, :unshift
-end
+  alias_method :prepend, :unshift unless [].respond_to?(:prepend)
+end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class Array
   # Wraps its argument in an array unless it is already an array (or array-like).
   #
   # Specifically:
   #
-  # * If the argument is +nil+ an empty list is returned.
+  # * If the argument is +nil+ an empty array is returned.
   # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
   # * Otherwise, returns an array with the argument as its single element.
   #
@@ -15,12 +17,13 @@ class Array
   #
   # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
   #   moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
-  #   +nil+ right away.
+  #   an array with the argument as its single element right away.
   # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
   #   raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
-  # * It does not call +to_a+ on the argument, but returns an empty array if argument is +nil+.
+  # * It does not call +to_a+ on the argument, if the argument does not respond to +to_ary+
+  #   it returns an array with the argument as its single element.
   #
-  # The second point is easily explained with some enumerables:
+  # The last point is easily explained with some enumerables:
   #
   #   Array(foo: :bar)      # => [[:foo, :bar]]
   #   Array.wrap(foo: :bar) # => [{:foo=>:bar}]

data/lib/active_support/core_ext/array.rb

@@ -1,6 +1,9 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/array/access'
-require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/array/grouping'
-require 'active_support/core_ext/array/prepend_and_append'
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/array/access"
+require "active_support/core_ext/array/conversions"
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/array/grouping"
+require "active_support/core_ext/array/prepend_and_append"
+require "active_support/core_ext/array/inquiry"

data/lib/active_support/core_ext/benchmark.rb

@@ -1,4 +1,6 @@
-require 'benchmark'
+# frozen_string_literal: true
+
+require "benchmark"
 
 class << Benchmark
   # Benchmark realtime in milliseconds.

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

@@ -1,16 +1,14 @@
-require 'bigdecimal'
-require 'bigdecimal/util'
+# frozen_string_literal: true
 
-class BigDecimal
-  DEFAULT_STRING_FORMAT = 'F'
-  def to_formatted_s(*args)
-    if args[0].is_a?(Symbol)
-      super
-    else
-      format = args[0] || DEFAULT_STRING_FORMAT
-      _original_to_s(format)
+require "bigdecimal"
+require "bigdecimal/util"
+
+module ActiveSupport
+  module BigDecimalWithDefaultFormat #:nodoc:
+    def to_s(format = "F")
+      super(format)
     end
   end
-  alias_method :_original_to_s, :to_s
-  alias_method :to_s, :to_formatted_s
 end
+
+BigDecimal.prepend(ActiveSupport::BigDecimalWithDefaultFormat)

data/lib/active_support/core_ext/big_decimal.rb

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