timecop 0.6.1 → 0.6.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 28306a2c78d6588f97b394b65bba1163a9a1cf4a
+  data.tar.gz: c2323a791bb954e70a70b9595cb56135e54ff64d
+SHA512:
+  metadata.gz: 5e445072106712764a97139527912b59ec29cb0e4a97b4a1203dd8c5d72aebea0788935ca56fec863285cb2d764f3312ad604f1d311fa51fcd4ea07a9bd4c8d8
+  data.tar.gz: 6f690a4c4d944c7f3df343616bb4e78c707e0efaf8b9c102d71da2a72029bffb0d26dcd64dea856e59183c04cc98d5c0c5d5c7549892338dc823ba3d963968cc

data/README.markdown

@@ -11,7 +11,7 @@ A gem providing "time travel" and "time freezing" capabilities, making it dead s
 
 ## INSTALL
 
-  gem install timecop
+`gem install timecop`
 
 ## FEATURES
 
@@ -49,7 +49,7 @@ describe "some set of tests to mock" do
   before do
     Timecop.freeze(Time.local(1990))
   end
-  
+
   after do
     Timecop.return
   end
@@ -62,7 +62,7 @@ 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
 appropriate (within your tests)
-  
+
 in config/environments/test.rb
 
 ```ruby
@@ -111,19 +111,30 @@ Time.now
 # => 2012-09-21 06:22:59 -0500
 ```
 
-See #42 for more information, thanks to Ken Mayer, David Holcomb, and Pivotal Labs.
+<<<<<<< HEAD
+### Timecop.safe_mode
+
+Safe mode forces you to use Timecop with the block syntax since it always puts time back the way it was. If you are running in safe mode and use Timecop without the block syntax `Timecop::SafeModeException` will be raised to tell the user they are not being safe.
 
-## REFERENCES
+``` ruby
+# turn on safe mode
+Timecop.safe_mode = true
+
+# check if you are in safe mode
+Timecop.safe_mode?
+# => true
+
+# using method without block
+Timecop.freeze
+# => Timecop::SafeModeException: Safe mode is enabled, only calls passing a block are allowed.
+```
 
