timecop 0.9.7 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 016ae208ea8ac5c5713b042c7ea1f030bd2d3ff312e95b349e3d31264fc0f0d4
-  data.tar.gz: ed69f4b76ca2a02af2c10f4ad486140bbfefae3d1f3ac13f2d0e7a9176ba09d8
+  metadata.gz: 5ffc3899071434ff0ae8eb0a9e4a6ea4c2d8794547113c272bdc24a384d2eb45
+  data.tar.gz: e9333e4c2cf362558c432d7b954a724ff588e66c4dcce8d3af4a327dd6dcb894
 SHA512:
-  metadata.gz: f47a6e763afa59b037e5e00250b63a623cf3e605135962ecca5bd7eba9e7e36db669c8c261dcefc52ee6c852f1a1507977d5266ad1c63bd007d1edc50414ea1e
-  data.tar.gz: b4a3bff764722b9d1c95d0e7f01dbdad3953503d87e4587c02ad12c0fc5ebe47598177cafdd4d81b9dfaee6ef76447a2e15f5382403cad224fbe08221886fc90
+  metadata.gz: 692759ecf208cccb83f72d2cd2a3632d6fb6477e9ac1dbf1ca19d8c23a0b864093abdfdc1d51ee98078858dc2dd3eab50f1bd8b469cc84f0619c99bed242169f
+  data.tar.gz: 85fc3b65a8f415601a047d4189ff497a73f49d4d48647881a6579d82dc6f12ab9e6a088da0ca2b3c2a25693f220ce3c8f31b5f2847f6a5d4784c63ace77136ff

data/README.markdown

@@ -5,7 +5,7 @@
 
 ## 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 `Time.now`, `Date.today`, and `DateTime.now` in a single call.
+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`, `Date.today`, `DateTime.now`, and `Process.clock_gettime` in a single call.
 
 ## INSTALL
 

data/lib/timecop/time_extensions.rb

@@ -58,14 +58,21 @@ class Date #:nodoc:
         Date.new(year, mon, d[:mday], start)
       elsif d[:yday]
         Date.new(year, 1, 1, start).next_day(d[:yday] - 1)
-      elsif d[:cwyear] || d[:cweek] || d[:wnum1] || d[:wday] || d[:cwday]
-        day_of_week_from_monday = if d[:wday]
-                                    (d[:wday] + 6)%7 + 1
-                                  else
-                                    d[:cwday] || 1
-                                  end
-        week = d[:cweek] || d[:wnum1] || now.strftime('%W').to_i
-        Date.commercial(year, week, day_of_week_from_monday, start)
+      elsif d[:cwyear] || d[:cweek] || d[:wnum0] || d[:wnum1] || d[:wday] || d[:cwday]
+        week = d[:cweek] || d[:wnum1] || d[:wnum0] || now.strftime('%W').to_i
+        if d[:wnum0] #Week of year where week starts on sunday
+          if d[:cwday] #monday based day of week
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:cwday]}", '%Y %U %u', start)
+          else
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:wday] || 0}", '%Y %U %w', start)
+          end
+        else #Week of year where week starts on monday
+          if d[:wday] #sunday based day of week
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:wday]}", '%Y %W %w', start)
+          else
+            Date.strptime_without_mock_date("#{year} #{week} #{d[:cwday] || 1}", '%Y %W %u', start)
+          end
+        end
       elsif d[:seconds]
         Time.at(d[:seconds]).to_date
       else
@@ -136,8 +143,17 @@ class DateTime #:nodoc:
         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_hash[:hour] && date_hash[:min]
+        closest_date = Date.closest_wday(date_hash[:wday]).to_datetime
+
+        DateTime.new(
+          closest_date.year, closest_date.month, closest_date.day,
+          date_hash[:hour], date_hash[:min]
+        )
       when date_hash[:wday]
         Date.closest_wday(date_hash[:wday]).to_datetime
+      when date_hash[:hour] && date_hash[:min] && date_hash[:sec]
+        DateTime.new(mocked_time_stack_item.year, mocked_time_stack_item.month, mocked_time_stack_item.day, date_hash[:hour], date_hash[:min], date_hash[:sec])
       else
         parsed_date + mocked_time_stack_item.travel_offset_days
       end
@@ -151,3 +167,59 @@ class DateTime #:nodoc:
     end
   end
 end
+
+if RUBY_VERSION >= '2.1.0'
+  module Process #:nodoc:
+    class << self
+      alias_method :clock_gettime_without_mock, :clock_gettime
+
+      def clock_gettime_mock_time(clock_id, unit = :float_second)
+        mock_time = case clock_id
+                    when Process::CLOCK_MONOTONIC
+                      mock_time_monotonic
+                    when Process::CLOCK_REALTIME
+                      mock_time_realtime
+                    end
+
+        return clock_gettime_without_mock(clock_id, unit) unless mock_time
+
+        divisor = case unit
+                  when :float_second
+                    1_000_000_000.0
+                  when :second
+                    1_000_000_000
+                  when :float_millisecond
+                    1_000_000.0
+                  when :millisecond
+                    1_000_000
+                  when :float_microsecond
+                    1000.0
+                  when :microsecond
+                    1000
+                  when :nanosecond
+                    1
+                  end
+
+        (mock_time / divisor)
+      end
+
+      alias_method :clock_gettime, :clock_gettime_mock_time
+
+      private
+
+      def mock_time_monotonic
+        mocked_time_stack_item = Timecop.top_stack_item
+        mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.monotonic
+      end
+
+      def mock_time_realtime
+        mocked_time_stack_item = Timecop.top_stack_item
+
+        return nil if mocked_time_stack_item.nil?
+
+        t = mocked_time_stack_item.time
+        t.to_i * 1_000_000_000 + t.nsec
+      end
+    end
+  end
+end

data/lib/timecop/time_stack_item.rb

@@ -9,6 +9,7 @@ class Timecop
       @travel_offset  = @scaling_factor = nil
       @scaling_factor = args.shift if mock_type == :scale
       @mock_type      = mock_type
+      @monotonic      = parse_monotonic_time(*args) if RUBY_VERSION >= '2.1.0'
       @time           = parse_time(*args)
       @time_was       = Time.now_without_mock_time
       @travel_offset  = compute_travel_offset
@@ -54,9 +55,29 @@ class Timecop
       @scaling_factor
     end
 
+    if RUBY_VERSION >= '2.1.0'
+      def monotonic
+        if travel_offset.nil?
+          @monotonic
+        elsif scaling_factor.nil?
+          current_monotonic + travel_offset * (10 ** 9)
+        else
+          (@monotonic + (current_monotonic - @monotonic) * scaling_factor).to_i
+        end
+      end
+
+      def current_monotonic
+        Process.clock_gettime_without_mock(Process::CLOCK_MONOTONIC, :nanosecond)
+      end
+
+      def current_monotonic_with_mock
+        Process.clock_gettime_mock_time(Process::CLOCK_MONOTONIC, :nanosecond)
+      end
+    end
+
     def time(time_klass = Time) #:nodoc:
       if @time.respond_to?(:in_time_zone)
-        time = time_klass.at(@time.localtime)
+        time = time_klass.at(@time.dup.localtime)
       else
         time = time_klass.at(@time)
       end
@@ -97,6 +118,16 @@ class Timecop
       Rational(utc_offset, 24 * 60 * 60)
     end
 
+    def parse_monotonic_time(*args)
+      arg = args.shift
+      offset_in_nanoseconds = if args.empty? && (arg.kind_of?(Integer) || arg.kind_of?(Float))
+        arg * 1_000_000_000
+      else
+        0
+      end
+      current_monotonic_with_mock + offset_in_nanoseconds
+    end
+
     def parse_time(*args)
       arg = args.shift
       if arg.is_a?(Time)

data/lib/timecop/timecop.rb

@@ -38,6 +38,12 @@ class Timecop
     # previous values after the block has finished executing.  This allows us to nest multiple
     # calls to Timecop.travel and have each block maintain it's concept of "now."
     #
+    # The Process.clock_gettime call mocks both CLOCK::MONOTIC and CLOCK::REALTIME
+    #
+    # CLOCK::MONOTONIC works slightly differently than other clocks. This clock cannot move to a
+    # particular date/time. So the only option that changes this clock is #4 which will move the
+    # clock the requested offset. Otherwise the clock is frozen to the current tick.
+    #
     # * Note: Timecop.freeze will actually freeze time.  This can cause unanticipated problems if
     #   benchmark or other timing calls are executed, which implicitly expect Time to actually move
     #   forward.
@@ -126,6 +132,16 @@ class Timecop
       !instance.stack.empty? && instance.stack.last.mock_type == :freeze
     end
 
+    # Returns whether or not Timecop is currently travelled
+    def travelled?
+      !instance.stack.empty? && instance.stack.last.mock_type == :travel
+    end
+
+    # Returns whether or not Timecop is currently scaled
+    def scaled?
+      !instance.stack.empty? && instance.stack.last.mock_type == :scale
+    end
+
     private
     def send_travel(mock_type, *args, &block)
       val = instance.travel(mock_type, *args, &block)

data/lib/timecop/version.rb

@@ -1,3 +1,3 @@
 class Timecop
-  VERSION = "0.9.7"
+  VERSION = "0.9.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 0.9.9
 platform: ruby
 authors:
 - Travis Jeffery
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-12 00:00:00.000000000 Z
+date: 2024-06-01 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