timecop 0.5.2 → 0.9.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 681f52d846b808b06ff833f3fbfc21e3c7c4c1bf426baa03f101c0a2c3b79ce8
+  data.tar.gz: b95b6d4a3c357e7f11f046d82dad3badd81d4903c96ef2b8e77762f241eeb66e
+SHA512:
+  metadata.gz: e62e48939fb924a78d59199222688ae7692a2f6649c16daac296375ac1e537fa1c85e6a34d1a5cbd64b209e643ffa08d180ce3d933905f91284ce4c819873c1e
+  data.tar.gz: f6f5ef32ee1bfadfd43a5a8899bb521873d61eafd2f242942df6e80a3ed11f80a170d074ada23a61eb3b92009eeaf3a1046b126c802dc9a1c014c77d32acb3ab

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,7 +1,7 @@
 # timecop
 
-- Source[http://github.com/jtrupiano/timecop]
-- Documentation[http://johntrupiano.rubyforge.org/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
 
@@ -9,7 +9,7 @@ A gem providing "time travel" and "time freezing" capabilities, making it dead s
 
 ## INSTALL
 
-  gem install timecop
+`gem install timecop`
 
 ## FEATURES
 
@@ -40,11 +40,28 @@ Timecop.freeze(Date.today + 30) do
 end
 ```
 
+You can mock the time for a set of tests easily via setup/teardown methods
+
+```ruby
+describe "some set of tests to mock" do
+  before do
+    Timecop.freeze(Time.local(1990))
+  end
+
+  after do
+    Timecop.return
+  end
+
+  it "should do blah blah blah" do
+  end
+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
@@ -85,25 +102,43 @@ being able to simulate activity via subsequent calls to your application.
 
 ```ruby
 # seconds will now seem like hours
-Timecop.lens(3600)
+Timecop.scale(3600)
 Time.now
 # => 2012-09-20 21:23:25 -0500
-# seconds later, hours have past it's gone from 9pm at night to 6am in the morning
+# seconds later, hours have passed and it's gone from 9pm at night to 6am in the morning
 Time.now
 # => 2012-09-21 06:22:59 -0500
 ```
 
-## REFERENCES
+See [#42](https://github.com/travisjeffery/timecop/pull/42) for more information, thanks to Ken Mayer, David Holcomb, and Pivotal Labs.
+
+### 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.
+
+``` 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.
+```
+
+### 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)
 
-* {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/]
+Be careful mixing Ruby `Date.today` with Rails `Date.tomorrow` / `Date.yesterday` as things might break.
 
 ## Contribute
 
-timecop is maintained by [travisjeffery](http://github.com/travisjeffery), who
-you can also hit up on [Twitter](http://twitter.com/travisjeffery).
+timecop is maintained by [travisjeffery](http://github.com/travisjeffery), and
+was created by [jtrupiano](https://github.com/jtrupiano).
 
 Here's the most direct way to get your work merged into the project.
 

data/Rakefile

@@ -3,8 +3,6 @@ require 'bundler/gem_tasks'
 require 'rake/testtask'
 require 'rdoc/task'
 
-$LOAD_PATH.unshift("lib")
-
 Rake::RDocTask.new do |rdoc|
   if File.exist?('VERSION')
     version = File.read('VERSION')
@@ -20,8 +18,16 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-task :test do 
-  system "cd test && ./run_tests.sh"
+task :test do
+  failed = Dir["test/*_test.rb"].map do |test|
+    command = "ruby #{test}"
+    puts
+    puts command
+    command unless system(command)
+  end.compact
+  if failed.any?
+    abort "#{failed.count} Tests failed\n#{failed.join("\n")}"
+  end
 end
 
 desc 'Default: run tests'

data/lib/timecop/time_extensions.rb

@@ -1,85 +1,159 @@
+require 'time'
+require 'date'
 
 class Time #:nodoc:
   class << self
-    # 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(self)
     end
-    
-    # Alias the original now
+
     alias_method :now_without_mock_time, :now
 
-    # Define now_with_mock_time
     def now_with_mock_time
       mock_time || now_without_mock_time
     end
-    
-    # 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
+    def new_with_mock_time(*args)
+      args.size <= 0 ? now : new_without_mock_time(*args)
     end
 
+    ruby2_keywords :new_with_mock_time if Module.private_method_defined?(:ruby2_keywords)
+
     alias_method :new, :new_with_mock_time
   end
-end 
-
-if Object.const_defined?(:Date) && Date.respond_to?(:today)
-  class Date #:nodoc:
-    class << self
-      # 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(self)
+end
+
+class Date #:nodoc:
+  class << self
+    def mock_date
+      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
+
+    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."
       end
-      
-      # Alias the original today
-      alias_method :today_without_mock_date, :today
-    
-      # Define today_with_mock_date
-      def today_with_mock_date
-        mock_date || today_without_mock_date
+
+      #If date is not valid the following line raises
+      Date.strptime_without_mock_date(str, fmt)
+
+      d = Date._strptime(str, fmt)
+      now = Time.now.to_date
+      year = d[:year] || now.year
+      mon = d[:mon] || now.mon
+      if d.keys == [:year]
+        Date.new(year)
+      elsif d[:mday]
+        Date.new(year, mon, d[:mday])
+      elsif d[:wday]
+        Date.new(year, mon, now.mday) + (d[:wday] - now.wday)
+      elsif d[:yday]
+        Date.new(year).next_day(d[:yday] - 1)
+      elsif d[:cwyear] && d[:cweek]
+        if d[:cwday]
+          Date.commercial(d[:cwyear], d[:cweek], d[:cwday])
+        else
+          Date.commercial(d[:cwyear], d[:cweek])
+        end
+      elsif d[:seconds]
+        Time.at(d[:seconds]).to_date
+      else
+        Date.new(year, mon)
       end
-    
-      # Alias today to today_with_mock_date
-      alias_method :today, :today_with_mock_date
+    end
+
+    alias_method :strptime, :strptime_with_mock_date
+
+    def parse_with_mock_date(*args)
+      parsed_date = parse_without_mock_date(*args)
+      return parsed_date unless mocked_time_stack_item
+      date_hash = Date._parse(*args)
+
+      case
+      when date_hash[:year] && date_hash[:mon]
+        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
+        parsed_date + mocked_time_stack_item.travel_offset_days
+      end
+    end
+
+    alias_method :parse_without_mock_date, :parse
+    alias_method :parse, :parse_with_mock_date
+
+    def mocked_time_stack_item
+      Timecop.top_stack_item
+    end
+
+    def closest_wday(wday)
+      today = Date.today
+      result = today - today.wday
+      result += 1 until wday == result.wday
+      result
     end
   end
 end
 
-if Object.const_defined?(:DateTime) && DateTime.respond_to?(:now)
-  class DateTime #:nodoc:
-    class << self
-      # 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(self)
-      end
-      
-      # Fake alias :now_without_mock_time :now
-      # It appears that the DateTime library itself references Time.now
-      # for it's interpretation of now which caused 
-      # DateTime.now_without_mock_time to incorrectly return the frozen time.
-      def now_without_mock_time
-        Time.now_without_mock_time.send :to_datetime
-      end
-      
-      # Define now_with_mock_time
-      def now_with_mock_time
-        mock_time || now_without_mock_time
+class DateTime #:nodoc:
+  class << self
+    def mock_time
+      mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.datetime(self)
+    end
+
+    def now_with_mock_time
+      mock_time || now_without_mock_time
+    end
+
+    alias_method :now_without_mock_time, :now
+
+    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)
+
+      case
+      when date_hash[:year] && date_hash[:mon]
+        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.closest_wday(date_hash[:wday]).to_datetime
+      else
+        parsed_date + mocked_time_stack_item.travel_offset_days
       end
+    end
+
+    alias_method :parse_without_mock_date, :parse
+    alias_method :parse, :parse_with_mock_date
 
-      # Alias now to now_with_mock_time
-      alias_method :now, :now_with_mock_time
+    def mocked_time_stack_item
+      Timecop.top_stack_item
     end
   end
 end

data/lib/timecop/time_stack_item.rb

@@ -1,145 +1,140 @@
-
 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
-      @dst_adjustment = compute_dst_adjustment(@time)
     end
-    
+
     def year
       time.year
     end
-    
+
     def month
       time.month
     end
-    
+
     def day
       time.day
     end
-    
+
     def hour
       time.hour
     end
-    
+
     def min
       time.min
     end
-    
+
     def sec
       time.sec
     end
-    
+
     def utc_offset
       time.utc_offset
     end
-    
+
     def travel_offset
-      @travel_offset
+      @travel_offset unless mock_type == :freeze
+    end
+
+    def travel_offset_days
+      (@travel_offset / 60 / 60 / 24).round
     end
 
     def scaling_factor
       @scaling_factor
     end
-    
-    def time(time_klass=Time) #:nodoc:
+
+    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
+
       if travel_offset.nil?
-        time_klass.at( @time.to_f )
+        time
       elsif scaling_factor.nil?
-        time_klass.at( ( Time.now_without_mock_time + travel_offset ).to_f )
+        time_klass.at(Time.now_without_mock_time + travel_offset)
       else
-        time_klass.at( scaled_time )
+        time_klass.at(scaled_time)
       end
     end
 
     def scaled_time
       (@time + (Time.now_without_mock_time - @time_was) * scaling_factor).to_f
     end
-    
-    def date(date_klass=Date)
+
+    def date(date_klass = Date)
       date_klass.jd(time.__send__(:to_date).jd)
     end
-    
-    def datetime(datetime_klass=DateTime)
-      # DateTime doesn't know about DST, so let's remove its presence
-      our_offset = utc_offset + dst_adjustment
+
+    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, sec + fractions_of_a_second,
-                           utc_offset_to_rational(our_offset))
+        datetime_klass.new(year, month, day, hour, min, (fractions_of_a_second + sec), utc_offset_to_rational(utc_offset))
       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)
-        ((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_time(*args)
-        time_klass = Time.respond_to?(:zone) && Time.zone ? Time.zone : Time
-        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
-        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)
-        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)
-          Time.now + arg
-        elsif arg.nil?
-          Time.now
+
+    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_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) && 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
+          # 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
-      
-      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
-      end
-      
+    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 time_klass
+      Time.respond_to?(:zone) && Time.zone ? Time.zone : Time
+    end
   end
 end