timecop 0.5.2 → 0.9.5

data/lib/timecop/timecop.rb

@@ -1,6 +1,5 @@
 require 'singleton'
-require 'timecop/time_extensions'
-require 'timecop/time_stack_item'
+require File.join(File.dirname(__FILE__), "time_stack_item")
 
 # Timecop
 # * Wrapper class for manipulating the extensions to the Time, Date, and DateTime objects
@@ -14,7 +13,7 @@ class Timecop
   include Singleton
 
   class << self
-    attr_accessor :active_support
+    private :instance
 
     # Allows you to run a block of code and "fake" a time throughout the execution of that block.
     # This is particularly useful for writing test methods where the passage of time is critical to the business
@@ -33,6 +32,7 @@ class Timecop
     # 3. Timecop.freeze(date_inst)
     # 4. Timecop.freeze(offset_in_seconds)
     # 5. Timecop.freeze(year, month, day, hour=0, minute=0, second=0)
+    # 6. Timecop.freeze() # Defaults to Time.now
     #
     # When a block is also passed, Time.now, DateTime.now and Date.today are all reset to their
     # previous values after the block has finished executing.  This allows us to nest multiple
@@ -47,11 +47,9 @@ class Timecop
     #   which will lead to files being generated with the timestamp set by the Timecop.freeze call
     #   in your dev environment
     #
-    # Returns the value of the block or nil.
+    # Returns the value of the block if one is given, or the mocked time.
     def freeze(*args, &block)
-      val = instance().send(:travel, :freeze, *args, &block)
-
-      block_given? ? val : nil
+      send_travel(:freeze, *args, &block)
     end
 
     # Allows you to run a block of code and "fake" a time throughout the execution of that block.
@@ -60,11 +58,9 @@ class Timecop
     # * Note: Timecop.travel will not freeze time (as opposed to Timecop.freeze).  This is a particularly
     #   good candidate for use in environment files in rails projects.
     #
-    # Returns the value of the block or nil.
+    # Returns the value of the block if one is given, or the mocked time.
     def travel(*args, &block)
-      val = instance().send(:travel, :travel, *args, &block)
-
-      block_given? ? val : nil
+      send_travel(:travel, *args, &block)
     end
 
     # Allows you to run a block of code and "scale" a time throughout the execution of that block.
@@ -74,74 +70,171 @@ class Timecop
     #   end
     # See Timecop#freeze for exact usage of the other arguments
     #
-    # Returns the value of the block or nil.
+    # Returns the value of the block if one is given, or the mocked time.
     def scale(*args, &block)
-      val = instance().send(:travel, :scale, *args, &block)
-
-      block_given? ? val : nil
+      send_travel(:scale, *args, &block)
     end
 
     def baseline
-      instance().send(:baseline)
+      instance.baseline
     end
 
     def baseline=(baseline)
-      instance().send(:baseline=, baseline)
+      instance.baseline = baseline
     end
 
-    # Reverts back to system's Time.now, Date.today and DateTime.now (if it exists).
-    def return
-      instance().send(:unmock!)
-      nil
+    # Reverts back to system's Time.now, Date.today and DateTime.now (if it exists) permamently when
+    # no block argument is given, or temporarily reverts back to the system's time temporarily for
+    # the given block.
+    def return(&block)
+      if block_given?
+        instance.return(&block)
+      else
+        instance.unmock!
+        nil
+      end
     end
+    alias :unfreeze :return
 
     def return_to_baseline
-      instance().send(:return_to_baseline)
+      instance.return_to_baseline
       Time.now
     end
 
     def top_stack_item #:nodoc:
-      instance().instance_variable_get(:@_stack).last
+      instance.stack.last
+    end
+
+    def safe_mode=(safe)
+      @safe_mode = safe
+    end
+
+    def safe_mode?
+      @safe_mode ||= false
+    end
+
+    def thread_safe=(t)
+      instance.thread_safe = t
+    end
+
+    def thread_safe
+      instance.thread_safe
+    end
+
+    # Returns whether or not Timecop is currently frozen/travelled
+    def frozen?
+      !instance.stack.empty?
+    end
+
+    private
+    def send_travel(mock_type, *args, &block)
+      val = instance.travel(mock_type, *args, &block)
+      block_given? ? val : Time.now
     end
   end
 
-  protected
+  def baseline=(b)
+    set_baseline(b)
+    stack << TimeStackItem.new(:travel, b)
+  end
 
-    def baseline=(baseline)
-      @baseline = baseline
-      @_stack << TimeStackItem.new(:travel, baseline)
+  def baseline
+    if @thread_safe
+      Thread.current[:timecop_baseline]
+    else
+      @baseline
     end
+  end
 
-    def initialize #:nodoc:
-      @_stack = []
+  def set_baseline(b)
+    if @thread_safe
+      Thread.current[:timecop_baseline] = b
+    else
+      @baseline = b
     end
+  end
 
-    def travel(mock_type, *args, &block) #:nodoc:
-      stack_item = TimeStackItem.new(mock_type, *args)
+  def stack
+    if @thread_safe
+      Thread.current[:timecop_stack] ||= []
+      Thread.current[:timecop_stack]
+    else
+      @stack
+    end
+  end
 
