timecop 0.9.1 → 0.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 73784bb387b1ff9addf9f0ea04a14e28d679a577
-  data.tar.gz: 18fbfbd85ceae5b1a23111267b7b39287911b080
+SHA256:
+  metadata.gz: c86a01ea95f5019cb15a6a66c5668e68e7f1e293ca14b910a10cbe1cdd70d668
+  data.tar.gz: e5c6987d3a452fa9ead841021f93bf4ea6bac713c1f6cea38cfc1c1d49baf6ee
 SHA512:
-  metadata.gz: 39552bdc1d0278558f91802906da230656323690b3a4663c6c054e2f8ad379df9f593e65265faa6d0ee6769423b0d73d3ab3a1e16c8ac0ee80896cd88e5661ba
-  data.tar.gz: 669823d9cd754f2fa5ec195012aa43f43a070e61e3be41dda3ada13eceaffa06733cb6302bbdf88b0764da28d6a3860d74d4505ba3fa4a75be88ef96c03d0ad1
+  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,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
 
@@ -8,7 +9,7 @@ A gem providing "time travel" and "time freezing" capabilities, making it dead s
 
 ## INSTALL
 
-`gem install timecop`
+`bundle add timecop`
 
 ## FEATURES
 

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
@@ -43,12 +45,32 @@ 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
+      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
-
-      Time.strptime(str, fmt).to_date
     end
 
     alias_method :strptime, :strptime_with_mock_date
@@ -63,6 +85,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
@@ -111,6 +135,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

@@ -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:
@@ -75,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
@@ -87,20 +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
@@ -235,3 +235,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.6"
 end

data/test/test_helper.rb

@@ -1,10 +1,11 @@
 require 'bundler/setup'
 require 'minitest/autorun'
 require 'minitest/rg'
+require 'pry'
 
 $VERBOSE = true # enable ruby warnings
 
-require 'mocha/setup'
+require 'mocha/minitest'
 
 class Minitest::Test
   private
@@ -28,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/time_stack_item_test.rb

@@ -181,7 +181,7 @@ class TestTimeStackItem < Minitest::Test
     t = Time.local(2009, 10, 1, 0, 0, 30)
     tsi = Timecop::TimeStackItem.new(:freeze, t)
 
-    assert_equal nil, tsi.send(:travel_offset)
+    assert_nil tsi.send(:travel_offset)
   end
 
   def test_timezones
@@ -206,7 +206,7 @@ class TestTimeStackItem < Minitest::Test
     time = Time.zone.local(2013,1,3)
 
     Timecop.freeze(time) do
-      assert_equal time.to_date, Time.now.to_date
+      assert_equal time.to_date, Time.zone.now.to_date
     end
   end
 

data/test/timecop_test.rb

@@ -37,6 +37,12 @@ class TestTimecop < Minitest::Test
     assert_nil Time.send(:mock_time)
   end
 
+  def test_freeze_then_unfreeze_unsets_mock_time
+    Timecop.freeze(1)
+    Timecop.unfreeze
+    assert_nil Time.send(:mock_time)
+  end
+
   def test_travel_then_return_unsets_mock_time
     Timecop.travel(1)
     Timecop.return
@@ -283,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
@@ -388,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)
@@ -396,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)
@@ -422,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)
@@ -527,18 +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_frozen_after_freeze
     Timecop.freeze
     assert Timecop.frozen?
@@ -556,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
@@ -573,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,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.6
 platform: ruby
 authors:
 - Travis Jeffery
 - John Trupiano
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-07-05 00:00:00.000000000 Z
+date: 2022-11-29 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
@@ -38,7 +38,7 @@ homepage: https://github.com/travisjeffery/timecop
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -54,9 +54,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: timecop
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.2.15
+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,
@@ -67,4 +66,3 @@ test_files:
 - test/timecop_test.rb
 - test/timecop_without_date_test.rb
 - test/timecop_without_date_but_with_time_test.rb
-has_rdoc: