timecop 0.9.9 → 0.9.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ffc3899071434ff0ae8eb0a9e4a6ea4c2d8794547113c272bdc24a384d2eb45
-  data.tar.gz: e9333e4c2cf362558c432d7b954a724ff588e66c4dcce8d3af4a327dd6dcb894
+  metadata.gz: '079905b60d7144434c07560dadc7a1dbd36d19ad27f25ecaf52e0143e0656d23'
+  data.tar.gz: f34eb8593ccdd28571a4ccbdd710f518e628da6113eeb0f904e2f04d91dc5bf1
 SHA512:
-  metadata.gz: 692759ecf208cccb83f72d2cd2a3632d6fb6477e9ac1dbf1ca19d8c23a0b864093abdfdc1d51ee98078858dc2dd3eab50f1bd8b469cc84f0619c99bed242169f
-  data.tar.gz: 85fc3b65a8f415601a047d4189ff497a73f49d4d48647881a6579d82dc6f12ab9e6a088da0ca2b3c2a25693f220ce3c8f31b5f2847f6a5d4784c63ace77136ff
+  metadata.gz: bd112c3657079e9c927d266725ba6d231a23658da5f385f1dca760011eff2021a30a1607cc187b26737b6d20244a0e9d54130a5a4c46b93e04c0ddebd3ba4fad
+  data.tar.gz: fa6dc270173399ff8c112624913703f612ea0d25720f13b01be67ee41781b07bd6661a502b0db1e1fdbc34fc91b4acd2966526f2ee1f1acd7463d8db26f40b8e

data/README.markdown

@@ -129,6 +129,15 @@ Timecop.freeze
 # => Timecop::SafeModeException: Safe mode is enabled, only calls passing a block are allowed.
 ```
 
+### Configuring Mocking Process.clock_gettime
+
+By default Timecop does not mock Process.clock_gettime. You must enable it like this:
+
+``` ruby
+# turn on
+Timecop.mock_process_clock = true
+```
+
 ### Rails v Ruby Date/Time libraries
 
 Sometimes [Rails Date/Time methods don't play nicely with Ruby Date/Time methods.](https://rails.lighthouseapp.com/projects/8994/tickets/6410-dateyesterday-datetoday)

data/lib/timecop/time_extensions.rb

@@ -18,12 +18,16 @@ class Time #:nodoc:
 
     alias_method :new_without_mock_time, :new
 
-    def new_with_mock_time(*args)
-      args.size <= 0 ? now : new_without_mock_time(*args)
+    def new_with_mock_time(*args, **kwargs)
+      if args.empty? && kwargs.empty?
+        now
+      elsif kwargs.any?
+        new_without_mock_time(*args, **kwargs)
+      else
+        new_without_mock_time(*args)
+      end
     end
 
-    ruby2_keywords :new_with_mock_time if Module.private_method_defined?(:ruby2_keywords)
-
     alias_method :new, :new_with_mock_time
   end
 end
@@ -50,7 +54,12 @@ class Date #:nodoc:
 
       d = Date._strptime(str, fmt)
       now = Time.now.to_date
-      year = d[:year] || d[:cwyear] || now.year
+
+      # If "current" time falls near a year boundary, with a year-ambiguous str, we need to explicitly handle it
+      cwday = d[:cwday] && (now + (d[:cwday] - now.wday))
+      wday = d[:wday] && (now + (d[:wday] - now.wday))
+
+      year = d[:year] || d[:cwyear] || (cwday || wday || now).year
       mon = d[:mon] || now.mon
       if d.keys == [:year]
         Date.new(year, 1, 1, start)
@@ -59,7 +68,8 @@ class Date #:nodoc:
       elsif d[:yday]
         Date.new(year, 1, 1, start).next_day(d[:yday] - 1)
       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
+        # When only a day (wday/cwday) is present, derive the week from the resolved date; otherwise fall back to now's week
+        week = d[:cweek] || d[:wnum1] || d[:wnum0] || (cwday || wday || 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)
@@ -154,6 +164,8 @@ class DateTime #:nodoc:
         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])
+      when date_hash[:hour] && date_hash[:min]
+        DateTime.new(mocked_time_stack_item.year, mocked_time_stack_item.month, mocked_time_stack_item.day, date_hash[:hour], date_hash[:min], 0)
       else
         parsed_date + mocked_time_stack_item.travel_offset_days
       end
@@ -168,58 +180,56 @@ class DateTime #:nodoc:
   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
+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
 
-        (mock_time / divisor)
-      end
+      return clock_gettime_without_mock(clock_id, unit) unless Timecop.mock_process_clock? && 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
+    alias_method :clock_gettime, :clock_gettime_mock_time
 
-      private
+    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_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
+    def mock_time_realtime
+      mocked_time_stack_item = Timecop.top_stack_item
 
-        return nil if mocked_time_stack_item.nil?
+      return nil if mocked_time_stack_item.nil?
 
-        t = mocked_time_stack_item.time
-        t.to_i * 1_000_000_000 + t.nsec
-      end
+      t = mocked_time_stack_item.time
+      t.to_i * 1_000_000_000 + t.nsec
     end
   end
 end

data/lib/timecop/time_stack_item.rb

@@ -9,7 +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'
+      @monotonic      = parse_monotonic_time(*args)
       @time           = parse_time(*args)
       @time_was       = Time.now_without_mock_time
       @travel_offset  = compute_travel_offset
@@ -55,24 +55,22 @@ 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
+    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
+      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
+    def current_monotonic_with_mock
+      Process.clock_gettime_mock_time(Process::CLOCK_MONOTONIC, :nanosecond)
     end
 
     def time(time_klass = Time) #:nodoc:

data/lib/timecop/timecop.rb

@@ -142,6 +142,14 @@ class Timecop
       !instance.stack.empty? && instance.stack.last.mock_type == :scale
     end
 
+    def mock_process_clock=(mock)
+      @mock_process_clock = mock
+    end
+
+    def mock_process_clock?
+      @mock_process_clock ||= false
+    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.9"
+  VERSION = "0.9.11"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timecop
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.9.11
 platform: ruby
 authors:
 - Travis Jeffery
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-01 00:00:00.000000000 Z
+date: 2026-04-12 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
@@ -42,7 +42,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="