-* {0.3.4 release}[http://blog.smartlogicsolutions.com/2009/12/07/timecop-0-3-4-released/]
-* {0.3.0 release}[http://blog.smartlogicsolutions.com/2009/09/20/timecop-0-3-0-released/]
-* {0.2.0 release}[http://blog.smartlogicsolutions.com/2008/12/24/timecop-2-released-freeze-and-rebase-time-ruby/]
-* {0.1.0 release}[http://blog.smartlogicsolutions.com/2008/11/19/timecop-freeze-time-in-ruby-for-better-testing/]
+See [#42](https://github.com/travisjeffery/timecop/pull/42) for more information, thanks to Ken Mayer, David Holcomb, and Pivotal Labs.
 
 ## Contribute
 
 timecop is maintained by [travisjeffery](http://github.com/travisjeffery), and
-was created by [jtrupiano](https://github.com/jtrupiano). 
+was created by [jtrupiano](https://github.com/jtrupiano).
 
 Here's the most direct way to get your work merged into the project.
 

data/Rakefile

@@ -20,8 +20,8 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-task :test do 
-  system "cd test && ./run_tests.sh"
+task :test do
+  system "cd test && ./run_tests.sh" or fail
 end
 
 desc 'Default: run tests'

data/lib/timecop/time_extensions.rb

@@ -1,3 +1,4 @@
+require 'date'
 
 class Time #:nodoc:
   class << self
@@ -5,77 +6,57 @@ class Time #:nodoc:
       mocked_time_stack_item = Timecop.top_stack_item
       mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.time(self)
     end
-    
+
     alias_method :now_without_mock_time, :now
 
     def now_with_mock_time
       mock_time || now_without_mock_time
     end
-    
+
     alias_method :now, :now_with_mock_time
 
     alias_method :new_without_mock_time, :new
 
     def new_with_mock_time(*args)
-      begin
-        raise ArgumentError.new if args.size <= 0
-        new_without_mock_time(*args)
-      rescue ArgumentError
-        now
-      end
+      args.size <= 0 ? now : new_without_mock_time(*args)
     end
 
     alias_method :new, :new_with_mock_time
   end
-end 
+end
 
-if Object.const_defined?(:Date) && Date.respond_to?(:today)
-  class Date #:nodoc:
-    class << self
-      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_method :today_without_mock_date, :today
-    
-      def today_with_mock_date
-        mock_date || today_without_mock_date
-      end
-    
-      alias_method :today, :today_with_mock_date
+class Date #:nodoc:
+  class << self
+    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_method :today_without_mock_date, :today
+
+    def today_with_mock_date
+      mock_date || today_without_mock_date
+    end
+
+    alias_method :today, :today_with_mock_date
   end
 end
 
-if Object.const_defined?(:DateTime) && DateTime.respond_to?(:now)
-  class DateTime #:nodoc:
-    class << self
-      def mock_time
-        mocked_time_stack_item = Timecop.top_stack_item
-        mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.datetime(self)
-      end
-      
-      def now_without_mock_time
-        Time.now_without_mock_time.to_datetime
-      end
-      
-      def now_with_mock_time
-        mock_time || now_without_mock_time
-      end
+class DateTime #:nodoc:
+  class << self
+    def mock_time
+      mocked_time_stack_item = Timecop.top_stack_item
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.datetime(self)
+    end
 
-      alias_method :now, :now_with_mock_time
+    def now_without_mock_time
+      Time.now_without_mock_time.to_datetime
     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
+    def now_with_mock_time
+      mock_time || now_without_mock_time
     end
+
+    alias_method :now, :now_with_mock_time
   end
 end

data/lib/timecop/time_stack_item.rb

@@ -11,7 +11,6 @@ class Timecop
         @time           = parse_time(*args)
         @time_was       = Time.now_without_mock_time
         @travel_offset  = compute_travel_offset
-        @dst_adjustment = compute_dst_adjustment(@time)
       end
 
       def year
@@ -50,21 +49,19 @@ class Timecop
         @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)
+      def time(time_klass = Time) #:nodoc:
+        if @time.respond_to?(:in_time_zone)
+          time = time_klass.at(@time.utc.to_r)
+        else
+          time = time_klass.at(@time)
         end
 
         if travel_offset.nil?
           time
         elsif scaling_factor.nil?
-          klass.at(Time.now_without_mock_time + travel_offset)
+          time_klass.at((Time.now_without_mock_time + travel_offset).to_f)
         else
-          klass.at(scaled_time)
+          time_klass.at(scaled_time)
         end
       end
 
@@ -77,21 +74,18 @@ class Timecop
       end
 
       def datetime(datetime_klass = DateTime)
-        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))
+          if !sec.zero?
+            fractions_of_a_second = time.to_f % 1
+            datetime_klass.new(year, month, day, hour, min, (fractions_of_a_second + sec), utc_offset_to_rational(utc_offset))
+          else 
+            datetime_klass.new(year, month, day, hour, min, sec, utc_offset_to_rational(utc_offset))
+          end
         else
-          our_offset = utc_offset + dst_adjustment
-          datetime_klass.new(year, month, day, hour, min, sec, utc_offset_to_rational(our_offset))
+          datetime_klass.new(year, month, day, hour, min, sec, utc_offset_to_rational(utc_offset))
         end
       end
 
-      def dst_adjustment
-        @dst_adjustment
-      end
-
       private
 
       def rational_to_utc_offset(rational)
@@ -105,15 +99,9 @@ class Timecop
       def parse_time(*args)
         arg = args.shift
         if arg.is_a?(Time)
-          if Timecop.active_support != false && arg.respond_to?(:in_time_zone)
-            arg.in_time_zone
-          else
-            arg.getlocal
-          end
+          arg
         elsif Object.const_defined?(:DateTime) && arg.is_a?(DateTime)
-          expected_time = time_klass.local(arg.year, arg.month, arg.day, arg.hour, arg.min, arg.sec)
-          expected_time += expected_time.utc_offset - rational_to_utc_offset(arg.offset)
-          expected_time + compute_dst_adjustment(expected_time)
+          time_klass.at(arg.to_time.to_f).getlocal
         elsif Object.const_defined?(:Date) && arg.is_a?(Date)
           time_klass.local(arg.year, arg.month, arg.day, 0, 0, 0)
         elsif args.empty? && arg.kind_of?(Integer)
@@ -121,7 +109,7 @@ class Timecop
         elsif arg.nil?
           Time.now
         else
-          if arg.is_a?(String) && Timecop.active_support != false && Time.respond_to?(:parse)
+          if arg.is_a?(String) && Time.respond_to?(:parse)
             Time.parse(arg)
           else
             # we'll just assume it's a list of y/m/d/h/m/s
@@ -136,12 +124,6 @@ class Timecop
         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

data/lib/timecop/timecop.rb

@@ -14,8 +14,6 @@ class Timecop
   include Singleton
 
   class << self
-    attr_accessor :active_support
-
     # 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
     # logic being tested.  For example:
@@ -104,6 +102,14 @@ class Timecop
       instance.instance_variable_get(:@_stack).last
     end
 
+    def safe_mode=(safe)
+      @safe_mode = safe
+    end
+
+    def safe_mode?
+      false || @safe_mode
+    end
+
     private
     def send_travel(mock_type, *args, &block)
       val = instance.send(:travel, mock_type, *args, &block)
@@ -123,15 +129,18 @@ class Timecop
   end
 
   def travel(mock_type, *args, &block) #:nodoc:
+    raise SafeModeException if Timecop.safe_mode? && !block_given?
+
     stack_item = TimeStackItem.new(mock_type, *args)
 
+    stack_backup = @_stack.dup
     @_stack << stack_item
 
     if block_given?
       begin
         yield stack_item.time
       ensure
-        @_stack.pop
+        @_stack.replace stack_backup
       end
     end
   end
@@ -157,4 +166,10 @@ class Timecop
       unmock!
     end
   end
+
+  class SafeModeException < StandardError
+    def initialize
+      super "Safe mode is enabled, only calls passing a block are allowed."
+    end
+  end
 end

data/lib/timecop/version.rb

@@ -1,3 +1,3 @@
 class Timecop
-  VERSION = "0.6.1"
+  VERSION = "0.6.3"
 end

data/test/run_tests.sh

@@ -1,6 +1,10 @@
 #!/bin/sh
 
+FAILEDCASES=0
 for f in *_test.rb; do
-  ${RUBY:-ruby} -I../lib:. $f 
+  if ! ${RUBY:-ruby} -I../lib:. $f; then
+      FAILEDCASES=`expr "$FAILEDCASES" + 1`
+  fi
 done
-
+echo "$FAILEDCASES test cases had failures"
+exit $FAILEDCASES

data/test/test_helper.rb

@@ -48,7 +48,7 @@ class Test::Unit::TestCase
     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
     
 end

data/test/time_stack_item_test.rb

@@ -2,10 +2,12 @@ require 'date'
 require File.join(File.dirname(__FILE__), "test_helper")
 require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
 
+require 'active_support/all'
+
 class TestTimeStackItem < Test::Unit::TestCase
   def teardown
-    Timecop.active_support = nil
     Timecop.return
+    Time.zone = nil
   end
 
   def test_new_with_time
@@ -111,49 +113,35 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal Rational(1, 24),  a_time_stack_item.send(:utc_offset_to_rational, 3600)
   end
 
-  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)
-  end
+  def test_datetime_in_presence_of_activesupport_timezone
+    skip('requires ActiveSupport') unless Time.respond_to? :zone
+    backed_up_zone, backed_up_tzvar = Time.zone, ENV['TZ']
 
-  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")
+    Time.zone = ENV['TZ'] = 'America/Los_Angeles'
+    t = DateTime.new(2001, 2, 28, 23, 59, 59.5)
     tsi = Timecop::TimeStackItem.new(:freeze, t)
-    return if !Time.now.dst? || tsi.time.dst?
 
-    assert_equal 60 * 60, tsi.send(:dst_adjustment)
+    assert_date_times_equal t, tsi.datetime
+  ensure
+    Time.zone, ENV['TZ'] = backed_up_zone, backed_up_tzvar
   end
 
-  def test_compute_dst_adjustment_for_non_dst_to_dst
-    Timecop.freeze(DateTime.parse("2009-12-1 00:38:00 -0400"))
+  # 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)
-    return if Time.now.dst? || !tsi.time.dst?
 
-    assert_equal -1 * 60 * 60, tsi.send(:dst_adjustment)
+    assert_date_times_equal t, tsi.datetime
   end
 
-  # Ensure DateTimes handle changing DST properly
-  def test_datetime_for_dst_to_non_dst
+  # Ensure DateTimes handle changing DST properly when changing from DateTime to Time
+  def test_datetime_for_dst_to_time_for_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
+    assert_date_times_equal t.to_time, tsi.time
   end
 
   def test_datetime_for_non_dst_to_dst
@@ -184,7 +172,6 @@ class TestTimeStackItem < Test::Unit::TestCase
   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|
@@ -193,12 +180,11 @@ class TestTimeStackItem < Test::Unit::TestCase
   end
 
   def test_timezones_apply_dates
-    require 'active_support/all'
-    Time.zone = "Marshall Is."
+    Time.zone = "Central Time (US & Canada)"
     time = Time.zone.local(2013,1,3)
 
     Timecop.freeze(time) do
-      assert_equal time.to_date, Date.today
+      assert_equal time.to_date, Time.now.to_date
     end
   end
 
@@ -212,36 +198,11 @@ class TestTimeStackItem < Test::Unit::TestCase
     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))
-    Timecop.freeze(date)
-  end
-
   def test_parse_only_string_with_active_support
     Time.expects(:parse).never
     Timecop.freeze(2011, 01, 02, hour=0, minute=0, second=0)
   end
 
-  def test_parse_with_active_support_off
-    date = '2012-01-02'
-    Timecop.active_support = false
-    Time.expects(:parse).never
-    Timecop.freeze(date)
-  end
-
-  def test_uses_active_supports_in_time_zone
-    time = Time.now
-    Time.any_instance.expects(:in_time_zone).returns(time)
-    Timecop::TimeStackItem.new(:freeze, time)
-  end
-
-  def test_configured_off_active_support_in_time_zone_xxx
-    Timecop.active_support = false
-    Time.any_instance.expects(:in_time_zone).never
-    Timecop::TimeStackItem.new(:freeze, Time.now)
-  end
-
   def test_parse_date
     assert_nothing_raised do
       Timecop.freeze(Date.new(2012, 6, 9))
@@ -249,8 +210,7 @@ class TestTimeStackItem < Test::Unit::TestCase
   end
 
   def test_time_zone_returns_nil
-    c = class << Time; self end
-    c.send(:define_method, :zone) { nil }
+    Time.zone = nil
     assert_nothing_raised do
       Timecop.freeze
     end
@@ -263,13 +223,51 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal time.nsec, Time.now.nsec if (Time.now.respond_to?(:nsec))
   end
 
-  def test_time_with_different_timezone
-    require 'active_support/all'
-
+  def test_time_with_different_timezone_keeps_nsec
     Time.zone = "Tokyo"
     t = Time.now
     Timecop.freeze(t) do
-      assert_times_effectively_equal t, Time.now
+      assert_equal t, Time.now
+      assert_equal t.nsec, Time.now.nsec if (Time.now.respond_to?(:nsec))
+    end
+  end
+
+  def test_time_now_always_returns_local_time
+    Time.zone = "Tokyo"
+    t = Time.utc(2000, 1, 1)
+    Timecop.freeze(t) do
+      assert_equal t.getlocal.zone, Time.now.zone
+    end
+  end
+
+  def test_time_zone_now_returns_time_in_that_zone
+    Time.zone = "Hawaii"
+    t = Time.utc(2000, 1, 1)
+    Timecop.freeze(t) do
+      assert_equal t, Time.zone.now
+      assert_equal 'HST', Time.zone.now.zone
+    end
+  end
+
+  def test_freezing_a_time_with_zone_returns_proper_zones
+    Time.zone = "Hawaii"
+    t = ActiveSupport::TimeWithZone.new(Time.utc(2000, 1, 1), ActiveSupport::TimeZone['Tokyo'])
+    Timecop.freeze(t) do
+      local_now = Time.now
+      assert_equal t, local_now
+      assert_equal t.getlocal.zone, local_now.zone
+
+      zoned_now = Time.zone.now
+      assert_equal t, zoned_now
+      assert_equal 'HST', zoned_now.zone
+    end
+  end
+
+  def test_datetime_timezones
+    dt = DateTime.new(2011,1,3,15,25,0,"-6")
+    Timecop.travel(dt) do
+      now = DateTime.now
+      assert_equal dt, now, "#{dt.to_f}, #{now.to_f}"
     end
   end
 end

data/test/timecop_test.rb

@@ -8,16 +8,22 @@ class TestTimecop < Test::Unit::TestCase
   end
 
   def test_freeze_changes_and_resets_time
-    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
+    outer_freeze_time = Time.local(2001, 01, 01)
+    inner_freeze_block = Time.local(2002, 02, 02)
+    inner_freeze_one = Time.local(2003, 03, 03)
+    inner_freeze_two = Time.local(2004, 04, 04)
+
+    Timecop.freeze(outer_freeze_time) do
+      assert_times_effectively_equal outer_freeze_time, Time.now
+      Timecop.freeze(inner_freeze_block) do
+        assert_times_effectively_equal inner_freeze_block, Time.now
+        Timecop.freeze(inner_freeze_one)
+        assert_times_effectively_equal inner_freeze_one, Time.now
+        Timecop.freeze(inner_freeze_two)
+        assert_times_effectively_equal inner_freeze_two, Time.now
+      end
+      assert_times_effectively_equal outer_freeze_time, Time.now
     end
-
-    assert_not_equal t, Time.now
   end
 
   def test_freeze_yields_mocked_time
@@ -435,4 +441,55 @@ class TestTimecop < Test::Unit::TestCase
       Timecop.send_travel(:travel, Time.now - 100)
     end
   end
+
+  def test_datetime_to_time_for_dst_to_non_dst
+    # Start at a time subject to DST
+    Timecop.travel(2009, 4, 1, 0, 0, 0, -4*60*60) do
+
+      # Then freeze, via DateTime, at a time not subject to DST
+      t = DateTime.new(2009,01,01,0,0,0, "-0500")
+      Timecop.freeze(t) do
+
+        # Check the current time via DateTime.now--should be what we asked for
+        assert_date_times_equal t, DateTime.now
+
+        # Then check the current time via Time.now (not DateTime.now)
+        assert_times_effectively_equal Time.new(2009, 1, 1, 0, 0, 0, -5*60*60), Time.now
+      end
+    end
+  end
+
+  def test_raises_when_safe_mode_and_no_block
+    with_safe_mode do
+      assert_raise Timecop::SafeModeException do
+        Timecop.freeze
+      end
+    end
+  end
+
+  def test_no_raise_when_safe_mode_and_block_used
+    with_safe_mode do
+      assert_nothing_raised do
+        Timecop.freeze {}
+      end
+    end
+  end
+
+  def test_no_raise_when_not_safe_mode_and_no_block
+    with_safe_mode(false) do
+      assert_nothing_raised do
+        Timecop.freeze
+      end
+    end
+  end
+
+  private
+
+  def with_safe_mode(enabled=true)
+    mode = Timecop.safe_mode?
+    Timecop.safe_mode = enabled
+    yield
+  ensure
+    Timecop.safe_mode = mode
+  end
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.6.1
-  prerelease: 
+  version: 0.6.3
 platform: ruby
 authors:
 - Travis Jeffery
@@ -10,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-11 00:00:00.000000000 Z
+date: 2013-08-04 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
@@ -39,26 +38,25 @@ files:
 homepage: https://github.com/travisjeffery/timecop
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options:
 - --charset=UTF-8
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: timecop
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 3
 summary: A gem providing "time travel" and "time freezing" capabilities, making it