activesupport 5.0.0 → 6.1.0

data/lib/active_support/concern.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   # A typical module looks like this:
   #
@@ -17,7 +19,7 @@ module ActiveSupport
   # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
   # written as:
   #
-  #   require 'active_support/concern'
+  #   require "active_support/concern"
   #
   #   module M
   #     extend ActiveSupport::Concern
@@ -74,7 +76,7 @@ module ActiveSupport
   # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
   # module dependencies are properly resolved:
   #
-  #   require 'active_support/concern'
+  #   require "active_support/concern"
   #
   #   module Foo
   #     extend ActiveSupport::Concern
@@ -97,6 +99,14 @@ module ActiveSupport
   #   class Host
   #     include Bar # It works, now Bar takes care of its dependencies
   #   end
+  #
+  # === Prepending concerns
+  #
+  # Just like <tt>include</tt>, concerns also support <tt>prepend</tt> with a corresponding
+  # <tt>prepended do</tt> callback. <tt>module ClassMethods</tt> or <tt>class_methods do</tt> are
+  # prepended as well.
+  #
+  # <tt>prepend</tt> is also used for any dependencies.
   module Concern
     class MultipleIncludedBlocks < StandardError #:nodoc:
       def initialize
@@ -104,14 +114,20 @@ module ActiveSupport
       end
     end
 
+    class MultiplePrependBlocks < StandardError #:nodoc:
+      def initialize
+        super "Cannot define multiple 'prepended' blocks for a Concern"
+      end
+    end
+
     def self.extended(base) #:nodoc:
       base.instance_variable_set(:@_dependencies, [])
     end
 
-    def append_features(base)
+    def append_features(base) #:nodoc:
       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.include(dep) }
@@ -121,16 +137,73 @@ module ActiveSupport
       end
     end
 
+    def prepend_features(base) #:nodoc:
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies).unshift self
+        false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.prepend(dep) }
+        super
+        base.singleton_class.prepend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_prepended_block) if instance_variable_defined?(:@_prepended_block)
+      end
+    end
+
+    # Evaluate given block in context of base class,
+    # so that you can write class macros here.
+    # When you define more than one +included+ block, it raises an exception.
     def included(base = nil, &block)
       if base.nil?
