activesupport 3.0.0.beta4 → 3.0.pre

data/lib/active_support/testing/setup_and_teardown.rb

@@ -1,29 +1,16 @@
-require 'active_support/concern'
-require 'active_support/callbacks'
-
 module ActiveSupport
   module Testing
     module SetupAndTeardown
-      extend ActiveSupport::Concern
-
-      included do
-        include ActiveSupport::Callbacks
-        define_callbacks :setup, :teardown
-
-        if defined?(MiniTest::Assertions) && TestCase < MiniTest::Assertions
-          include ForMiniTest
-        else
-          include ForClassicTestUnit
-        end
-      end
+      def self.included(base)
+        base.class_eval do
+          include ActiveSupport::DeprecatedCallbacks
+          define_callbacks :setup, :teardown
 
-      module ClassMethods
-        def setup(*args, &block)
-          set_callback(:setup, :before, *args, &block)
-        end
-
-        def teardown(*args, &block)
-          set_callback(:teardown, :after, *args, &block)
+          if defined?(MiniTest::Assertions) && TestCase < MiniTest::Assertions
+            include ForMiniTest
+          else
+            include ForClassicTestUnit
+          end
         end
       end
 
@@ -31,16 +18,15 @@ module ActiveSupport
         def run(runner)
           result = '.'
           begin
-            _run_setup_callbacks do
-              result = super
-            end
+            run_callbacks :setup
+            result = super
           rescue Exception => e
-            result = runner.puke(self.class, method_name, e)
+            result = runner.puke(self.class, self.name, e)
           ensure
             begin
-              _run_teardown_callbacks
+              run_callbacks :teardown, :enumerator => :reverse_each
             rescue Exception => e
-              result = runner.puke(self.class, method_name, e)
+              result = runner.puke(self.class, self.name, e)
             end
           end
           result
@@ -56,17 +42,23 @@ module ActiveSupport
         def run(result)
           return if @method_name.to_s == "default_test"
 
-          mocha_counter = retrieve_mocha_counter(result)
+          if using_mocha = respond_to?(:mocha_verify)
+            assertion_counter_klass = if defined?(Mocha::TestCaseAdapter::AssertionCounter)
+                                        Mocha::TestCaseAdapter::AssertionCounter
+                                      else
+                                        Mocha::Integration::TestUnit::AssertionCounter
+                                      end
+            assertion_counter = assertion_counter_klass.new(result)
+          end
+
           yield(Test::Unit::TestCase::STARTED, name)
           @_result = result
-
           begin
             begin
-              _run_setup_callbacks do
-                setup
-                __send__(@method_name)
-                mocha_verify(mocha_counter) if mocha_counter
-              end
+              run_callbacks :setup
+              setup
+              __send__(@method_name)
+              mocha_verify(assertion_counter) if using_mocha
             rescue Mocha::ExpectationError => e
               add_failure(e.message, e.backtrace)
             rescue Test::Unit::AssertionFailedError => e
@@ -77,7 +69,7 @@ module ActiveSupport
             ensure
               begin
                 teardown
-                _run_teardown_callbacks
+                run_callbacks :teardown, :enumerator => :reverse_each
               rescue Test::Unit::AssertionFailedError => e
                 add_failure(e.message, e.backtrace)
               rescue Exception => e
@@ -86,26 +78,12 @@ module ActiveSupport
               end
             end
           ensure
-            mocha_teardown if mocha_counter
+            mocha_teardown if using_mocha
           end
-
           result.add_run
           yield(Test::Unit::TestCase::FINISHED, name)
         end
-
-        protected
-
-        def retrieve_mocha_counter(result) #:nodoc:
-          if using_mocha = respond_to?(:mocha_verify)
-            if defined?(Mocha::TestCaseAdapter::AssertionCounter)
-              Mocha::TestCaseAdapter::AssertionCounter.new(result)
-            else
-              Mocha::Integration::TestUnit::AssertionCounter.new(result)
-            end
-          end
-        end
       end
