working_hours 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c941c0a9419ac6c9518eb678158e34a1bd7a1c2
-  data.tar.gz: 2d67809674b2e66e74a8df2300feba9d6afc0ed4
+  metadata.gz: 2504840e341046d817df5de9c4e7d8271e192177
+  data.tar.gz: 2a97bd89965b04bd6b68c1bdcaf90a27ca0ae2ec
 SHA512:
-  metadata.gz: 22c7e703ea00a9237d6c6050dce76e48e7521c7041358eb2d6ae7d4f1fcf2a79db0557c80001e499e18a7a63af9c2f36fce7cff71204fd3bdad91040c0855300
-  data.tar.gz: 45fb3490c70fa7e22d6b92f7eebdc60ef296b185378ab62a56fd0247ca04cfb91fb4b27bf7c95179de0edb6506e5f4944aa3613d60f8d5e6d81f7a4d9a618623
+  metadata.gz: 213aed1c4be42b0ff98a9e926253941da1cc4e05bfc85be8d3ca77e51082b87da00da0169410e16c3045366eaf0c202fd7c352d000df19d0edeee3c4b89fa976
+  data.tar.gz: 016639b14b4a5ec24be13ea3415223fef1c7743c04654e23c2346ecaaef4d83c9985c3a63f4786c4430e4b087a3b95b0a04b5ae80ab538dfe186ce4ac26d294f

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Unreleased
+
+[Compare master with v1.0.0](https://github.com/intrepidd/working_hours/compare/v1.0.0...master)
+
+# v1.0.0
+
+* Replace config freeze by hash based caching (config is recompiled when changed), this avoids freezing unwanted objects (nil, timezones, integers, etc..)
+
+_15/09/2014_
+
+# v0.9.0
+
+* First beta release
+
+_24/08/2014_

data/README.md

@@ -74,8 +74,6 @@ WorkingHours::Config.time_zone = 'Paris'
 WorkingHours::Config.holidays = [Date.new(2014, 12, 31)]
 ```
 
-> Once the config has been set, internal objects are frozen and you **can't** modify them (ex: `holidays << Date.today`). This is because the configuration is precompiled to a computing friendly form and changes would not be taken into account. To change the config you **must use** one of the 3 setters shown above.
-
 ## No core extensions / monkey patching
 
 Core extensions (monkey patching to add methods on Time, Date, Numbers, etc.) are handy but not appreciated by everyone. WorkingHours can also be used **without any monkey patching**:
@@ -117,33 +115,35 @@ WorkingHours.in_working_hours?(Time.utc(2014, 8, 4, 7, 16)) # => false
 
 ## Use in your class/module
 
-If you want to use working hours inside a specific class or module, you can include its computation methods like this:
+If you want to use working hours only inside a specific class or module, you can include its computation methods like this:
 
 ```ruby
-require 'working_hours'
+require 'working_hours/module'
 
 class Order
-  include WorkingHours::Computation
+  include WorkingHours
 
   def shipping_date_estimate
-    order_date + 2.working.days
+    Duration.new(2, :days).since(paiement_received_at)
+  end
+
+  def paiement_delay
+    working_days_between(created_at, paiement_received_at)
   end
 end
 ```
 
-> This also works with zero monkey patch by requiring `working_hours/module`
-
 ## Timezones
 
 This gem uses a simple but efficient approach in dealing with timezones. When you define your working hours **you have to choose** a timezome associated with it (in the config example, the working hours are in Paris time). Then, any time used in calcultation will be converted to this timezone first, so you don't have to worry if your times are local or UTC as long as they are correct :)
 
 ## Alternatives
 
-There is a gem called [business_time](https://github.com/bokmann/business_time) already available to do this kind of computation and it was of great help to us. But we decided to start another one because business_time is suffering from a [few](https://github.com/bokmann/business_time/issues/50) [bugs](https://github.com/bokmann/business_time/pull/84) and inconsistencies regarding timezones. It also lacks essential features to us (like working minutes computation).
+There is a gem called [business_time](https://github.com/bokmann/business_time) already available to do this kind of computation and it was of great help to us. But we decided to start another one because business_time is suffering from a few [bugs](https://github.com/bokmann/business_time/pull/84) and [inconsistencies](https://github.com/bokmann/business_time/issues/50). It also lacks essential features to us (like working minutes computation).
 
 ## Contributing
 
-1. Fork it ( http://github.com/<my-github-username>/working_hours/fork )
+1. Fork it ( http://github.com/intrepidd/working_hours/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/working_hours/computation.rb

@@ -4,35 +4,39 @@ require 'working_hours/config'
 module WorkingHours
   module Computation
 
-    def add_days origin, days
-      time = in_config_zone(origin)
+    def add_days origin, days, config: nil
+      config ||= wh_config
+      time = in_config_zone(origin, config: config)
       while days > 0
         time += 1.day
-        days -= 1 if working_day?(time)
+        days -= 1 if working_day?(time, config: config)
       end
       while days < 0
         time -= 1.day
-        days += 1 if working_day?(time)
+        days += 1 if working_day?(time, config: config)
       end
       convert_to_original_format time, origin
     end
 
-    def add_hours origin, hours
-      add_minutes origin, hours * 60
+    def add_hours origin, hours, config: nil
+      config ||= wh_config
+      add_minutes origin, hours * 60, config: config
     end
 
-    def add_minutes origin, minutes
-      add_seconds origin, minutes * 60
+    def add_minutes origin, minutes, config: nil
+      config ||= wh_config
+      add_seconds origin, minutes * 60, config: config
     end
 
-    def add_seconds origin, seconds
-      time = in_config_zone(origin).round
+    def add_seconds origin, seconds, config: nil
+      config ||= wh_config
+      time = in_config_zone(origin, config: config).round
       while seconds > 0
         # roll to next business period
-        time = advance_to_working_time(time)
+        time = advance_to_working_time(time, config: config)
         # look at working ranges
         time_in_day = time.seconds_since_midnight
-        wh_config[:working_hours][time.wday].each do |from, to|
+        config[:working_hours][time.wday].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
@@ -45,10 +49,10 @@ module WorkingHours
       end
       while seconds < 0
         # roll to previous business period
-        time = return_to_working_time(time)
+        time = return_to_working_time(time, config: config)
         # look at working ranges
         time_in_day = time.seconds_since_midnight
-        wh_config[:working_hours][time.wday].reverse_each do |from, to|
+        config[:working_hours][time.wday].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
@@ -62,16 +66,17 @@ module WorkingHours
       convert_to_original_format time, origin
     end
 
-    def advance_to_working_time time
-      time = in_config_zone(time).round
+    def advance_to_working_time time, config: nil
+      config ||= wh_config
+      time = in_config_zone(time, config: config).round
       loop do
         # skip holidays and weekends
-        while not working_day?(time)
+        while not working_day?(time, config: config)
           time = (time + 1.day).beginning_of_day
         end
         # find first working range after time
         time_in_day = time.seconds_since_midnight
-        (Config.precompiled[:working_hours][time.wday] || {}).each do |from, to|
+        (config[:working_hours][time.wday] || {}).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
         end
@@ -80,16 +85,17 @@ module WorkingHours
       end
     end
 
-    def return_to_working_time time
-      time = in_config_zone(time).round
+    def return_to_working_time time, config: nil
+      config ||= wh_config
+      time = in_config_zone(time, config: config).round
       loop do
         # skip holidays and weekends
-        while not working_day?(time)
+        while not working_day?(time, config: config)
           time = (time - 1.day).end_of_day
         end
         # find last working range before time
         time_in_day = time.seconds_since_midnight
-        (Config.precompiled[:working_hours][time.wday] || {}).reverse_each do |from, to|
+        (config[:working_hours][time.wday] || {}).reverse_each do |from, to|
           # round is used to suppress miliseconds hack from `end_of_day`
           return time.round if time_in_day > from and time_in_day <= to
           return (time - (time_in_day - to)).round if to <= time_in_day
@@ -99,47 +105,51 @@ module WorkingHours
       end
     end
 
-    def working_day? time
-      time = in_config_zone(time)
-      Config.precompiled[:working_hours][time.wday].present? and not Config.precompiled[:holidays].include?(time.to_date)
+    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)
     end
 
-    def in_working_hours? time
-      time = in_config_zone(time)
-      return false if not working_day?(time)
+    def in_working_hours? time, config: nil
+      config ||= wh_config
+      time = in_config_zone(time, config: config)
+      return false if not working_day?(time, config: config)
       time_in_day = time.seconds_since_midnight
-      Config.precompiled[:working_hours][time.wday].each do |from, to|
+      config[:working_hours][time.wday].each do |from, to|
         return true if time_in_day >= from and time_in_day < to
       end
       false
     end
 
-    def working_days_between from, to
+    def working_days_between from, to, config: nil
+      config ||= wh_config
       if to < from
-        -working_days_between(to, from)
+        -working_days_between(to, from, config: config)
       else
-        from = in_config_zone(from)
-        to = in_config_zone(to)
+        from = in_config_zone(from, config: config)
+        to = in_config_zone(to, config: config)
         days = 0
         while from.to_date < to.to_date
           from += 1.day
-          days += 1 if working_day?(from)
+          days += 1 if working_day?(from, config: config)
         end
         days
       end
     end
 
-    def working_time_between from, to
+    def working_time_between from, to, config: nil
+      config ||= wh_config
       if to < from
-        -working_time_between(to, from)
+        -working_time_between(to, from, config: config)
       else
-        from = advance_to_working_time(in_config_zone(from))
-        to = in_config_zone(to).round
+        from = advance_to_working_time(in_config_zone(from, config: config))
+        to = in_config_zone(to, config: config).round
         distance = 0
         while from < to
           # look at working ranges
           time_in_day = from.seconds_since_midnight
-          wh_config[:working_hours][from.wday].each do |begins, ends|
+          config[:working_hours][from.wday].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
@@ -150,7 +160,7 @@ module WorkingHours
             end
           end
           # roll to next business period
-          from = advance_to_working_time(from)
+          from = advance_to_working_time(from, config: config)
         end
         distance
       end
@@ -163,11 +173,11 @@ module WorkingHours
     end
 
     # fix for ActiveRecord < 4, doesn't implement in_time_zone for Date
-    def in_config_zone time
+    def in_config_zone time, config: nil
       if time.respond_to? :in_time_zone
-        time.in_time_zone(wh_config[:time_zone])
+        time.in_time_zone(config[:time_zone])
       elsif time.is_a? Date
-        wh_config[:time_zone].local(time.year, time.month, time.day)
+        config[:time_zone].local(time.year, time.month, time.day)
       else
         raise TypeError.new("Can't convert #{time.class} to a Time")
       end

data/lib/working_hours/config.rb

@@ -1,11 +1,9 @@
 require 'set'
-require 'working_hours/deep_freeze'
 
 module WorkingHours
   InvalidConfiguration = Class.new StandardError
 
   class Config
-    extend WorkingHours::DeepFreeze
 
     TIME_FORMAT = /\A([0-1][0-9]|2[0-3]):([0-5][0-9])\z/
     DAYS_OF_WEEK = [:sun, :mon, :tue, :wed, :thu, :fri, :sat]
@@ -18,7 +16,7 @@ module WorkingHours
 
       def working_hours=(val)
         validate_working_hours! val
-        config[:working_hours] = deep_freeze(val)
+        config[:working_hours] = val
         config.delete :precompiled
       end
 
@@ -28,12 +26,18 @@ module WorkingHours
 
       def holidays=(val)
         validate_holidays! val
-        config[:holidays] = deep_freeze(val)
+        config[:holidays] = val
         config.delete :precompiled
       end
 
       # Returns an optimized for computing version
       def precompiled
+        config_hash = [config[:working_hours], config[:holidays], config[:time_zone]].hash
+        if config_hash != config[:config_hash]
+          config[:config_hash] = config_hash
+          config.delete :precompiled
+        end
+
         config[:precompiled] ||= begin
           compiled = {working_hours: []}
           working_hours.each do |day, hours|
@@ -54,7 +58,7 @@ module WorkingHours
 
       def time_zone=(val)
         zone = validate_time_zone! val
-        config[:time_zone] = zone.freeze
+        config[:time_zone] = zone
         config.delete :precompiled
       end
 
@@ -76,9 +80,9 @@ module WorkingHours
             wed: {'09:00' => '17:00'},
             thu: {'09:00' => '17:00'},
             fri: {'09:00' => '17:00'}
-          }.freeze,
-          holidays: [].freeze,
-          time_zone: ActiveSupport::TimeZone['UTC'].freeze
+          },
+          holidays: [],
+          time_zone: ActiveSupport::TimeZone['UTC']
         }
       end
 

data/lib/working_hours/version.rb

@@ -1,3 +1,3 @@
 module WorkingHours
-  VERSION = "0.9.0"
+  VERSION = "1.0.0"
 end

data/spec/working_hours/computation_spec.rb

@@ -90,6 +90,14 @@ describe WorkingHours::Computation do
       time = Time.utc(1991, 11, 15, 16, 59, 42) # Friday
       expect(add_seconds(time, 120)).to eq(Time.utc(1991, 11, 18, 9, 1, 42))
     end
+
+    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
+      add_seconds(time, 120)
+    end
+
   end
 
   describe '#advance_to_working_time' do
@@ -313,4 +321,4 @@ describe WorkingHours::Computation do
       )).to eq(7.hours)
     end
   end
-end
+end

data/spec/working_hours/config_spec.rb

@@ -44,15 +44,15 @@ describe WorkingHours::Config do
       expect(config).to eq(time_sheet)
     end
 
-    it "can't be modified once precompiled" do
+    it "recomputes precompiled when modified" do
       time_sheet = {:mon => {'08:00' => '14:00'}}
       WorkingHours::Config.working_hours = time_sheet
       expect {
         WorkingHours::Config.working_hours[:tue] = {'08:00' => '14:00'}
-      }.to raise_error(RuntimeError, "can't modify frozen Hash")
+      }.to change { WorkingHours::Config.precompiled[:working_hours][2] }
       expect {
         WorkingHours::Config.working_hours[:mon]['08:00'] = '15:00'
-      }.to raise_error(RuntimeError, "can't modify frozen Hash")
+      }.to change { WorkingHours::Config.precompiled[:working_hours][1] }
     end
 
     describe 'validations' do
@@ -116,10 +116,10 @@ describe WorkingHours::Config do
       expect(config).to eq([Date.today])
     end
 
-    it "can't be modified once precompiled" do
+    it "recomputes precompiled when modified" do
       expect {
         WorkingHours::Config.holidays << Date.today
-      }.to raise_error(RuntimeError, "can't modify frozen Array")
+      }.to change { WorkingHours::Config.precompiled[:holidays] }.by(Set.new([Date.today]))
     end
 
     describe 'validation' do
@@ -154,10 +154,10 @@ describe WorkingHours::Config do
       expect(config).to eq(ActiveSupport::TimeZone['Tokyo'])
     end
 
-    it "can't be modified once precompiled" do
+    it "recomputes precompiled when modified" do
       expect {
         WorkingHours::Config.time_zone.instance_variable_set(:@name, 'Bordeaux')
-      }.to raise_error(RuntimeError, "can't modify frozen ActiveSupport::TimeZone")
+      }.to change { WorkingHours::Config.time_zone.name }.from('UTC').to('Bordeaux')
     end
 
     describe 'validation' do
@@ -224,8 +224,9 @@ describe WorkingHours::Config do
     end
 
     it 'is computed only once' do
-      expect(WorkingHours::Config).to receive(:compile_time).exactly(10).times
+      precompiled = WorkingHours::Config.precompiled
       3.times { WorkingHours::Config.precompiled }
+      expect(WorkingHours::Config.precompiled).to be(precompiled)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: working_hours
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Adrien Jarthon
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-24 00:00:00.000000000 Z
+date: 2014-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -106,6 +106,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -119,7 +120,6 @@ files:
 - lib/working_hours/config.rb
 - lib/working_hours/core_ext/date_and_time.rb
 - lib/working_hours/core_ext/fixnum.rb
-- lib/working_hours/deep_freeze.rb
 - lib/working_hours/duration.rb
 - lib/working_hours/duration_proxy.rb
 - lib/working_hours/module.rb

data/lib/working_hours/deep_freeze.rb

@@ -1,12 +0,0 @@
-module WorkingHours
-  module DeepFreeze
-    def deep_freeze object
-      if object.is_a? Array
-        object.replace(object.dup.each { |_, value| deep_freeze(value) })
-      elsif object.is_a? Hash
-        object.replace(object.dup.each { |_, value| deep_freeze(value) })
-      end
-      object.freeze
-    end
-  end
-end