business_calendar 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7e437b2a3580ac2cac07f883e3acc42dfa39e0bd3506e95e1e46a1441d14f7d
-  data.tar.gz: 13769d2f539ae93f3579c1b46378c5da5708b039b63f186e910d9f528e4b5041
+  metadata.gz: 216930bd93cbe52079f053f6bb5f67cfb3efbaa0478bb4474a98e1b4912023b7
+  data.tar.gz: 1b0242038fdbfd28978c7e9551b3f225ad43413bd7b19d19f9e9fe59c409e6e5
 SHA512:
-  metadata.gz: 625699922d3aa15522193ab57de09fa8ac5c0d13623afd47bfdbda65b2e2b2798d623ea316c0db5570b3e0c4c69de18cb4a47793167bcacf458642c516a2e0af
-  data.tar.gz: de9860000e204fc1fb05a853c437277bda370033046cc2ff43d954af432b715d39bba09f8a9d085621876f2cf508e6434063ad8ea238e01cde8eea955b7b1f42
+  metadata.gz: 4744b858e9faa599b605c0912337dff1480ac092644d9b3b3a9666c4657daaa8e98b5e905529246ac8580c793786f8334cdaf2023d62e8a07e2dd094ab124daf
+  data.tar.gz: ef328442115bcbb191992c2279d99accb5a1bd39e3cadc753404a15504549e8943889f0cd6739ad4c265a5465aacb0ee4b5e6127544fe68e688a586466f9b864

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # business_calendar changes by version
 
+1.1.0
+---------
+
+- Cache parsed responses from API endpoints for TTL (Time to Live) duration.
+- Increase default TTL duration from 5 minutes to 1 day.
+  Holidays are not expected to frequently change.
+- Allow disabling cache clearing by setting `ttl` to `false`.
+- Set hard limit to size of memoized holidays cache,
+  since large quantities of user supplied dates could consume excessive memory / cause DoS.
+
 1.0.0
 ---------
 

data/lib/business_calendar.rb

@@ -18,8 +18,7 @@ module BusinessCalendar
     end
 
     def for_endpoint(additions, removals, options = {})
-      ttl = options["ttl"] || 300
-      Calendar.new(holiday_determiner_for_endpoint(additions, removals, options), options.merge({"ttl" => ttl}))
+      Calendar.new(holiday_determiner_for_endpoint(additions, removals, options), options)
     end
 
     private
@@ -46,6 +45,10 @@ module BusinessCalendar
          :additions_only  => cfg['additions_only'] )
     end
 
+    def holiday_dates_for_endpoint(client, endpoint)
+      Proc.new { JSON.parse(client.get(endpoint).body).fetch('holidays').map { |s| Date.parse s } }
+    end
+
     def holiday_determiner_for_endpoint(additions_endpoint, removals_endpoint, opts)
       client = Faraday.new do |conn|
         conn.response :selective_errors
@@ -53,11 +56,11 @@ module BusinessCalendar
       end
 
       additions = if additions_endpoint
-                    Proc.new { JSON.parse(client.get(additions_endpoint).body).fetch('holidays').map { |s| Date.parse s } }
+                    holiday_dates_for_endpoint(client, additions_endpoint)
                   end
 
       removals = if removals_endpoint
-                   Proc.new { JSON.parse(client.get(removals_endpoint).body).fetch('holidays').map { |s| Date.parse s } }
+                   holiday_dates_for_endpoint(client, removals_endpoint)
                  end
 
       HolidayDeterminer.new(
@@ -65,7 +68,8 @@ module BusinessCalendar
         opts["holiday_names"] || [],
         :additions       => additions,
         :removals        => removals,
-        :additions_only  => opts["additions_only"] || []
+        :additions_only  => opts["additions_only"] || [],
+        :ttl => opts['ttl']
       )
     end
 

data/lib/business_calendar/calendar.rb

@@ -1,9 +1,12 @@
 class BusinessCalendar::Calendar
+  DEFAULT_TIME_TO_LIVE = 24 * 60 * 60
   attr_reader :holiday_determiner
 
   # @param [Proc[Date -> Boolean]] a proc which returns whether or not a date is a
   #                                holiday.
   def initialize(holiday_determiner, options = {})