-      # store this time traveling on our stack...
-      @_stack << stack_item
+  def set_stack(s)
+    if @thread_safe
+      Thread.current[:timecop_stack] = s
+    else
+      @stack = s
+    end
+  end
 
-      if block_given?
-        begin
-          yield stack_item.time
-        ensure
-          # pull it off the stack...
-          @_stack.pop
-        end
+  def initialize #:nodoc:
+    @stack = []
+    @safe = nil
+    @thread_safe = false
+  end
+
+  def thread_safe=(t)
+    initialize
+    @thread_safe = t
+  end
+
+  def thread_safe
+    @thread_safe
+  end
+
+  def travel(mock_type, *args, &block) #:nodoc:
+    raise SafeModeException if Timecop.safe_mode? && !block_given? && !@safe
+
+    stack_item = TimeStackItem.new(mock_type, *args)
+
+    stack_backup = stack.dup
+    stack << stack_item
+
+    if block_given?
+      safe_backup = @safe
+      @safe = true
+      begin
+        yield stack_item.time
+      ensure
+        stack.replace stack_backup
+        @safe = safe_backup
       end
     end
+  end
+
+  def return(&block)
+    current_stack = stack
+    current_baseline = baseline
+    unmock!
+    yield
+  ensure
+    set_stack current_stack
+    set_baseline current_baseline
+  end
 
-    def unmock! #:nodoc:
-      @baseline = nil
-      @_stack = []
+  def unmock! #:nodoc:
+    set_baseline nil
+    set_stack []
+  end
+
+  def return_to_baseline
+    if baseline
+      set_stack [stack.shift]
+    else
+      unmock!
     end
+  end
 
-    def return_to_baseline
-      if @baseline
-        @_stack = [@_stack.shift]
-      else
-        unmock!
-      end
+  class SafeModeException < StandardError
+    def initialize
+      super "Safe mode is enabled, only calls passing a block are allowed."
     end
+  end
 end
+
+# This must be done after TimeCop is available
+require File.join(File.dirname(__FILE__), "time_extensions")

data/lib/timecop/version.rb

@@ -1,3 +1,3 @@
 class Timecop
-  VERSION = "0.5.2"
-end
+  VERSION = "0.9.5"
+end

data/lib/timecop.rb

@@ -1,2 +1,2 @@
-require 'timecop/timecop'
-require 'timecop/version'
+require File.join(File.dirname(__FILE__), "timecop", "timecop")
+require File.join(File.dirname(__FILE__), "timecop", "version")

data/test/test_helper.rb

@@ -1,34 +1,39 @@
-require 'rubygems'
 require 'bundler/setup'
-require 'test/unit'
-require 'mocha'
+require 'minitest/autorun'
+require 'minitest/rg'
+require 'pry'
 
-class Test::Unit::TestCase
+$VERBOSE = true # enable ruby warnings
 
+require 'mocha/minitest'
+
+class Minitest::Test
   private
     # Tests to see that two times are within the given distance,
     # in seconds, from each other.
     def times_effectively_equal(time1, time2, seconds_interval = 1)
       (time1 - time2).abs <= seconds_interval
     end
-    
+
     def assert_times_effectively_equal(time1, time2, seconds_interval = 1, msg = nil)
       assert times_effectively_equal(time1, time2, seconds_interval), "#{msg}: time1 = #{time1.to_s}, time2 = #{time2.to_s}"
     end
-    
+
     def assert_times_effectively_not_equal(time1, time2, seconds_interval = 1, msg = nil)
       assert !times_effectively_equal(time1, time2, seconds_interval), "#{msg}: time1 = #{time1.to_s}, time2 = #{time2.to_s}"
     end
-    
-    def local_offset
-      DateTime.now_without_mock_time.offset
+
+    # Gets the local offset (supplied by ENV['TZ'] or your computer's clock)
+    # At the given timestamp, or Time.now if not time is given.
+    def local_offset(time = Time.now)
+      Time.at(time.to_i).to_datetime.offset
     end
-  
-    TIMEZONES = ["Europe/Paris", "UTC", "EDT"]
-  
+
+    TIMEZONES = ["Pacific/Midway", "Europe/Paris", "UTC", "America/Chicago"]
+
     def each_timezone
       old_tz = ENV["TZ"]
-    
+
       begin
         TIMEZONES.each do |timezone|
           ENV["TZ"] = timezone
@@ -38,13 +43,17 @@ class Test::Unit::TestCase
         ENV["TZ"] = old_tz
       end
     end
-    
+
     def a_time_stack_item
       Timecop::TimeStackItem.new(:freeze, 2008, 1, 1, 0, 0, 0)
     end
-  
+
     def assert_date_times_equal(dt1, dt2)
-      assert_equal dt1, dt2, "Failed for timezone: #{ENV['TZ']}: #{dt1.to_s} not equal to #{dt2.to_s}"
+      assert_in_delta dt1.to_time.to_f, dt2.to_time.to_f, 0.01, "Failed for timezone: #{ENV['TZ']}: #{dt1.to_s} not equal to #{dt2.to_s}"
     end
-    
+
+    def jruby?
+      RUBY_PLATFORM == "java"
+    end
+
 end