working_hours 1.3.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bdb747e39a652368403adb9ad97f3776a8d8ab28f841d70912bcab6141118ea
-  data.tar.gz: 74e1447b590b829f95e52fe3c5bac18e7a690dcc8b21683402982f5810b94d8c
+  metadata.gz: 9d51f59c3456e35117b42605450d911595a331ef6a72303aba33a6eedcdabd6f
+  data.tar.gz: '0527249d73eb1da76205e5b02bd7d67226a105c91f2a14240ddfd39abc0daeb6'
 SHA512:
-  metadata.gz: ee953af27c8d6622d8089feec9cd5b966613baff8239c11e488668ad07a48023efbd98d28599f9723c913b7e295ced2ac2b4cb5ef70711c4950ed8afea2aa107
-  data.tar.gz: 5b632e842d20ff83173c83a3e34c4bf166237f3689ba130db2cfd3031e027078f1efa1acbddac588198d78b07f3775c94e88f6d83fba328a9400629e92fab107
+  metadata.gz: b276429238c21dbb526c53d4be5082450c99b5c5414d9b21786ec4278ef83ff07c6e2a952cdf6bbb9125f0b32b013f7d2b009cadb020b062a780dcf119d733aa
+  data.tar.gz: 77524f554091fccfdd9b96ea0ff64295fb55a8358f010adac5f008455428fd91c3b8ef80111f515529f2059b4e3db6081177b3563b2c16c83ee5d6e829e27789

data/.gitignore

@@ -6,6 +6,7 @@
 .ruby-gemset
 .ruby-version
 Gemfile.lock
+gemfiles/*.lock
 InstalledFiles
 _yardoc
 coverage

data/.travis.yml

@@ -1,9 +1,10 @@
 language: ruby
+dist: bionic
 rvm:
-  - 2.4.9
-  - 2.5.7
-  - 2.6.5
-  - 2.7.0
+  - 2.4.10
+  - 2.5.8
+  - 2.6.6
+  - 2.7.2
   - 3.0.0
   - jruby-9.2.14.0
 gemfile:
@@ -12,17 +13,15 @@ gemfile:
   - gemfiles/Gemfile.activesupport-6.x
 jobs:
   exclude:
-    - rvm: 2.4.9
+    - rvm: 2.4.10
       gemfile: gemfiles/Gemfile.activesupport-6.x
-    - rvm: 2.7.0
+    - rvm: 2.7.2
       gemfile: gemfiles/Gemfile.activesupport-4.x
     - rvm: 3.0.0
       gemfile: gemfiles/Gemfile.activesupport-4.x
   include:
     - rvm: ruby-head
       gemfile: gemfiles/Gemfile.activesupport-edge
-    - rvm: jruby-head
-      gemfile: gemfiles/Gemfile.activesupport-edge
   allow_failures:
     - gemfile: gemfiles/Gemfile.activesupport-edge
   fast_finish: true

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Unreleased
 
-[Compare master with v1.3.0](https://github.com/intrepidd/working_hours/compare/v1.3.0...master)
+[Compare master with v1.4.1](https://github.com/intrepidd/working_hours/compare/v1.4.1...master)
+
+# v1.4.1
+* Add InvalidConfiguration error code to allow custom message or behavior - [#47](https://github.com/Intrepidd/working_hours/pull/47)
+
+# v1.4.0
+* New config option: holiday_hours - [#37](https://github.com/Intrepidd/working_hours/pull/37)
+
+# v1.3.2
+* Improve support for time shifts - [#46](https://github.com/Intrepidd/working_hours/pull/46)
+
+# v1.3.1
+* Improve computation accuracy in `advance_to_working_time` and `working_time_between` by using more exact (integer-based) time operations instead of floating point numbers - [#44](https://github.com/Intrepidd/working_hours/pull/44)
+* Raise an exception when we detect an infinite loops in `advance_to_working_time` to improve resilience and make debugging easier - [#44](https://github.com/Intrepidd/working_hours/pull/44)
+* Use a Rational number for the midnight value to avoid leaking sub-nanoseconds residue because of floating point accuracy - [#44](https://github.com/Intrepidd/working_hours/pull/44)
 
 # v1.3.0
 * Improve supports for fractional seconds in input times by only rounding results at the end - [#42](https://github.com/Intrepidd/working_hours/issues/42) [#43](https://github.com/Intrepidd/working_hours/pull/43)

data/README.md

@@ -104,6 +104,32 @@ end
 - ``holidays``
 - ``time_zone``
 
+### Holiday hours
+Sometimes you need to configure different working hours as a one-off, e.g. the working day might end earlier on Christmas Eve.
+
+You can configure this with the `holiday_hours` option, either as an override on the existing working hours, or as a set of hours that *are* being worked on a holiday day.
+
+If *any* hours are set for a calendar day in `holiday_hours`, then the `working_hours` for that day will be ignored, and only the entries in `holiday_hours` taken into consideration.
+
+```ruby
+# Configure holiday hours
+WorkingHours::Config.holiday_hours = {Date.new(2020, 12, 24) => {'09:00' => '12:00', '13:00' => '15:00'}}
+```
+
+### Handling errors
+
+If the configuration is erroneous, an ``WorkingHours::InvalidConfiguration`` exception will be raised containing the appropriate error message.
+
+You can also access the error code in case you want to implement custom behavior or changing one specific message, e.g:
+
+```ruby
+rescue WorkingHours::InvalidConfiguration => e
+  if e.error_code == :empty
+    raise StandardError.new "Config is required"
+  end
+  raise e
+end
+```
 
 ## No core extensions / monkey patching
 

data/gemfiles/Gemfile.activesupport-6.x

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 
 gemspec :path => '..'
 
-gem 'activesupport', '~> 6.0'
+gem 'activesupport', '~> 6.1'

data/gemfiles/Gemfile.activesupport-edge

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 
 gemspec :path => '..'
 
-gem 'activesupport', github: 'rails/rails'
+gem 'activesupport', github: 'rails/rails', branch: 'main'

data/lib/working_hours/computation.rb

@@ -40,7 +40,7 @@ module WorkingHours
         time = advance_to_working_time(time, config: config)
         # look at working ranges
         time_in_day = time.seconds_since_midnight
-        config[:working_hours][time.wday].each do |from, to|
+        working_hours_for(time, config: config).each do |from, to|
           if time_in_day >= from and time_in_day < to
             # take all we can
             take = [to - time_in_day, seconds].min
@@ -56,7 +56,8 @@ module WorkingHours
         time = return_to_exact_working_time(time, config: config)
         # look at working ranges
         time_in_day = time.seconds_since_midnight
-        config[:working_hours][time.wday].reverse_each do |from, to|
+        
+        working_hours_for(time, config: config).reverse_each do |from, to|
           if time_in_day > from and time_in_day <= to
             # take all we can
             take = [time_in_day - from, -seconds].min
@@ -80,9 +81,10 @@ module WorkingHours
         end
         # find first working range after time
         time_in_day = time.seconds_since_midnight
-        config[:working_hours][time.wday].each do |from, to|
+        
+        working_hours_for(time, config: config).each do |from, to|
           return time if time_in_day >= from and time_in_day < to
-          return time + (from - time_in_day) if from >= time_in_day
+          return move_time_of_day(time, from) if from >= time_in_day
         end
         # if none is found, go to next day and loop
         time = (time + 1.day).beginning_of_day
@@ -99,13 +101,11 @@ module WorkingHours
         end
         # find next working range after time
         time_in_day = time.seconds_since_midnight
-        time = time.beginning_of_day
-        config[:working_hours][time.wday].each do |from, to|
-          return time + to if time_in_day >= from and time_in_day < to
-          return time + to if from >= time_in_day
+        working_hours_for(time, config: config).each do |from, to|
+          return move_time_of_day(time, to) if time_in_day < to
         end
         # if none is found, go to next day and loop
-        time = time + 1.day
+        time = (time + 1.day).beginning_of_day
       end
     end
 
@@ -131,10 +131,9 @@ module WorkingHours
         end
         # find last working range before time
         time_in_day = time.seconds_since_midnight
-        config[:working_hours][time.wday].reverse_each do |from, to|
-          # round is used to suppress miliseconds hack from `end_of_day`
+        working_hours_for(time, config: config).reverse_each do |from, to|
           return time if time_in_day > from and time_in_day <= to
-          return (time - (time_in_day - to)) if to <= time_in_day
+          return move_time_of_day(time, to) if to <= time_in_day
         end
         # if none is found, go to previous day and loop
         time = (time - 1.day).end_of_day
@@ -144,7 +143,9 @@ module WorkingHours
     def working_day? time, config: nil
       config ||= wh_config
       time = in_config_zone(time, config: config)
-      config[:working_hours][time.wday].present? and not config[:holidays].include?(time.to_date)
+
+      (config[:working_hours][time.wday].present? && !config[:holidays].include?(time.to_date)) ||
+        config[:holiday_hours].include?(time.to_date)
     end
 
     def in_working_hours? time, config: nil
@@ -152,7 +153,7 @@ module WorkingHours
       time = in_config_zone(time, config: config)
       return false if not working_day?(time, config: config)
       time_in_day = time.seconds_since_midnight
-      config[:working_hours][time.wday].each do |from, to|
+      working_hours_for(time, config: config).each do |from, to|
         return true if time_in_day >= from and time_in_day < to
       end
       false
@@ -183,20 +184,25 @@ module WorkingHours
         to = in_config_zone(to, config: config)
         distance = 0
         while from < to
+          from_was = from
           # look at working ranges
           time_in_day = from.seconds_since_midnight
-          config[:working_hours][from.wday].each do |begins, ends|
+          working_hours_for(from, config: config).each do |begins, ends|
             if time_in_day >= begins and time_in_day < ends
-              # take all we can
-              take = [ends - time_in_day, to - from].min
-              # advance time
-              from += take
-              # increase counter
-              distance += take
+              if (to - from) > (ends - time_in_day)
+                # take all the range and continue
+                distance += (ends - time_in_day)
+                from = move_time_of_day(from, ends)
+              else
+                # take only what's needed and stop
+                distance += (to - from)
+                from = to
+              end
             end
           end
           # roll to next business period
           from = advance_to_working_time(from, config: config)
+          raise "Invalid loop detected in working_time_between (from=#{from.iso8601(12)}, to=#{to.iso8601(12)}, distance=#{distance}, config=#{config}), please open an issue ;)" unless from > from_was
         end
         distance.round # round up to supress miliseconds introduced by 24:00 hack
       end
@@ -204,6 +210,23 @@ module WorkingHours
 
     private
 
+    # Changes the time of the day to match given time (in seconds since midnight)
+    # preserving nanosecond prevision (rational number) and honoring time shifts
+    #
+    # This replaces the previous implementation which was:
+    #   time.beginning_of_day + seconds
+    # (because this one would shift hours during time shifts days)
+    def move_time_of_day time, seconds
+      # return time.beginning_of_day + seconds
+      hour = (seconds / 3600).to_i
+      seconds %= 3600
+      minutes = (seconds / 60).to_i
+      seconds %= 60
+      # sec/usec separation is required for ActiveSupport <= 5.1
+      usec = ((seconds % 1) * 10**6)
+      time.change(hour: hour, min: minutes, sec: seconds.to_i, usec: usec)
+    end
+
     def wh_config
       WorkingHours::Config.precompiled
     end
@@ -227,5 +250,8 @@ module WorkingHours
       end
     end
 
+    def working_hours_for(time, config:)
+      config[:holiday_hours][time.to_date] || config[:working_hours][time.wday]
+    end
   end
 end

data/lib/working_hours/config.rb

@@ -1,15 +1,42 @@
 require 'set'
 
 module WorkingHours
-  InvalidConfiguration = Class.new StandardError
+  class InvalidConfiguration < StandardError
+    attr_reader :data, :error_code
 
-  class Config
+    def initialize(error_code, data: nil)
+      @data = data
+      @error_code = error_code
+      super compose_message(error_code)
+    end
 
+    def compose_message(error_code)
+      case error_code
+      when :empty then "No working hours given"
+      when :empty_day then "No working hours given for day `#{@data[:day]}`"
+      when :holidays_not_array then "Invalid type for holidays: #{@data[:holidays_class]} - must act like an array"
+      when :holiday_not_date then "Invalid holiday: #{@data[:day]} - must be Date"
+      when :invalid_day_keys then "Invalid day identifier(s): #{@data[:invalid_keys]} - must be 3 letter symbols"
+      when :invalid_format then "Invalid time: #{@data[:time]} - must be 'HH:MM(:SS)'"
+      when :invalid_holiday_keys then "Invalid day identifier(s): #{@data[:invalid_keys]} - must be a Date object"
+      when :invalid_timezone then "Invalid time zone: #{@data[:zone]} - must be String or ActiveSupport::TimeZone"
+      when :invalid_type then "Invalid type for `#{@data[:day]}`: #{@data[:hours_class]} - must be Hash"
+      when :outside_of_day then "Invalid time: #{@data[:time]} - outside of day"
+      when :overlap then "Invalid range: #{@data[:start]} => #{@data[:finish]} - overlaps previous range"
+      when :unknown_timezone then "Unknown time zone: #{@data[:zone]}"
+      when :wrong_order then "Invalid range: #{@data[:start]} => #{@data[:finish]} - ends before it starts"
+      else "Invalid Configuration"
+      end
+    end
+  end
+
+
+  class Config
     TIME_FORMAT = /\A([0-2][0-9])\:([0-5][0-9])(?:\:([0-5][0-9]))?\z/
     DAYS_OF_WEEK = [:sun, :mon, :tue, :wed, :thu, :fri, :sat]
+    MIDNIGHT = Rational('86399.999999')
 
     class << self
-
       def working_hours
         config[:working_hours]
       end
@@ -32,9 +59,26 @@ module WorkingHours
         config.delete :precompiled
       end
 
+      def holiday_hours
+        config[:holiday_hours]
+      end
+
+      def holiday_hours=(val)
+        validate_holiday_hours! val
+        config[:holiday_hours] = val
+        global_config[:holiday_hours] = val
+        config.delete :precompiled
+      end
+
       # Returns an optimized for computing version
       def precompiled
-        config_hash = [config[:working_hours], config[:holidays], config[:time_zone]].hash
+        config_hash = [
+          config[:working_hours],
+          config[:holiday_hours],
+          config[:holidays],
+          config[:time_zone]
+        ].hash
+
         if config_hash != config[:config_hash]
           config[:config_hash] = config_hash
           config.delete :precompiled
@@ -42,14 +86,21 @@ module WorkingHours
 
         config[:precompiled] ||= begin
           validate_working_hours! config[:working_hours]
+          validate_holiday_hours! config[:holiday_hours]
           validate_holidays! config[:holidays]
           validate_time_zone! config[:time_zone]
-          compiled = { working_hours: Array.new(7) { Hash.new } }
+          compiled = { working_hours: Array.new(7) { Hash.new }, holiday_hours: {} }
           working_hours.each do |day, hours|
             hours.each do |start, finish|
               compiled[:working_hours][DAYS_OF_WEEK.index(day)][compile_time(start)] = compile_time(finish)
             end
           end
+          holiday_hours.each do |day, hours|
+            compiled[:holiday_hours][day] = {}
+            hours.each do |start, finish|
+              compiled[:holiday_hours][day][compile_time(start)] = compile_time(finish)
+            end
+          end
           compiled[:holidays] = Set.new(holidays)
           compiled[:time_zone] = time_zone
           compiled
@@ -71,16 +122,19 @@ module WorkingHours
         Thread.current[:working_hours] = default_config
       end
 
-      def with_config(working_hours: nil, holidays: nil, time_zone: nil)
+      def with_config(working_hours: nil, holiday_hours: nil, holidays: nil, time_zone: nil)
         original_working_hours = self.working_hours
+        original_holiday_hours = self.holiday_hours
         original_holidays = self.holidays
         original_time_zone = self.time_zone
         self.working_hours = working_hours if working_hours
+        self.holiday_hours = holiday_hours if holiday_hours
         self.holidays = holidays if holidays
         self.time_zone = time_zone if time_zone
         yield
       ensure
         self.working_hours = original_working_hours
+        self.holiday_hours = original_holiday_hours
         self.holidays = original_holidays
         self.time_zone = original_time_zone
       end
@@ -104,6 +158,7 @@ module WorkingHours
             thu: {'09:00' => '17:00'},
             fri: {'09:00' => '17:00'}
           },
+          holiday_hours: {},
           holidays: [],
           time_zone: ActiveSupport::TimeZone['UTC']
         }
@@ -115,48 +170,59 @@ module WorkingHours
         sec = time[TIME_FORMAT,3].to_i
         time = hour * 3600 + min * 60 + sec
         # Converts 24:00 to 23:59:59.999999
-        return 86399.999999 if time == 86400
+        return MIDNIGHT if time == 86400
         time
       end
 
-      def validate_working_hours! week
-        if week.empty?
-          raise InvalidConfiguration.new "No working hours given"
-        end
-        if (invalid_keys = (week.keys - DAYS_OF_WEEK)).any?
-          raise InvalidConfiguration.new "Invalid day identifier(s): #{invalid_keys.join(', ')} - must be 3 letter symbols"
-        end
-        week.each do |day, hours|
+      def validate_hours! dates
+        dates.each do |day, hours|
           if not hours.is_a? Hash
-            raise InvalidConfiguration.new "Invalid type for `#{day}`: #{hours.class} - must be Hash"
+            raise InvalidConfiguration.new :invalid_type, data: { day: day, hours_class: hours.class }
           elsif hours.empty?
-            raise InvalidConfiguration.new "No working hours given for day `#{day}`"
+            raise InvalidConfiguration.new :empty_day, data: { day: day }
           end
           last_time = nil
           hours.sort.each do |start, finish|
             if not start =~ TIME_FORMAT
-              raise InvalidConfiguration.new "Invalid time: #{start} - must be 'HH:MM(:SS)'"
+              raise InvalidConfiguration.new :invalid_format, data: { time: start }
             elsif not finish =~ TIME_FORMAT
-              raise InvalidConfiguration.new "Invalid time: #{finish} - must be 'HH:MM(:SS)'"
+              raise InvalidConfiguration.new :invalid_format, data: { time: finish }
             elsif compile_time(finish) >= 24 * 60 * 60
-              raise InvalidConfiguration.new "Invalid time: #{finish} - outside of day"
+              raise InvalidConfiguration.new :outside_of_day, data: { time: finish }
             elsif start >= finish
-              raise InvalidConfiguration.new "Invalid range: #{start} => #{finish} - ends before it starts"
+              raise InvalidConfiguration.new :wrong_order, data: { start: start, finish: finish }
             elsif last_time and start < last_time
-              raise InvalidConfiguration.new "Invalid range: #{start} => #{finish} - overlaps previous range"
+              raise InvalidConfiguration.new :overlap, data: { start: start, finish: finish }
             end
             last_time = finish
           end
         end
       end
 
+      def validate_working_hours! week
+        if week.empty?
+          raise InvalidConfiguration.new :empty
+        end
+        if (invalid_keys = (week.keys - DAYS_OF_WEEK)).any?
+          raise InvalidConfiguration.new :invalid_day_keys, data: { invalid_keys: invalid_keys.join(', ') }
+        end
+        validate_hours!(week)
+      end
+
+      def validate_holiday_hours! days
+        if (invalid_keys = (days.keys.reject{ |day| day.is_a?(Date) })).any?
+          raise InvalidConfiguration.new :invalid_holiday_keys, data: { invalid_keys: invalid_keys.join(', ') }
+        end
+        validate_hours!(days)
+      end
+
       def validate_holidays! holidays
         if not holidays.respond_to?(:to_a)
-          raise InvalidConfiguration.new "Invalid type for holidays: #{holidays.class} - must act like an array"
+          raise InvalidConfiguration.new :holidays_not_array, data: { holidays_class: holidays.class }
         end
         holidays.to_a.each do |day|
           if not day.is_a? Date
-            raise InvalidConfiguration.new "Invalid holiday: #{day} - must be Date"
+            raise InvalidConfiguration.new :holiday_not_date, data: { day: day }
           end
         end
       end
@@ -165,21 +231,19 @@ module WorkingHours
         if zone.is_a? String
           res = ActiveSupport::TimeZone[zone]
           if res.nil?
-            raise InvalidConfiguration.new "Unknown time zone: #{zone}"
+            raise InvalidConfiguration.new :unknown_timezone, data: { zone: zone }
           end
         elsif zone.is_a? ActiveSupport::TimeZone
           res = zone
         else
-          raise InvalidConfiguration.new "Invalid time zone: #{zone.inspect} - must be String or ActiveSupport::TimeZone"
+          raise InvalidConfiguration.new :invalid_timezone, data: { zone: zone.inspect }
         end
         res
       end
-
     end
 
     private
 
-    def initialize
-    end
+    def initialize; end
   end
 end

data/lib/working_hours/version.rb

@@ -1,3 +1,3 @@
 module WorkingHours
-  VERSION = "1.3.0"
+  VERSION = "1.4.1"
 end

data/spec/working_hours/computation_spec.rb

@@ -111,7 +111,7 @@ describe WorkingHours::Computation do
       expect(add_seconds(time, 120)).to eq(Time.utc(1991, 11, 18, 9, 1, 42))
     end
 
-    it 'Calls precompiled only once' do
+    it 'calls precompiled only once' do
       precompiled = WorkingHours::Config.precompiled
       expect(WorkingHours::Config).to receive(:precompiled).once.and_return(precompiled) # in_config_zone and add_seconds
       time = Time.utc(1991, 11, 15, 16, 59, 42) # Friday
@@ -130,12 +130,94 @@ describe WorkingHours::Computation do
       expect(add_seconds(time, -60)).to eq(Time.utc(2014, 4, 7, 23, 59, 00))
     end
 
+    context 'with holiday hours' do
+      before do
+        WorkingHours::Config.working_hours = { thu: { '08:00' => '18:00' }, fri: { '08:00' => '18:00' } }
+      end
+
+      context 'with a later starting hour' do
+        before do
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 27) => { '10:00' => '18:00' } }
+        end
+
+        it 'adds working seconds' do
+          time = Time.utc(2019, 12, 27, 9)
+          expect(add_seconds(time, 120)).to eq(Time.utc(2019, 12, 27, 10, 2))
+        end
+
+        it 'removes working seconds' do
+          time = Time.utc(2019, 12, 27, 9)
+          expect(add_seconds(time, -120)).to eq(Time.utc(2019, 12, 26, 17, 58))
+        end
+
+        context 'working back from working hours' do
+          it 'moves to the previous working day' do
+            time = Time.utc(2019, 12, 27, 11)
+            expect(add_seconds(time, -2.hours)).to eq(Time.utc(2019, 12, 26, 17))
+          end
+        end
+      end
+
+      context 'with an earlier ending hour' do
+        before do
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 27) => { '08:00' => '17:00' } }
+        end
+
+        it 'adds working seconds' do
+          time = Time.utc(2019, 12, 27, 17, 59)
+          expect(add_seconds(time, 120)).to eq(Time.utc(2020, 1, 2, 8, 2))
+        end
+
+        it 'removes working seconds' do
+          time = Time.utc(2019, 12, 27, 18)
+          expect(add_seconds(time, -120)).to eq(Time.utc(2019, 12, 27, 16, 58))
+        end
+
+        context 'working forward from working hours' do
+          it 'moves to the next working day' do
+            time = Time.utc(2019, 12, 27, 16)
+            expect(add_seconds(time, 2.hours)).to eq(Time.utc(2020, 1, 2, 9))
+          end
+        end
+      end
+
+      context 'with an earlier starting time in the second set of hours within a day' do
+        before do
+          WorkingHours::Config.working_hours = { thu: { '08:00' => '18:00' }, fri: { '08:00' => '12:00', '13:00' => '18:00' } }
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 27) => { '08:00' => '12:00', '14:00' => '18:00' } }
+        end
+
+        it 'adds working seconds' do
+          time = Time.utc(2019, 12, 27, 12, 59)
+          expect(add_seconds(time, 120)).to eq(Time.utc(2019, 12, 27, 14, 2))
+        end
+
+        it 'removes working seconds' do
+          time = Time.utc(2019, 12, 27, 14)
+          expect(add_seconds(time, -120)).to eq(Time.utc(2019, 12, 27, 11, 58))
+        end
+
+        context 'from morning to afternoon' do
+          it 'takes into account the additional hour for lunch set in `holiday_hours`' do
+            time = Time.utc(2019, 12, 27, 10)
+            expect(add_seconds(time, 4.hours)).to eq(Time.utc(2019, 12, 27, 16))
+          end
+        end
+
+        context 'from afternoon to morning' do
+          it 'takes into account the additional hour for lunch set in `holiday_hours`' do
+            time = Time.utc(2019, 12, 27, 16)
+            expect(add_seconds(time, -4.hours)).to eq(Time.utc(2019, 12, 27, 10))
+          end
+        end
+      end
+    end
+
     it 'honors miliseconds in the base time and increment (but return rounded result)' do
       # Rounding the base time or increments before the end would yield a wrong result
       time = Time.utc(1991, 11, 15, 16, 59, 42.25) # +250ms
       expect(add_seconds(time, 120.4)).to eq(Time.utc(1991, 11, 18, 9, 1, 43))
     end
-
   end
 
   describe '#advance_to_working_time' do
@@ -173,10 +255,45 @@ describe WorkingHours::Computation do
       WorkingHours::Config.time_zone = 'Tokyo'
       expect(advance_to_working_time(Time.new(2014, 4, 7, 0, 0, 0)).zone).to eq('JST')
     end
+
+    it 'jumps outside holiday hours' do
+      WorkingHours::Config.working_hours = { fri: { '08:00' => '18:00' } }
+      WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 27) => { '10:00' => '18:00' } }
+      expect(advance_to_working_time(Time.utc(2019, 12, 27, 9))).to eq(Time.utc(2019, 12, 27, 10))
+    end
+
+    it 'do not leak nanoseconds when advancing' do
+      expect(advance_to_working_time(Time.utc(2014, 4, 7, 5, 0, 0, 123456.789))).to eq(Time.utc(2014, 4, 7, 9, 0, 0, 0))
+    end
+
+    it 'returns correct hour during positive time shifts' do
+      WorkingHours::Config.working_hours = {sun: {'09:00' => '17:00'}}
+      WorkingHours::Config.time_zone = 'Paris'
+      from = Time.new(2020, 3, 29, 0, 0, 0, "+01:00")
+      expect(from.utc_offset).to eq(3600)
+      res = advance_to_working_time(from)
+      expect(res).to eq(Time.new(2020, 3, 29, 9, 0, 0, "+02:00"))
+      expect(res.utc_offset).to eq(7200)
+      # starting from wrong time-zone
+      expect(advance_to_working_time(Time.new(2020, 3, 29, 5, 0, 0, "+01:00"))).to eq(Time.new(2020, 3, 29, 9, 0, 0, "+02:00"))
+      expect(advance_to_working_time(Time.new(2020, 3, 29, 1, 0, 0, "+02:00"))).to eq(Time.new(2020, 3, 29, 9, 0, 0, "+02:00"))
+    end
+
+    it 'returns correct hour during negative time shifts' do
+      WorkingHours::Config.working_hours = {sun: {'09:00' => '17:00'}}
+      WorkingHours::Config.time_zone = 'Paris'
+      from = Time.new(2020, 10, 25, 0, 0, 0, "+02:00")
+      expect(from.utc_offset).to eq(7200)
+      res = advance_to_working_time(from)
+      expect(res).to eq(Time.new(2020, 10, 25, 9, 0, 0, "+01:00"))
+      expect(res.utc_offset).to eq(3600)
+      # starting from wrong time-zone
+      expect(advance_to_working_time(Time.new(2020, 10, 25, 4, 0, 0, "+02:00"))).to eq(Time.new(2020, 10, 25, 9, 0, 0, "+01:00"))
+      expect(advance_to_working_time(Time.new(2020, 10, 25, 1, 0, 0, "+01:00"))).to eq(Time.new(2020, 10, 25, 9, 0, 0, "+01:00"))
+    end
   end
 
   describe '#advance_to_closing_time' do
-
     it 'jumps non-working day' do
       WorkingHours::Config.holidays = [Date.new(2014, 5, 1)]
       holiday = Time.utc(2014, 5, 1, 12, 0)
@@ -240,7 +357,7 @@ describe WorkingHours::Computation do
       end
 
       let(:monday_morning) { Time.utc(2014, 4, 7, 0) }
-      let(:monday_closing) { Time.utc(2014, 4, 7) + 86399.999999 }
+      let(:monday_closing) { Time.utc(2014, 4, 7) + WorkingHours::Config::MIDNIGHT }
       let(:tuesday_closing) { Time.utc(2014, 4, 8, 17) }
       let(:sunday) { Time.utc(2014, 4, 6, 17) }
 
@@ -255,6 +372,11 @@ describe WorkingHours::Computation do
       it 'moves over midnight' do
         expect(advance_to_closing_time(sunday)).to eq(monday_closing)
       end
+
+      it 'give precise computation with nothing other than miliseconds' do
+        pending "iso8601 is not precise enough on AS < 4" if ActiveSupport::VERSION::MAJOR <= 4
+        expect(advance_to_closing_time(monday_morning).iso8601(25)).to eq("2014-04-07T23:59:59.9999990000000000000000000Z")
+      end
     end
 
     it 'works with any input timezone (converts to config)' do
@@ -271,10 +393,55 @@ describe WorkingHours::Computation do
       WorkingHours::Config.time_zone = 'Tokyo'
       expect(advance_to_closing_time(Time.new(2014, 4, 7, 0, 0, 0)).zone).to eq('JST')
     end
+
+    context 'with holiday hours' do
+      before do
+        WorkingHours::Config.working_hours = { thu: { '08:00' => '18:00' }, fri: { '08:00' => '18:00' } }
+      end
+
+      it 'takes into account reduced holiday closing' do
+        WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 27) => { '10:00' => '17:00' } }
+        expect(advance_to_closing_time(Time.new(2019, 12, 26, 20))).to eq(Time.new(2019, 12, 27, 17))
+      end
+
+      it 'takes into account extended holiday closing' do
+        WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 26) => { '10:00' => '21:00' } }
+        expect(advance_to_closing_time(Time.new(2019, 12, 26, 20))).to eq(Time.new(2019, 12, 26, 21))
+      end
+    end
+
+    it 'do not leak nanoseconds when advancing' do
+      expect(advance_to_closing_time(Time.utc(2014, 4, 7, 5, 0, 0, 123456.789))).to eq(Time.utc(2014, 4, 7, 17, 0, 0, 0))
+    end
+
+    it 'returns correct hour during positive time shifts' do
+      WorkingHours::Config.working_hours = {sun: {'09:00' => '17:00'}}
+      WorkingHours::Config.time_zone = 'Paris'
+      from = Time.new(2020, 3, 29, 0, 0, 0, "+01:00")
+      expect(from.utc_offset).to eq(3600)
+      res = advance_to_closing_time(from)
+      expect(res).to eq(Time.new(2020, 3, 29, 17, 0, 0, "+02:00"))
+      expect(res.utc_offset).to eq(7200)
+      # starting from wrong time-zone
+      expect(advance_to_closing_time(Time.new(2020, 3, 29, 5, 0, 0, "+01:00"))).to eq(Time.new(2020, 3, 29, 17, 0, 0, "+02:00"))
+      expect(advance_to_closing_time(Time.new(2020, 3, 29, 1, 0, 0, "+02:00"))).to eq(Time.new(2020, 3, 29, 17, 0, 0, "+02:00"))
+    end
+
+    it 'returns correct hour during negative time shifts' do
+      WorkingHours::Config.working_hours = {sun: {'09:00' => '17:00'}}
+      WorkingHours::Config.time_zone = 'Paris'
+      from = Time.new(2020, 10, 25, 0, 0, 0, "+02:00")
+      expect(from.utc_offset).to eq(7200)
+      res = advance_to_closing_time(from)
+      expect(res).to eq(Time.new(2020, 10, 25, 17, 0, 0, "+01:00"))
+      expect(res.utc_offset).to eq(3600)
+      # starting from wrong time-zone
+      expect(advance_to_closing_time(Time.new(2020, 10, 25, 4, 0, 0, "+02:00"))).to eq(Time.new(2020, 10, 25, 17, 0, 0, "+01:00"))
+      expect(advance_to_closing_time(Time.new(2020, 10, 25, 1, 0, 0, "+01:00"))).to eq(Time.new(2020, 10, 25, 17, 0, 0, "+01:00"))
+    end
   end
 
   describe '#next_working_time' do
-
     it 'jumps non-working day' do
       WorkingHours::Config.holidays = [Date.new(2014, 5, 1)]
       holiday = Time.utc(2014, 5, 1, 12, 0)
@@ -377,6 +544,32 @@ describe WorkingHours::Computation do
       WorkingHours::Config.time_zone = 'Tokyo'
       expect(return_to_working_time(Time.new(2014, 4, 7, 1, 0, 0)).zone).to eq('JST')
     end
+
+    it 'returns correct hour during positive time shifts' do
+      WorkingHours::Config.working_hours = {sun: {'00:00' => '01:00'}}
+      WorkingHours::Config.time_zone = 'Paris'
+      from = Time.new(2020, 3, 29, 9, 0, 0, "+02:00")
+      expect(from.utc_offset).to eq(7200)
+      res = return_to_working_time(from)
+      expect(res).to eq(Time.new(2020, 3, 29, 1, 0, 0, "+01:00"))
+      expect(res.utc_offset).to eq(3600)
+      # starting from wrong time-zone
+      expect(return_to_working_time(Time.new(2020, 3, 29, 2, 0, 0, "+02:00"))).to eq(Time.new(2020, 3, 29, 1, 0, 0, "+01:00"))
+      expect(return_to_working_time(Time.new(2020, 3, 29, 9, 0, 0, "+01:00"))).to eq(Time.new(2020, 3, 29, 1, 0, 0, "+01:00"))
+    end
+
+    it 'returns correct hour during negative time shifts' do
+      WorkingHours::Config.working_hours = {sun: {'00:00' => '01:00'}}
+      WorkingHours::Config.time_zone = 'Paris'
+      from = Time.new(2020, 10, 25, 9, 0, 0, "+01:00")
+      expect(from.utc_offset).to eq(3600)
+      res = return_to_working_time(from)
+      expect(res).to eq(Time.new(2020, 10, 25, 1, 0, 0, "+02:00"))
+      expect(res.utc_offset).to eq(7200)
+      # starting from wrong time-zone
+      expect(return_to_working_time(Time.new(2020, 10, 25, 9, 0, 0, "+02:00"))).to eq(Time.new(2020, 10, 25, 1, 0, 0, "+02:00"))
+      expect(return_to_working_time(Time.new(2020, 10, 25, 1, 0, 0, "+01:00"))).to eq(Time.new(2020, 10, 25, 1, 0, 0, "+02:00"))
+    end
   end
 
   describe '#working_day?' do
@@ -424,6 +617,23 @@ describe WorkingHours::Computation do
       WorkingHours::Config.time_zone = 'Tokyo'
       expect(in_working_hours?(Time.utc(2014, 4, 7, 0, 0))).to be(true)
     end
+
+    context 'with holiday hours' do
+      before do
+        WorkingHours::Config.working_hours = { thu: { '08:00' => '18:00' }, fri: { '08:00' => '18:00' } }
+        WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 27) => { '10:00' => '20:00' } }
+      end
+
+      it 'returns true during working hours' do
+        expect(in_working_hours?(Time.utc(2019, 12, 26, 9))).to be(true)
+        expect(in_working_hours?(Time.utc(2019, 12, 27, 19))).to be(true)
+      end
+
+      it 'returns false outside working hours' do
+        expect(in_working_hours?(Time.utc(2019, 12, 26, 7))).to be(false)
+        expect(in_working_hours?(Time.utc(2019, 12, 27, 9))).to be(false)
+      end
+    end
   end
 
   describe '#working_days_between' do
@@ -544,6 +754,63 @@ describe WorkingHours::Computation do
       )).to eq(7.hours)
     end
 
+    it 'uses precise computation to avoid useless loops' do
+      # +200 usec on each time, using floating point would cause
+      # precision issues and require several iterations
+      expect(self).to receive(:advance_to_working_time).twice.and_call_original
+      expect(working_time_between(
+        Time.utc(2014, 4, 7, 5, 0, 0, 200),
+        Time.utc(2014, 4, 7, 15, 0, 0, 200),
+      )).to eq(6.hours)
+    end
+
+    it 'works across positive time shifts' do
+      WorkingHours::Config.working_hours = {sun: {'08:00' => '21:00'}}
+      WorkingHours::Config.time_zone = 'Paris'
+      expect(working_time_between(
+        Time.utc(2020, 3, 29, 1, 0),
+        Time.utc(2020, 3, 30, 0, 0),
+      )).to eq(13.hours)
+    end
+
+    it 'works across negative time shifts' do
+      WorkingHours::Config.working_hours = {sun: {'08:00' => '21:00'}}
+      WorkingHours::Config.time_zone = 'Paris'
+      expect(working_time_between(
+        Time.utc(2019, 10, 27, 1, 0),
+        Time.utc(2019, 10, 28, 0, 0),
+      )).to eq(13.hours)
+    end
+
+    it 'works across time shifts + midnight' do
+      WorkingHours::Config.working_hours = {sun: {'00:00' => '24:00'}}
+      WorkingHours::Config.time_zone = 'Paris'
+      expect(working_time_between(
+        Time.utc(2020, 10, 24, 22, 0),
+        Time.utc(2020, 10, 25, 23, 0),
+      )).to eq(24.hours)
+    end
+
+    it 'works across multiple time shifts' do
+      WorkingHours::Config.working_hours = {sun: {'08:00' => '21:00'}}
+      WorkingHours::Config.time_zone = 'Paris'
+      expect(working_time_between(
+        Time.utc(2002, 10, 27, 6, 0),
+        Time.utc(2021, 10, 30, 0, 0),
+      )).to eq(12896.hours)
+    end
+
+    it 'do not cause infinite loop if the time is not advancing properly' do
+      # simulate some computation/precision error
+      expect(self).to receive(:advance_to_working_time).twice do |time|
+        time.change(hour: 9) - 0.0001
+      end
+      expect { working_time_between(
+        Time.utc(2014, 4, 7, 5, 0, 0),
+        Time.utc(2014, 4, 7, 15, 0, 0),
+      ) }.to raise_error(RuntimeError, /Invalid loop detected in working_time_between \(from=2014-04-07T08:59:59.999/)
+    end
+
     # generates two times with +0ms, +250ms, +500ms, +750ms and +1s
     # then for each combination compare the result with a ruby diff
     context 'with precise miliseconds timings' do
@@ -558,5 +825,66 @@ describe WorkingHours::Computation do
         end
       end
     end
+
+    context 'with holiday hours' do
+      before do
+        WorkingHours::Config.working_hours = { mon: { '08:00' => '18:00' }, tue: { '08:00' => '18:00' } }
+        WorkingHours::Config.holiday_hours = { Date.new(2014, 4, 7) => { '10:00' => '12:00', '14:00' => '17:00' } }
+      end
+
+      context 'time is before the start of holiday hours' do
+        it 'does not count holiday hours as working time' do
+          expect(working_time_between(
+            Time.utc(2014, 4, 7, 8),
+            Time.utc(2014, 4, 7, 9)
+          )).to eq(0)
+        end
+      end
+
+      context 'time is between holiday hours' do
+        it 'does not count holiday hours as working time' do
+          expect(working_time_between(
+            Time.utc(2014, 4, 7, 13),
+            Time.utc(2014, 4, 7, 13, 30)
+          )).to eq(0)
+        end
+      end
+
+      context 'time is after the end of holiday hours' do
+        it 'does not count holiday hours as working time' do
+          expect(working_time_between(
+            Time.utc(2014, 4, 7, 19),
+            Time.utc(2014, 4, 7, 20)
+          )).to eq(0)
+        end
+      end
+
+      context 'time is before the start of the holiday hours' do
+        it 'does not count holiday hours as working time' do
+          expect(working_time_between(
+            Time.utc(2014, 4, 7, 9),
+            Time.utc(2014, 4, 7, 12)
+          )).to eq(7200)
+        end
+      end
+
+      context 'time crosses overridden holiday hours at midday' do
+        it 'does not count holiday hours as working time' do
+          expect(working_time_between(
+            Time.utc(2014, 4, 7, 9),
+            Time.utc(2014, 4, 7, 14)
+          )).to eq(7200)
+        end
+      end
+
+      context 'time crosses overridden holiday hours at midday' do
+        it 'does not count holiday hours as working time' do
+          expect(working_time_between(
+            Time.utc(2014, 4, 7, 12),
+            Time.utc(2014, 4, 7, 18)
+          )).to eq(10800)
+        end
+      end
+    end
   end
 end

data/spec/working_hours/config_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 describe WorkingHours::Config do
 
   describe '.working_hours' do
-
     let(:config) { WorkingHours::Config.working_hours }
     let(:config2) { { :mon => { '08:00' => '14:00' } } }
     let(:config3) { { :tue => { '10:00' => '16:00' } } }
@@ -155,7 +154,132 @@ describe WorkingHours::Config do
           1.working.hour.ago
         }.to raise_error(WorkingHours::InvalidConfiguration, 'Invalid type for `mon`: String - must be Hash')
       end
+    end
+  end
+
+  describe '.holiday_hours' do
+    let(:config) { WorkingHours::Config.holiday_hours }
+    let(:config2) { { Date.new(2019, 12, 1) => { '08:00' => '14:00' } } }
+    let(:config3) { { Date.new(2019, 12, 2) => { '10:00' => '16:00' } } }
+
+    it 'has a default config' do
+      expect(config).to be_kind_of(Hash)
+    end
+
+    it 'is thread safe' do
+      expect(WorkingHours::Config.holiday_hours).to eq(config)
+
+      thread = Thread.new do
+        WorkingHours::Config.holiday_hours = config2
+        expect(WorkingHours::Config.holiday_hours).to eq(config2)
+        Thread.stop
+        expect(WorkingHours::Config.holiday_hours).to eq(config2)
+      end
+
+      expect {
+        sleep 0.1 # let the thread begin its execution
+      }.not_to change { WorkingHours::Config.holiday_hours }.from(config)
+
+      expect {
+        WorkingHours::Config.holiday_hours = config3
+      }.to change { WorkingHours::Config.holiday_hours }.from(config).to(config3)
+
+      expect {
+        thread.run
+        thread.join
+      }.not_to change { WorkingHours::Config.holiday_hours }.from(config3)
+    end
+
+    it 'is fiber safe' do
+      expect(WorkingHours::Config.holiday_hours).to eq(config)
+
+      fiber = Fiber.new do
+        WorkingHours::Config.holiday_hours = config2
+        expect(WorkingHours::Config.holiday_hours).to eq(config2)
+        Fiber.yield
+        expect(WorkingHours::Config.holiday_hours).to eq(config2)
+      end
+
+      expect {
+        fiber.resume
+      }.not_to change { WorkingHours::Config.holiday_hours }.from(config)
+
+      expect {
+        WorkingHours::Config.holiday_hours = config3
+      }.to change { WorkingHours::Config.holiday_hours }.from(config).to(config3)
+
+      expect {
+        fiber.resume
+      }.not_to change { WorkingHours::Config.holiday_hours }.from(config3)
+    end
+
+    it 'is initialized from last known global config' do
+      WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 1) => { '08:00' => '14:00' } }
+      Thread.new {
+        expect(WorkingHours::Config.holiday_hours).to match Date.new(2019, 12, 1) => {'08:00' => '14:00'}
+      }.join
+    end
+
+    it 'should support multiple timespan per day' do
+      time_sheet = { Date.new(2019, 12, 1) => { '08:00' => '12:00', '14:00' => '18:00' } }
+      WorkingHours::Config.holiday_hours = time_sheet
+      expect(config).to eq(time_sheet)
+    end
+
+    describe 'validations' do
+      it 'rejects invalid day' do
+        expect {
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 1) => 1, 'aaaaaa' => 2 }
+        }.to raise_error(WorkingHours::InvalidConfiguration, "Invalid day identifier(s): aaaaaa - must be a Date object")
+      end
+
+      it 'rejects other type than hash' do
+        expect {
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 1) => [] }
+        }.to raise_error(WorkingHours::InvalidConfiguration, "Invalid type for `2019-12-01`: Array - must be Hash")
+      end
+
+      it 'rejects empty range' do
+        expect {
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 1) => {} }
+        }.to raise_error(WorkingHours::InvalidConfiguration, "No working hours given for day `2019-12-01`")
+      end
+
+      it 'rejects invalid time format' do
+        expect {
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 1) => { '8:0' => '12:00' } }
+        }.to raise_error(WorkingHours::InvalidConfiguration, "Invalid time: 8:0 - must be 'HH:MM(:SS)'")
+
+        expect {
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 1) => { '08:00' => '24:10' }}
+        }.to raise_error(WorkingHours::InvalidConfiguration, "Invalid time: 24:10 - outside of day")
+      end
+
+      it 'rejects invalid range' do
+        expect {
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 1) => { '12:30' => '12:00' } }
+        }.to raise_error(WorkingHours::InvalidConfiguration, "Invalid range: 12:30 => 12:00 - ends before it starts")
+      end
+
+      it 'rejects overlapping range' do
+        expect {
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 1) => { '08:00' => '13:00', '12:00' => '18:00' } }
+        }.to raise_error(WorkingHours::InvalidConfiguration, "Invalid range: 12:00 => 18:00 - overlaps previous range")
+      end
 
+      it 'does not reject out-of-order, non-overlapping ranges' do
+        expect {
+          WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 1) => { '10:00' => '11:00', '08:00' => '09:00' } }
+        }.not_to raise_error
+      end
+
+      it 'raises an error when precompiling if working hours are invalid after assignment' do
+        WorkingHours::Config.holiday_hours = { Date.new(2019, 12, 1) => { '10:00' => '11:00', '08:00' => '09:00' } }
+        WorkingHours::Config.holiday_hours[Date.new(2019, 12, 1)] = 'Not correct'
+        expect {
+          1.working.hour.ago
+        }.to raise_error(WorkingHours::InvalidConfiguration, 'Invalid type for `2019-12-01`: String - must be Hash')
+      end
     end
   end
 
@@ -267,6 +391,7 @@ describe WorkingHours::Config do
     it 'computes an optimized version' do
       expect(subject).to eq({
           :working_hours => [{}, {32400=>61200}, {32400=>61200}, {32400=>61200}, {32400=>61200}, {32400=>61200}, {}],
+          :holiday_hours => {},
           :holidays => Set.new([]),
           :time_zone => ActiveSupport::TimeZone['UTC']
         })
@@ -283,6 +408,7 @@ describe WorkingHours::Config do
       WorkingHours::Config.working_hours = {:mon => {'20:32:59' => '22:59:59'}}
       expect(subject).to eq({
         :working_hours => [{}, {73979 => 82799}, {}, {}, {}, {}, {}],
+        :holiday_hours => {},
         :holidays => Set.new([]),
         :time_zone => ActiveSupport::TimeZone['UTC']
       })
@@ -292,6 +418,7 @@ describe WorkingHours::Config do
       WorkingHours::Config.working_hours = {:mon => {'20:00' => '24:00'}}
       expect(subject).to eq({
         :working_hours => [{}, {72000 => 86399.999999}, {}, {}, {}, {}, {}],
+        :holiday_hours => {},
         :holidays => Set.new([]),
         :time_zone => ActiveSupport::TimeZone['UTC']
       })

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: working_hours
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Adrien Jarthon
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-31 00:00:00.000000000 Z
+date: 2021-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -152,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: time calculation with working hours