timecop 0.8.0 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6e96be7760b99a2b26e5d68800d2980190fe22c2
-  data.tar.gz: 9c55cc8abe218ff8dd6035452ffe5e1056d592a4
+SHA256:
+  metadata.gz: ad1963ee820d4d3519b4e078879aaa3914b2e9802460480fd9ca3c4a239677e4
+  data.tar.gz: 49a827fc02c8580d33d6861f51974dd046996e7281442c33f89c527d4d4c5af0
 SHA512:
-  metadata.gz: 6f5b765cd3bc5ead77b8947e18d8230f164a1b4655f26ccc73bc7715a70666bf6e623a8567274fda5b375955f30a7bbeb825921fa24c2bb046de9cd8b26df429
-  data.tar.gz: 2170ebdcf36371775b6b2abd27faf6ed435ba3d7469c405d8dbda47328622a9375b847de7663e25ff23a6dd8fbddc64012246f4127752a21a143d87458ee0f94
+  metadata.gz: d18895efbc69f3768fcf68fa372759e727c30869e5ff1a77c8b7a2901e4a89dd49fe61df38c0a5c57dd9604250e0c49733c990c32757ac9a374a56fb3962d441
+  data.tar.gz: 6938b5dfc45c545d8c0e83b757f1b99d9b69b2cfe23d5e1d0f9b4fc4ff56282af201a982bcf52084f05b0de88ea36256ecbe54e2988fc944693940f5179dcb97

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,14 +1,15 @@
 # timecop
 
