timecop 0.5.1 → 0.5.2

data/History.rdoc

@@ -1,3 +1,8 @@
+=== 0.5.2 / 2012-09-20
+
+* Feature
+  * Timecop#scale, ability to accelerate time by a given scaling factor
+
 === 0.5.0 / 2012-09-12
 
 * Maintenance

data/README.markdown

@@ -15,6 +15,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
@@ -75,6 +76,23 @@ 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.lens(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
+```
+
 ## REFERENCES
 
 * {0.3.4 release}[http://blog.smartlogicsolutions.com/2009/12/07/timecop-0-3-4-released/]

data/lib/timecop/time_stack_item.rb

@@ -6,9 +6,11 @@ class Timecop
   
     attr_reader :mock_type
     def initialize(mock_type, *args)
-      raise "Unknown mock_type #{mock_type}" unless [:freeze, :travel].include?(mock_type)
+      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
@@ -44,14 +46,24 @@ class Timecop
     def travel_offset
       @travel_offset
     end
+
+    def scaling_factor
+      @scaling_factor
+    end
     
     def time(time_klass=Time) #:nodoc:
       if travel_offset.nil?
         time_klass.at( @time.to_f )
-      else
+      elsif scaling_factor.nil?
         time_klass.at( ( Time.now_without_mock_time + travel_offset ).to_f )
+      else
+        time_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)

data/lib/timecop/timecop.rb

@@ -67,6 +67,20 @@ class Timecop
       block_given? ? val : nil
     end
 
+    # 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 or nil.
+    def scale(*args, &block)
+      val = instance().send(:travel, :scale, *args, &block)
+
+      block_given? ? val : nil
+    end
+
     def baseline
       instance().send(:baseline)
     end

data/lib/timecop/version.rb

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

data/test/time_stack_item_test.rb

@@ -172,6 +172,15 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal nil, tsi.send(:travel_offset)
   end
 
+  def test_set_scaling_factor_for_lens
+    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))

data/test/timecop_test.rb

@@ -250,6 +250,16 @@ class TestTimecop < Test::Unit::TestCase
     end
   end
 
+  def test_lensing_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_freeze_with_utc_time
     each_timezone do
       t = Time.utc(2008, 10, 10, 10, 10, 10)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-05 00:00:00.000000000 Z
+date: 2012-09-20 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
@@ -50,6 +50,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1525074573276164628
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: