holidays 2.2.0 → 3.0.0

data/lib/holidays/definition/context/merger.rb

@@ -0,0 +1,26 @@
+module Holidays
+  module Definition
+    module Context
+      # Merge a new set of definitions into the Holidays module.
+      #
+      # This method is automatically called when including holiday definition
+      # files. This is accomplished because the Generator class generates the
+      # definition source with this class explicitly.
+      class Merger
+        def initialize(holidays_by_month_repo, regions_repo)
+          @holidays_repo = holidays_by_month_repo
+          @regions_repo = regions_repo
+        end
+
+        def call(target_regions, target_holidays)
+          regions_repo.add(target_regions)
+          holidays_repo.add(target_holidays)
+        end
+
+        private
+
+        attr_reader :holidays_repo, :regions_repo
+      end
+    end
+  end
+end

data/lib/holidays/definition/repository/cache.rb

@@ -0,0 +1,33 @@
+module Holidays
+  module Definition
+    module Repository
+      class Cache
+        def initialize
+          reset!
+        end
+
+        def cache_between(start_date, end_date, cache_data, *options)
+          raise ArgumentError unless cache_data
+
+          @cache_range[options] = start_date..end_date
+          @cache[options] = cache_data
+        end
+
+        def find(start_date, end_date, *options)
+          if range = @cache_range[options]
+            if range.begin <= start_date && range.end >= end_date
+              return @cache[options].select do |holiday|
+                holiday[:date] >= start_date && holiday[:date] <= end_date
+              end
+            end
+          end
+        end
+
+        def reset!
+          @cache = {}
+          @cache_range = {}
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition/repository/holidays_by_month.rb

@@ -0,0 +1,49 @@
+module Holidays
+  module Definition
+    module Repository
+      class HolidaysByMonth
+        def initialize
+          @holidays_by_month = {}
+        end
+
+        def all
+          @holidays_by_month
+        end
+
+        def find_by_month(month)
+          raise ArgumentError unless month >= 0 && month <= 12
+          @holidays_by_month[month]
+        end
+
+        def add(new_holidays)
+          new_holidays.each do |month, holiday_defs|
+            @holidays_by_month[month] = [] unless @holidays_by_month[month]
+
+            holiday_defs.each do |holiday_def|
+              exists = false
+              @holidays_by_month[month].each do |existing_def|
+                if definition_exists?(existing_def, holiday_def)
+                  # append regions
+                  existing_def[:regions] << holiday_def[:regions]
+
+                  # Should do this once we're done
+                  existing_def[:regions].flatten!
+                  existing_def[:regions].uniq!
+                  exists = true
+                end
+              end
+
+              @holidays_by_month[month] << holiday_def  unless exists
+            end
+          end
+        end
+
+        private
+
+        def definition_exists?(existing_def, target_def)
+          existing_def[:name] == target_def[:name] && existing_def[:wday] == target_def[:wday] && existing_def[:mday] == target_def[:mday] && existing_def[:week] == target_def[:week] && existing_def[:function_id] == target_def[:function_id] && existing_def[:type] == target_def[:type] && existing_def[:observed_id] == target_def[:observed_id]
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition/repository/proc_cache.rb

@@ -0,0 +1,36 @@
+module Holidays
+  module Definition
+    module Repository
+      # ==== Benchmarks
+      #
+      # Lookup Easter Sunday, with caching, by number of iterations:
+      #
+      #       user     system      total        real
+      # 0001  0.000000   0.000000   0.000000 (  0.000000)
+      # 0010  0.000000   0.000000   0.000000 (  0.000000)
+      # 0100  0.078000   0.000000   0.078000 (  0.078000)
+      # 1000  0.641000   0.000000   0.641000 (  0.641000)
+      # 5000  3.172000   0.015000   3.187000 (  3.219000)
+      #
+      # Lookup Easter Sunday, without caching, by number of iterations:
+      #
+      #       user     system      total        real
+      # 0001  0.000000   0.000000   0.000000 (  0.000000)
+      # 0010  0.016000   0.000000   0.016000 (  0.016000)
+      # 0100  0.125000   0.000000   0.125000 (  0.125000)
+      # 1000  1.234000   0.000000   1.234000 (  1.234000)
+      # 5000  6.094000   0.031000   6.125000 (  6.141000)
+      class ProcCache
+        def initialize
+          @proc_cache = {}
+        end
+
+        def lookup(function, year)
+          proc_key = Digest::MD5.hexdigest("#{function.to_s}_#{year.to_s}")
+          @proc_cache[proc_key] = function.call(year) unless @proc_cache[proc_key]
+          @proc_cache[proc_key]
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition/repository/regions.rb