+    ttl = options['ttl']
+    @time_to_live = ttl.nil? ? DEFAULT_TIME_TO_LIVE : ttl
     @options = options
     @holiday_cache = {}
     @holiday_determiner = holiday_determiner
@@ -14,7 +17,7 @@ class BusinessCalendar::Calendar
   def is_holiday?(date)
     date = date.send(:to_date) if date.respond_to?(:to_date, true)
 
-    clear_cache if @options["ttl"]
+    clear_cache if should_clear_cache?
 
     @holiday_cache[date] ||= holiday_determiner.call(date)
   end
@@ -22,7 +25,7 @@ class BusinessCalendar::Calendar
   # @param [Date]     date
   # @return [Boolean] Whether or not banking can be done on <date>.
   def is_business_day?(date)
-    return false if !@options["business_weekends"] && (date.saturday? || date.sunday?)
+    return false if !@options['business_weekends'] && (date.saturday? || date.sunday?)
     return false if is_holiday?(date)
     true
   end
@@ -108,6 +111,19 @@ class BusinessCalendar::Calendar
   end
 
   private
+
+  def should_clear_cache?
+    return false unless @time_to_live
+
+    # limit size using a heuristic, to prevent cache growing arbitrarily large
+    !@last_cleared || (Time.now - @last_cleared) >= @time_to_live || @holiday_cache.size > 365 * 3
+  end
+
+  def clear_cache
+    @last_cleared = Time.now
+    @holiday_cache = {}
+  end
+
   def with_one_or_many(thing_or_things)
     if thing_or_things.is_a? Enumerable
       thing_or_things.collect do |thing|
@@ -117,11 +133,4 @@ class BusinessCalendar::Calendar
       yield thing_or_things
     end
   end
-
-  def clear_cache
-    if !@issued_at || (Time.now - @issued_at) >= @options["ttl"]
-      @issued_at = Time.now
-      @holiday_cache = {}
-    end
-  end
 end

data/lib/business_calendar/holiday_determiner.rb

@@ -1,9 +1,12 @@
 require 'holidays'
 
 class BusinessCalendar::HolidayDeterminer
+  DEFAULT_TIME_TO_LIVE = 24 * 60 * 60
   attr_reader :regions, :holiday_names, :additions, :removals, :additions_only
 
   def initialize(regions, holiday_names, opts = {})
+    ttl = opts[:ttl]
+    @time_to_live = ttl.nil? ? DEFAULT_TIME_TO_LIVE : ttl
     @regions        = regions
     @holiday_names  = holiday_names
     @additions      = opts[:additions]      || []
@@ -12,6 +15,8 @@ class BusinessCalendar::HolidayDeterminer
   end
 
   def call(date)
+    clear_cache if should_clear_cache?
+
     if additions.include? date
       true
     elsif removals.include? date
@@ -23,11 +28,24 @@ class BusinessCalendar::HolidayDeterminer
   end
 
   private
+
+  def should_clear_cache?
+    return false unless @time_to_live
+
+    !@last_cleared || (Time.now - @last_cleared) >= @time_to_live
+  end
+
+  def clear_cache
+    @last_cleared = Time.now
+    @additions_cache = nil
+    @removals_cache = nil
+  end
+
   def additions
-    @additions.is_a?(Proc) ? @additions.call : @additions
+    @additions_cache ||= @additions.is_a?(Proc) ? @additions.call : @additions
   end
 
   def removals
-    @removals.is_a?(Proc) ? @removals.call : @removals
+    @removals_cache ||= @removals.is_a?(Proc) ? @removals.call : @removals
   end
 end

data/lib/business_calendar/version.rb

@@ -1,3 +1,3 @@
 module BusinessCalendar
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/business_calendar/holiday_determiner_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe BusinessCalendar::HolidayDeterminer do
   let(:regions) { [ :us ] }
-  let(:opts)    {{}}
+  let(:opts)    { {} }
   subject { BusinessCalendar::HolidayDeterminer.new(regions, ["Independence Day"], opts) }
 
   it "initializes with list of regions and a list of accepted holidays" do

