holidays 5.4.0 → 5.5.0

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

@@ -9,54 +9,59 @@ module Holidays
           @proc_result_cache_repo = proc_result_cache_repo
         end
 
-        def call(year, month, day, func_id, desired_func_args, func_modifier = nil)
-          validate!(year, month, day, func_id, desired_func_args)
+        def call(input, func_id, desired_func_args, func_modifier = nil)
+          validate!(input, func_id, desired_func_args)
 
           function = @custom_methods_repo.find(func_id)
           raise Holidays::FunctionNotFound.new("Unable to find function with id '#{func_id}'") if function.nil?
 
-          calculate(year, month, function, parse_arguments(year, month, day, desired_func_args), func_modifier)
+          calculate(input, function, parse_arguments(input, desired_func_args), func_modifier)
         end
 
         private
 
-        VALID_ARGUMENTS = [:year, :month, :day, :date]
+        VALID_ARGUMENTS = [:year, :month, :day, :date, :region]
 
-        def validate!(year, month, day, func_id, desired_func_args)
+        def validate!(input, func_id, desired_func_args)
           raise ArgumentError if desired_func_args.nil? || desired_func_args.empty?
 
           desired_func_args.each do |name|
             raise ArgumentError unless VALID_ARGUMENTS.include?(name)
           end
 
-          raise ArgumentError if desired_func_args.include?(:year) && !year.is_a?(Integer)
-          raise ArgumentError if desired_func_args.include?(:month) && (month < 0 || month > 12)
-          raise ArgumentError if desired_func_args.include?(:day) && (day < 1 || day > 31)
+          raise ArgumentError if desired_func_args.include?(:year) && !input[:year].is_a?(Integer)
+          raise ArgumentError if desired_func_args.include?(:month) && (input[:month] < 0 || input[:month] > 12)
+          raise ArgumentError if desired_func_args.include?(:day) && (input[:day] < 1 || input[:day] > 31)
+          raise ArgumentError if desired_func_args.include?(:region) && !input[:region].is_a?(Symbol)
         end
 
-        def parse_arguments(year, month, day, target_args)
+        def parse_arguments(input, target_args)
           args = []
 
           if target_args.include?(:year)
-            args << year
+            args << input[:year]
           end
 
           if target_args.include?(:month)
-            args << month
+            args << input[:month]
           end
 
           if target_args.include?(:day)
-            args << day
+            args << input[:day]
           end
 
           if target_args.include?(:date)
-            args << Date.civil(year, month, day)
+            args << Date.civil(input[:year], input[:month], input[:day])
+          end
+
+          if target_args.include?(:region)
+            args << input[:region]
           end
 
           args
         end
 
-        def calculate(year, month, id, args, modifier)
+        def calculate(input, id, args, modifier)
           result = @proc_result_cache_repo.lookup(id, *args)
           if result.kind_of?(Date)
             if modifier
@@ -64,7 +69,7 @@ module Holidays
             end
           elsif result.is_a?(Integer)
             begin
-              result = Date.civil(year, month, result)
+              result = Date.civil(input[:year], input[:month], result)
             rescue ArgumentError
               raise Holidays::InvalidFunctionResponse.new("invalid day response from custom method call resulting in invalid date. Result: '#{result}'")
             end

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

@@ -235,12 +235,6 @@ module Holidays
   #
   # Definitions loaded: #{files.join(', ')}
   #
-  # To use the definitions in this file, load it right after you load the
-  # Holiday gem:
-  #
-  #   require 'holidays'
-  #   require '#{DEFINITIONS_PATH}/#{module_name.to_s.downcase}'
-  #
   # All the definitions are available at https://github.com/holidays/holidays
   module #{module_name.to_s.upcase} # :nodoc:
     def self.defined_regions

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