@@ -0,0 +1,36 @@
+module Holidays
+  module Definition
+    module Repository
+      class Regions
+        def initialize
+          @regions = []
+        end
+
+        def all
+          @regions
+        end
+
+        def add(regions)
+          regions = [regions] unless regions.is_a?(Array)
+
+          regions.each do |region|
+            raise ArgumentError unless region.is_a?(Symbol)
+          end
+
+          @regions = @regions | regions
+          @regions.uniq!
+        end
+
+        def exists?(region)
+          raise ArgumentError unless region.is_a?(Symbol)
+          @regions.include?(region)
+        end
+
+        def search(prefix)
+          raise ArgumentError unless prefix.is_a?(String)
+          @regions.select { |region| region.to_s =~ Regexp.new("^#{prefix}") }
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition/validator/region.rb

@@ -0,0 +1,45 @@
+module Holidays
+  module Definition
+    module Validator
+      class Region
+        def initialize(regions_repo)
+          @regions_repo = regions_repo
+        end
+
+        def valid?(r)
+          return false unless r.is_a?(Symbol)
+
+          region = find_wildcard_base(r)
+
+          (region == :any ||
+           regions_repo.exists?(region) ||
+           region_in_static_definitions?(region))
+        end
+
+        private
+
+        attr_reader :regions_repo
+
+        # Ex: :gb_ transformed to :gb
+        def find_wildcard_base(region)
+          r = region.to_s
+
+          if r =~ /_$/
+            base = r.split('_').first
+          else
+            base = r
+          end
+
+          base.to_sym
+        end
+
+        def region_in_static_definitions?(region)
+          static_regions_definition = "#{DEFINITIONS_PATH}/REGIONS.rb"
+          require static_regions_definition
+
+          Holidays::REGIONS.include?(region)
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition_factory.rb

@@ -0,0 +1,50 @@
+require 'holidays/definition/context/generator'
+require 'holidays/definition/context/merger'
+require 'holidays/definition/repository/holidays_by_month'
+require 'holidays/definition/repository/regions'
+require 'holidays/definition/repository/cache'
+require 'holidays/definition/repository/proc_cache'
+require 'holidays/definition/validator/region'
+
+module Holidays
+  module DefinitionFactory
+    class << self
+      def file_parser
+        Definition::Context::Generator.new
+      end
+
+      def source_generator
+        Definition::Context::Generator.new
+      end
+
+      def merger
+        Definition::Context::Merger.new(
+          holidays_by_month_repository,
+          regions_repository
+        )
+      end
+
+      def region_validator
+        Definition::Validator::Region.new(
+          regions_repository
+        )
+      end
+
+      def holidays_by_month_repository
+        @holidays_repo ||= Definition::Repository::HolidaysByMonth.new
+      end
+
+      def regions_repository
+        @regions_repo ||= Definition::Repository::Regions.new
+      end
+
+      def cache_repository
+        @cache_repo ||= Definition::Repository::Cache.new
+      end
+
+      def proc_cache_repository
+        @proc_cache_repo ||= Definition::Repository::ProcCache.new
+      end
+    end
+  end
+end

data/lib/holidays/option/context/parse_options.rb

@@ -0,0 +1,96 @@
+module Holidays
+  module Option
+    module Context
+      class ParseOptions
+        def initialize(regions_repo, region_validator)
+          @regions_repo = regions_repo
+          @region_validator = region_validator
+        end
+
+        # Returns [(arr)regions, (bool)observed, (bool)informal]
+        def call(*options)
+          options.flatten!
+
+          #TODO This is garbage. These two deletes MUST come before the
+          # parse_regions call, otherwise it thinks that :observed and :informal
+          # are regions to parse. We should be splitting these things out.
+          observed = options.delete(:observed) ? true : false
+          informal = options.delete(:informal) ? true : false
+          regions = parse_regions!(options)
+
+          return regions, observed, informal
+        end
+
+        private
+
+        attr_reader :regions_repo, :region_validator
+
+        # Check regions against list of supported regions and return an array of
+        # symbols.
+        #
+        # If a wildcard region is found (e.g. <tt>:ca_</tt>) it is expanded into all
+        # of its available sub regions.
+        def parse_regions!(regions)
+          regions = [regions] unless regions.kind_of?(Array)
+          return [:any] if regions.empty?
+
+          regions = regions.collect { |r| r.to_sym }
+
+          validate!(regions)
+
+          # Found sub region wild-card
+          regions.delete_if do |r|
+            if r.to_s =~ /_$/
+              load_containing_region(r.to_s)
+              regions << regions_repo.search(r.to_s)
+              true
+            end
+          end
+
+          regions.flatten!
+
+          require "#{DEFINITIONS_PATH}/north_america" if regions.include?(:us) # special case for north_america/US cross-linking
+
+          regions.each do |region|
+            unless region == :any or regions_repo.exists?(region)
+              region_definition = "#{DEFINITIONS_PATH}/#{region.to_s}"
+              begin
+                require region_definition #FIXME This is unacceptable, we can't be loading external files while parsing options
+              rescue LoadError => e
+                # This could be a sub region that does not have any holiday
+                # definitions of its own; try to load the containing region instead.
+                if region.to_s =~ /_/
+                  load_containing_region(region.to_s)
+                else
+                  raise UnknownRegionError, "Could not load #{region_definition}"
+                end
+              end
+            end
+          end
+
+          regions
+        end
+
+        def validate!(regions)
+          regions.each do |r|
+            raise UnknownRegionError unless region_validator.valid?(r)
+          end
+        end
+
+        # Derive the containing region from a sub region wild-card or a sub region
+        # and load its definition. (Common code factored out from parse_regions)
+        def load_containing_region(sub_reg)
+          prefix = sub_reg.split('_').first
+          region_definition = "#{DEFINITIONS_PATH}/#{prefix}"
+          unless regions_repo.exists?(prefix.to_sym)
+            begin
+              require region_definition #FIXME This is not acceptable, we can't be loading external things while parsing options.
+            rescue LoadError
+              raise UnknownRegionError, "Could not load #{region_definition}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/holidays/option_factory.rb