data/spec/business_calendar_spec.rb

@@ -191,31 +191,175 @@ describe BusinessCalendar do
       it_behaves_like "weekends as business days"
     end
 
-    it 'hits the configured endpoint for each call to an addition or removal' do
+    it 'hits the configured endpoint and then reuses the cached result' do
+      subject.is_business_day?('2014-07-03'.to_date)
       subject.is_business_day?('2014-07-03'.to_date)
       subject.is_business_day?('2014-07-04'.to_date)
       subject.is_holiday?('2014-07-06'.to_date)
+      subject.is_holiday?('2014-07-06'.to_date)
       subject.is_holiday?('2014-12-24'.to_date)
 
-      expect(a_request(:get, additions)).to have_been_made.times(4)
-      expect(a_request(:get, removals)).to have_been_made.times(3)
+      expect(a_request(:get, additions)).to have_been_made.times(1)
+      expect(a_request(:get, removals)).to have_been_made.times(1)
     end
 
-    it 'caches holidays for 5 min' do
-      start = Time.now
+    context 'after 24 hours without specifying a Time to Live override' do
+      subject { BusinessCalendar.for_endpoint(additions, removals) }
+      let!(:start) { Time.now }
+      let!(:one_day) { 86400 }
 
-      allow(Time).to receive(:now) { start }
+      it 'expires the holidays cache' do
+        allow(Time).to receive(:now) { start }
 
-      subject.is_business_day?('2014-07-04'.to_date)
-      subject.is_business_day?('2014-07-04'.to_date)
+        subject.is_business_day?('2014-01-01'.to_date)
 
-      expect(a_request(:get, additions)).to have_been_made.times(1)
+        # initial request was made
+        expect(a_request(:get, additions)).to have_been_made.times(1)
 
-      allow(Time).to receive(:now) { start + 301 }
+        subject.is_business_day?('2014-07-04'.to_date)
+        subject.is_business_day?('2014-11-28'.to_date)
 
-      subject.is_business_day?('2014-07-04'.to_date)
+        # cache from initial request was still used
+        expect(a_request(:get, additions)).to have_been_made.times(1)
+
+        # 24 hours + 1 second have passed
+        # cache should be cleared and fresh API request made
+        allow(Time).to receive(:now) { start + one_day + 1 }
+
+        subject.is_business_day?('2014-01-01'.to_date)
+
+        # 2nd request was made
+        expect(a_request(:get, additions)).to have_been_made.times(2)
+
+        subject.is_business_day?('2014-07-04'.to_date)
+        subject.is_business_day?('2014-11-28'.to_date)
+
+        # 2nd request is now cached, so no new request should have been issued
+        expect(a_request(:get, additions)).to have_been_made.times(2)
+      end
+    end
+
+    context 'turning off Time to Live functionality' do
+      subject { BusinessCalendar.for_endpoint(additions, removals, {'ttl' => false}) }
+      let!(:start) { Time.now }
+      let!(:one_day) { 86400 }
+
+      it 'will never clear the cache' do
+        allow(Time).to receive(:now) { start }
+
+        subject.is_business_day?('2014-01-01'.to_date)
+        expect(a_request(:get, additions)).to have_been_made.times(1)
+
+        allow(Time).to receive(:now) { start + 301 }
+        subject.is_business_day?('2014-01-01'.to_date)
+        subject.is_business_day?('2014-07-04'.to_date)
+        subject.is_business_day?('2014-07-04'.to_date)
+        subject.is_business_day?('2014-11-28'.to_date)
+        expect(a_request(:get, additions)).to have_been_made.times(1)
+
+        allow(Time).to receive(:now) { start + one_day + 1 }
+        subject.is_business_day?('2014-01-01'.to_date)
+        subject.is_business_day?('2014-07-04'.to_date)
+        subject.is_business_day?('2014-11-28'.to_date)
+        expect(a_request(:get, additions)).to have_been_made.times(1)
+      end
+    end
+
+    context 'setting Time to Live override to zero' do
+      subject { BusinessCalendar.for_endpoint(additions, removals, {'ttl' => 0}) }
+      let!(:start) { Time.now }
+
+      it 'will always clear the cache' do
+        allow(Time).to receive(:now) { start }
+
+        subject.is_holiday?('2014-01-01'.to_date)
+        expect(a_request(:get, additions)).to have_been_made.times(1)
+
+        allow(Time).to receive(:now) { start + 301 }
+
+        subject.is_holiday?('2014-01-01'.to_date)
+        subject.is_holiday?('2014-07-04'.to_date)
+        subject.is_holiday?('2014-07-04'.to_date)
+        subject.is_holiday?('2014-11-28'.to_date)
+
+        expect(a_request(:get, additions)).to have_been_made.times(5)
+
+        subject.is_holiday?('2014-01-01'.to_date)
+        subject.is_holiday?('2014-01-01'.to_date)
+        subject.is_holiday?('2014-07-04'.to_date)
+        subject.is_holiday?('2014-11-28'.to_date)
+        expect(a_request(:get, additions)).to have_been_made.times(9)
+      end
+    end
 
