timecop 0.3.5 → 0.5.0

data/History.rdoc

@@ -1,3 +1,38 @@
+=== 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

data/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2008
+Copyright (c) 2012 — Travis Jeffery, John Trupiano
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -0,0 +1,100 @@
+# timecop
+
+- Source[http://github.com/jtrupiano/timecop]
+- Documentation[http://johntrupiano.rubyforge.org/timecop]
+
+## 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 Time.now, Date.today, and DateTime.now in a single call.
+
+## INSTALL
+
+  gem install timecop
+
+## FEATURES
+
+- Freeze time to a specific point.
+- Travel back to a specific point in time, but allow time to continue moving forward from there.
+- 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
+  - DateTime instance
+  - Date instance
+  - individual arguments (year, month, day, hour, minute, second)
+  - a single integer argument that is interpreted as an offset in seconds from Time.now
+- Nested calls to Timecop#travel and Timecop#freeze are supported -- each block will maintain its interpretation of now.
+- Works with regular Ruby projects, and Ruby on Rails projects
+
+## USAGE
+
+Run a time-sensitive test
+
+```ruby
+joe = User.find(1)
+joe.purchase_home()
+assert !joe.mortgage_due?
+# move ahead a month and assert that the mortgage is due
+Timecop.freeze(Date.today + 30) do
+  assert joe.mortgage_due?
+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
+appropriate (within your tests)
+  
+in config/environments/test.rb
+
+```ruby
+config.after_initialize do
+  # Set Time.now to September 1, 2008 10:05:00 AM (at this instant), but allow it to move forward
+  t = Time.local(2008, 9, 1, 10, 5, 0)
+  Timecop.travel(t)
+end
+```
+
+### The difference between Timecop.freeze and Timecop.travel
+
+freeze is used to statically mock the concept of now. As your program executes,
+Time.now will not change unless you make subsequent calls into the Timecop API.
+travel, on the other hand, computes an offset between what we currently think
+Time.now is (recall that we support nested traveling) and the time passed in.
+It uses this offset to simulate the passage of time.  To demonstrate, consider
+the following code snippets:
+
+```ruby
+new_time = Time.local(2008, 9, 1, 12, 0, 0)
+Timecop.freeze(new_time)
+sleep(10)
+new_time == Time.now # ==> true
+
+Timecop.return # "turn off" Timecop
+Timecop.travel(new_time)
+sleep(10)
+new_time == Time.now # ==> false
+```
+
+## 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), who
+you can also hit up on [Twitter](http://twitter.com/travisjeffery).
+
+Here's the most direct way to get your work merged into the project.
+
+- Fork the project
+- Clone down your fork
+- Create a feature branch
+- Hack away and add tests, not necessarily in that order
+- Make sure everything still passes by running tests
+- If necessary, rebase your commits into logical chunks without errors
+- Push the branch up to your fork
+- Send a pull request for your branch
+

data/Rakefile

@@ -1,42 +1,10 @@
-require 'rake'
+require 'bundler/setup'
+require 'bundler/gem_tasks'
 require 'rake/testtask'
-require 'rake/rdoctask'
+require 'rdoc/task'
 
-gem 'jeweler', '~> 1.3.0'
+$LOAD_PATH.unshift("lib")
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "timecop"
-    s.rubyforge_project = 'johntrupiano' # if different than lowercase project name
-    s.description = %q(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 Time.now, Date.today, and DateTime.now in a single call.)
-    s.summary = s.description # More details later??
-    s.email = "jtrupiano@gmail.com"
-    s.homepage = "http://github.com/jtrupiano/timecop"
-    s.authors = ["John Trupiano"]
-    s.files =  FileList["[A-Z]*", "{bin,lib,test}/**/*"]
-  end
-  Jeweler::GemcutterTasks.new
-  Jeweler::RubyforgeTasks.new do |rubyforge|
-    rubyforge.doc_task = "rdoc"
-    rubyforge.remote_doc_path = "timecop"
-  end
-rescue LoadError
-  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
-
-# Override the test task and instruct them how to actually run the tests.
-Rake.application.send(:eval, "@tasks.delete('test')")
-desc "Does not execute tests.  Manually run shell script ./run_tests.sh to execute tests."
-task :test do
-  puts <<-MSG
-    In order to run the test suite, run: cd test && ./run_tests.sh
-    The tests need to be run with different libraries loaded, which rules out using Rake
-    to automate them.
-  MSG
-end
-
-require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|
   if File.exist?('VERSION')
     version = File.read('VERSION')
@@ -52,4 +20,9 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-task :default => :test
+task :test do 
+  system "cd test && ./run_tests.sh"
+end
+
+desc 'Default: run tests'
+task :default => [:test]

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 5
+:patch: 0
 :major: 0
-:minor: 3
+:minor: 5

data/lib/timecop/time_extensions.rb

@@ -4,7 +4,7 @@ class Time #:nodoc:
     # 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
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.time(self)
     end
     
     # Alias the original now
@@ -17,6 +17,19 @@ class Time #:nodoc:
     
     # 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
+      begin
+        raise ArgumentError.new if args.size <= 0
+        new_without_mock_time *args
+      rescue ArgumentError
+        now
+      end
+    end
+
+    alias_method :new, :new_with_mock_time
   end
 end 
 
@@ -26,7 +39,7 @@ if Object.const_defined?(:Date) && Date.respond_to?(:today)
       # 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
+        mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.date(self)
       end
       
       # Alias the original today
@@ -49,7 +62,7 @@ if Object.const_defined?(:DateTime) && DateTime.respond_to?(:now)
       # 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
+        mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.datetime(self)
       end
       
       # Fake alias :now_without_mock_time :now
@@ -69,4 +82,4 @@ if Object.const_defined?(:DateTime) && DateTime.respond_to?(:now)
       alias_method :now, :now_with_mock_time
     end
   end
-end
+end

data/lib/timecop/time_stack_item.rb

@@ -10,7 +10,7 @@ class Timecop
       @mock_type      = mock_type
       @time           = parse_time(*args)
       @travel_offset  = compute_travel_offset
-      @dst_adjustment = compute_dst_adjustment
+      @dst_adjustment = compute_dst_adjustment(@time)
     end
     
     def year
@@ -45,22 +45,29 @@ class Timecop
       @travel_offset
     end
     
-    def time #:nodoc:
+    def time(time_klass=Time) #:nodoc:
       if travel_offset.nil?
-        @time.clone
+        time_klass.at( @time.to_f )
       else
-        Time.now_without_mock_time + travel_offset
+        time_klass.at( ( Time.now_without_mock_time + travel_offset ).to_f )
       end
     end
     
-    def date
-      time.send(:to_date)
+    def date(date_klass=Date)
+      date_klass.jd(time.__send__(:to_date).jd)
     end
     
-    def datetime
+    def datetime(datetime_klass=DateTime)
       # DateTime doesn't know about DST, so let's remove its presence
       our_offset = utc_offset + dst_adjustment
-      DateTime.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
     
     def dst_adjustment
@@ -77,28 +84,42 @@ class Timecop
       end
       
       def parse_time(*args)
+        time_klass = Time
+        time_klass = Time.zone if Time.respond_to? :zone
         arg = args.shift
-        if arg.is_a?(Time)
-          arg.getlocal
+        if arg.is_a?(Time) 
+          if Timecop.active_support != false && arg.respond_to?(:in_time_zone)
+            arg.in_time_zone
+          else
+            arg.getlocal
+          end
         elsif Object.const_defined?(:DateTime) && arg.is_a?(DateTime)
-          offset_difference = Time.now.utc_offset - rational_to_utc_offset(arg.offset)
-          Time.local(arg.year, arg.month, arg.day, arg.hour, arg.min, arg.sec) + offset_difference
+          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)
         elsif Object.const_defined?(:Date) && arg.is_a?(Date)
-          Time.local(arg.year, arg.month, arg.day, 0, 0, 0)
+          time_klass.local(arg.year, arg.month, arg.day, 0, 0, 0)
         elsif args.empty? && arg.kind_of?(Integer)
           Time.now + arg
-        else # we'll just assume it's a list of y/m/d/h/m/s
-          year   = arg        || 0
-          month  = args.shift || 1
-          day    = args.shift || 1
-          hour   = args.shift || 0
-          minute = args.shift || 0
-          second = args.shift || 0
-          Time.local(year, month, day, hour, minute, second)
+        elsif arg.nil?
+          Time.now
+        else
+          if arg.is_a?(String) && Timecop.active_support != false && Time.respond_to?(:parse)
+            Time.parse(arg)
+          else
+            # we'll just assume it's a list of y/m/d/h/m/s
+            year   = arg        || 2000
+            month  = args.shift || 1
+            day    = args.shift || 1
+            hour   = args.shift || 0
+            minute = args.shift || 0
+            second = args.shift || 0
+            time_klass.local(year, month, day, hour, minute, second)
+          end
         end
       end
       
-      def compute_dst_adjustment
+      def compute_dst_adjustment(time)
         return 0 if !(time.dst? ^ Time.now.dst?)
         return -1 * 60 * 60 if time.dst?
         return 60 * 60

data/lib/timecop/timecop.rb

@@ -6,98 +6,128 @@ require 'timecop/time_stack_item'
 # * Wrapper class for manipulating the extensions to the Time, Date, and DateTime objects
 # * Allows us to "freeze" time in our Ruby applications.
 # * Optionally allows time travel to simulate a running clock, such time is not technically frozen.
-# 
-# This is very useful when your app's functionality is dependent on time (e.g. 
+#
+# This is very useful when your app's functionality is dependent on time (e.g.
 # anything that might expire).  This will allow us to alter the return value of
 # Date.today, Time.now, and DateTime.now, such that our application code _never_ has to change.
 class Timecop
   include Singleton
-  
-  # 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:
-  #
-  #   joe = User.find(1)
-  #   joe.purchase_home()
-  #   assert !joe.mortgage_due?
-  #   Timecop.freeze(2008, 10, 5) do
-  #     assert joe.mortgage_due?
-  #   end
-  #
-  # freeze and travel will respond to several different arguments:
-  # 1. Timecop.freeze(time_inst)
-  # 2. Timecop.freeze(datetime_inst)
-  # 3. Timecop.freeze(date_inst)
-  # 4. Timecop.freeze(offset_in_seconds)
-  # 5. Timecop.freeze(year, month, day, hour=0, minute=0, second=0)
-  #
-  # 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 
-  # calls to Timecop.travel and have each block maintain it's concept of "now."
-  #
-  # * Note: Timecop.freeze will actually freeze time.  This can cause unanticipated problems if
-  #   benchmark or other timing calls are executed, which implicitly expect Time to actually move
-  #   forward.
-  #
-  # * Rails Users: Be especially careful when setting this in your development environment in a 
-  #   rails project.  Generators will load your environment, including the migration generator, 
-  #   which will lead to files being generated with the timestamp set by the Timecop.freeze call 
-  #   in your dev environment
-  #
-  # Returns the frozen time.
-  def self.freeze(*args, &block)
-    instance().send(:travel, :freeze, *args, &block)
-    Time.now
-  end
-  
-  # Allows you to run a block of code and "fake" a time throughout the execution of that block.
-  # See Timecop#freeze for a sample of how to use (same exact usage syntax)
-  #
-  # * 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 'new' current Time.
-  def self.travel(*args, &block)
-    instance().send(:travel, :travel, *args, &block)
-    Time.now
-  end
-  
-  # Reverts back to system's Time.now, Date.today and DateTime.now (if it exists).
-  #
-  # Returns Time.now, which is now the real current time.
-  def self.return
-    instance().send(:unmock!)
-    Time.now
-  end
-  
-  def self.top_stack_item #:nodoc:
-    instance().instance_variable_get(:@_stack).last
+
+  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:
+    #
+    #   joe = User.find(1)
+    #   joe.purchase_home()
+    #   assert !joe.mortgage_due?
+    #   Timecop.freeze(2008, 10, 5) do
+    #     assert joe.mortgage_due?
+    #   end
+    #
+    # freeze and travel will respond to several different arguments:
+    # 1. Timecop.freeze(time_inst)
+    # 2. Timecop.freeze(datetime_inst)
+    # 3. Timecop.freeze(date_inst)
+    # 4. Timecop.freeze(offset_in_seconds)
+    # 5. Timecop.freeze(year, month, day, hour=0, minute=0, second=0)
+    #
+    # 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
+    # calls to Timecop.travel and have each block maintain it's concept of "now."
+    #
+    # * Note: Timecop.freeze will actually freeze time.  This can cause unanticipated problems if
+    #   benchmark or other timing calls are executed, which implicitly expect Time to actually move
+    #   forward.
+    #
+    # * Rails Users: Be especially careful when setting this in your development environment in a
+    #   rails project.  Generators will load your environment, including the migration generator,
+    #   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.
+    def freeze(*args, &block)
+      val = instance().send(:travel, :freeze, *args, &block)
+
+      block_given? ? val : nil
+    end
+
+    # Allows you to run a block of code and "fake" a time throughout the execution of that block.
+    # See Timecop#freeze for a sample of how to use (same exact usage syntax)
+    #
+    # * 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.
+    def travel(*args, &block)
+      val = instance().send(:travel, :travel, *args, &block)
+
+      block_given? ? val : nil
+    end
+
+    def baseline
+      instance().send(:baseline)
+    end
+
+    def 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
+    end
+
+    def return_to_baseline
+      instance().send(:return_to_baseline)
+      Time.now
+    end
+
+    def top_stack_item #:nodoc:
+      instance().instance_variable_get(:@_stack).last
+    end
   end
 
   protected
-  
+
+    def baseline=(baseline)
+      @baseline = baseline
+      @_stack << TimeStackItem.new(:travel, baseline)
+    end
+
     def initialize #:nodoc:
       @_stack = []
     end
-    
+
     def travel(mock_type, *args, &block) #:nodoc:
       stack_item = TimeStackItem.new(mock_type, *args)
-      
+
       # store this time traveling on our stack...
       @_stack << stack_item
-    
+
       if block_given?
         begin
-          yield
+          yield stack_item.time
         ensure
           # pull it off the stack...
           @_stack.pop
         end
       end
     end
-  
+
     def unmock! #:nodoc:
+      @baseline = nil
       @_stack = []
     end
-  
+
+    def return_to_baseline
+      if @baseline
+        @_stack = [@_stack.shift]
+      else
+        unmock!
+      end
+    end
 end

data/test/run_tests.sh

@@ -1,13 +1,6 @@
 #!/bin/sh
 
-echo "\033[1;81m Running test_time_stack_item...\033[0m"
-ruby -I../lib test_time_stack_item.rb || (echo "FAILED!!!!!!!!!!!!")
+for f in *_test.rb; do
+  ${RUBY:-ruby} -I../lib:. $f 
+done
 
-echo "\033[1;81m Running test_timecop_without_date...\033[0m"
-ruby -I../lib test_timecop_without_date.rb || (echo "FAILED!!!!!!!!!!!!")
-
-echo "\033[1;81m Running test_timecop_without_date_but_with_time...\033[0m"
-ruby -I../lib test_timecop_without_date_but_with_time.rb || (echo "FAILED!!!!!!!!!!!!")
-
-echo "\033[1;81m Running test_timecop...\033[0m"
-ruby -I../lib test_timecop.rb || (echo "FAILED!!!!!!!!!!!!")

data/test/test_helper.rb

@@ -1,6 +1,10 @@
+require 'rubygems'
+require 'bundler/setup'
 require 'test/unit'
+require 'mocha'
 
 class Test::Unit::TestCase
+
   private
     # Tests to see that two times are within the given distance,
     # in seconds, from each other.
@@ -43,4 +47,4 @@ class Test::Unit::TestCase
       assert_equal dt1, dt2, "Failed for timezone: #{ENV['TZ']}: #{dt1.to_s} not equal to #{dt2.to_s}"
     end
     
-end
+end

data/test/{test_time_stack_item.rb → time_stack_item_test.rb}

@@ -5,6 +5,7 @@ require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
 class TestTimeStackItem < Test::Unit::TestCase
   
   def teardown
+    Timecop.active_support = nil
     Timecop.return
   end
   
@@ -19,6 +20,18 @@ class TestTimeStackItem < Test::Unit::TestCase
     assert_equal min, stack_item.min
     assert_equal s,   stack_item.sec
   end
+
+  def test_new_with_time_and_arguments
+    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
+    assert_equal h,   stack_item.hour
+    assert_equal min, stack_item.min
+    assert_equal s,   stack_item.sec
+  end
   
   def test_new_with_datetime_now
     t = DateTime.now
@@ -97,8 +110,7 @@ class TestTimeStackItem < Test::Unit::TestCase
     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)
-    assert Time.now.dst?, "precondition"
-    assert tsi.time.dst?, "precondition"
+    return if !(Time.now.dst? && tsi.time.dst?)
     assert_equal 0, tsi.send(:dst_adjustment)
   end
   
@@ -106,8 +118,7 @@ class TestTimeStackItem < Test::Unit::TestCase
     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)
-    assert !Time.now.dst?, "precondition"
-    assert !tsi.time.dst?, "precondition"
+    return if Time.now.dst? || tsi.time.dst?
     assert_equal 0, tsi.send(:dst_adjustment)    
   end
   
@@ -115,8 +126,7 @@ class TestTimeStackItem < Test::Unit::TestCase
     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)
-    assert Time.now.dst?, "precondition"
-    assert !tsi.time.dst?, "precondition"
+    return if !Time.now.dst? || tsi.time.dst?
     assert_equal 60 * 60, tsi.send(:dst_adjustment)
   end
   
@@ -124,27 +134,24 @@ class TestTimeStackItem < Test::Unit::TestCase
     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)
-    assert !Time.now.dst?, "precondition"
-    assert tsi.time.dst?, "precondition"
+    return if Time.now.dst? || !tsi.time.dst?
     assert_equal -1 * 60 * 60, tsi.send(:dst_adjustment)
   end
   
-  # Ensure DateTime's handle changing DST properly
+  # 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
-    # verify Date also 'moves backward' an hour to change the day
-    assert_equal Date.new(2009, 10, 10), tsi.date
   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
-    # verify Date also 'moves forward' an hour to change the day
     assert_equal Date.new(2009, 12, 1), tsi.date
   end
   
@@ -164,4 +171,34 @@ class TestTimeStackItem < Test::Unit::TestCase
     tsi = Timecop::TimeStackItem.new(:freeze, t)
     assert_equal nil, tsi.send(:travel_offset)
   end
-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
+end

data/test/{test_timecop.rb → timecop_test.rb}

@@ -3,20 +3,20 @@ require '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
@@ -24,6 +24,12 @@ class TestTimecop < Test::Unit::TestCase
     end
     assert_not_equal t, Time.now
   end
+
+  def test_freeze_yields_mocked_time
+    Timecop.freeze(2008, 10, 10, 10, 10, 10) do |frozen_time|
+      assert_equal frozen_time, Time.now
+    end
+  end
   
   def test_freeze_then_return_unsets_mock_time
     Timecop.freeze(1)
@@ -36,22 +42,66 @@ class TestTimecop < Test::Unit::TestCase
     Timecop.return
     assert_nil Time.send(:mock_time)
   end
-  
+
   def test_freeze_with_block_unsets_mock_time
     assert_nil Time.send(:mock_time), "test is invalid"
     Timecop.freeze(1) do; end
     assert_nil Time.send(:mock_time)
   end
-  
+
   def test_travel_with_block_unsets_mock_time
     assert_nil Time.send(:mock_time), "test is invalid"
     Timecop.travel(1) do; end
     assert_nil Time.send(:mock_time)
   end
-  
+
+  def test_travel_does_not_reduce_precision_of_datetime
+    # requires to_r on Float (>= 1.9)
+    if Float.method_defined?(:to_r)
+      Timecop.travel(1)
+      assert_not_equal DateTime.now, DateTime.now
+    end
+  end
+
+  def test_freeze_in_time_subclass_returns_mocked_subclass
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    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
+      assert custom_timeklass.now.respond_to? :custom_format_method
+    end
+  end
+
+  def test_freeze_in_date_subclass_returns_mocked_subclass
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    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
+      assert custom_dateklass.today.respond_to? :custom_format_method
+    end
+  end
+
+  def test_freeze_in_datetime_subclass_returns_mocked_subclass
+    t = Time.local(2008, 10, 10, 10, 10, 10)
+    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
+      assert custom_datetimeklass.now.respond_to? :custom_format_method
+    end
+  end
+
   def test_recursive_freeze
     t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(2008, 10, 10, 10, 10, 10) do 
+    Timecop.freeze(2008, 10, 10, 10, 10, 10) do
       assert_equal t, Time.now
       t2 = Time.local(2008, 9, 9, 9, 9, 9)
       Timecop.freeze(2008, 9, 9, 9, 9, 9) do
@@ -61,10 +111,10 @@ class TestTimecop < Test::Unit::TestCase
     end
     assert_not_equal t, Time.now
   end
-  
+
   def test_freeze_with_time_instance_works_as_expected
     t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(t) do 
+    Timecop.freeze(t) do
       assert_equal t, Time.now
       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
@@ -73,7 +123,7 @@ class TestTimecop < Test::Unit::TestCase
     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
   end
-  
+
   def test_freeze_with_datetime_on_specific_timezone_during_dst
     each_timezone do
       # Start from a time that is subject to DST
@@ -87,7 +137,7 @@ class TestTimecop < Test::Unit::TestCase
       Timecop.return
     end
   end
-  
+
   def test_freeze_with_datetime_on_specific_timezone_not_during_dst
     each_timezone do
       # Start from a time that is not subject to DST
@@ -99,7 +149,7 @@ class TestTimecop < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_freeze_with_datetime_from_a_non_dst_time_to_a_dst_time
     each_timezone do
       # Start from a time that is not subject to DST
@@ -109,7 +159,7 @@ class TestTimecop < Test::Unit::TestCase
       Timecop.freeze(t) do
         assert_date_times_equal t, DateTime.now
       end
-    end    
+    end
   end
 
   def test_freeze_with_datetime_from_a_dst_time_to_a_non_dst_time
@@ -121,9 +171,9 @@ class TestTimecop < Test::Unit::TestCase
       Timecop.freeze(t) do
         assert_date_times_equal t, DateTime.now
       end
-    end    
+    end
   end
-  
+
   def test_freeze_with_date_instance_works_as_expected
     d = Date.new(2008, 10, 10)
     Timecop.freeze(d) do
@@ -133,9 +183,9 @@ class TestTimecop < Test::Unit::TestCase
     end
     assert_not_equal d, Date.today
     assert_not_equal Time.local(2008, 10, 10, 0, 0, 0), Time.now
-    assert_not_equal DateTime.new(2008, 10, 10, 0, 0, 0, local_offset), DateTime.now    
+    assert_not_equal DateTime.new(2008, 10, 10, 0, 0, 0, local_offset), DateTime.now
   end
-  
+
   def test_freeze_with_integer_instance_works_as_expected
     t = Time.local(2008, 10, 10, 10, 10, 10)
     Timecop.freeze(t) do
@@ -165,7 +215,7 @@ class TestTimecop < Test::Unit::TestCase
       assert_nil Time.send(:mock_time)
     end
   end
-  
+
   def test_freeze_freezes_time
     t = Time.local(2008, 10, 10, 10, 10, 10)
     now = Time.now
@@ -179,7 +229,7 @@ class TestTimecop < Test::Unit::TestCase
       assert_equal new_dt, DateTime.now
     end
   end
-  
+
   def test_travel_keeps_time_moving
     t = Time.local(2008, 10, 10, 10, 10, 10)
     now = Time.now
@@ -190,7 +240,7 @@ class TestTimecop < Test::Unit::TestCase
       assert_times_effectively_not_equal new_now, Time.now, 0.25, "Looks like time is not moving"
     end
   end
-  
+
   def test_mocked_date_time_now_is_local
     each_timezone do
       t = DateTime.parse("2009-10-11 00:38:00 +0200")
@@ -199,7 +249,7 @@ class TestTimecop < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_freeze_with_utc_time
     each_timezone do
       t = Time.utc(2008, 10, 10, 10, 10, 10)
@@ -224,10 +274,10 @@ class TestTimecop < Test::Unit::TestCase
       assert !Time.now.utc?, "Failed to thwart destructive methods."
     end
   end
-  
+
   def test_recursive_travel_maintains_each_context
     t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.travel(2008, 10, 10, 10, 10, 10) do 
+    Timecop.travel(2008, 10, 10, 10, 10, 10) do
       assert((t - Time.now).abs < 50, "Failed to travel time.")
       t2 = Time.local(2008, 9, 9, 9, 9, 9)
       Timecop.travel(2008, 9, 9, 9, 9, 9) do
@@ -238,10 +288,18 @@ class TestTimecop < Test::Unit::TestCase
     end
     assert_nil Time.send(:mock_time)
   end
+
+  def test_recursive_travel_yields_correct_time
+    Timecop.travel(2008, 10, 10, 10, 10, 10) do 
+      Timecop.travel(2008, 9, 9, 9, 9, 9) do |inner_freeze|
+        assert_times_effectively_equal inner_freeze, Time.now, 1, "Failed to yield current time back to block"
+      end
+    end
+  end
   
   def test_recursive_travel_then_freeze
     t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.travel(2008, 10, 10, 10, 10, 10) do 
+    Timecop.travel(2008, 10, 10, 10, 10, 10) do
       assert((t - Time.now).abs < 50, "Failed to travel time.")
       t2 = Time.local(2008, 9, 9, 9, 9, 9)
       Timecop.freeze(2008, 9, 9, 9, 9, 9) do
@@ -251,10 +309,10 @@ class TestTimecop < Test::Unit::TestCase
     end
     assert_nil Time.send(:mock_time)
   end
-  
+
   def test_recursive_freeze_then_travel
     t = Time.local(2008, 10, 10, 10, 10, 10)
-    Timecop.freeze(t) do 
+    Timecop.freeze(t) do
       assert_equal t, Time.now
       t2 = Time.local(2008, 9, 9, 9, 9, 9)
       Timecop.travel(t2) do
@@ -263,32 +321,86 @@ class TestTimecop < Test::Unit::TestCase
       end
       assert_equal t, Time.now
     end
-    assert_nil Time.send(:mock_time)    
+    assert_nil Time.send(:mock_time)
   end
-  
-  def test_return_values_are_Time_instances
-    assert Timecop.freeze.is_a?(Time)
-    assert Timecop.travel.is_a?(Time)
-    assert Timecop.return.is_a?(Time)
+
+  def test_travel_time_returns_nil
+    t_future = Time.local(2030, 10, 10, 10, 10, 10)
+    assert_nil Timecop.travel(t_future)
   end
-  
-  def test_travel_time_returns_passed_value
+
+  def test_travel_time_with_block_returns_the_value_of_the_block
     t_future = Time.local(2030, 10, 10, 10, 10, 10)
-    t_travel = Timecop.travel t_future
-    assert times_effectively_equal(t_future, t_travel)
+    expected = :foo
+    actual = Timecop.travel(t_future) { expected }
+
+    assert_equal expected, actual
   end
-  
-  def test_freeze_time_returns_passed_value
+
+  def test_freeze_time_returns_nil
     t_future = Time.local(2030, 10, 10, 10, 10, 10)
-    t_frozen = Timecop.freeze t_future
-    assert times_effectively_equal(t_future, t_frozen)
+    assert_nil Timecop.freeze(t_future)
   end
-  
-  def test_return_time_returns_actual_time
-    t_real = Time.now
-    Timecop.freeze Time.local(2030, 10, 10, 10, 10, 10)
-    t_return = Timecop.return
-    assert times_effectively_equal(t_real, t_return)
+
+  def test_freeze_time_with_block_returns_the_value_of_the_block
+    t_future = Time.local(2030, 10, 10, 10, 10, 10)
+    expected = :foo
+    actual = Timecop.freeze(t_future) { expected }
+
+    assert_equal expected, actual
+  end
+
+  def test_return_returns_nil
+    assert_nil Timecop.return
+  end
+
+  def test_freeze_without_params
+    Timecop.freeze 1 do
+      current_time = Time.now
+      Timecop.freeze do
+        assert_equal Time.now, current_time
+      end
+    end
+  end
+
+  def test_freeze_with_new_date
+    date = Date.new(2012, 6, 9)
+    Timecop.freeze(Date.new(2012, 6, 9)) do
+      assert_equal date, Time.now.__send__(:to_date)
+    end
   end
 
-end
+  def test_return_to_baseline_without_a_baseline_set_returns_to_current_time
+    time_before_travel = Time.now
+    Timecop.travel Time.now - 60
+    Timecop.return_to_baseline
+    assert times_effectively_equal(time_before_travel, Time.now)
+  end
+
+  def test_return_to_baseline_with_a_baseline_set_returns_to_baseline
+    baseline = Time.local(1945, 10, 10, 10, 10, 10)
+    Timecop.baseline = baseline
+    Timecop.travel Time.now - 60
+    time_now = Timecop.return_to_baseline
+    assert times_effectively_equal(baseline, time_now),
+      "expected to return to #{baseline}, but returned to #{time_now}"
+  end
+
+  def test_return_eliminates_baseline
+    time_before_travel = Time.now
+    Timecop.baseline = Time.local(1937, 9, 9, 9, 9, 9)
+    Timecop.return
+    assert times_effectively_equal(time_before_travel, Time.now)
+
+    Timecop.travel(Time.now - 100)
+    Timecop.return_to_baseline
+    assert times_effectively_equal(time_before_travel, Time.now)
+  end
+
+  def test_mock_time_new_same_as_now
+    date = Time.local(2011, 01, 02)
+    Timecop.freeze date
+    assert_equal date, Time.now
+    assert_equal date, Time.new
+  end
+end

data/test/{test_timecop_without_date.rb → timecop_without_date_test.rb}

@@ -5,8 +5,8 @@ require File.join(File.dirname(__FILE__), '..', 'lib', 'timecop')
 class TestTimecopWithoutDate < Test::Unit::TestCase
   
   def setup
-    assert !Object.const_defined?(:Date)
-    assert !Object.const_defined?(:DateTime)
+    Object.send(:remove_const, :Date) if Object.const_defined?(:Date)
+    Object.send(:remove_const, :DateTime) if Object.const_defined?(:DateTime)
   end
   
   # just in case...let's really make sure that Timecop is disabled between tests...
@@ -116,4 +116,4 @@ class TestTimecopWithoutDate < Test::Unit::TestCase
     assert_nil Time.send(:mock_time)    
   end
 
-end
+end

metadata

@@ -1,37 +1,38 @@
 --- !ruby/object:Gem::Specification 
 name: timecop
 version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: false
+  hash: 11
+  prerelease: 
   segments: 
   - 0
-  - 3
   - 5
-  version: 0.3.5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
+- Travis Jeffery
 - John Trupiano
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-06-07 00:00:00 -04:00
+date: 2012-09-05 00:00:00 -05:00
 default_executable: 
 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 Time.now, Date.today, and DateTime.now in a single call.
-email: jtrupiano@gmail.com
+email: travisjeffery@gmail.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
+- README.markdown
 files: 
 - History.rdoc
 - LICENSE
-- README.rdoc
+- README.markdown
 - Rakefile
 - VERSION.yml
 - lib/timecop.rb
@@ -40,10 +41,10 @@ files:
 - lib/timecop/timecop.rb
 - test/run_tests.sh
 - test/test_helper.rb
-- test/test_time_stack_item.rb
-- test/test_timecop.rb
-- test/test_timecop_without_date.rb
-- test/test_timecop_without_date_but_with_time.rb
+- test/time_stack_item_test.rb
+- test/timecop_test.rb
+- test/timecop_without_date_test.rb
+- test/timecop_without_date_but_with_time_test.rb
 has_rdoc: true
 homepage: http://github.com/jtrupiano/timecop
 licenses: []
@@ -74,13 +75,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: johntrupiano
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: 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 Time.now, Date.today, and DateTime.now in a single call.
 test_files: 
 - test/test_helper.rb
-- test/test_time_stack_item.rb
-- test/test_timecop.rb
-- test/test_timecop_without_date.rb
-- test/test_timecop_without_date_but_with_time.rb
+- test/time_stack_item_test.rb
+- test/timecop_test.rb
+- test/timecop_without_date_test.rb
+- test/timecop_without_date_but_with_time_test.rb

data/README.rdoc

@@ -1,68 +0,0 @@
-= timecop
-
-* Source[http://github.com/jtrupiano/timecop]
-* Documentation[http://johntrupiano.rubyforge.org/timecop]
-
-== 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 Time.now, Date.today, and DateTime.now in a single call.
-
-== INSTALL
-
-  gem install timecop
-
-== FEATURES
-
-* Freeze time to a specific point.
-* Travel back to a specific point in time, but allow time to continue moving forward from there.
-* 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
-  * DateTime instance
-  * Date instance
-  * individual arguments (year, month, day, hour, minute, second)
-  * a single integer argument that is interpreted as an offset in seconds from Time.now
-* Nested calls to Timecop#travel and Timecop#freeze are supported -- each block will maintain its interpretation of now.
-
-== USAGE
-
-Run a time-sensitive test
-
-  joe = User.find(1)
-  joe.purchase_home()
-  assert !joe.mortgage_due?
-  # move ahead a month and assert that the mortgage is due
-  Timecop.freeze(Date.today + 30) do
-    assert joe.mortgage_due?
-  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 appropriate (within your tests)
-  
-in config/environments/test.rb
-
-  config.after_initialize do
-    # Set Time.now to September 1, 2008 10:05:00 AM (at this instant), but allow it to move forward
-    t = Time.local(2008, 9, 1, 10, 5, 0)
-    Timecop.travel(t)
-  end
-
-=== The difference between Timecop.freeze and Timecop.travel
-
-#freeze is used to statically mock the concept of now.  As your program executes, Time.now will not change unless you make subsequent calls into the Timecop API.  #travel, on the other hand, computes an offset between what we currently think Time.now is (recall that we support nested traveling) and the time passed in.  It uses this offset to simulate the passage of time.  To demonstrate, consider the following code snippets:
-
-  new_time = Time.local(2008, 9, 1, 12, 0, 0)
-  Timecop.freeze(new_time)
-  sleep(10)
-  new_time == Time.now # ==> true
-  
-  Timecop.return # "turn off" Timecop
-  Timecop.travel(new_time)
-  sleep(10)
-  new_time == Time.now # ==> false
-
-== 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/]