timecop 0.6.1 → 0.6.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 50d8a097f64ecc69c2fd97409fd484d4ae24ea32
+  data.tar.gz: 2331d9650b9cbcc142d4dbddf9a93c615bf18e1d
+SHA512:
+  metadata.gz: fe7d7dc16fa00728272702b53e7fb8dc9bc1736e43085696a20f3bd381941704d9112639e1c3623278bdf0709986361664777d1efb97a9e34961ff9f14d33dc1
+  data.tar.gz: e03aec0f8836e109a6d399e3a983757b35a31c701944396ac0a4154d2ba08be333c032af7af42836b6c3746cb3af09cfde30b0899ca0b39d8d3bea04c3b18989

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
@@ -113,17 +113,10 @@ Time.now
 
 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/]
-* {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/]
-
 ## 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.
 
@@ -136,3 +129,4 @@ Here's the most direct way to get your work merged into the project.
 - Push the branch up to your fork
 - Send a pull request for your branch
 
+

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:
@@ -125,13 +123,14 @@ class Timecop
   def travel(mock_type, *args, &block) #:nodoc:
     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

data/lib/timecop/version.rb

@@ -1,3 +1,3 @@
 class Timecop
-  VERSION = "0.6.1"
+  VERSION = "0.6.2.2"
 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,22 @@ 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
+
 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.2.2
 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-07-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
@@ -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