timecop 0.9.2 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e1bf57b28c2d86304d5ca7192fb44fab26457ea631ebe45d1361b4e8ad165e5
-  data.tar.gz: cbd98da4611a74dda4c377a89b25a9e66be575fde9278663a36386857f0b80db
+  metadata.gz: 681f52d846b808b06ff833f3fbfc21e3c7c4c1bf426baa03f101c0a2c3b79ce8
+  data.tar.gz: b95b6d4a3c357e7f11f046d82dad3badd81d4903c96ef2b8e77762f241eeb66e
 SHA512:
-  metadata.gz: 5f3d6796ee0f520b1bcc6dfc3cd7251f8a9ae32b6079e29b7564418f9250da70bd3d39042c311d17e7f1507ff2a6522ece4a4160d6bb8170db820b6b60c9493d
-  data.tar.gz: bc5600d477a487a23892ffed0a57511aa66dfb188b8b6600ff82194afe8b38921ed869fc184f15584be18f7b1f8a68bebe15b9f96ee0628bd2bde60302cb4fc5
+  metadata.gz: e62e48939fb924a78d59199222688ae7692a2f6649c16daac296375ac1e537fa1c85e6a34d1a5cbd64b209e643ffa08d180ce3d933905f91284ce4c819873c1e
+  data.tar.gz: f6f5ef32ee1bfadfd43a5a8899bb521873d61eafd2f242942df6e80a3ed11f80a170d074ada23a61eb3b92009eeaf3a1046b126c802dc9a1c014c77d32acb3ab

data/README.markdown

@@ -1,6 +1,7 @@
 # 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
 

data/lib/timecop/time_extensions.rb

@@ -22,6 +22,8 @@ class Time #:nodoc:
       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
@@ -48,16 +50,31 @@ class Date #:nodoc:
           "supports Date::ITALY for the start argument."
       end
 
-      d = Date._strptime(str, fmt) || Date.strptime_without_mock_date(str, fmt)
+      #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[:mday]
+      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, now.mday)
+        Date.new(year, mon)
       end
     end
 
@@ -73,6 +90,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
@@ -121,6 +140,8 @@ 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.closest_wday(date_hash[:wday]).to_datetime
       else

data/lib/timecop/time_stack_item.rb

@@ -1,140 +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
-      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 unless mock_type == :freeze
-      end
+    def utc_offset
+      time.utc_offset
+    end
 
-      def travel_offset_days
-        (@travel_offset / 60 / 60 / 24).round
-      end
+    def travel_offset
+      @travel_offset unless mock_type == :freeze
+    end
 
-      def scaling_factor
-        @scaling_factor
-      end
+    def travel_offset_days
+      (@travel_offset / 60 / 60 / 24).round
+    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 scaling_factor
+      @scaling_factor
+    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
+    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 scaled_time
-        (@time + (Time.now_without_mock_time - @time_was) * scaling_factor).to_f
+      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 date(date_klass = Date)
-        date_klass.jd(time.__send__(:to_date).jd)
-      end
+    def scaled_time
+      (@time + (Time.now_without_mock_time - @time_was) * scaling_factor).to_f
+    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
+    def date(date_klass = Date)
+      date_klass.jd(time.__send__(:to_date).jd)
+    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
 
-      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)
-          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

@@ -13,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:
@@ -74,11 +76,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
@@ -86,21 +88,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 +114,25 @@ 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
     def frozen?
-      !instance.send(:stack).empty?
+      !instance.stack.empty?
     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 +200,7 @@ class Timecop
       begin
         yield stack_item.time
       ensure
-        @stack.replace stack_backup
+        stack.replace stack_backup
         @safe = safe_backup
       end
     end

data/lib/timecop/version.rb

@@ -1,3 +1,3 @@
 class Timecop
-  VERSION = "0.9.2"
+  VERSION = "0.9.5"
 end

data/test/test_helper.rb

@@ -29,7 +29,7 @@ class Minitest::Test
       Time.at(time.to_i).to_datetime.offset
     end
 
-    TIMEZONES = ["Europe/Paris", "UTC", "America/Chicago"]
+    TIMEZONES = ["Pacific/Midway", "Europe/Paris", "UTC", "America/Chicago"]
 
     def each_timezone
       old_tz = ENV["TZ"]

data/test/timecop_test.rb

@@ -289,6 +289,17 @@ class TestTimecop < Minitest::Test
     t = Time.local(2008, 10, 10, 10, 10, 10)
     assert_times_effectively_equal t, Timecop.scale(4, t)
   end
