timecop 0.9.1 → 0.9.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 73784bb387b1ff9addf9f0ea04a14e28d679a577
-  data.tar.gz: 18fbfbd85ceae5b1a23111267b7b39287911b080
+SHA256:
+  metadata.gz: '079905b60d7144434c07560dadc7a1dbd36d19ad27f25ecaf52e0143e0656d23'
+  data.tar.gz: f34eb8593ccdd28571a4ccbdd710f518e628da6113eeb0f904e2f04d91dc5bf1
 SHA512:
-  metadata.gz: 39552bdc1d0278558f91802906da230656323690b3a4663c6c054e2f8ad379df9f593e65265faa6d0ee6769423b0d73d3ab3a1e16c8ac0ee80896cd88e5661ba
-  data.tar.gz: 669823d9cd754f2fa5ec195012aa43f43a070e61e3be41dda3ada13eceaffa06733cb6302bbdf88b0764da28d6a3860d74d4505ba3fa4a75be88ef96c03d0ad1
+  metadata.gz: bd112c3657079e9c927d266725ba6d231a23658da5f385f1dca760011eff2021a30a1607cc187b26737b6d20244a0e9d54130a5a4c46b93e04c0ddebd3ba4fad
+  data.tar.gz: fa6dc270173399ff8c112624913703f612ea0d25720f13b01be67ee41781b07bd6661a502b0db1e1fdbc34fc91b4acd2966526f2ee1f1acd7463d8db26f40b8e

data/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2012 — Travis Jeffery, John Trupiano
+Copyright (c) 2019 — 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

@@ -1,14 +1,15 @@
 # timecop
 
-[![Build Status](https://secure.travis-ci.org/travisjeffery/timecop.svg)](http://travis-ci.org/travisjeffery/timecop)
+[![Gem Version](https://badge.fury.io/rb/timecop.svg)](https://rubygems.org/gems/timecop)
+[![Build Status](https://github.com/travisjeffery/timecop/workflows/CI/badge.svg)](https://github.com/travisjeffery/timecop/actions?query=workflow%3ACI)
 
 ## 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.
+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`, `DateTime.now`, and `Process.clock_gettime` in a single call.
 
 ## INSTALL
 
-`gem install timecop`
+`bundle add timecop`
 
 ## FEATURES
 
@@ -16,13 +17,13 @@ A gem providing "time travel" and "time freezing" capabilities, making it dead s
 - 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:
+- 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.
+  - 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
@@ -61,7 +62,7 @@ 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
+in `config/environments/test.rb`
 
 ```ruby
 config.after_initialize do
@@ -73,10 +74,10 @@ 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.
+`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:
 
@@ -128,6 +129,15 @@ Timecop.freeze
 # => Timecop::SafeModeException: Safe mode is enabled, only calls passing a block are allowed.
 ```
 
+### Configuring Mocking Process.clock_gettime
+
+By default Timecop does not mock Process.clock_gettime. You must enable it like this:
+
+``` ruby
+# turn on
+Timecop.mock_process_clock = true
+```
+
 ### Rails v Ruby Date/Time libraries
 
 Sometimes [Rails Date/Time methods don't play nicely with Ruby Date/Time methods.](https://rails.lighthouseapp.com/projects/8994/tickets/6410-dateyesterday-datetoday)

data/lib/timecop/time_extensions.rb

@@ -18,8 +18,14 @@ class Time #:nodoc:
 
     alias_method :new_without_mock_time, :new
 
-    def new_with_mock_time(*args)
-      args.size <= 0 ? now : new_without_mock_time(*args)
+    def new_with_mock_time(*args, **kwargs)
+      if args.empty? && kwargs.empty?
+        now
+      elsif kwargs.any?
+        new_without_mock_time(*args, **kwargs)
+      else
+        new_without_mock_time(*args)
+      end
     end
 
     alias_method :new, :new_with_mock_time
@@ -43,12 +49,45 @@ class Date #:nodoc:
     alias_method :strptime_without_mock_date, :strptime
 
     def strptime_with_mock_date(str = '-4712-01-01', fmt = '%F', start = Date::ITALY)
-      unless start == Date::ITALY
-        raise ArgumentError, "Timecop's #{self}::#{__method__} only " +
-          "supports Date::ITALY for the start argument."
+      #If date is not valid the following line raises
+      Date.strptime_without_mock_date(str, fmt, start)
+
+      d = Date._strptime(str, fmt)
+      now = Time.now.to_date
+
+      # If "current" time falls near a year boundary, with a year-ambiguous str, we need to explicitly handle it
+      cwday = d[:cwday] && (now + (d[:cwday] - now.wday))
+      wday = d[:wday] && (now + (d[:wday] - now.wday))
+
+      year = d[:year] || d[:cwyear] || (cwday || wday || now).year
+      mon = d[:mon] || now.mon
+      if d.keys == [:year]
+        Date.new(year, 1, 1, start)
+      elsif d[:mday]
+        Date.new(year, mon, d[:mday], start)
+      elsif d[:yday]
+        Date.new(year, 1, 1, start).next_day(d[:yday] - 1)
+      elsif d[:cwyear] || d[:cweek] || d[:wnum0] || d[:wnum1] || d[:wday] || d[:cwday]
+        # When only a day (wday/cwday) is present, derive the week from the resolved date; otherwise fall back to now's week
+        week = d[:cweek] || d[:wnum1] || d[:wnum0] || (cwday || wday || now).strftime('%W').to_i
+        if d[:wnum0] #Week of year where week starts on sunday
+          if d[:cwday] #monday based day of week
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:cwday]}", '%Y %U %u', start)
+          else
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:wday] || 0}", '%Y %U %w', start)
+          end
+        else #Week of year where week starts on monday
+          if d[:wday] #sunday based day of week
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:wday]}", '%Y %W %w', start)
+          else
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:cwday] || 1}", '%Y %W %u', start)
+          end
+        end
+      elsif d[:seconds]
+        Time.at(d[:seconds]).to_date
+      else
+        Date.new(year, mon, 1, start)
       end