-
     end
   end
 end

data/lib/active_support/time.rb

@@ -1,4 +1,7 @@
 require 'active_support'
+require 'active_support/core_ext/time'
+require 'active_support/core_ext/date'
+require 'active_support/core_ext/date_time'
 
 module ActiveSupport
   autoload :Duration, 'active_support/duration'
@@ -9,26 +12,3 @@ module ActiveSupport
     [Duration, TimeWithZone, TimeZone]
   end
 end
-
-require 'date'
-require 'time'
-
-require 'active_support/core_ext/time/publicize_conversion_methods'
-require 'active_support/core_ext/time/marshal'
-require 'active_support/core_ext/time/acts_like'
-require 'active_support/core_ext/time/calculations'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/time/zones'
-
-require 'active_support/core_ext/date/acts_like'
-require 'active_support/core_ext/date/freeze'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date/conversions'
-
-require 'active_support/core_ext/date_time/acts_like'
-require 'active_support/core_ext/date_time/calculations'
-require 'active_support/core_ext/date_time/conversions'
-require 'active_support/core_ext/date_time/zones'
-
-require 'active_support/core_ext/integer/time'
-require 'active_support/core_ext/numeric/time'

data/lib/active_support/time_with_zone.rb

@@ -1,5 +1,9 @@
-require "active_support/values/time_zone"
-require 'active_support/core_ext/object/acts_like'
+require 'active_support/duration'
+require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/integer/time'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/date/conversions'
+require 'active_support/core_ext/date_time/conversions'
 
 module ActiveSupport
   # A Time-like class that can represent a time in any time zone. Necessary because standard Ruby Time instances are
@@ -32,6 +36,7 @@ module ActiveSupport
   #   t.is_a?(Time)                         # => true
   #   t.is_a?(ActiveSupport::TimeWithZone)  # => true
   class TimeWithZone
+    
     def self.name
       'Time' # Report class name as 'Time' to thwart type checking
     end
@@ -113,9 +118,9 @@ module ActiveSupport
     end
     alias_method :iso8601, :xmlschema
 
-    # Coerces the date to a string for JSON encoding. The default format is ISO 8601. You can get
-    # %Y/%m/%d %H:%M:%S +offset style by setting ActiveSupport::JSON::Encoding.use_standard_json_time_format
-    # to false.
+    # Coerces the date to a string for JSON encoding.
+    #
+    # ISO 8601 format is used if ActiveSupport::JSON::Encoding.use_standard_json_time_format is set.
     #
     # ==== Examples
     #

data/lib/active_support/values/time_zone.rb

@@ -1,11 +1,6 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/try'
-begin
-  require 'tzinfo'
-rescue LoadError => e
-  $stderr.puts "You don't have tzinfo installed in your application. Please add it to your Gemfile and run bundle install"
-  raise e
-end
+require 'active_support/core_ext/time'
+require 'active_support/core_ext/date'
+require 'active_support/core_ext/date_time'
 
 # The TimeZone class serves as a wrapper around TZInfo::Timezone instances. It allows us to do the following:
 #
@@ -62,13 +57,13 @@ module ActiveSupport
         "Newfoundland"                 => "America/St_Johns",
         "Brasilia"                     => "America/Sao_Paulo",
         "Buenos Aires"                 => "America/Argentina/Buenos_Aires",
-        "Georgetown"                   => "America/Guyana",
+        "Georgetown"                   => "America/Argentina/San_Juan",
         "Greenland"                    => "America/Godthab",
         "Mid-Atlantic"                 => "Atlantic/South_Georgia",
         "Azores"                       => "Atlantic/Azores",
         "Cape Verde Is."               => "Atlantic/Cape_Verde",
         "Dublin"                       => "Europe/Dublin",