@@ -0,0 +1,29 @@
+module Holidays
+  module Definition
+    module Context
+      class Load
+        def initialize(definition_merger, full_definitions_path)
+          @definition_merger = definition_merger
+          @full_definitions_path = full_definitions_path
+        end
+
+        def call(region)
+          region_definition_file = "#{@full_definitions_path}/#{region}"
+          require region_definition_file
+
+          target_region_module = Module.const_get("Holidays").const_get(region.upcase)
+
+          @definition_merger.call(
+            target_region_module.defined_regions,
+            target_region_module.holidays_by_month,
+            target_region_module.custom_methods,
+          )
+
+          target_region_module.defined_regions
+        rescue  NameError, LoadError => e
+          raise UnknownRegionError.new(e), "Could not load region prefix: #{region.to_s}"
+        end
+      end
+    end
+  end
+end

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

@@ -2,10 +2,6 @@ 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, custom_methods_repo)
           @holidays_repo = holidays_by_month_repo

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

@@ -0,0 +1,50 @@
+module Holidays
+  module Definition
+    module Generator
+      class Regions
+        def call(regions)
+          validate!(regions)
+
+          <<-EOF
+# encoding: utf-8
+module Holidays
+  REGIONS = #{to_array(regions)}
+
+  PARENT_REGION_LOOKUP = #{generate_parent_lookup(regions)}
+end
+EOF
+        end
+
+        private
+
+        def validate!(regions)
+          raise ArgumentError.new("regions cannot be missing") if regions.nil?
+          raise ArgumentError.new("regions must be a hash") unless regions.is_a?(Hash)
+          raise ArgumentError.new("regions cannot be empty") if regions.empty?
+        end
+
+        def to_array(regions)
+          all_regions = []
+
+          regions.each do |region, subregions|
+            all_regions << subregions
+          end
+
+          all_regions.flatten.uniq
+        end
+
+        def generate_parent_lookup(regions)
+          lookup = {}
+
+          regions.each do |region, subregions|
+            subregions.each do |s|
+              lookup[s] = region unless lookup.has_key?(s)
+            end
+          end
+
+          lookup
+        end
+      end
+    end
+  end
+end

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

@@ -10,16 +10,18 @@ module Holidays
           raise ArgumentError unless cache_data
 
           @cache_range[options] = start_date..end_date
-          @cache[options] = cache_data
+          @cache[options] = cache_data.group_by { |holiday| holiday[:date] }
         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
+          return nil unless in_cache_range?(start_date, end_date, options)
+          
+          if start_date == end_date
+            @cache[options].fetch(start_date, [])
+          else
+            @cache[options].select do |date, holidays|
+              date >= start_date && date <= end_date
+            end.flat_map { |date, holidays| holidays }
           end
         end
 
@@ -27,6 +29,17 @@ module Holidays
           @cache = {}
           @cache_range = {}
         end
+
+        private
+
+        def in_cache_range?(start_date, end_date, options)
+          range = @cache_range[options]
+          if range
+            range.begin <= start_date && range.end >= end_date
+          else
+            false
+          end
+        end
       end
     end
   end

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

@@ -38,7 +38,7 @@ module Holidays
         def validate!(function, function_arguments)
           raise ArgumentError.new("function must be a proc") unless function.is_a?(Proc)
           function_arguments.each do |arg|
-            raise ArgumentError.new("function arguments '#{function_arguments}' must contain either integers or dates") unless arg.is_a?(Integer) || arg.is_a?(Date)
+            raise ArgumentError.new("function arguments '#{function_arguments}' must contain either integers or dates") unless arg.is_a?(Integer) || arg.is_a?(Date) || arg.is_a?(Symbol)
           end
         end
 

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

@@ -2,12 +2,27 @@ module Holidays
   module Definition
     module Repository
       class Regions
-        def initialize
-          @regions = []
+        def initialize(all_generated_regions, parent_region_lookup)
+          @loaded_regions = []
+          @all_generated_regions = all_generated_regions
+          @parent_region_lookup = parent_region_lookup
         end
 
