activesupport 3.1.0 → 5.0.0

data/lib/active_support/concern.rb

@@ -4,20 +4,18 @@ module ActiveSupport
   #   module M
   #     def self.included(base)
   #       base.extend ClassMethods
-  #       base.send(:include, InstanceMethods)
-  #       scope :disabled, where(:disabled => true)
+  #       base.class_eval do
+  #         scope :disabled, -> { where(disabled: true) }
+  #       end
   #     end
   #
   #     module ClassMethods
   #       ...
   #     end
-  #
-  #     module InstanceMethods
-  #       ...
-  #     end
   #   end
   #
-  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be written as:
+  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
+  # written as:
   #
   #   require 'active_support/concern'
   #
@@ -25,20 +23,17 @@ module ActiveSupport
   #     extend ActiveSupport::Concern
   #
   #     included do
-  #       scope :disabled, where(:disabled => true)
+  #       scope :disabled, -> { where(disabled: true) }
   #     end
   #
-  #     module ClassMethods
-  #       ...
-  #     end
-  #
-  #     module InstanceMethods
+  #     class_methods do
   #       ...
   #     end
   #   end
   #
-  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module and a +Bar+
-  # module which depends on the former, we would typically write the following:
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+  # and a +Bar+ module which depends on the former, we would typically write the
+  # following:
   #
   #   module Foo
   #     def self.included(base)
@@ -61,11 +56,11 @@ module ActiveSupport
   #     include Bar # Bar is the module that Host really needs
   #   end
   #
-  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We could try to hide
-  # these from +Host+ directly including +Foo+ in +Bar+:
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
   #
   #   module Bar
-  #     include Foo 
+  #     include Foo
   #     def self.included(base)
   #       base.method_injected_by_foo
   #     end
@@ -75,18 +70,17 @@ module ActiveSupport
   #     include Bar
   #   end
   #
-  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt> is the +Bar+ module,
-  # not the +Host+ class. With <tt>ActiveSupport::Concern</tt>, module dependencies are properly resolved:
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
+  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
+  # module dependencies are properly resolved:
   #
   #   require 'active_support/concern'
   #
   #   module Foo
   #     extend ActiveSupport::Concern
   #     included do
-  #       class_eval do
-  #         def self.method_injected_by_foo
-  #           ...
-  #         end
+  #       def self.method_injected_by_foo
+  #         ...
   #       end
   #     end
   #   end
@@ -101,34 +95,48 @@ module ActiveSupport
   #   end
   #
   #   class Host
-  #     include Bar # works, Bar takes care now of its dependencies
+  #     include Bar # It works, now Bar takes care of its dependencies
   #   end
-  #
   module Concern
-    def self.extended(base)
-      base.instance_variable_set("@_dependencies", [])
+    class MultipleIncludedBlocks < StandardError #:nodoc:
+      def initialize
+        super "Cannot define multiple 'included' blocks for a Concern"
+      end
+    end
+
+    def self.extended(base) #:nodoc:
+      base.instance_variable_set(:@_dependencies, [])
     end
 
     def append_features(base)
-      if base.instance_variable_defined?("@_dependencies")
-        base.instance_variable_get("@_dependencies") << self
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies) << self
         return 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.send :include, const_get("InstanceMethods") if const_defined?("InstanceMethods")
-        base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
+        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
       end
     end
 
     def included(base = nil, &block)
       if base.nil?
+        raise MultipleIncludedBlocks if instance_variable_defined?(:@_included_block)
+
         @_included_block = block
       else
         super
       end
     end
+
+    def class_methods(&class_methods_module_definition)
+      mod = const_defined?(:ClassMethods, false) ?
+        const_get(:ClassMethods) :
+        const_set(:ClassMethods, Module.new)
+
+      mod.module_eval(&class_methods_module_definition)
+    end
   end
 end

data/lib/active_support/concurrency/latch.rb

@@ -0,0 +1,19 @@
+require 'concurrent/atomic/count_down_latch'
+
+module ActiveSupport
+  module Concurrency
+    class Latch < Concurrent::CountDownLatch
+
+      def initialize(count = 1)
+        ActiveSupport::Deprecation.warn("ActiveSupport::Concurrency::Latch is deprecated. Please use Concurrent::CountDownLatch instead.")
+        super(count)
+      end
+
+      alias_method :release, :count_down
+
+      def await
+        wait(nil)
+      end
+    end
+  end
+end

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

@@ -1,7 +1,5 @@
 require 'active_support/concern'
 require 'active_support/ordered_options'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/array/extract_options'
 
 module ActiveSupport
@@ -15,7 +13,7 @@ module ActiveSupport
         self.class.compile_methods!(keys)
       end
 
-      # compiles reader methods so we don't have to go through method_missing
+      # Compiles reader methods so we don't have to go through method_missing.
       def self.compile_methods!(keys)
         keys.reject { |m| method_defined?(m) }.each do |key|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -39,31 +37,92 @@ module ActiveSupport
         yield config
       end
 
