timecop 0.5.1 → 0.6.0

data/README.markdown

@@ -1,6 +1,8 @@
 # timecop
 
-- Source[http://github.com/jtrupiano/timecop]
+[![Build Status](https://secure.travis-ci.org/travisjeffery/timecop.png)](http://travis-ci.org/travisjeffery/timecop)
+
+- Source[http://github.com/travisjeffery/timecop]
 - Documentation[http://johntrupiano.rubyforge.org/timecop]
 
 ## DESCRIPTION
@@ -15,6 +17,7 @@ A gem providing "time travel" and "time freezing" capabilities, making it dead s
 
 - Freeze time to a specific point.
 - Travel back to a specific point in time, but allow time to continue moving forward from there.
+- Scale time by a given scaling factor that will cause time to move at an accelerated pace.
 - No dependencies, can be used with _any_ ruby project
 - Timecop api allows arguments to be passed into #freeze and #travel as one of the following:
   - Time instance
@@ -39,6 +42,22 @@ Timecop.freeze(Date.today + 30) do
 end
 ```
 
+You can mock the time for a set of tests easily via setup/teardown methods
+
+```ruby
+describe "some set of tests to mock" do
+  before do
+    Timecop.freeze(Time.local(1990))
+  end
+  
+  after do
+    Timecop.return
+  end
+
+  it "should do blah blah blah" {}
+end
+```
+
 Set the time for the test environment of a rails app -- this is particularly
 helpful if your whole application is time-sensitive.  It allows you to build
 your test data at a single point in time, and to move in/out of that time as
@@ -75,6 +94,25 @@ sleep(10)
 new_time == Time.now # ==> false
 ```
 
+### Timecop.scale
+
+Let's say you want to test a "live" integration wherein entire days could pass by
+in minutes while you're able to simulate "real" activity. For example, one such use case
+is being able to test reports and invoices that run in 30 day cycles in very little time, while also
+being able to simulate activity via subsequent calls to your application.
+
+```ruby
+# seconds will now seem like hours
+Timecop.scale(3600)
+Time.now
+# => 2012-09-20 21:23:25 -0500
+# seconds later, hours have past it's gone from 9pm at night to 6am in the morning
+Time.now
+# => 2012-09-21 06:22:59 -0500
+```
+
+See #42 for more information, thanks to Ken Mayer, David Holcomb, and Pivotal Labs.
+
 ## REFERENCES
 
 * {0.3.4 release}[http://blog.smartlogicsolutions.com/2009/12/07/timecop-0-3-4-released/]
@@ -84,8 +122,8 @@ new_time == Time.now # ==> false
 
 ## Contribute
 
-timecop is maintained by [travisjeffery](http://github.com/travisjeffery), who
-you can also hit up on [Twitter](http://twitter.com/travisjeffery).
+timecop is maintained by [travisjeffery](http://github.com/travisjeffery), and
+was created by [jtrupiano](https://github.com/jtrupiano). 
 
 Here's the most direct way to get your work merged into the project.
 

data/lib/timecop/time_extensions.rb

@@ -1,29 +1,25 @@
 
 class Time #:nodoc:
   class << self
-    # Time we are behaving as
     def mock_time
       mocked_time_stack_item = Timecop.top_stack_item
       mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.time(self)
     end
     
-    # Alias the original now
     alias_method :now_without_mock_time, :now
 
-    # Define now_with_mock_time
     def now_with_mock_time
       mock_time || now_without_mock_time
     end
     
-    # Alias now to now_with_mock_time
     alias_method :now, :now_with_mock_time
 
     alias_method :new_without_mock_time, :new
 
-    def new_with_mock_time *args
+    def new_with_mock_time(*args)
       begin
         raise ArgumentError.new if args.size <= 0
-        new_without_mock_time *args
+        new_without_mock_time(*args)
       rescue ArgumentError
         now
       end
@@ -36,21 +32,17 @@ end
 if Object.const_defined?(:Date) && Date.respond_to?(:today)
   class Date #:nodoc:
     class << self
-      # Date we are behaving as
       def mock_date
         mocked_time_stack_item = Timecop.top_stack_item
         mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.date(self)
       end
       
-      # Alias the original today
       alias_method :today_without_mock_date, :today
     
-      # Define today_with_mock_date
       def today_with_mock_date
         mock_date || today_without_mock_date
       end
     
-      # Alias today to today_with_mock_date
       alias_method :today, :today_with_mock_date
     end
   end
@@ -59,27 +51,31 @@ end
 if Object.const_defined?(:DateTime) && DateTime.respond_to?(:now)
   class DateTime #:nodoc:
     class << self
-      # Time we are behaving as
       def mock_time
         mocked_time_stack_item = Timecop.top_stack_item
         mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.datetime(self)
       end
       
-      # Fake alias :now_without_mock_time :now
-      # It appears that the DateTime library itself references Time.now
-      # for it's interpretation of now which caused 
-      # DateTime.now_without_mock_time to incorrectly return the frozen time.
       def now_without_mock_time
-        Time.now_without_mock_time.send :to_datetime
+        Time.now_without_mock_time.to_datetime
       end
       
-      # Define now_with_mock_time
       def now_with_mock_time
         mock_time || now_without_mock_time
       end
 
-      # Alias now to now_with_mock_time
       alias_method :now, :now_with_mock_time
     end
   end
+
+  # for ruby1.8
+  unless Time::public_instance_methods.include? :to_datetime
+    class DateTime
+      class << self
+        def now_without_mock_time
+          Time.now_without_mock_time.send(:to_datetime)
+        end
+      end
+    end
+  end
 end

data/lib/timecop/time_stack_item.rb

@@ -1,92 +1,110 @@
-
 class Timecop
-  # A data class for carrying around "time movement" objects.  Makes it easy to keep track of the time
-  # movements on a simple stack.
-  class TimeStackItem #:nodoc:
-  
-    attr_reader :mock_type
-    def initialize(mock_type, *args)
-      raise "Unknown mock_type #{mock_type}" unless [:freeze, :travel].include?(mock_type)
-      @mock_type      = mock_type
-      @time           = parse_time(*args)
-      @travel_offset  = compute_travel_offset
-      @dst_adjustment = compute_dst_adjustment(@time)
-    end
-    
-    def year
-      time.year
-    end
-    
-    def month
-      time.month
-    end
-    
-    def day
-      time.day
-    end
-    
-    def hour
-      time.hour
-    end
-    
-    def min
-      time.min
-    end
-    
-    def sec
-      time.sec
-    end
-    
-    def utc_offset
-      time.utc_offset
-    end
-    
-    def travel_offset
-      @travel_offset
-    end
-    
-    def time(time_klass=Time) #:nodoc:
-      if travel_offset.nil?
-        time_klass.at( @time.to_f )
-      else
-        time_klass.at( ( Time.now_without_mock_time + travel_offset ).to_f )
+    # A data class for carrying around "time movement" objects.  Makes it easy to keep track of the time
+    # movements on a simple stack.
+    class TimeStackItem #:nodoc:
+      attr_reader :mock_type
+
+      def initialize(mock_type, *args)
+        raise "Unknown mock_type #{mock_type}" unless [:freeze, :travel, :scale].include?(mock_type)
+        @scaling_factor = args.shift if mock_type == :scale
+        @mock_type      = mock_type
+        @time           = parse_time(*args)
+        @time_was       = Time.now_without_mock_time
+        @travel_offset  = compute_travel_offset
+        @dst_adjustment = compute_dst_adjustment(@time)
       end
-    end
-    
-    def date(date_klass=Date)
-      date_klass.jd(time.__send__(:to_date).jd)
-    end
-    
-    def datetime(datetime_klass=DateTime)
-      # DateTime doesn't know about DST, so let's remove its presence
-      our_offset = utc_offset + dst_adjustment
-      if Float.method_defined?(:to_r)
-        fractions_of_a_second = time.to_f % 1
-        datetime_klass.new(year, month, day, hour, min, sec + fractions_of_a_second,
-                           utc_offset_to_rational(our_offset))
-      else
+
+      def year
+        time.year
+      end
+
+      def month
+        time.month
+      end
+
+      def day
+        time.day
+      end
+
+      def hour
+        time.hour
+      end
+
+      def min
+        time.min
+      end
+
+      def sec
+        time.sec
+      end
+
+      def utc_offset
+        time.utc_offset
+      end
+
+      def travel_offset
+        @travel_offset
+      end
+
+      def scaling_factor
+        @scaling_factor
+      end
+
+      def time(klass = time_klass) #:nodoc:
+        begin
+          actual_time = klass.at(@time)
+          calculated_time = klass.at(@time.to_f)
+          time = times_are_equal_within_epsilon(actual_time, calculated_time, 1) ? actual_time : calculated_time
+        rescue
+          time = klass.at(@time.to_f)
+        end
+
+        if travel_offset.nil?
+          time
+        elsif scaling_factor.nil?
+          klass.at(Time.now_without_mock_time + travel_offset)
+        else
+          klass.at(scaled_time)
+        end
+      end
+
+      def scaled_time
+        (@time + (Time.now_without_mock_time - @time_was) * scaling_factor).to_f
+      end
+
+      def date(date_klass = Date)
+        date_klass.jd(time.__send__(:to_date).jd)
+      end
+
+      def datetime(datetime_klass = DateTime)
         our_offset = utc_offset + dst_adjustment
-        datetime_klass.new(year, month, day, hour, min, sec, utc_offset_to_rational(our_offset))
+
+        if Float.method_defined?(:to_r)
+          fractions_of_a_second = time.to_f % 1
+          datetime_klass.new(year, month, day, hour, min, sec + fractions_of_a_second, utc_offset_to_rational(our_offset))
+        else
+          our_offset = utc_offset + dst_adjustment
+          datetime_klass.new(year, month, day, hour, min, sec, utc_offset_to_rational(our_offset))
+        end
       end
-    end
-    
-    def dst_adjustment
-      @dst_adjustment
-    end
-    
-    private
+
+      def dst_adjustment
+        @dst_adjustment
+      end
+
+      private
+
       def rational_to_utc_offset(rational)
         ((24.0 / rational.denominator) * rational.numerator) * (60 * 60)
       end
-      
+
       def utc_offset_to_rational(utc_offset)
         Rational(utc_offset, 24 * 60 * 60)
       end
-      
+
       def parse_time(*args)
-        time_klass = Time.respond_to?(:zone) && Time.zone ? Time.zone : Time
         arg = args.shift
-        if arg.is_a?(Time) 
+        if arg.is_a?(Time)
           if Timecop.active_support != false && arg.respond_to?(:in_time_zone)
             arg.in_time_zone
           else
@@ -117,17 +135,24 @@ class Timecop
           end
         end
       end
-      
+
       def compute_dst_adjustment(time)
         return 0 if !(time.dst? ^ Time.now.dst?)
         return -1 * 60 * 60 if time.dst?
         return 60 * 60
       end
-      
+
       def compute_travel_offset
         return nil if mock_type == :freeze
         time - Time.now_without_mock_time
       end
-      
+
+      def times_are_equal_within_epsilon t1, t2, epsilon_in_seconds
+        (t1 - t2).abs < epsilon_in_seconds
+      end
+
+      def time_klass
+        Time.respond_to?(:zone) ? Time.zone : Time
+      end
+    end
   end
-end

data/lib/timecop/timecop.rb

@@ -1,6 +1,6 @@
 require 'singleton'
-require 'timecop/time_extensions'
-require 'timecop/time_stack_item'
+require File.join(File.dirname(__FILE__), "time_extensions")
+require File.join(File.dirname(__FILE__), "time_stack_item")
 
 # Timecop
 # * Wrapper class for manipulating the extensions to the Time, Date, and DateTime objects
@@ -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,74 +58,103 @@ 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)
+      send_travel(:travel, *args, &block)
+    end
 
-      block_given? ? val : nil
+    # Allows you to run a block of code and "scale" a time throughout the execution of that block.
+    # The first argument is a scaling factor, for example:
+    #   Timecop.scale(2) do
+    #     ... time will 'go' twice as fast here
+    #   end
+    # See Timecop#freeze for exact usage of the other arguments
+    #
+    # Returns the value of the block if one is given, or the mocked time.
+    def scale(*args, &block)
+      send_travel(:scale, *args, &block)
     end
 
     def baseline
-      instance().send(:baseline)
+      instance.send(:baseline)
     end
 
     def baseline=(baseline)
-      instance().send(:baseline=, baseline)
+      instance.send(: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.send(:return, &block)
+      else
+        instance.send(:unmock!)
+        nil
+      end
     end
 
     def return_to_baseline
-      instance().send(:return_to_baseline)
+      instance.send(:return_to_baseline)
       Time.now
     end
 
     def top_stack_item #:nodoc:
-      instance().instance_variable_get(:@_stack).last
+      instance.instance_variable_get(:@_stack).last
+    end
+
+    private
+    def send_travel(mock_type, *args, &block)
+      val = instance.send(:travel, mock_type, *args, &block)
+      block_given? ? val : Time.now
     end
   end
 
-  protected
+  private
 
-    def baseline=(baseline)
-      @baseline = baseline
-      @_stack << TimeStackItem.new(:travel, baseline)
-    end
+  def baseline=(baseline)
+    @baseline = baseline
+    @_stack << TimeStackItem.new(:travel, baseline)
+  end
 
-    def initialize #:nodoc:
-      @_stack = []
-    end
+  def initialize #:nodoc:
+    @_stack = []
+  end
 
-    def travel(mock_type, *args, &block) #:nodoc:
-      stack_item = TimeStackItem.new(mock_type, *args)
+  def travel(mock_type, *args, &block) #:nodoc:
+    stack_item = TimeStackItem.new(mock_type, *args)
 
-      # store this time traveling on our stack...
-      @_stack << stack_item
+    @_stack << stack_item
 
-      if block_given?
-        begin
-          yield stack_item.time
-        ensure
-          # pull it off the stack...
-          @_stack.pop
-        end
+    if block_given?
+      begin
+        yield stack_item.time
+      ensure
+        @_stack.pop
       end
     end
+  end
 
-    def unmock! #:nodoc:
-      @baseline = nil
-      @_stack = []
-    end
+  def return(&block)
+    current_stack = @_stack
+    current_baseline = @baseline
+    unmock!
+    yield
+    @_stack = current_stack
+    @baseline = current_baseline
+  end
 
-    def return_to_baseline
-      if @baseline
-        @_stack = [@_stack.shift]
-      else
-        unmock!
-      end
+  def unmock! #:nodoc:
+    @baseline = nil
+    @_stack = []
+  end
+
+  def return_to_baseline
+    if @baseline
+      @_stack = [@_stack.shift]
+    else
+      unmock!
     end
+  end
 end

data/lib/timecop/version.rb

@@ -1,3 +1,3 @@
 class Timecop
-  VERSION = "0.5.1"
-end
+  VERSION = "0.6.0"
+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,7 +1,11 @@
 require 'rubygems'
 require 'bundler/setup'
 require 'test/unit'
-require 'mocha'
+begin
+  require 'mocha/setup'
+rescue LoadError
+  require 'mocha'
+end
 
 class Test::Unit::TestCase
 

data/test/time_stack_item_test.rb

@@ -1,18 +1,18 @@
 require 'date'
-require 'test_helper'
+require File.join(File.dirname(__FILE__), "test_helper")
 require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
 
 class TestTimeStackItem < Test::Unit::TestCase
-  
   def teardown
     Timecop.active_support = nil
     Timecop.return
   end
-  
+
   def test_new_with_time
     t = Time.now
     y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
     stack_item = Timecop::TimeStackItem.new(:freeze, t)
+
     assert_equal y,   stack_item.year
     assert_equal m,   stack_item.month
     assert_equal d,   stack_item.day
@@ -25,6 +25,7 @@ class TestTimeStackItem < Test::Unit::TestCase
     t = Time.new(2012, 7, 28, 20, 0)
     y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
     stack_item = Timecop::TimeStackItem.new(:freeze, t)
+
     assert_equal y,   stack_item.year
     assert_equal m,   stack_item.month
     assert_equal d,   stack_item.day
@@ -32,11 +33,12 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal min, stack_item.min
     assert_equal s,   stack_item.sec
   end
-  
+
   def test_new_with_datetime_now
     t = DateTime.now
     y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
     stack_item = Timecop::TimeStackItem.new(:freeze, t)
+
     assert_equal y,   stack_item.year
     assert_equal m,   stack_item.month
     assert_equal d,   stack_item.day
@@ -44,19 +46,21 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal min, stack_item.min
     assert_equal s,   stack_item.sec
   end
-  
+
   def test_new_with_datetime_in_different_timezone
     each_timezone do
       t = DateTime.parse("2009-10-11 00:38:00 +0200")
       stack_item = Timecop::TimeStackItem.new(:freeze, t)
+
       assert_date_times_equal(t, stack_item.datetime)
     end
   end
-  
+
   def test_new_with_date
     date = Date.today
     y, m, d, h, min, s = date.year, date.month, date.day, 0, 0, 0
     stack_item = Timecop::TimeStackItem.new(:freeze, date)
+
     assert_equal y,   stack_item.year
     assert_equal m,   stack_item.month
     assert_equal d,   stack_item.day
@@ -64,7 +68,7 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal min, stack_item.min
     assert_equal s,   stack_item.sec
   end
-  
+
   # Due to the nature of this test (calling Time.now once in this test and
   # once in #new), this test may fail when two subsequent calls
   # to Time.now return a different second.
@@ -72,6 +76,7 @@ class TestTimeStackItem < Test::Unit::TestCase
     t = Time.now
     y, m, d, h, min, s = t.year, t.month, t.day, t.hour, t.min, t.sec
     stack_item = Timecop::TimeStackItem.new(:freeze, 0)
+
     assert_equal y,   stack_item.year
     assert_equal m,   stack_item.month
     assert_equal d,   stack_item.day
@@ -79,10 +84,11 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal min, stack_item.min
     assert_equal s,   stack_item.sec
   end
-  
+
   def test_new_with_individual_arguments
     y, m, d, h, min, s = 2008, 10, 10, 10, 10, 10
     stack_item = Timecop::TimeStackItem.new(:freeze, y, m, d, h, min, s)
+
     assert_equal y,   stack_item.year
     assert_equal m,   stack_item.month
     assert_equal d,   stack_item.day
@@ -90,88 +96,122 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal min, stack_item.min
     assert_equal s,   stack_item.sec
   end
-  
+
   def test_rational_to_utc_offset
     assert_equal -14400, a_time_stack_item.send(:rational_to_utc_offset, Rational(-1, 6))
     assert_equal -18000, a_time_stack_item.send(:rational_to_utc_offset, Rational(-5, 24))
     assert_equal 0,      a_time_stack_item.send(:rational_to_utc_offset, Rational(0, 1))
     assert_equal 3600,   a_time_stack_item.send(:rational_to_utc_offset, Rational(1, 24))
   end
-  
+
   def test_utc_offset_to_rational
     assert_equal Rational(-1, 6),  a_time_stack_item.send(:utc_offset_to_rational, -14400)
     assert_equal Rational(-5, 24), a_time_stack_item.send(:utc_offset_to_rational, -18000)
     assert_equal Rational(0, 1),   a_time_stack_item.send(:utc_offset_to_rational, 0)
     assert_equal Rational(1, 24),  a_time_stack_item.send(:utc_offset_to_rational, 3600)
   end
-  
-  # Ensure DST adjustment is calculated properly for DateTime's
+
   def test_compute_dst_adjustment_for_dst_to_dst
     Timecop.freeze(DateTime.parse("2009-10-1 00:38:00 -0400"))
     t = DateTime.parse("2009-10-11 00:00:00 -0400")
     tsi = Timecop::TimeStackItem.new(:freeze, t)
     return if !(Time.now.dst? && tsi.time.dst?)
+
     assert_equal 0, tsi.send(:dst_adjustment)
   end
-  
+
   def test_compute_dst_adjustment_for_non_dst_to_non_dst
     Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0400"))
     t = DateTime.parse("2009-12-11 00:00:00 -0400")
     tsi = Timecop::TimeStackItem.new(:freeze, t)
     return if Time.now.dst? || tsi.time.dst?
-    assert_equal 0, tsi.send(:dst_adjustment)    
+
+    assert_equal 0, tsi.send(:dst_adjustment)
   end
-  
+
   def test_compute_dst_adjustment_for_dst_to_non_dst
     Timecop.freeze(DateTime.parse("2009-10-1 00:38:00 -0400"))
     t = DateTime.parse("2009-12-11 00:00:00 -0400")
     tsi = Timecop::TimeStackItem.new(:freeze, t)
     return if !Time.now.dst? || tsi.time.dst?
+
     assert_equal 60 * 60, tsi.send(:dst_adjustment)
   end
-  
+
   def test_compute_dst_adjustment_for_non_dst_to_dst
     Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0400"))
     t = DateTime.parse("2009-10-11 00:00:00 -0400")
     tsi = Timecop::TimeStackItem.new(:freeze, t)
     return if Time.now.dst? || !tsi.time.dst?
+
     assert_equal -1 * 60 * 60, tsi.send(:dst_adjustment)
   end
-  
+
   # Ensure DateTimes handle changing DST properly
   def test_datetime_for_dst_to_non_dst
     Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0500"))
     t = DateTime.parse("2009-10-11 00:00:00 -0400")
     tsi = Timecop::TimeStackItem.new(:freeze, t)
+
     assert_date_times_equal t, tsi.datetime
   end
-  
+
   def test_datetime_for_non_dst_to_dst
     Timecop.freeze(DateTime.parse("2009-10-11 00:00:00 -0400"))
     t = DateTime.parse("2009-11-30 23:38:00 -0500")
     tsi = Timecop::TimeStackItem.new(:freeze, t)
     return if !tsi.time.dst?
+
     assert_date_times_equal t, tsi.datetime
     assert_equal Date.new(2009, 12, 1), tsi.date
   end
-  
-  # Ensure @travel_offset is set properly
+
   def test_set_travel_offset_for_travel
-    # Timecop.freeze(2009, 10, 1, 0, 0, 0)
     t_now = Time.now
     t = Time.local(2009, 10, 1, 0, 0, 30)
     expected_offset = t - t_now
     tsi = Timecop::TimeStackItem.new(:travel, t)
+
     assert_times_effectively_equal expected_offset, tsi.send(:travel_offset), 1, "Offset not calculated correctly"
   end
-  
+
   def test_set_travel_offset_for_freeze
     Timecop.freeze(2009, 10, 1, 0, 0, 0)
     t = Time.local(2009, 10, 1, 0, 0, 30)
     tsi = Timecop::TimeStackItem.new(:freeze, t)
+
     assert_equal nil, tsi.send(:travel_offset)
   end
 
+  def test_timezones
+    require 'active_support/all'
+    Time.zone = "Europe/Zurich"
+    time = Time.zone.parse("2012-12-27T12:12:12+08:00")
+    Timecop.freeze(time) do |frozen_time|
+      assert_equal time, frozen_time
+    end
+  end
+
+  def test_timezones_apply_dates
+    require 'active_support/all'
+    Time.zone = "Marshall Is."
+    time = Time.zone.local(2013,1,3)
+
+    Timecop.freeze(time) do
+      assert_equal time.to_date, Date.today
+    end
+  end
+
+  def test_set_scaling_factor_for_scale
+    t_now = Time.now
+    t = Time.local(2009, 10, 1, 0, 0, 30)
+    expected_offset = t - t_now
+    tsi = Timecop::TimeStackItem.new(:scale, 4, t)
+
+    assert_times_effectively_equal expected_offset, tsi.send(:travel_offset), 1, "Offset not calculated correctly"
+    assert_equal tsi.send(:scaling_factor), 4, "Scaling factor not set"
+  end
+
   def test_parse_string_date_with_active_support
     date = '2012-01-02'
     Time.expects(:parse).with(date).returns(Time.local(2012, 01, 02))
@@ -207,4 +247,21 @@ class TestTimeStackItem < Test::Unit::TestCase
       Timecop.freeze(Date.new(2012, 6, 9))
     end
   end
+
+  def test_nsecs_are_set
+    time = Time.now
+    Timecop.freeze time
+    assert_equal time, Time.now
+    assert_equal time.nsec, Time.now.nsec if (Time.now.respond_to?(:nsec))
+  end
+
+  def test_time_with_different_timezone
+    require 'active_support/all'
+
+    Time.zone = "Tokyo"
+    t = Time.now
+    Timecop.freeze(t) do
+      assert_times_effectively_equal t, Time.now
+    end
+  end
 end

data/test/timecop_test.rb

@@ -1,27 +1,22 @@
 require 'date'
-require 'test_helper'
+require File.join(File.dirname(__FILE__), "test_helper")
 require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
 
 class TestTimecop < Test::Unit::TestCase
-
-  def setup
-
-  end
-
-  # just in case...let's really make sure that Timecop is disabled between tests...
   def teardown
     Timecop.return
   end
 
   def test_freeze_changes_and_resets_time
-    # depending on how we're invoked (individually or via the rake test suite)
     assert !Time.respond_to?(:zone) || Time.zone.nil?
 
     t = Time.local(2008, 10, 10, 10, 10, 10)
     assert_not_equal t, Time.now
+
     Timecop.freeze(2008, 10, 10, 10, 10, 10) do
       assert_equal t, Time.now
     end
+
     assert_not_equal t, Time.now
   end
 
@@ -68,6 +63,7 @@ class TestTimecop < Test::Unit::TestCase
     custom_timeklass = Class.new(Time) do
       def custom_format_method() strftime('%F') end
     end
+
     Timecop.freeze(2008, 10, 10, 10, 10, 10) do
       assert custom_timeklass.now.is_a? custom_timeklass
       assert Time.now.eql? custom_timeklass.now
@@ -80,6 +76,7 @@ class TestTimecop < Test::Unit::TestCase
     custom_dateklass = Class.new(Date) do
       def custom_format_method() strftime('%F') end
     end
+
     Timecop.freeze(2008, 10, 10, 10, 10, 10) do
       assert custom_dateklass.today.is_a? custom_dateklass
       assert Date.today.eql? custom_dateklass.today
@@ -92,6 +89,7 @@ class TestTimecop < Test::Unit::TestCase
     custom_datetimeklass = Class.new(DateTime) do
       def custom_format_method() strftime('%F') end
     end
+
     Timecop.freeze(2008, 10, 10, 10, 10, 10) do
       assert custom_datetimeklass.now.is_a? custom_datetimeklass
       assert DateTime.now.eql? custom_datetimeklass.now
@@ -119,6 +117,7 @@ class TestTimecop < Test::Unit::TestCase
       assert_date_times_equal DateTime.new(2008, 10, 10, 10, 10, 10, local_offset), DateTime.now
       assert_equal Date.new(2008, 10, 10), Date.today
     end
+
     assert_not_equal t, Time.now
     assert_not_equal DateTime.new(2008, 10, 10, 10, 10, 10, local_offset), DateTime.now
     assert_not_equal Date.new(2008, 10, 10), Date.today
@@ -133,7 +132,6 @@ class TestTimecop < Test::Unit::TestCase
       Timecop.freeze(t) do
         assert_date_times_equal t, DateTime.now
       end
-      # Undo the original freeze
       Timecop.return
     end
   end
@@ -250,6 +248,21 @@ class TestTimecop < Test::Unit::TestCase
     end
   end
 
+  def test_scaling_keeps_time_moving_at_an_accelerated_rate
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    Timecop.scale(4, t) do
+      start = Time.now
+      assert_times_effectively_equal start, t, 1, "Looks like we failed to actually travel time"
+      sleep(0.25)
+      assert_times_effectively_equal Time.at((start + 4*0.25).to_f), Time.now, 0.25, "Looks like time is not moving at 4x"
+    end
+  end
+
+  def test_scaling_returns_now_if_no_block_given
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    assert_times_effectively_equal t, Timecop.scale(4, t)
+  end
+
   def test_freeze_with_utc_time
     each_timezone do
       t = Time.utc(2008, 10, 10, 10, 10, 10)
@@ -324,9 +337,22 @@ class TestTimecop < Test::Unit::TestCase
     assert_nil Time.send(:mock_time)
   end
 
-  def test_travel_time_returns_nil
+  def test_travel_time_returns_now_if_no_block_given
     t_future = Time.local(2030, 10, 10, 10, 10, 10)
-    assert_nil Timecop.travel(t_future)
+    assert_times_effectively_equal t_future, Timecop.travel(t_future)
+  end
+
+  def test_return_temporarily_returns_to_current_time_in_given_block
+    time_after_travel = Time.local(1990, 7, 16)
+    now = Time.now
+
+    Timecop.travel(time_after_travel)
+
+    assert_times_effectively_equal(time_after_travel, Time.now)
+    Timecop.return do
+      assert_times_effectively_equal(now, Time.now)
+    end
+    assert_times_effectively_equal(time_after_travel, Time.now)
   end
 
   def test_travel_time_with_block_returns_the_value_of_the_block
@@ -337,9 +363,9 @@ class TestTimecop < Test::Unit::TestCase
     assert_equal expected, actual
   end
 
-  def test_freeze_time_returns_nil
+  def test_freeze_time_returns_now_if_no_block_given
     t_future = Time.local(2030, 10, 10, 10, 10, 10)
-    assert_nil Timecop.freeze(t_future)
+    assert_times_effectively_equal t_future, Timecop.freeze(t_future)
   end
 
   def test_freeze_time_with_block_returns_the_value_of_the_block
@@ -403,4 +429,10 @@ class TestTimecop < Test::Unit::TestCase
     assert_equal date, Time.now
     assert_equal date, Time.new
   end
+
+  def test_not_callable_send_travel
+    assert_raise NoMethodError do
+      Timecop.send_travel(:travel, Time.now - 100)
+    end
+  end
 end

data/test/timecop_without_date_test.rb

@@ -1,5 +1,5 @@
 
-require 'test_helper'
+require File.join(File.dirname(__FILE__), "test_helper")
 require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
 
 class TestTimecopWithoutDate < Test::Unit::TestCase

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-05 00:00:00.000000000 Z
+date: 2013-03-08 00:00:00.000000000 Z
 dependencies: []
 description: A gem providing "time travel" and "time freezing" capabilities, making
   it dead simple to test time-dependent code.  It provides a unified method to mock
@@ -22,7 +22,6 @@ extra_rdoc_files:
 - LICENSE
 - README.markdown
 files:
-- History.rdoc
 - LICENSE
 - README.markdown
 - Rakefile
@@ -37,8 +36,9 @@ files:
 - test/timecop_test.rb
 - test/timecop_without_date_test.rb
 - test/timecop_without_date_but_with_time_test.rb
-homepage: http://github.com/jtrupiano/timecop
-licenses: []
+homepage: https://github.com/travisjeffery/timecop
+licenses:
+- MIT
 post_install_message: 
 rdoc_options:
 - --charset=UTF-8
@@ -57,8 +57,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: johntrupiano
-rubygems_version: 1.8.10
+rubyforge_project: timecop
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: A gem providing "time travel" and "time freezing" capabilities, making it

data/History.rdoc

@@ -1,132 +0,0 @@
-=== 0.5.0 / 2012-09-12
-
-* Maintenance
-  * Timecop#travel, Timecop#freeze blocks return nil or block value
-
-=== 0.4.6 / 2012-09-05
-
-* Maintenance
-  * Fix rounding support for Ruby < 1.9
-
-=== 0.4.5 / 2012-08-09
-
-* Maintenance
-  * Subclasses of Time/Date/DateTime now return proper instances
-
-=== 0.4.4 / 2012-07-29
-
-* Maintenance
-  * Can now configure Timecop to not use ActiveSupport by setting Timecop.active_support = false
-
-=== 0.4.3 / 2012-07-27
-
-* Maintenance
-  * Fix alias of Time#new/Time#now when Time#new given with args
-
-=== 0.4.2 / 2012-07-27
-
-* Maintenance
-  * Mock Time#new the same as Time#now since they're synonyms
-  * Set default arg in parsing to 2000
-  * Time.freeze defaults to Time#now
-  * Use Time#parse is available to parse Time's given as strings
-  * Add ActiveSupport Time.zone support
-  * Stop DateTime from losing precision after traveling
-
-=== 0.3.5 / 2010-06-07
-
-* Maintenance
-  * Return a cloned time instance in order to support the destructive methods #gmt, #utc and #localtime
-  * Don't use full path requires where unnecessary
-
-=== 0.3.4 / 2009-12-07
-
-* Maintenance
-  * Fix various timezone-related issues.  Notably, when traveling to a DateTime
-    instance specified in a non-local timezone, convert provided DateTime 
-    instance to a local instance and return that from DateTime.now.
-    Code contributed by Michaël Witrant [piglop]
-  * Fix bug that would not allow Timecop to be used when Ruby's 'date'
-    library had not been previously loaded.
-    Code contributed by Tuomas Kareinen [tuomas]
-  * Fix bug when traveling to a DateTime across a DST boundary that
-    resulted in DateTime's being off by an hour.
-  * Migrate argument parsing into Timecop::TimeStackItem to reduce the
-    responsibility of the Timecop class.
-
-=== 0.3.3  2009-10-30
-
-* Revoked due to regression.
-
-=== 0.3.2 / 2009-10-24
-
-* Revoked due to regression.
-    
-=== 0.3.1 / 2009-09-30
-
-* Maintenance
-  * DRY up the Timecop class internals.
-
-=== 0.3.0 / 2009-09-20
-
-* API
-  * Completely remove Timecop#unset_all (deprecated by Timecop#return in 0.2.0)
-  * Return Time.now from #freeze, #travel and #return  -- code contributed by Keith Bennett [keithrbennett]
-
-* Maintenance
-  * Fix bug that left Time#mock_time set in some instances
-  * Upped build dependency to jeweler ~> 1.2.1
-  * Don't pollute top-level namespace with classes/constants
-
-* Documentation
-  * Clearer examples in the README, better description in the gemspec
-  * Improve RDoc
-
-=== 0.2.1 / 2009-03-06
-* API Changes
-  
-  * Introduced a 5th style of arguments to be passed into #travel and #freeze.  Now, if you pass in a single integer value,
-    it will be interpreted as a relative offset in seconds from the current Time.now.  Previously this was interpreted as
-    only the year, similar to calling Time.local(2008) --> Jan. 1, 2008.  This is no longer the case.
-    
-* Documentation
-
-  * Moved to Textile for the README.
-  
-  * Added documentation for the new feature, and fixed a few typos.
-
-=== 0.2.0 / 2008-12-23
-
-* API Changes
-
-  * Timecop#travel no longer freezes time.  Rather, it computes the current offset between the new "now" and the real "now", and
-    returns times as if Time had continued to move forward
-    
-  * Timecop#freeze now behaves exactly as the old Timecop#travel behaved.  Unless you depended on the actual freezing of time
-    (which I think would be rare), you should be able to continue to use #travel without worry.
-    
-  * Timecop#return is now exposed (previously Timecop#unset_all, but not well advertised).  It will completely unmock time,
-    and will probably be rarely used outside of the actual implementation of this library.
-    
-* More Test Coverage
-
-  * Tests now explicitly cover the cases when the Date and DateTime objects are not loaded, and ensures proper functionality
-    in their absence and existence.
-    
-  * Still haven't done regression testing against anything other than a few version of 1.8.6 (including REE).  We should
-    probably try to get this tested on both 1.8.7 and 1.9.1.
-
-* Documentation
-
-  * Fixed up a lot of the poorly-formatted rdoc syntax.  The public API should now be properly published in the rdoc,
-    and the internals are omitted.
-    
-=== 0.1.0 / 2008-11-09
-
-* Initial Feature Set
-
-  * Temporarily (or permanently if you prefer) change the concept of Time.now, DateTime.now (if defined), and Date.today (if defined)
-  * Timecop#travel api allows an argument to be passed in as one of: 1) Time instance, 2) DateTime instance, 3) Date instance,
-    4) individual arguments (year, month, day, hour, minute, second)
-  * Nested calls to Timecop#travel are supported -- each block will maintain it's interpretation of now.
-