-        def all
-          @regions
+        def all_generated
+          @all_generated_regions
+        end
+
+        def parent_region_lookup(r)
+          @parent_region_lookup[r]
+        end
+
+        def all_loaded
+          @loaded_regions
+        end
+
+        def loaded?(region)
+          raise ArgumentError unless region.is_a?(Symbol)
+          @loaded_regions.include?(region)
         end
 
         def add(regions)
@@ -17,18 +32,13 @@ module Holidays
             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)
+          @loaded_regions = @loaded_regions | regions
+          @loaded_regions.uniq!
         end
 
         def search(prefix)
-          raise ArgumentError unless prefix.is_a?(String)
-          @regions.select { |region| region.to_s =~ Regexp.new("^#{prefix}") }
+          raise ArgumentError unless prefix.is_a?(Symbol)
+          @loaded_regions.select { |region| region.to_s =~ Regexp.new("^#{prefix}") }
         end
       end
     end

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

@@ -2,7 +2,7 @@ module Holidays
   module Definition
     module Validator
       class CustomMethod
-        VALID_ARGUMENTS = ["date", "year", "month", "day"]
+        VALID_ARGUMENTS = ["date", "year", "month", "day", "region"]
 
         def valid?(m)
           valid_name?(m[:name]) &&

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

@@ -12,8 +12,8 @@ module Holidays
           region = find_wildcard_base(r)
 
           (region == :any ||
-           @regions_repo.exists?(region) ||
-           region_in_static_definitions?(region))
+           @regions_repo.loaded?(region) ||
+           @regions_repo.all_generated.include?(region))
         end
 
         private
@@ -30,13 +30,6 @@ module Holidays
 
           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

data/lib/holidays/factory/date_calculator.rb

@@ -1,6 +1,7 @@
 require 'holidays/date_calculator/easter'
 require 'holidays/date_calculator/weekend_modifier'
 require 'holidays/date_calculator/day_of_month'
+require 'holidays/date_calculator/lunar_date'
 
 module Holidays
   module Factory
@@ -24,6 +25,10 @@ module Holidays
       end
 
       class << self
+        def lunar_date 
+          Holidays::DateCalculator::LunarDate.new
+        end
+
         def weekend_modifier
           Holidays::DateCalculator::WeekendModifier.new
         end

data/lib/holidays/factory/definition.rb

@@ -1,8 +1,10 @@
 require 'holidays/definition/context/generator'
 require 'holidays/definition/context/merger'
 require 'holidays/definition/context/function_processor'
+require 'holidays/definition/context/load'
 require 'holidays/definition/decorator/custom_method_proc'
 require 'holidays/definition/decorator/custom_method_source'
+require 'holidays/definition/generator/regions'
 require 'holidays/definition/parser/custom_method'
 require 'holidays/definition/repository/holidays_by_month'
 require 'holidays/definition/repository/regions'
@@ -76,7 +78,10 @@ module Holidays
         end
 
         def regions_repository
-          @regions_repo ||= Holidays::Definition::Repository::Regions.new
+          @regions_repo ||= Holidays::Definition::Repository::Regions.new(
+            Holidays::REGIONS,
+            Holidays::PARENT_REGION_LOOKUP,
+          )
         end
 
         def cache_repository
@@ -90,6 +95,17 @@ module Holidays
         def custom_methods_repository
           @custom_methods_repository ||= Holidays::Definition::Repository::CustomMethods.new
         end
+
+        def regions_generator
+          Holidays::Definition::Generator::Regions.new
+        end
+
+        def loader
+          Holidays::Definition::Context::Load.new(
+            merger,
+            Holidays::FULL_DEFINITIONS_PATH,
+          )
+        end
       end
     end
   end

data/lib/holidays/factory/finder.rb

@@ -48,7 +48,7 @@ module Holidays
           Holidays::Finder::Context::ParseOptions.new(
             Factory::Definition.regions_repository,
             Factory::Definition.region_validator,
-            Factory::Definition.merger,
+            Factory::Definition.loader,
           )
         end
 

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