-
-      Time.strptime(str, fmt).to_date
     end
 
     alias_method :strptime, :strptime_with_mock_date
@@ -63,6 +102,8 @@ class Date #:nodoc:
         parsed_date
       when date_hash[:mon] && date_hash[:mday]
         Date.new(mocked_time_stack_item.year, date_hash[:mon], date_hash[:mday])
+      when date_hash[:mday]
+        Date.new(mocked_time_stack_item.year, mocked_time_stack_item.month, date_hash[:mday])
       when date_hash[:wday]
         closest_wday(date_hash[:wday])
       else
@@ -101,7 +142,6 @@ class DateTime #:nodoc:
     alias_method :now, :now_with_mock_time
 
     def parse_with_mock_date(*args)
-      date_hash = Date._parse(*args)
       parsed_date = parse_without_mock_date(*args)
       return parsed_date unless mocked_time_stack_item
       date_hash = DateTime._parse(*args)
@@ -111,8 +151,21 @@ class DateTime #:nodoc:
         parsed_date
       when date_hash[:mon] && date_hash[:mday]
         DateTime.new(mocked_time_stack_item.year, date_hash[:mon], date_hash[:mday])
+      when date_hash[:mday]
+        DateTime.new(mocked_time_stack_item.year, mocked_time_stack_item.month, date_hash[:mday])
+      when date_hash[:wday] && date_hash[:hour] && date_hash[:min]
+        closest_date = Date.closest_wday(date_hash[:wday]).to_datetime
+
+        DateTime.new(
+          closest_date.year, closest_date.month, closest_date.day,
+          date_hash[:hour], date_hash[:min]
+        )
       when date_hash[:wday]
         Date.closest_wday(date_hash[:wday]).to_datetime
+      when date_hash[:hour] && date_hash[:min] && date_hash[:sec]
+        DateTime.new(mocked_time_stack_item.year, mocked_time_stack_item.month, mocked_time_stack_item.day, date_hash[:hour], date_hash[:min], date_hash[:sec])
+      when date_hash[:hour] && date_hash[:min]
+        DateTime.new(mocked_time_stack_item.year, mocked_time_stack_item.month, mocked_time_stack_item.day, date_hash[:hour], date_hash[:min], 0)
       else
         parsed_date + mocked_time_stack_item.travel_offset_days
       end
