timecop 0.6.1 → 0.9.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c86a01ea95f5019cb15a6a66c5668e68e7f1e293ca14b910a10cbe1cdd70d668
+  data.tar.gz: e5c6987d3a452fa9ead841021f93bf4ea6bac713c1f6cea38cfc1c1d49baf6ee
+SHA512:
+  metadata.gz: 4abbcd2d37b9fdf6dfb1ed1f63f945a882cd62a47ae2ae237da003ccac0bc660572be0800933ea484fb1632707bdc2de457b96f9aad8a62b1dfd96d766220692
+  data.tar.gz: a19cc9026478a29161a832454edebf76105d56d3841575af71e9dbaa305a40a68af285d17b7473369ae913e463cadd7b67ab2e099d13d3162b713d2c3cd87d05

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,9 +1,7 @@
 # timecop
 
-[![Build Status](https://secure.travis-ci.org/travisjeffery/timecop.png)](http://travis-ci.org/travisjeffery/timecop)
-
-- Source[http://github.com/travisjeffery/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
 
@@ -11,7 +9,7 @@ A gem providing "time travel" and "time freezing" capabilities, making it dead s
 
 ## INSTALL
 
-  gem install timecop
+`bundle add timecop`
 
 ## FEATURES
 
@@ -49,12 +47,13 @@ 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" {}
+  it "should do blah blah blah" do
+  end
 end
 ```
 
@@ -62,7 +61,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
@@ -106,24 +105,40 @@ being able to simulate activity via subsequent calls to your application.
 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
 ```
 
-See #42 for more information, thanks to Ken Mayer, David Holcomb, and Pivotal Labs.
+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
 
-## REFERENCES
+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), and
-was created by [jtrupiano](https://github.com/jtrupiano). 
+was created by [jtrupiano](https://github.com/jtrupiano).
 
 Here's the most direct way to get your work merged into the project.
 

data/Rakefile

@@ -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,3 +1,5 @@
+require 'time'
+require 'date'
 
 class Time #:nodoc:
   class << self
@@ -5,77 +7,148 @@ 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
 
+    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
-      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)
+      #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
+      year = d[:year] || 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[:wday]
+        Date.new(year, mon, now.mday, start) + (d[:wday] - now.wday)
+      elsif d[:yday]
+        Date.new(year, 1, 1, start).next_day(d[:yday] - 1)
+      elsif d[:cwyear] && d[:cweek]
+        if d[:cwday]
+          Date.commercial(d[:cwyear], d[:cweek], d[:cwday], start)
+        else
+          Date.commercial(d[:cwyear], d[:cweek], 1, start)
+        end
+      elsif d[:seconds]
+        Time.at(d[:seconds]).to_date
+      else
+        Date.new(year, mon, 1, start)
       end
-      
-      alias_method :today_without_mock_date, :today
-    
-      def today_with_mock_date
-        mock_date || today_without_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
-    
-      alias_method :today, :today_with_mock_date
+    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
-      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.nil? ? nil : mocked_time_stack_item.datetime(self)
+    end
 
-      alias_method :now, :now_with_mock_time
+    def now_with_mock_time
+      mock_time || now_without_mock_time
     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
+    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
+
+    def mocked_time_stack_item
+      Timecop.top_stack_item
+    end
   end
 end

data/lib/timecop/time_stack_item.rb

@@ -1,158 +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)
-        @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
+  # 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
 
-      def month
-        time.month
-      end
+    def year
+      time.year
+    end
 
-      def day
-        time.day
-      end
+    def month
+      time.month
+    end
 
-      def hour
-        time.hour
-      end
+    def day
+      time.day
+    end
 
-      def min
-        time.min
-      end
+    def hour
+      time.hour
+    end
 
-      def sec
-        time.sec
-      end
+    def min
+      time.min
+    end
 
-      def utc_offset
-        time.utc_offset
-      end
+    def sec
+      time.sec
+    end
 
-      def travel_offset
-        @travel_offset
-      end
+    def utc_offset
+      time.utc_offset
+    end
 
-      def scaling_factor
-        @scaling_factor
-      end
+    def travel_offset
+      @travel_offset unless mock_type == :freeze
+    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)
-        end
+    def travel_offset_days
+      (@travel_offset / 60 / 60 / 24).round
+    end
 
-        if travel_offset.nil?
-          time
-        elsif scaling_factor.nil?
-          klass.at(Time.now_without_mock_time + travel_offset)
-        else
-          klass.at(scaled_time)
-        end
-      end
+    def scaling_factor
+      @scaling_factor
+    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)
-        our_offset = utc_offset + dst_adjustment
+    def scaled_time
+      (@time + (Time.now_without_mock_time - @time_was) * scaling_factor).to_f
+    end
 
-        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 date(date_klass = Date)
+      date_klass.jd(time.__send__(:to_date).jd)
+    end
 
-      def dst_adjustment
-        @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, (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
 
-      private
+    private
 
-      def rational_to_utc_offset(rational)
-        ((24.0 / rational.denominator) * rational.numerator) * (60 * 60)
-      end
+    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 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)
-          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 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
+    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
+    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