@@ -15,6 +15,9 @@ module Holidays
           dates_driver = @dates_driver_builder.call(start_date, end_date)
 
           holidays = []
+
+          #FIXME Why are we calling the options_parser to convert the observed/informal
+          # symbols to bool and then...converting them back? O_o
           opts = gather_options(observed, informal)
 
           holidays = @definition_search.call(dates_driver, regions, opts)

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

@@ -2,10 +2,10 @@ module Holidays
   module Finder
     module Context
       class ParseOptions
-        def initialize(regions_repo, region_validator, definition_merger)
+        def initialize(regions_repo, region_validator, definition_loader)
           @regions_repo = regions_repo
           @region_validator = region_validator
-          @definition_merger = definition_merger
+          @definition_loader = definition_loader
         end
 
         # Returns [(arr)regions, (bool)observed, (bool)informal]
@@ -31,42 +31,57 @@ module Holidays
         # 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 }
+          if regions.empty?
+            regions = [:any]
+          else
+            regions = regions.collect { |r| r.to_sym }
+          end
 
           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
+          loaded_regions = []
+
+          #FIXME I don't know what this means or why we have it! I'm reluctant to remove it
+          # at this time without understanding more. -PP 2017/3/29
+          #
+          # special case for north_america/US cross-linking
+          load_region!(:north_america) if regions.include?(:us)
 
-          regions.flatten!
-
-          load_definition_data("north_america") if regions.include?(:us) # special case for north_america/US cross-linking
-
-          regions.each do |region|
-            unless region == :any || @regions_repo.exists?(region)
-              begin
-                load_definition_data(region.to_s)
-              rescue NameError, 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.new(e), "Could not load #{region.to_s}"
+          if regions.include?(:any)
+            @regions_repo.all_generated.each do |r|
+              if @regions_repo.loaded?(r)
+                loaded_regions << r
+                next
+              end
+
+              target = @regions_repo.parent_region_lookup(r)
+              load_region!(target)
+
+              loaded_regions << r
+            end
+          else
+            regions.each do |r|
+              if is_wildcard?(r)
+                loaded_regions << load_wildcard_parent!(r)
+              else
+                parent = @regions_repo.parent_region_lookup(r)
+
+                target = parent || r
+
+                if @regions_repo.loaded?(target)
+                  loaded_regions << r
+                  next
                 end
+
+                load_region!(target)
+
+                loaded_regions << r
               end
             end
           end
 
-          regions
+          loaded_regions.flatten.compact.uniq
         end
 
         def validate!(regions)
@@ -75,33 +90,19 @@ module Holidays
           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
-
-          return if @regions_repo.exists?(prefix.to_sym)
-
-          begin
-            load_definition_data(prefix)
-          rescue NameError, LoadError => e
-            raise UnknownRegionError.new(e), "Could not load region prefix: #{prefix.to_s}, original subregion: #{sub_reg.to_s}"
-          end
+        def is_wildcard?(r)
+          r.to_s =~ /_$/
         end
 
-        def load_definition_data(region)
-          # Lazy loading of definition files. We verify the region doesn't
-          # contain malicious stuff in the initial validation.
-          region_definition_file = "#{FULL_DEFINITIONS_PATH}/#{region}"
-          require region_definition_file
-
-          target_region_module = Module.const_get("Holidays").const_get(region.upcase)
+        def load_wildcard_parent!(wildcard_region)
+          prefix = wildcard_region.to_s.split('_').first.to_sym
+          load_region!(prefix)
+        end
 
-          @definition_merger.call(
-            target_region_module.defined_regions,
-            target_region_module.holidays_by_month,
-            target_region_module.custom_methods,
-          )
+        def load_region!(r)
+          @definition_loader.call(r)
+        rescue NameError, LoadError => e
+          raise UnknownRegionError.new(e), "Could not load region: #{r}"
         end
       end
     end