activesupport 3.1.0 → 5.0.0

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

@@ -1,6 +1,9 @@
 require 'active_support/time_with_zone'
+require 'active_support/core_ext/time/acts_like'
+require 'active_support/core_ext/date_and_time/zones'
 
 class Time
+  include DateAndTime::Zones
   class << self
     attr_accessor :zone_default
 
@@ -23,21 +26,37 @@ class Time
     # <tt>current_user.time_zone</tt> just needs to return a string identifying the user's preferred time zone:
     #
     #   class ApplicationController < ActionController::Base
-    #     around_filter :set_time_zone
+    #     around_action :set_time_zone
     #
     #     def set_time_zone
-    #       old_time_zone = Time.zone
-    #       Time.zone = current_user.time_zone if logged_in?
-    #       yield
-    #     ensure
-    #       Time.zone = old_time_zone
+    #       if logged_in?
+    #         Time.use_zone(current_user.time_zone) { yield }
+    #       else
+    #         yield
+    #       end
     #     end
     #   end
     def zone=(time_zone)
       Thread.current[:time_zone] = find_zone!(time_zone)
     end
 
-    # Allows override of <tt>Time.zone</tt> locally inside supplied block; resets <tt>Time.zone</tt> to existing value when done.
+    # Allows override of <tt>Time.zone</tt> locally inside supplied block;
+    # resets <tt>Time.zone</tt> to existing value when done.
+    #
+    #   class ApplicationController < ActionController::Base
+    #     around_action :set_time_zone
+    #
+    #     private
+    #
+    #     def set_time_zone
+    #       Time.use_zone(current_user.timezone) { yield }
+    #     end
+    #   end
+    #
+    #  NOTE: This won't affect any <tt>ActiveSupport::TimeWithZone</tt>
+    #  objects that have already been created, e.g. any model timestamp
+    #  attributes that have been read before the block will remain in
+    #  the application's default timezone.
     def use_zone(time_zone)
       new_zone = find_zone!(time_zone)
       begin
@@ -48,39 +67,45 @@ class Time
       end
     end
 
-    # Returns a TimeZone instance or nil, or raises an ArgumentError for invalid timezones.
+    # Returns a TimeZone instance matching the time zone provided.
+    # Accepts the time zone in any format supported by <tt>Time.zone=</tt>.
+    # Raises an +ArgumentError+ for invalid time zones.
+    #
+    #   Time.find_zone! "America/New_York" # => #<ActiveSupport::TimeZone @name="America/New_York" ...>
+    #   Time.find_zone! "EST"              # => #<ActiveSupport::TimeZone @name="EST" ...>
+    #   Time.find_zone! -5.hours           # => #<ActiveSupport::TimeZone @name="Bogota" ...>
+    #   Time.find_zone! nil                # => nil
+    #   Time.find_zone! false              # => false
+    #   Time.find_zone! "NOT-A-TIMEZONE"   # => ArgumentError: Invalid Timezone: NOT-A-TIMEZONE
     def find_zone!(time_zone)
-      return time_zone if time_zone.nil? || time_zone.is_a?(ActiveSupport::TimeZone)
-      # lookup timezone based on identifier (unless we've been passed a TZInfo::Timezone)
-      unless time_zone.respond_to?(:period_for_local)
-        time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone)
+      if !time_zone || time_zone.is_a?(ActiveSupport::TimeZone)
+        time_zone
+      else
+        # Look up the timezone based on the identifier (unless we've been
+        # passed a TZInfo::Timezone)
+        unless time_zone.respond_to?(:period_for_local)
+          time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone)
+        end
+
+        # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
+        if time_zone.is_a?(ActiveSupport::TimeZone)
+          time_zone
+        else
+          ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
+        end
       end
-      # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
-      time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
     rescue TZInfo::InvalidTimezoneIdentifier
       raise ArgumentError, "Invalid Timezone: #{time_zone}"
     end
 
+    # Returns a TimeZone instance matching the time zone provided.
+    # Accepts the time zone in any format supported by <tt>Time.zone=</tt>.
+    # Returns +nil+ for invalid time zones.
+    #
+    #   Time.find_zone "America/New_York" # => #<ActiveSupport::TimeZone @name="America/New_York" ...>
+    #   Time.find_zone "NOT-A-TIMEZONE"   # => nil
     def find_zone(time_zone)
       find_zone!(time_zone) rescue nil
     end
   end
-
-  # Returns the simultaneous time in <tt>Time.zone</tt>.
-  #
-  #   Time.zone = 'Hawaii'         # => 'Hawaii'
-  #   Time.utc(2000).in_time_zone  # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-  #
-  # This method is similar to Time#localtime, except that it uses <tt>Time.zone</tt> as the local zone
-  # instead of the operating system's time zone.
-  #
-  # You can also pass in a TimeZone instance or string that identifies a TimeZone as an argument,
-  # and the conversion will be based on that zone instead of <tt>Time.zone</tt>.
-  #
-  #   Time.utc(2000).in_time_zone('Alaska')  # => Fri, 31 Dec 1999 15:00:00 AKST -09:00
-  def in_time_zone(zone = ::Time.zone)
-    return self unless zone
-
-    ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.find_zone!(zone))
-  end
 end

data/lib/active_support/core_ext/time.rb

@@ -0,0 +1,5 @@
+require 'active_support/core_ext/time/acts_like'
+require 'active_support/core_ext/time/calculations'
+require 'active_support/core_ext/time/compatibility'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/time/zones'

data/lib/active_support/core_ext/uri.rb

@@ -1,22 +1,16 @@
-# encoding: utf-8
+require 'uri'
+str = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E" # Ni-ho-nn-go in UTF-8, means Japanese.
+parser = URI::Parser.new
 