+  
+  def test_scaling_returns_now_if_nil_supplied
+    assert_times_effectively_equal Time.now, Timecop.scale(nil)
+  end
+
+  def test_scaling_raises_when_empty_string_supplied
+    err = assert_raises(TypeError) do
+      Timecop.scale("")
+    end
+    assert_match /String can't be coerced into Float/, err.message
+  end
 
   def test_freeze_with_utc_time
     each_timezone do
@@ -394,6 +405,10 @@ class TestTimecop < Minitest::Test
     end
     assert_times_effectively_equal(time_after_travel, Time.now)
   end
+  
+  def test_travel_returns_now_if_nil_supplied
+    assert_times_effectively_equal Time.now, Timecop.travel(nil)
+  end
 
   def test_travel_time_with_block_returns_the_value_of_the_block
     t_future = Time.local(2030, 10, 10, 10, 10, 10)
@@ -402,6 +417,13 @@ class TestTimecop < Minitest::Test
 
     assert_equal expected, actual
   end
+  
+  def test_travel_raises_when_empty_string_supplied
+    err = assert_raises(ArgumentError) do
+      Timecop.travel("")
+    end
+    assert_match /no time information in \"\"/, err.message
+  end
 
   def test_freeze_time_returns_now_if_no_block_given
     t_future = Time.local(2030, 10, 10, 10, 10, 10)
@@ -428,6 +450,17 @@ class TestTimecop < Minitest::Test
       end
     end
   end
+  
+   def test_freeze_returns_now_if_nil_supplied
+    assert_times_effectively_equal Time.now, Timecop.freeze(nil)
+  end
+
+  def test_freeze_raises_when_empty_string_supplied
+    err = assert_raises(ArgumentError) do
+      Timecop.freeze("")
+    end
+     assert_match /no time information in \"\"/, err.message
+  end
 
   def test_freeze_with_new_date
     date = Date.new(2012, 6, 9)
@@ -533,38 +566,6 @@ class TestTimecop < Minitest::Test
     end
   end
 
-  def test_date_strptime_without_year
-    Timecop.freeze(Time.new(1984,2,28)) do
-      assert_equal Date.strptime('04-14', '%m-%d'), Date.new(1984, 4, 14)
-    end
-  end
-
-  def test_date_strptime_without_specifying_format
-    Timecop.freeze(Time.new(1984,2,28)) do
-      assert_equal Date.strptime('1999-04-14'), Date.new(1999, 4, 14)
-    end
-  end
-
-  def test_date_strptime_with_day_of_week
-    Timecop.freeze(Time.new(1984,2,28)) do
-      assert_equal Date.strptime('Thursday', '%A'), Date.new(1984, 3, 1)
-      assert_equal Date.strptime('Monday', '%A'), Date.new(1984, 2, 27)
-    end
-  end
-
-  def test_date_strptime_with_invalid_date
-    begin
-      Date.strptime('', '%Y-%m-%d')
-    rescue ArgumentError => e
-      assert_equal 'invalid date', e.message
-    end
-  end
-
-  def test_ancient_strptime
-    ancient = Date.strptime('11-01-08', '%Y-%m-%d').strftime
-    assert_equal '0011-01-08', ancient # Failed before fix to strptime_with_mock_date
-  end
-
   def test_frozen_after_freeze
     Timecop.freeze
     assert Timecop.frozen?
@@ -582,7 +583,7 @@ class TestTimecop < Minitest::Test
     assert !Timecop.frozen?
   end
 
-  def test_thread_safe_timecop
+  def test_thread_safe_timecop_in_parallel
     Timecop.thread_safe = true
     date = Time.local(2011, 01, 02)
     thread = Thread.new do
@@ -599,6 +600,16 @@ class TestTimecop < Minitest::Test
     Timecop.thread_safe = false
   end
 
+  def test_thread_safe_timecop_returns_after_block
+    Timecop.thread_safe = true
+    date = Time.local(2017, 10, 8)
+
+    Timecop.freeze(date) { }
+    assert Time.now != date
+  ensure
+    Timecop.thread_safe = false
+  end
+
   private
 
   def with_safe_mode(enabled=true)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.5
 platform: ruby
 authors:
 - Travis Jeffery
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-14 00:00:00.000000000 Z
+date: 2022-03-07 00:00:00.000000000 Z
 dependencies: []
 description: A gem providing "time travel" and "time freezing" capabilities, making
   it dead simple to test time-dependent code.  It provides a unified method to mock
@@ -54,7 +54,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 3
 summary: A gem providing "time travel" and "time freezing" capabilities, making it