@@ -126,3 +179,57 @@ class DateTime #:nodoc:
     end
   end
 end
+
+module Process #:nodoc:
+  class << self
+    alias_method :clock_gettime_without_mock, :clock_gettime
+
+    def clock_gettime_mock_time(clock_id, unit = :float_second)
+      mock_time = case clock_id
+                  when Process::CLOCK_MONOTONIC
+                    mock_time_monotonic
+                  when Process::CLOCK_REALTIME
+                    mock_time_realtime
+                  end
+
+      return clock_gettime_without_mock(clock_id, unit) unless Timecop.mock_process_clock? && mock_time
+
+      divisor = case unit
+                when :float_second
+                  1_000_000_000.0
+                when :second
+                  1_000_000_000
+                when :float_millisecond
+                  1_000_000.0
+                when :millisecond
+                  1_000_000
+                when :float_microsecond
+                  1000.0
+                when :microsecond
+                  1000
+                when :nanosecond
+                  1
+                end
+
+      (mock_time / divisor)
+    end
+
+    alias_method :clock_gettime, :clock_gettime_mock_time
+
+    private
+
+    def mock_time_monotonic
+      mocked_time_stack_item = Timecop.top_stack_item
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.monotonic
+    end
+
+    def mock_time_realtime
+      mocked_time_stack_item = Timecop.top_stack_item
+
+      return nil if mocked_time_stack_item.nil?
+
+      t = mocked_time_stack_item.time
+      t.to_i * 1_000_000_000 + t.nsec
+    end
+  end
+end

data/lib/timecop/time_stack_item.rb

@@ -1,140 +1,169 @@
 class Timecop
-    # A data class for carrying around "time movement" objects.  Makes it easy to keep track of the time
-    # movements on a simple stack.
-    class TimeStackItem #:nodoc:
-      attr_reader :mock_type
-
-      def initialize(mock_type, *args)
-        raise "Unknown mock_type #{mock_type}" unless [:freeze, :travel, :scale].include?(mock_type)
-        @travel_offset  = @scaling_factor = nil
-        @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
-      end
+  # A data class for carrying around "time movement" objects.  Makes it easy to keep track of the time
+  # movements on a simple stack.
+  class TimeStackItem #:nodoc:
+    attr_reader :mock_type
+
+    def initialize(mock_type, *args)
+      raise "Unknown mock_type #{mock_type}" unless [:freeze, :travel, :scale].include?(mock_type)
+      @travel_offset  = @scaling_factor = nil
+      @scaling_factor = args.shift if mock_type == :scale
+      @mock_type      = mock_type
+      @monotonic      = parse_monotonic_time(*args)
+      @time           = parse_time(*args)
+      @time_was       = Time.now_without_mock_time
+      @travel_offset  = compute_travel_offset
+    end
 
-      def year
-        time.year
-      end
+    def year
+      time.year
+    end
 
-      def month
-        time.month
-      end
+    def month
+      time.month
+    end
 
-      def day
-        time.day
-      end
+    def day
+      time.day
+    end
 
-      def hour
-        time.hour
-      end
+    def hour
+      time.hour
+    end
 
-      def min
-        time.min
-      end
+    def min
+      time.min
+    end
 
-      def sec
-        time.sec
-      end
+    def sec
+      time.sec
+    end
 
-      def utc_offset
-        time.utc_offset
-      end
+    def utc_offset
+      time.utc_offset
+    end
 
-      def travel_offset
-        @travel_offset unless mock_type == :freeze
-      end
+    def travel_offset
+      @travel_offset unless mock_type == :freeze
+    end
 
-      def travel_offset_days
-        (@travel_offset / 60 / 60 / 24).round
-      end
+    def travel_offset_days
+      (@travel_offset / 60 / 60 / 24).round
+    end
+
+    def scaling_factor
+      @scaling_factor
+    end
 
-      def scaling_factor
-        @scaling_factor
+    def monotonic
+      if travel_offset.nil?
+        @monotonic
+      elsif scaling_factor.nil?
+        current_monotonic + travel_offset * (10 ** 9)
+      else
+        (@monotonic + (current_monotonic - @monotonic) * scaling_factor).to_i
       end