-        "Edinburgh"                    => "Europe/London",
+        "Edinburgh"                    => "Europe/Dublin",
         "Lisbon"                       => "Europe/Lisbon",
         "London"                       => "Europe/London",
         "Casablanca"                   => "Africa/Casablanca",
@@ -179,7 +174,7 @@ module ActiveSupport
       MAPPING.freeze
     end
 
-    UTC_OFFSET_WITH_COLON = '%s%02d:%02d'
+    UTC_OFFSET_WITH_COLON = '%+03d:%02d'
     UTC_OFFSET_WITHOUT_COLON = UTC_OFFSET_WITH_COLON.sub(':', '')
 
     # Assumes self represents an offset from UTC in seconds (as returned from Time#utc_offset)
@@ -188,34 +183,26 @@ module ActiveSupport
     #   TimeZone.seconds_to_utc_offset(-21_600) # => "-06:00"
     def self.seconds_to_utc_offset(seconds, colon = true)
       format = colon ? UTC_OFFSET_WITH_COLON : UTC_OFFSET_WITHOUT_COLON
-      sign = (seconds < 0 ? '-' : '+')
-      hours = seconds.abs / 3600
+      hours = seconds / 3600
       minutes = (seconds.abs % 3600) / 60
-      format % [sign, hours, minutes]
+      format % [hours, minutes]
     end
 
     include Comparable
     attr_reader :name
-    attr_reader :tzinfo
 
     # Create a new TimeZone object with the given name and offset. The
     # offset is the number of seconds that this time zone is offset from UTC
     # (GMT). Seconds were chosen as the offset unit because that is the unit that
     # Ruby uses to represent time zone offsets (see Time#utc_offset).
-    def initialize(name, utc_offset = nil, tzinfo = nil)
+    def initialize(name, utc_offset, tzinfo = nil)
       @name = name
       @utc_offset = utc_offset
-      @tzinfo = tzinfo || TimeZone.find_tzinfo(name)
-      @current_period = nil
+      @tzinfo = tzinfo
     end
 
     def utc_offset
-      if @utc_offset
-        @utc_offset
-      else
-        @current_period ||= tzinfo.try(:current_period)
-        @current_period.try(:utc_offset)
-      end
+      @utc_offset ||= tzinfo.current_period.utc_offset
     end
 
     # Returns the offset of this time zone as a formatted string, of the
@@ -318,9 +305,76 @@ module ActiveSupport
     end
 
     # TODO: Preload instead of lazy load for thread safety