-      # Allows you to add shortcut so that you don't have to refer to attribute through config.
-      # Also look at the example for config to contrast.
+      # Allows you to add shortcut so that you don't have to refer to attribute
+      # through config. Also look at the example for config to contrast.
+      #
+      # Defines both class and instance config accessors.
       #
       #   class User
       #     include ActiveSupport::Configurable
       #     config_accessor :allowed_access
       #   end
       #
+      #   User.allowed_access # => nil
+      #   User.allowed_access = false
+      #   User.allowed_access # => false
+      #
       #   user = User.new
+      #   user.allowed_access # => false
       #   user.allowed_access = true
       #   user.allowed_access # => true
       #
+      #   User.allowed_access # => false
+      #
+      # The attribute name must be a valid method name in Ruby.
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #     config_accessor :"1_Badname"
+      #   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>.
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #     config_accessor :allowed_access, instance_reader: false, instance_writer: false
+      #   end
+      #
+      #   User.allowed_access = false
+      #   User.allowed_access # => false
+      #
+      #   User.new.allowed_access = true # => NoMethodError
+      #   User.new.allowed_access        # => NoMethodError
+      #
+      # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #     config_accessor :allowed_access, instance_accessor: false
+      #   end
+      #
+      #   User.allowed_access = false
+      #   User.allowed_access # => false
+      #
+      #   User.new.allowed_access = true # => NoMethodError
+      #   User.new.allowed_access        # => NoMethodError
+      #
+      # Also you can pass a block to set up the attribute with a default value.
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #     config_accessor :hair_colors do
+      #       [:brown, :black, :blonde, :red]
+      #     end
+      #   end
+      #
+      #   User.hair_colors # => [:brown, :black, :blonde, :red]
       def config_accessor(*names)
         options = names.extract_options!
 
         names.each do |name|
-          reader, line = "def #{name}; config.#{name}; end", __LINE__
-          writer, line = "def #{name}=(value); config.#{name} = value; end", __LINE__
+          raise NameError.new('invalid config attribute name') unless name =~ /\A[_A-Za-z]\w*\z/
 
-          singleton_class.class_eval reader, __FILE__, line
-          singleton_class.class_eval writer, __FILE__, line
-          class_eval reader, __FILE__, line unless options[:instance_reader] == false
-          class_eval writer, __FILE__, line unless options[:instance_writer] == false
+          reader, reader_line = "def #{name}; config.#{name}; end", __LINE__
+          writer, writer_line = "def #{name}=(value); config.#{name} = value; end", __LINE__
+
+          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
+          end
+          send("#{name}=", yield) if block_given?
         end
       end
+      private :config_accessor
     end
 
     # Reads and writes attributes from a configuration <tt>OrderedHash</tt>.
@@ -81,7 +140,6 @@ module ActiveSupport
     #
     #   user.config.allowed_access # => true
     #   user.config.level          # => 1
-    #
     def config
       @_config ||= self.class.config.inheritable_copy
     end

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

@@ -1,46 +1,90 @@
 class Array
   # Returns the tail of the array from +position+.
   #
-  #   %w( a b c d ).from(0)  # => %w( a b c d )
-  #   %w( a b c d ).from(2)  # => %w( c d )
-  #   %w( a b c d ).from(10) # => %w()
-  #   %w().from(0)           # => %w()
+  #   %w( a b c d ).from(0)  # => ["a", "b", "c", "d"]
+  #   %w( a b c d ).from(2)  # => ["c", "d"]
+  #   %w( a b c d ).from(10) # => []
+  #   %w().from(0)           # => []
+  #   %w( a b c d ).from(-2) # => ["c", "d"]
+  #   %w( a b c ).from(-10)  # => []
   def from(position)
     self[position, length] || []
   end
 
   # Returns the beginning of the array up to +position+.
   #
-  #   %w( a b c d ).to(0)  # => %w( a )
-  #   %w( a b c d ).to(2)  # => %w( a b c )
-  #   %w( a b c d ).to(10) # => %w( a b c d )
-  #   %w().to(0)           # => %w()
+  #   %w( a b c d ).to(0)  # => ["a"]
+  #   %w( a b c d ).to(2)  # => ["a", "b", "c"]
+  #   %w( a b c d ).to(10) # => ["a", "b", "c", "d"]
+  #   %w().to(0)           # => []
+  #   %w( a b c d ).to(-2) # => ["a", "b", "c"]
+  #   %w( a b c ).to(-10)  # => []
   def to(position)
-    self[0..position]
+    if position >= 0
+      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"
   def second
     self[1]
   end
 
   # Equal to <tt>self[2]</tt>.
+  #
+  #   %w( a b c d e ).third # => "c"
   def third
     self[2]
   end
 
   # Equal to <tt>self[3]</tt>.
+  #
+  #   %w( a b c d e ).fourth # => "d"
   def fourth
     self[3]
   end
 
   # Equal to <tt>self[4]</tt>.
+  #
+  #   %w( a b c d e ).fifth # => "e"
   def fifth
     self[4]
   end
 
   # Equal to <tt>self[41]</tt>. Also known as accessing "the reddit".
+  #
+  #   (1..42).to_a.forty_two # => 42
   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