+    end
 
-      def time(time_klass = Time) #:nodoc:
-        if @time.respond_to?(:in_time_zone)
-          time = time_klass.at(@time.dup.localtime)
-        else
-          time = time_klass.at(@time)
-        end
+    def current_monotonic
+      Process.clock_gettime_without_mock(Process::CLOCK_MONOTONIC, :nanosecond)
+    end
 
-        if travel_offset.nil?
-          time
-        elsif scaling_factor.nil?
-          time_klass.at(Time.now_without_mock_time + travel_offset)
-        else
-          time_klass.at(scaled_time)
-        end
-      end
+    def current_monotonic_with_mock
+      Process.clock_gettime_mock_time(Process::CLOCK_MONOTONIC, :nanosecond)
+    end
 
-      def scaled_time
-        (@time + (Time.now_without_mock_time - @time_was) * scaling_factor).to_f
+    def time(time_klass = Time) #:nodoc:
+      if @time.respond_to?(:in_time_zone)
+        time = time_klass.at(@time.dup.localtime)
+      else
+        time = time_klass.at(@time)
       end
 
-      def date(date_klass = Date)
-        date_klass.jd(time.__send__(:to_date).jd)
+      if travel_offset.nil?
+        time
+      elsif scaling_factor.nil?
+        time_klass.at(Time.now_without_mock_time + travel_offset)
+      else
+        time_klass.at(scaled_time)
       end
+    end
 
-      def datetime(datetime_klass = DateTime)
-        if Float.method_defined?(:to_r)
-          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
-      end
+    def scaled_time
+      (@time + (Time.now_without_mock_time - @time_was) * scaling_factor).to_f
+    end
 
-      private
+    def date(date_klass = Date)
+      date_klass.jd(time.__send__(:to_date).jd)
+    end
 
-      def rational_to_utc_offset(rational)
-        ((24.0 / rational.denominator) * rational.numerator) * (60 * 60)
+    def datetime(datetime_klass = DateTime)
+      if Float.method_defined?(:to_r)
+        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
+    end
 
-      def utc_offset_to_rational(utc_offset)
-        Rational(utc_offset, 24 * 60 * 60)
+    private
+
+    def rational_to_utc_offset(rational)
+      ((24.0 / rational.denominator) * rational.numerator) * (60 * 60)
+    end
+
+    def utc_offset_to_rational(utc_offset)
+      Rational(utc_offset, 24 * 60 * 60)
+    end
+
+    def parse_monotonic_time(*args)
+      arg = args.shift
+      offset_in_nanoseconds = if args.empty? && (arg.kind_of?(Integer) || arg.kind_of?(Float))
+        arg * 1_000_000_000
+      else
+        0
       end
+      current_monotonic_with_mock + offset_in_nanoseconds
+    end
 
-      def parse_time(*args)
-        arg = args.shift
-        if arg.is_a?(Time)
-          arg
-        elsif Object.const_defined?(:DateTime) && arg.is_a?(DateTime)
-          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) || arg.kind_of?(Float))
-          time_klass.now + arg
-        elsif arg.nil?
-          time_klass.now
+    def parse_time(*args)
+      arg = args.shift
+      if arg.is_a?(Time)
+        arg
+      elsif Object.const_defined?(:DateTime) && arg.is_a?(DateTime)
+        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) || arg.kind_of?(Float))
+        time_klass.now + arg
+      elsif arg.nil?
+        time_klass.now
+      else
+        if arg.is_a?(String) && Time.respond_to?(:parse)
+          time_klass.parse(arg)
         else
-          if arg.is_a?(String) && Time.respond_to?(:parse)
-            time_klass.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
+          # 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_travel_offset
-        time - Time.now_without_mock_time
-      end
+    def compute_travel_offset
+      time - Time.now_without_mock_time
+    end
 
-      def times_are_equal_within_epsilon t1, t2, epsilon_in_seconds
-        (t1 - t2).abs < epsilon_in_seconds
-      end
+    def times_are_equal_within_epsilon t1, t2, epsilon_in_seconds
+      (t1 - t2).abs < epsilon_in_seconds
+    end
 