-    def self.find_tzinfo(name)
-      require 'active_support/tzinfo' unless defined?(::TZInfo)
-      ::TZInfo::TimezoneProxy.new(MAPPING[name] || name)
+    def tzinfo
+      require 'tzinfo' unless defined?(TZInfo)
+      @tzinfo ||= TZInfo::Timezone.get(MAPPING[name])
+    end
+
+    unless const_defined?(:ZONES)
+      ZONES = []
+      ZONES_MAP = {}
+      [[-39_600, "International Date Line West", "Midway Island", "Samoa" ],
+       [-36_000, "Hawaii" ],
+       [-32_400, "Alaska" ],
+       [-28_800, "Pacific Time (US & Canada)", "Tijuana" ],
+       [-25_200, "Mountain Time (US & Canada)", "Chihuahua", "Mazatlan",
+                 "Arizona" ],
+       [-21_600, "Central Time (US & Canada)", "Saskatchewan", "Guadalajara",
+                 "Mexico City", "Monterrey", "Central America" ],
+       [-18_000, "Eastern Time (US & Canada)", "Indiana (East)", "Bogota",
+                 "Lima", "Quito" ],
+       [-16_200, "Caracas" ],
+       [-14_400, "Atlantic Time (Canada)", "La Paz", "Santiago" ],
+       [-12_600, "Newfoundland" ],
+       [-10_800, "Brasilia", "Buenos Aires", "Georgetown", "Greenland" ],
+       [ -7_200, "Mid-Atlantic" ],
+       [ -3_600, "Azores", "Cape Verde Is." ],
+       [      0, "Dublin", "Edinburgh", "Lisbon", "London", "Casablanca",
+                 "Monrovia", "UTC" ],
+       [  3_600, "Belgrade", "Bratislava", "Budapest", "Ljubljana", "Prague",
+                 "Sarajevo", "Skopje", "Warsaw", "Zagreb", "Brussels",
+                 "Copenhagen", "Madrid", "Paris", "Amsterdam", "Berlin",
+                 "Bern", "Rome", "Stockholm", "Vienna",
+                 "West Central Africa" ],
+       [  7_200, "Bucharest", "Cairo", "Helsinki", "Kyiv", "Riga", "Sofia",
+                 "Tallinn", "Vilnius", "Athens", "Istanbul", "Minsk",
+                 "Jerusalem", "Harare", "Pretoria" ],
+       [ 10_800, "Moscow", "St. Petersburg", "Volgograd", "Kuwait", "Riyadh",
+                 "Nairobi", "Baghdad" ],
+       [ 12_600, "Tehran" ],
+       [ 14_400, "Abu Dhabi", "Muscat", "Baku", "Tbilisi", "Yerevan" ],
+       [ 16_200, "Kabul" ],
+       [ 18_000, "Ekaterinburg", "Islamabad", "Karachi", "Tashkent" ],
+       [ 19_800, "Chennai", "Kolkata", "Mumbai", "New Delhi", "Sri Jayawardenepura" ],
+       [ 20_700, "Kathmandu" ],
+       [ 21_600, "Astana", "Dhaka", "Almaty",
+                 "Novosibirsk" ],
+       [ 23_400, "Rangoon" ],
+       [ 25_200, "Bangkok", "Hanoi", "Jakarta", "Krasnoyarsk" ],
+       [ 28_800, "Beijing", "Chongqing", "Hong Kong", "Urumqi",
+                 "Kuala Lumpur", "Singapore", "Taipei", "Perth", "Irkutsk",
+                 "Ulaan Bataar" ],
+       [ 32_400, "Seoul", "Osaka", "Sapporo", "Tokyo", "Yakutsk" ],
+       [ 34_200, "Darwin", "Adelaide" ],
+       [ 36_000, "Canberra", "Melbourne", "Sydney", "Brisbane", "Hobart",
+                 "Vladivostok", "Guam", "Port Moresby" ],
+       [ 39_600, "Magadan", "Solomon Is.", "New Caledonia" ],
+       [ 43_200, "Fiji", "Kamchatka", "Marshall Is.", "Auckland",
+                 "Wellington" ],
+       [ 46_800, "Nuku'alofa" ]].
+      each do |offset, *places|
+        places.sort.each do |place|
+          place.freeze
+          zone = new(place, offset)
+          ZONES << zone
+          ZONES_MAP[place] = zone
+        end
+      end
+      ZONES.freeze
+      ZONES_MAP.freeze
+
+      US_ZONES = ZONES.find_all { |z| z.name =~ /US|Arizona|Indiana|Hawaii|Alaska/ }
+      US_ZONES.freeze
     end
 
     class << self
@@ -337,11 +391,7 @@ module ActiveSupport
       # TimeZone objects per time zone, in many cases, to make it easier
       # for users to find their own time zone.
       def all
-        @zones ||= zones_map.values.sort
-      end
-
-      def zones_map
-        @zones_map ||= Hash[MAPPING.map { |place, _| [place, create(place)] }]
+        ZONES
       end
 
       # Locate a specific time zone object. If the argument is a string, it
@@ -352,7 +402,7 @@ module ActiveSupport
       def [](arg)
         case arg
           when String
-            zones_map[arg] ||= lookup(arg)
+            ZONES_MAP[arg]
           when Numeric, ActiveSupport::Duration
             arg *= 3600 if arg.abs <= 13
             all.find { |z| z.utc_offset == arg.to_i }