@@ -0,0 +1,14 @@
+require 'holidays/option/context/parse_options'
+
+module Holidays
+  module OptionFactory
+    class << self
+      def parse_options
+        Option::Context::ParseOptions.new(
+          DefinitionFactory.regions_repository,
+          DefinitionFactory.region_validator,
+        )
+      end
+    end
+  end
+end

data/lib/holidays/use_case/context/between.rb

@@ -0,0 +1,105 @@
+module Holidays
+  module UseCase
+    module Context
+      class Between
+        def initialize(holidays_by_month_repo, day_of_month_calculator, proc_cache_repo)
+          @holidays_by_month_repo = holidays_by_month_repo
+          @day_of_month_calculator = day_of_month_calculator
+          @proc_cache_repo = proc_cache_repo
+        end
+
+        def call(start_date, end_date, dates_driver, regions, observed, informal)
+          validate!(start_date, end_date, dates_driver, regions)
+
+          holidays = []
+
+          dates_driver.each do |year, months|
+            months.each do |month|
+              next unless hbm = holidays_by_month_repo.find_by_month(month)
+
+              hbm.each do |h|
+                next unless in_region?(regions, h[:regions])
+
+                # Skip informal holidays unless they have been requested
+                next if h[:type] == :informal and not informal
+
+                if h[:function]
+                  # Holiday definition requires a calculation
+                  result = call_proc(h[:function], year)
+
+                  # Procs may return either Date or an integer representing mday
+                  if result.kind_of?(Date)
+                    month = result.month
+                    mday = result.mday
+                  else
+                    mday = result
+                  end
+                else
+                  # Calculate the mday
+                  mday = h[:mday] || day_of_month_calculator.call(year, month, h[:week], h[:wday])
+                end
+
+                # Silently skip bad mdays
+                begin
+                  date = Date.civil(year, month, mday)
+                rescue; next; end
+
+                # If the :observed option is set, calculate the date when the holiday
+                # is observed.
+                if observed and h[:observed]
+                  date = call_proc(h[:observed], date)
+                end
+
+                if date.between?(start_date, end_date)
+                  holidays << {:date => date, :name => h[:name], :regions => h[:regions]}
+                end
+              end
+            end
+          end
+
+          holidays.sort{|a, b| a[:date] <=> b[:date] }
+        end
+
+        private
+
+        attr_reader :holidays_by_month_repo, :day_of_month_calculator, :proc_cache_repo
+
+        def validate!(start_date, end_date, dates_driver, regions)
+          raise ArgumentError unless start_date
+          raise ArgumentError unless end_date
+
+          raise ArgumentError if dates_driver.nil? || dates_driver.empty?
+
+          dates_driver.each do |year, months|
+            raise ArgumentError if months.nil? || months.empty?
+          end
+
+          raise ArgumentError if regions.nil? || regions.empty?
+        end
+
+        def call_proc(function, year)
+          proc_cache_repo.lookup(function, year)
+        end
+
+        # Check sub regions.
+        #
+        # When request :any, all holidays should be returned.
+        # When requesting :ca_bc, holidays in :ca or :ca_bc should be returned.
+        # When requesting :ca, holidays in :ca but not its subregions should be returned.
+        def in_region?(requested, available) # :nodoc:
+          return true if requested.include?(:any)
+
+          # When an underscore is encountered, derive the parent regions
+          # symbol and include both in the requested array.
+          requested = requested.collect do |r|
+            r.to_s =~ /_/ ? [r, r.to_s.gsub(/_[\w]*$/, '').to_sym] : r
+          end
+
+          requested = requested.flatten.uniq
+
+          available.any? { |avail| requested.include?(avail) }
+        end
+      end
+    end
+  end
+end