timecop 0.9.4 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e107de03899173505259909d8ec9e008082d8fa4cf551a2326a6bc98890285e
-  data.tar.gz: e50a9c462cafa4feb5a1b47fc720f853c1a7ac62bd5d404ecad3f2b749be0ef4
+  metadata.gz: 681f52d846b808b06ff833f3fbfc21e3c7c4c1bf426baa03f101c0a2c3b79ce8
+  data.tar.gz: b95b6d4a3c357e7f11f046d82dad3badd81d4903c96ef2b8e77762f241eeb66e
 SHA512:
-  metadata.gz: 427b83dd2d0506193c3c4d947cb1281817a531a64f09f73f004d97c17339665311774e775bc7506e4447ed2c66636e0df2cd954447e079409aef347262ab3e30
-  data.tar.gz: 631df874968afa111e81b255d665972085ec64a6c315b424304148a75c3226eb7e0f259ed7d149c6829950394f340b4cd595fa21720149104b2c4c8e2448b586
+  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

@@ -50,11 +50,16 @@ 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)
@@ -85,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
@@ -133,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)

data/lib/timecop/version.rb

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

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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.9.5
 platform: ruby
 authors:
 - Travis Jeffery
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-09 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.0.8
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 3
 summary: A gem providing "time travel" and "time freezing" capabilities, making it