activesupport 4.2.0 → 5.0.0

data/lib/active_support/concurrency/share_lock.rb

@@ -0,0 +1,186 @@
+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 initialize
+        super()
+
+        @cv = new_cond
+
+        @sharing = Hash.new(0)
+        @waiting = {}
+        @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
+                @cv.wait_while { 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
+                @cv.wait_while { @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
+            @cv.wait_while { @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) }
+          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
+            @cv.wait_while { @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
+    end
+  end
+end

data/lib/active_support/configurable.rb

@@ -122,6 +122,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>.

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

@@ -21,12 +21,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 `Enumerable#without` that uses `Array#-`
+  # instead of `Array#reject` 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 +73,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

@@ -32,7 +32,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"
@@ -74,7 +74,7 @@ class Array
     when 0
       ''
     when 1
-      self[0].to_s.dup
+      "#{self[0]}"
     when 2
       "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
     else
@@ -85,14 +85,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'
       else
-        collect { |element| element.id }.join(',')
+        collect(&:id).join(',')
       end
     else
       to_default_s

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

@@ -89,28 +89,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 = self.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,17 @@
+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/wrap.rb

@@ -3,7 +3,7 @@ class Array
   #
   # 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 +15,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

@@ -4,3 +4,4 @@ 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/big_decimal/conversions.rb

@@ -1,16 +1,14 @@
 require 'bigdecimal'
 require 'bigdecimal/util'
 
-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)
+module ActiveSupport
+  module BigDecimalWithDefaultFormat #:nodoc:
+    DEFAULT_STRING_FORMAT = 'F'
+
+    def to_s(format = nil)
+      super(format || DEFAULT_STRING_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/class/attribute.rb

@@ -75,11 +75,15 @@ class Class
     instance_predicate = options.fetch(:instance_predicate, true)
 
     attrs.each do |name|
+      remove_possible_singleton_method(name)
       define_singleton_method(name) { nil }
+
+      remove_possible_singleton_method("#{name}?")
       define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
 
       ivar = "@#{name}"
 
+      remove_possible_singleton_method("#{name}=")
       define_singleton_method("#{name}=") do |val|
         singleton_class.class_eval do
           remove_possible_method(name)
@@ -110,18 +114,15 @@ class Class
             self.class.public_send name
           end
         end
+
+        remove_possible_method "#{name}?"
         define_method("#{name}?") { !!public_send(name) } if instance_predicate
       end
 
-      attr_writer name if instance_writer
-    end
-  end
-
-  private
-
-    unless respond_to?(:singleton_class?)
-      def singleton_class?
-        ancestors.first != self
+      if instance_writer
+        remove_possible_method "#{name}="
+        attr_writer name
       end
     end
+  end
 end

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

@@ -3,7 +3,8 @@ require 'active_support/core_ext/module/reachable'
 
 class Class
   begin
-    ObjectSpace.each_object(Class.new) {}
+    # Test if this Ruby supports each_object against singleton_class
+    ObjectSpace.each_object(Numeric.singleton_class) {}
 
     def descendants # :nodoc:
       descendants = []
@@ -12,7 +13,7 @@ class Class
       end
       descendants
     end
-  rescue StandardError # JRuby
+  rescue StandardError # JRuby 9.0.4.0 and earlier
     def descendants # :nodoc:
       descendants = []
       ObjectSpace.each_object(Class) do |k|
@@ -25,8 +26,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/class.rb

@@ -1,3 +1,2 @@
 require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/class/delegating_attributes'
 require 'active_support/core_ext/class/subclasses'

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

@@ -0,0 +1,12 @@
+require 'date'
+
+class Date #:nodoc:
+  # No Date is blank:
+  #
+  #   Date.today.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end

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

@@ -26,7 +26,7 @@ class Date
       Thread.current[:beginning_of_week] = find_beginning_of_week!(week_start)
     end
 
-    # Returns week start day symbol (e.g. :monday), or raises an ArgumentError for invalid day symbol.
+    # Returns week start day symbol (e.g. :monday), or raises an +ArgumentError+ for invalid day symbol.
     def find_beginning_of_week!(week_start)
       raise ArgumentError, "Invalid beginning of week: #{week_start}" unless ::Date::DAYS_INTO_WEEK.key?(week_start)
       week_start

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

@@ -5,15 +5,15 @@ require 'active_support/core_ext/module/remove_method'
 
 class Date
   DATE_FORMATS = {
-    :short        => '%e %b',
-    :long         => '%B %e, %Y',
+    :short        => '%d %b',
+    :long         => '%B %d, %Y',
     :db           => '%Y-%m-%d',
     :number       => '%Y%m%d',
     :long_ordinal => lambda { |date|
       day_format = ActiveSupport::Inflector.ordinalize(date.day)
       date.strftime("%B #{day_format}, %Y") # => "April 25th, 2007"
     },
-    :rfc822       => '%e %b %Y',
+    :rfc822       => '%d %b %Y',
     :iso8601      => lambda { |date| date.iso8601 }
   }
 
@@ -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"
@@ -74,14 +75,20 @@ class Date
   #
   #   date = Date.new(2007, 11, 10)  # => Sat, 10 Nov 2007
   #
-  #   date.to_time                   # => Sat Nov 10 00:00:00 0800 2007
-  #   date.to_time(:local)           # => Sat Nov 10 00:00:00 0800 2007
+  #   date.to_time                   # => 2007-11-10 00:00:00 0800
+  #   date.to_time(:local)           # => 2007-11-10 00:00:00 0800
   #
-  #   date.to_time(:utc)             # => Sat Nov 10 00:00:00 UTC 2007
+  #   date.to_time(:utc)             # => 2007-11-10 00:00:00 UTC
   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)
   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.rb

@@ -1,5 +1,5 @@
 require 'active_support/core_ext/date/acts_like'
+require 'active_support/core_ext/date/blank'
 require 'active_support/core_ext/date/calculations'
 require 'active_support/core_ext/date/conversions'
 require 'active_support/core_ext/date/zones'
-