-if RUBY_VERSION >= '1.9'
-  require 'uri'
-
-  str = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E" # Ni-ho-nn-go in UTF-8, means Japanese.
-
-  parser = URI::Parser.new
-
-  unless str == parser.unescape(parser.escape(str))
-    URI::Parser.class_eval do
-      remove_method :unescape
-      def unescape(str, escaped = /%[a-fA-F\d]{2}/)
-        # TODO: Are we actually sure that ASCII == UTF-8?
-        # YK: My initial experiments say yes, but let's be sure please
-        enc = str.encoding
-        enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
-        str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(enc)
-      end
+unless str == parser.unescape(parser.escape(str))
+  URI::Parser.class_eval do
+    remove_method :unescape
+    def unescape(str, escaped = /%[a-fA-F\d]{2}/)
+      # TODO: Are we actually sure that ASCII == UTF-8?
+      # YK: My initial experiments say yes, but let's be sure please
+      enc = str.encoding
+      enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
+      str.gsub(escaped) { |match| [match[1, 2].hex].pack('C') }.force_encoding(enc)
     end
   end
 end
@@ -24,7 +18,7 @@ end
 module URI
   class << self
     def parser
-      @parser ||= URI.const_defined?(:Parser) ? URI::Parser.new : URI
+      @parser ||= URI::Parser.new
     end
   end
 end

data/lib/active_support/core_ext.rb

@@ -1,3 +1,4 @@
-Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].sort.each do |path|
-  require "active_support/core_ext/#{File.basename(path, '.rb')}"
+DEPRECATED_FILES = ["#{File.dirname(__FILE__)}/core_ext/struct.rb"]
+(Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"] - DEPRECATED_FILES).each do |path|
+  require path
 end

data/lib/active_support/dependencies/autoload.rb

@@ -1,50 +1,77 @@
 require "active_support/inflector/methods"
-require "active_support/lazy_load_hooks"
 
 module ActiveSupport
+  # Autoload and eager load conveniences for your library.
+  #
+  # This module allows you to define autoloads based on
+  # Rails conventions (i.e. no need to define the path
+  # it is automatically guessed based on the filename)
+  # and also define a set of constants that needs to be
+  # eager loaded:
+  #
+  #   module MyLib
+  #     extend ActiveSupport::Autoload
+  #
+  #     autoload :Model
+  #
+  #     eager_autoload do
+  #       autoload :Cache
+  #     end
+  #   end
+  #
+  # Then your library can be eager loaded by simply calling:
+  #
+  #   MyLib.eager_load!
   module Autoload
-    @@autoloads = {}
-    @@under_path = nil
-    @@at_path = nil
-    @@eager_autoload = false
+    def self.extended(base) # :nodoc:
+      base.class_eval do
+        @_autoloads = {}
+        @_under_path = nil
+        @_at_path = nil
+        @_eager_autoload = false
+      end
+    end
 
-    def autoload(const_name, path = @@at_path)
-      full = [self.name, @@under_path, const_name.to_s, path].compact.join("::")
-      location = path || Inflector.underscore(full)
+    def autoload(const_name, path = @_at_path)
+      unless path
+        full = [name, @_under_path, const_name.to_s].compact.join("::")
+        path = Inflector.underscore(full)
+      end
 
-      if @@eager_autoload
-        @@autoloads[const_name] = location
+      if @_eager_autoload
+        @_autoloads[const_name] = path
       end
-      super const_name, location
+
+      super const_name, path
     end
 
     def autoload_under(path)
-      @@under_path, old_path = path, @@under_path
+      @_under_path, old_path = path, @_under_path
       yield
     ensure
-      @@under_path = old_path
+      @_under_path = old_path
     end
 
     def autoload_at(path)
-      @@at_path, old_path = path, @@at_path
+      @_at_path, old_path = path, @_at_path
       yield
     ensure
-      @@at_path = old_path
+      @_at_path = old_path
     end
 
     def eager_autoload
-      old_eager, @@eager_autoload = @@eager_autoload, true
+      old_eager, @_eager_autoload = @_eager_autoload, true
       yield
     ensure
-      @@eager_autoload = old_eager
+      @_eager_autoload = old_eager
     end
 
-    def self.eager_autoload!
-      @@autoloads.values.each { |file| require file }
+    def eager_load!
+      @_autoloads.each_value { |file| require file }
     end
 
     def autoloads
-      @@autoloads
+      @_autoloads
     end
   end
 end

data/lib/active_support/dependencies/interlock.rb

@@ -0,0 +1,51 @@
+require 'active_support/concurrency/share_lock'
+
+module ActiveSupport #:nodoc:
+  module Dependencies #:nodoc:
+    class Interlock
+      def initialize # :nodoc:
+        @lock = ActiveSupport::Concurrency::ShareLock.new
+      end
+
+      def loading
+        @lock.exclusive(purpose: :load, compatible: [:load], after_compatible: [:load]) do
+          yield
+        end
+      end
+
+      def unloading
+        @lock.exclusive(purpose: :unload, compatible: [:load, :unload], after_compatible: [:load, :unload]) do
+          yield
+        end
+      end
+
+      def start_unloading
+        @lock.start_exclusive(purpose: :unload, compatible: [:load, :unload])
+      end
+
+      def done_unloading
+        @lock.stop_exclusive(compatible: [:load, :unload])
+      end
+
+      def start_running
+        @lock.start_sharing
+      end
+
+      def done_running
+        @lock.stop_sharing
+      end
+
+      def running
+        @lock.sharing do
+          yield
+        end
+      end
+
+      def permit_concurrent_loads
+        @lock.yield_shares(compatible: [:load]) do
+          yield
+        end
+      end
+    end
+  end
+end