-      def time_klass
-        Time.respond_to?(:zone) && Time.zone ? Time.zone : Time
-      end
+    def time_klass
+      Time.respond_to?(:zone) && Time.zone ? Time.zone : Time
     end
+  end
 end

data/lib/timecop/timecop.rb

@@ -1,5 +1,4 @@
 require 'singleton'
-require File.join(File.dirname(__FILE__), "time_extensions")
 require File.join(File.dirname(__FILE__), "time_stack_item")
 
 # Timecop
@@ -14,6 +13,8 @@ class Timecop
   include Singleton
 
   class << self
+    private :instance
+
     # 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:
@@ -37,6 +38,12 @@ class Timecop
     # 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."
     #
+    # The Process.clock_gettime call mocks both CLOCK::MONOTIC and CLOCK::REALTIME
+    #
+    # CLOCK::MONOTONIC works slightly differently than other clocks. This clock cannot move to a
+    # particular date/time. So the only option that changes this clock is #4 which will move the
+    # clock the requested offset. Otherwise the clock is frozen to the current tick.
+    #
     # * 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.
@@ -75,11 +82,11 @@ class Timecop
     end
 
     def baseline
-      instance.send(:baseline)
+      instance.baseline
     end
 
     def baseline=(baseline)
-      instance.send(:baseline=, baseline)
+      instance.baseline = baseline
     end
 
     # Reverts back to system's Time.now, Date.today and DateTime.now (if it exists) permamently when
@@ -87,20 +94,21 @@ class Timecop
     # the given block.
     def return(&block)
       if block_given?
-        instance.send(:return, &block)
+        instance.return(&block)
       else
-        instance.send(:unmock!)
+        instance.unmock!
         nil
       end
     end
+    alias :unfreeze :return
 
     def return_to_baseline
-      instance.send(:return_to_baseline)
+      instance.return_to_baseline
       Time.now
     end
 
     def top_stack_item #:nodoc:
-      instance.send(:stack).last
+      instance.stack.last
     end
 
     def safe_mode=(safe)
@@ -112,27 +120,43 @@ class Timecop
     end
 
     def thread_safe=(t)
-      instance.send(:thread_safe=, t)
+      instance.thread_safe = t
     end
 
     def thread_safe
-      instance.send(:thread_safe)
+      instance.thread_safe
     end
 
-    # Returns whether or not Timecop is currently frozen/travelled
+    # Returns whether or not Timecop is currently frozen
     def frozen?
-      !instance.send(:stack).empty?
+      !instance.stack.empty? && instance.stack.last.mock_type == :freeze
+    end
+
+    # Returns whether or not Timecop is currently travelled
+    def travelled?
+      !instance.stack.empty? && instance.stack.last.mock_type == :travel
+    end
+
+    # Returns whether or not Timecop is currently scaled
+    def scaled?
+      !instance.stack.empty? && instance.stack.last.mock_type == :scale
+    end
+
+    def mock_process_clock=(mock)
+      @mock_process_clock = mock
+    end
+
+    def mock_process_clock?
+      @mock_process_clock ||= false
     end
 
     private
     def send_travel(mock_type, *args, &block)
-      val = instance.send(:travel, mock_type, *args, &block)
+      val = instance.travel(mock_type, *args, &block)
       block_given? ? val : Time.now
     end
   end
 
-  private
-
   def baseline=(b)
     set_baseline(b)
     stack << TimeStackItem.new(:travel, b)
@@ -200,7 +224,7 @@ class Timecop
       begin
         yield stack_item.time
       ensure
-        @stack.replace stack_backup
+        stack.replace stack_backup
         @safe = safe_backup
       end
     end
@@ -235,3 +259,6 @@ class Timecop
     end
   end
 end
+
+# This must be done after TimeCop is available
+require File.join(File.dirname(__FILE__), "time_extensions")

data/lib/timecop/version.rb

@@ -1,3 +1,3 @@
 class Timecop
-  VERSION = "0.9.1"
+  VERSION = "0.9.11"
 end