@@ -364,14 +414,8 @@ module ActiveSupport
       # A convenience method for returning a collection of TimeZone objects
       # for time zones in the USA.
       def us_zones
-        @us_zones ||= all.find_all { |z| z.name =~ /US|Arizona|Indiana|Hawaii|Alaska/ }
+        US_ZONES
       end
-
-      private
-
-        def lookup(name)
-          (tzinfo = find_tzinfo(name)) && create(tzinfo.name.freeze)
-        end
     end
   end
 end

data/lib/active_support/vendor.rb

@@ -0,0 +1,16 @@
+def ActiveSupport.requirable?(file)
+  $LOAD_PATH.any? { |p| Dir.glob("#{p}/#{file}.*").any? }
+end
+
+[%w(builder 2.1.2), %w(i18n 0.1.3), %w(memcache-client 1.7.5), %w(tzinfo 0.3.13)].each do |lib, version|
+  # If the lib is not already requirable
+  unless ActiveSupport.requirable? lib
+    # Try to activate a gem ~> satisfying the requested version first.
+    begin
+      gem lib, "~> #{version}"
+      # Use the vendored lib if the gem's missing or we aren't using RubyGems.
+    rescue LoadError, NoMethodError
+      $LOAD_PATH.unshift File.expand_path("#{File.dirname(__FILE__)}/vendor/#{lib}-#{version}/lib")
+    end
+  end
+end

data/lib/active_support/vendor/builder-2.1.2/lib/blankslate.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+######################################################################
+# BlankSlate provides an abstract base class with no predefined
+# methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+# BlankSlate is useful as a base class when writing classes that
+# depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+#
+class BlankSlate
+  class << self
+
+    # Hide the method named +name+ in the BlankSlate class.  Don't
+    # hide +instance_eval+ or any method beginning with "__".
+    def hide(name)
+      if instance_methods.include?(name.to_s) and
+        name !~ /^(__|instance_eval)/
+        @hidden_methods ||= {}
+        @hidden_methods[name.to_sym] = instance_method(name)
+        undef_method name
+      end
+    end
+
+    def find_hidden_method(name)
+      @hidden_methods ||= {}
+      @hidden_methods[name] || superclass.find_hidden_method(name)
+    end
+
+    # Redefine a previously hidden method so that it may be called on a blank
+    # slate object.
+    def reveal(name)
+      bound_method = nil
+      unbound_method = find_hidden_method(name)
+      fail "Don't know how to reveal method '#{name}'" unless unbound_method
+      define_method(name) do |*args|
+        bound_method ||= unbound_method.bind(self)
+        bound_method.call(*args)
+      end
+    end
+  end
+
+  instance_methods.each { |m| hide(m) }
+end
+
+######################################################################
+# Since Ruby is very dynamic, methods added to the ancestors of
+# BlankSlate <em>after BlankSlate is defined</em> will show up in the
+# list of available BlankSlate methods.  We handle this by defining a
+# hook in the Object and Kernel classes that will hide any method
+# defined after BlankSlate has been loaded.
+#
+module Kernel
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Kernel and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Kernel
+      BlankSlate.hide(name)
+      result
+    end
+  end
+end
+
+######################################################################
+# Same as above, except in Object.
+#
+class Object
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Object and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Object
+      BlankSlate.hide(name)
+      result
+    end
+
+    def find_hidden_method(name)
+      nil
+    end
+  end
+end
+
+######################################################################
+# Also, modules included into Object need to be scanned and have their
+# instance methods removed from blank slate.  In theory, modules
+# included into Kernel would have to be removed as well, but a
+# "feature" of Ruby prevents late includes into modules from being
+# exposed in the first place.
+#
+class Module
+  alias blankslate_original_append_features append_features
+  def append_features(mod)
+    result = blankslate_original_append_features(mod)
+    return result if mod != Object
+    instance_methods.each do |name|
+      BlankSlate.hide(name)
+    end
+    result
+  end
+end