-[![Build Status](https://secure.travis-ci.org/travisjeffery/timecop.png)](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
 
-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`, and `DateTime.now` in a single call.
 
 ## INSTALL
 
-`gem install timecop`
+`bundle add timecop`
 
 ## FEATURES
 
@@ -16,13 +17,13 @@ A gem providing "time travel" and "time freezing" capabilities, making it dead s
 - Travel back to a specific point in time, but allow time to continue moving forward from there.
 - Scale time by a given scaling factor that will cause time to move at an accelerated pace.
 - No dependencies, can be used with _any_ ruby project
-- Timecop api allows arguments to be passed into #freeze and #travel as one of the following:
+- Timecop api allows arguments to be passed into `#freeze` and `#travel` as one of the following:
   - Time instance
   - DateTime instance
   - Date instance
   - individual arguments (year, month, day, hour, minute, second)
-  - a single integer argument that is interpreted as an offset in seconds from Time.now
-- Nested calls to Timecop#travel and Timecop#freeze are supported -- each block will maintain its interpretation of now.
+  - a single integer argument that is interpreted as an offset in seconds from `Time.now`
+- Nested calls to `Timecop#travel` and `Timecop#freeze` are supported -- each block will maintain its interpretation of now.
 - Works with regular Ruby projects, and Ruby on Rails projects
 
 ## USAGE
@@ -61,7 +62,7 @@ helpful if your whole application is time-sensitive.  It allows you to build
 your test data at a single point in time, and to move in/out of that time as
 appropriate (within your tests)
 
-in config/environments/test.rb
+in `config/environments/test.rb`
 
 ```ruby
 config.after_initialize do
@@ -73,10 +74,10 @@ end
 
 ### The difference between Timecop.freeze and Timecop.travel
 
-freeze is used to statically mock the concept of now. As your program executes,
-Time.now will not change unless you make subsequent calls into the Timecop API.
-travel, on the other hand, computes an offset between what we currently think
-Time.now is (recall that we support nested traveling) and the time passed in.
+`freeze` is used to statically mock the concept of now. As your program executes,
+`Time.now` will not change unless you make subsequent calls into the Timecop API.
+`travel`, on the other hand, computes an offset between what we currently think
+`Time.now` is (recall that we support nested traveling) and the time passed in.
 It uses this offset to simulate the passage of time.  To demonstrate, consider
 the following code snippets:
 
@@ -104,7 +105,7 @@ being able to simulate activity via subsequent calls to your application.
 Timecop.scale(3600)
 Time.now
 # => 2012-09-20 21:23:25 -0500
-# seconds later, hours have past it's gone from 9pm at night to 6am in the morning
+# seconds later, hours have passed and it's gone from 9pm at night to 6am in the morning
 Time.now
 # => 2012-09-21 06:22:59 -0500
 ```
@@ -128,6 +129,12 @@ Timecop.freeze
 # => Timecop::SafeModeException: Safe mode is enabled, only calls passing a block are allowed.
 ```
 
+### 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)
+
+Be careful mixing Ruby `Date.today` with Rails `Date.tomorrow` / `Date.yesterday` as things might break.
+
 ## Contribute
 
 timecop is maintained by [travisjeffery](http://github.com/travisjeffery), and

data/Rakefile

@@ -3,8 +3,6 @@ require 'bundler/gem_tasks'
 require 'rake/testtask'
 require 'rdoc/task'
 
-$LOAD_PATH.unshift("lib")
-
 Rake::RDocTask.new do |rdoc|
   if File.exist?('VERSION')
     version = File.read('VERSION')
@@ -21,7 +19,15 @@ Rake::RDocTask.new do |rdoc|
 end
 
 task :test do
-  system "cd test && ./run_tests.sh" or fail
+  failed = Dir["test/*_test.rb"].map do |test|
+    command = "ruby #{test}"
+    puts
+    puts command
+    command unless system(command)
+  end.compact
+  if failed.any?
+    abort "#{failed.count} Tests failed\n#{failed.join("\n")}"
+  end
 end
 
 desc 'Default: run tests'

data/lib/timecop/time_extensions.rb

@@ -22,24 +22,15 @@ 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
 
 class Date #:nodoc:
-  WEEKDAYS = {
-    "sunday"    => 0,
-    "monday"    => 1,
-    "tuesday"   => 2,
-    "wednesday" => 3,
-    "thursday"  => 4,
-    "friday"    => 5,
-    "saturday"  => 6
-  }
-
   class << self
     def mock_date
-      mocked_time_stack_item = Timecop.top_stack_item
       mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.date(self)
     end
 
@@ -54,37 +45,81 @@ 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] || d[:cwyear] || 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[: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
+        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
+        Date.new(year, mon, 1, start)
       end
-
-      Time.strptime(str, fmt).to_date
     end
 
     alias_method :strptime, :strptime_with_mock_date
 
     def parse_with_mock_date(*args)
-      str = args.first
-      if str && WEEKDAYS.keys.include?(str.downcase)
-        offset = WEEKDAYS[str.downcase] - Date.today.wday
-
-        Date.today + offset
+      parsed_date = parse_without_mock_date(*args)
+      return parsed_date unless mocked_time_stack_item
+      date_hash = Date._parse(*args)
+
+      case
+      when date_hash[:year] && date_hash[:mon]
+        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
-        parse_without_mock_date(*args)
+        parsed_date + mocked_time_stack_item.travel_offset_days
       end
     end
 
     alias_method :parse_without_mock_date, :parse
     alias_method :parse, :parse_with_mock_date
 
+    def mocked_time_stack_item
+      Timecop.top_stack_item
+    end
+
+    def closest_wday(wday)
+      today = Date.today
+      result = today - today.wday
+      result += 1 until wday == result.wday
+      result
+    end
   end
 end
 
 class DateTime #:nodoc:
   class << self
     def mock_time
-      mocked_time_stack_item = Timecop.top_stack_item
       mocked_time_stack_item.nil? ? nil : mocked_time_stack_item.datetime(self)
     end
 
@@ -97,19 +132,29 @@ class DateTime #:nodoc:
     alias_method :now, :now_with_mock_time
 
     def parse_with_mock_date(*args)
-      str = args.first
-      if str && Date::WEEKDAYS.keys.include?(str.downcase)
-        offset = Date::WEEKDAYS[str.downcase] - DateTime.now.wday
-
-        parsed_weekday =(DateTime.now + offset)
-
-        DateTime.new(parsed_weekday.year, parsed_weekday.month, parsed_weekday.day, 0, 0, 0, 0)
+      parsed_date = parse_without_mock_date(*args)
+      return parsed_date unless mocked_time_stack_item
+      date_hash = DateTime._parse(*args)
+
+      case
+      when date_hash[:year] && date_hash[:mon]
+        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
-        parse_without_mock_date(*args)
+        parsed_date + mocked_time_stack_item.travel_offset_days
       end
     end
 
     alias_method :parse_without_mock_date, :parse
     alias_method :parse, :parse_with_mock_date
+
+    def mocked_time_stack_item
+      Timecop.top_stack_item
+    end
   end
 end

data/lib/timecop/time_stack_item.rb

@@ -1,137 +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
+  # 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
+    def year
+      time.year
+    end
 
-      def month
-        time.month
-      end
+    def month
+      time.month
+    end
 
-      def day
-        time.day
-      end
+    def day
+      time.day
+    end
 
-      def hour
-        time.hour
-      end
+    def hour
+      time.hour
+    end
 
-      def min
-        time.min
-      end
+    def min
+      time.min
+    end
 
-      def sec
-        time.sec
-      end
+    def sec
+      time.sec
+    end
 
-      def utc_offset
-        time.utc_offset
-      end
+    def utc_offset
+      time.utc_offset
+    end
 
-      def travel_offset
-        @travel_offset
-      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.utc.to_r)
-        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).to_f)
-        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)
-          Time.now + arg
-        elsif arg.nil?
-          Time.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.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
-        return nil if mock_type == :freeze
-        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