-      expect(a_request(:get, additions)).to have_been_made.times(2)
+    context 'using a 5 minute Time to Live override' do
+      subject { BusinessCalendar.for_endpoint(additions, removals, {'ttl' => 300}) }
+      let!(:start) { Time.now }
+
+      it 'expires the holidays cache after the specified time has elapsed' do
+        allow(Time).to receive(:now) { start }
+
+        # initial request made and cached
+        subject.is_business_day?('2014-01-01'.to_date)
+        subject.is_business_day?('2014-07-04'.to_date)
+        subject.is_business_day?('2014-11-28'.to_date)
+        expect(a_request(:get, additions)).to have_been_made.times(1)
+
+        # 120 seconds pass, cache should still be used
+        allow(Time).to receive(:now) { start + 120 }
+        subject.is_business_day?('2014-01-01'.to_date)
+        subject.is_business_day?('2014-07-04'.to_date)
+        subject.is_business_day?('2014-11-28'.to_date)
+        expect(a_request(:get, additions)).to have_been_made.times(1)
+
+        # 301 seconds pass, cache is expired and 2nd request made
+        allow(Time).to receive(:now) { start + 301 }
+        subject.is_business_day?('2014-01-01'.to_date)
+        subject.is_business_day?('2014-07-04'.to_date)
+        subject.is_business_day?('2014-11-28'.to_date)
+        expect(a_request(:get, additions)).to have_been_made.times(2)
+
+        # 2nd request is now cached, so no new request should have been issued
+        subject.is_business_day?('2014-01-01'.to_date)
+        subject.is_business_day?('2014-07-04'.to_date)
+        subject.is_business_day?('2014-11-28'.to_date)
+        expect(a_request(:get, additions)).to have_been_made.times(2)
+      end
+    end
+
+    context 'with a few years in dates filling the cache' do
+      let!(:start) { Time.now }
+
+      # NOTE: this test cheats a bit to test class internals / implementation
+      it 'will clear out the holiday cache but keep the cached API result' do
+        allow(Time).to receive(:now) { start }
+        subject.is_business_day?('2014-07-04'.to_date)
+        expect(a_request(:get, additions)).to have_been_made.times(1)
+
+        expect(a_request(:get, additions)).to have_been_made.times(1)
+        (2014..2017).each do |year|
+          (1..12).each do |month|
+            (1..28).each do |day|
+              subject.is_business_day?("#{year}-#{month}-#{day}".to_date)
+            end
+          end
+        end
+
+        # about to reach cache size threshold
+        expect(subject.instance_variable_get('@holiday_cache').size).to be(960)
+
+        (1..7).each do |month|
+          (1..28).each do |day|
+            subject.is_business_day?("#2018-#{month}-#{day}".to_date)
+          end
+        end
+
+        # now holiday cache will have been cleared and should be small again
+        expect(subject.instance_variable_get('@holiday_cache').size).to be(4)
+
+        # and cached API response was still used
+        expect(a_request(:get, additions)).to have_been_made.times(1)
+      end
     end
 
     context 'http request fails' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: business_calendar
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Robert Nubel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-12 00:00:00.000000000 Z
+date: 2019-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: holidays
@@ -192,8 +192,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Country-aware business-date logic and handling.