-        raise MultipleIncludedBlocks if instance_variable_defined?(:@_included_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
+    end
 
-        @_included_block = block
+    # Evaluate given block in context of base class,
+    # so that you can write class macros here.
+    # When you define more than one +prepended+ block, it raises an exception.
+    def prepended(base = nil, &block)
+      if base.nil?
+        if instance_variable_defined?(:@_prepended_block)
+          if @_prepended_block.source_location != block.source_location
+            raise MultiplePrependBlocks
+          end
+        else
+          @_prepended_block = block
+        end
       else
         super
       end
     end
 
+    # Define class methods from given block.
+    # You can define private class methods as well.
+    #
+    #   module Example
+    #     extend ActiveSupport::Concern
+    #
+    #     class_methods do
+    #       def foo; puts 'foo'; end
+    #
+    #       private
+    #         def bar; puts 'bar'; end
+    #     end
+    #   end
+    #
+    #   class Buzz
+    #     include Example
+    #   end
+    #
+    #   Buzz.foo # => "foo"
+    #   Buzz.bar # => private method 'bar' called for Buzz:Class(NoMethodError)
     def class_methods(&class_methods_module_definition)
       mod = const_defined?(:ClassMethods, false) ?
         const_get(:ClassMethods) :

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

@@ -1,5 +1,7 @@
-require 'thread'
-require 'monitor'
+# frozen_string_literal: true
+
+require "thread"
+require "monitor"
 
 module ActiveSupport
   module Concurrency
@@ -13,6 +15,37 @@ module ActiveSupport
       # 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()
@@ -21,6 +54,7 @@ module ActiveSupport
 
         @sharing = Hash.new(0)
         @waiting = {}
+        @sleeping = {}
         @exclusive_thread = nil
         @exclusive_depth = 0
       end
@@ -46,7 +80,7 @@ module ActiveSupport
               return false if no_wait
 
               yield_shares(purpose: purpose, compatible: compatible, block_share: true) do
-                @cv.wait_while { busy_for_exclusive?(purpose) }
+                wait_for(:start_exclusive) { busy_for_exclusive?(purpose) }
               end
             end
             @exclusive_thread = Thread.current
@@ -69,7 +103,7 @@ module ActiveSupport
 
             if eligible_waiters?(compatible)
               yield_shares(compatible: compatible, block_share: true) do
-                @cv.wait_while { @exclusive_thread || eligible_waiters?(compatible) }
+                wait_for(:stop_exclusive) { @exclusive_thread || eligible_waiters?(compatible) }
               end
             end
             @cv.broadcast
@@ -84,11 +118,11 @@ module ActiveSupport
           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
-            @cv.wait_while { @exclusive_thread }
+            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
-            @cv.wait_while { busy_for_sharing?(false) }
+            wait_for(:start_sharing) { busy_for_sharing?(false) }
           end
           @sharing[Thread.current] += 1
         end
@@ -153,7 +187,7 @@ module ActiveSupport
           yield
         ensure
           synchronize do
-            @cv.wait_while { @exclusive_thread && @exclusive_thread != Thread.current }
+            wait_for(:yield_shares) { @exclusive_thread && @exclusive_thread != Thread.current }
 
             if previous_wait
               @waiting[Thread.current] = previous_wait
@@ -166,21 +200,27 @@ module ActiveSupport
       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
 
-      # 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 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 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,10 +1,11 @@
-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"
 
 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
 
@@ -66,8 +67,8 @@ module ActiveSupport
       #   end
       #   # => NameError: invalid config attribute name
       #
-      # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
-      # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+      # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
+      # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
       #
       #   class User
       #     include ActiveSupport::Configurable
@@ -80,7 +81,7 @@ module ActiveSupport
       #   User.new.allowed_access = true # => NoMethodError
       #   User.new.allowed_access        # => NoMethodError
       #
-      # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
+      # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
       #
       #   class User
       #     include ActiveSupport::Configurable
@@ -103,11 +104,9 @@ module ActiveSupport
       #   end
       #
       #   User.hair_colors # => [:brown, :black, :blonde, :red]
-      def config_accessor(*names)
-        options = names.extract_options!
-
+      def config_accessor(*names, instance_reader: true, instance_writer: true, instance_accessor: true) # :doc:
         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__
@@ -115,9 +114,9 @@ module ActiveSupport
           singleton_class.class_eval reader, __FILE__, reader_line
           singleton_class.class_eval writer, __FILE__, writer_line
 
-          unless options[:instance_accessor] == false
-            class_eval reader, __FILE__, reader_line unless options[:instance_reader] == false
-            class_eval writer, __FILE__, writer_line unless options[:instance_writer] == false
+          if instance_accessor
+            class_eval reader, __FILE__, reader_line if instance_reader
+            class_eval writer, __FILE__, writer_line if instance_writer
           end
           send("#{name}=", yield) if block_given?
         end
@@ -125,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
@@ -145,4 +144,3 @@ module ActiveSupport
     end
   end
 end
-

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/array/access.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Array
   # Returns the tail of the array from +position+.
   #
@@ -27,16 +29,28 @@ class Array
     end
   end
 
-  # Returns a copy of the Array without the specified elements.
+  # Returns a new array that includes the passed elements.
+  #
+  #   [ 1, 2, 3 ].including(4, 5) # => [ 1, 2, 3, 4, 5 ]
+  #   [ [ 0, 1 ] ].including([ [ 1, 0 ] ]) # => [ [ 0, 1 ], [ 1, 0 ] ]
+  def including(*elements)
+    self + elements.flatten(1)
+  end
+
+  # Returns a copy of the Array excluding the specified elements.
   #
-  #   people = ["David", "Rafael", "Aaron", "Todd"]
-  #   people.without "Aaron", "Todd"
-  #     => ["David", "Rafael"]
+  #   ["David", "Rafael", "Aaron", "Todd"].excluding("Aaron", "Todd") # => ["David", "Rafael"]
+  #   [ [ 0, 1 ], [ 1, 0 ] ].excluding([ [ 1, 0 ] ]) # => [ [ 0, 1 ] ]
   #
-  # Note: This is an optimization of `Enumerable#without` that uses `Array#-`
-  # instead of `Array#reject` for performance reasons.
+  # Note: This is an optimization of <tt>Enumerable#excluding</tt> that uses <tt>Array#-</tt>
+  # instead of <tt>Array#reject</tt> for performance reasons.
+  def excluding(*elements)
+    self - elements.flatten(1)
+  end
+
+  # Alias for #excluding.
   def without(*elements)
-    self - elements
+    excluding(*elements)
   end
 
   # Equal to <tt>self[1]</tt>.

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
@@ -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,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
 
@@ -92,9 +94,9 @@ class Array
     case format
     when :db
       if empty?
-        'null'
+        "null"
       else
-        collect(&:id).join(',')
+        collect(&:id).join(",")
       end
     else
       to_default_s
@@ -179,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
@@ -187,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]
@@ -197,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.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Array
+  # Removes and returns the elements for which the block returns a true value.
+  # If no block is given, an Enumerator is returned instead.
+  #
+  #   numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+  #   odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
+  #   numbers # => [0, 2, 4, 6, 8]
+  def extract!
+    return to_enum(:extract!) { size } unless block_given?
+
+    extracted_elements = []
+
+    reject! do |element|
+      extracted_elements << element if yield(element)
+    end
+
+    extracted_elements
+  end
+end

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,7 +91,7 @@ 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 = self.dup
+    arr = dup
     result = []
     if block_given?
       while (idx = arr.index { |i| yield i })

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

@@ -1,4 +1,6 @@
-require 'active_support/array_inquirer'
+# frozen_string_literal: true
+
+require "active_support/array_inquirer"
 
 class Array
   # Wraps the array in an +ArrayInquirer+ object, which gives a friendlier way

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Array
   # Wraps its argument in an array unless it is already an array (or array-like).
   #

data/lib/active_support/core_ext/array.rb

@@ -1,7 +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'
-require 'active_support/core_ext/array/inquiry'
+# 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"
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/array/grouping"
+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.
@@ -8,7 +10,7 @@ class << Benchmark
   #
   #   Benchmark.ms { User.all }
   #   # => 0.074
-  def ms
-    1000 * realtime { yield }
+  def ms(&block)
+    1000 * realtime(&block)
   end
 end