holidays 3.3.0 → 4.0.0

data/lib/holidays/definition/repository/{proc_cache.rb → proc_result_cache.rb}

@@ -20,16 +20,31 @@ module Holidays
       # 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
+      class ProcResultCache
         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]
+        def lookup(function, *function_arguments)
+          validate!(function, function_arguments)
+
+          proc_key = build_proc_key(function, function_arguments)
+          @proc_cache[proc_key] = function.call(*function_arguments) unless @proc_cache[proc_key]
           @proc_cache[proc_key]
         end
+
+        private
+
+        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)
+          end
+        end
+
+        def build_proc_key(function, function_arguments)
+          Digest::MD5.hexdigest("#{function.to_s}_#{function_arguments.join('_')}")
+        end
       end
     end
   end

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

@@ -0,0 +1,31 @@
+module Holidays
+  module Definition
+    module Validator
+      class CustomMethod
+        VALID_ARGUMENTS = ["date", "year", "month", "day"]
+
+        def valid?(m)
+          valid_name?(m[:name]) &&
+            valid_arguments?(m[:arguments]) &&
+            valid_source?(m[:source])
+        end
+
+        private
+
+        def valid_name?(name)
+          !name.nil? && !name.empty?
+        end
+
+        def valid_arguments?(arguments)
+          arguments.split(",").all? { |arg|
+            arg == arg.chomp && VALID_ARGUMENTS.include?(arg.strip)
+          }
+        end
+
+        def valid_source?(source)
+          !source.nil? && !source.empty?
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition_factory.rb

@@ -1,35 +1,67 @@
 require 'holidays/definition/context/generator'
 require 'holidays/definition/context/merger'
+require 'holidays/definition/decorator/custom_method_proc'
+require 'holidays/definition/decorator/custom_method_source'
+require 'holidays/definition/parser/custom_method'
 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/repository/proc_result_cache'
+require 'holidays/definition/repository/custom_methods'
+require 'holidays/definition/validator/custom_method'
 require 'holidays/definition/validator/region'
 
 module Holidays
   module DefinitionFactory
     class << self
       def file_parser
-        Definition::Context::Generator.new
+        Definition::Context::Generator.new(
+          custom_method_parser,
+          custom_method_source_decorator,
+          custom_methods_repository,
+        )
       end
 
       def source_generator
-        Definition::Context::Generator.new
+        Definition::Context::Generator.new(
+          custom_method_parser,
+          custom_method_source_decorator,
+          custom_methods_repository,
+        )
       end
 
       def merger
         Definition::Context::Merger.new(
           holidays_by_month_repository,
-          regions_repository
+          regions_repository,
+          custom_methods_repository,
         )
       end
 
+      def custom_method_parser
+        Definition::Parser::CustomMethod.new(
+          custom_method_validator,
+        )
+      end
+
+      def custom_method_proc_decorator
+        Definition::Decorator::CustomMethodProc.new
+      end
+
+      def custom_method_source_decorator
+        Definition::Decorator::CustomMethodSource.new
+      end
+
       def region_validator
         Definition::Validator::Region.new(
           regions_repository
         )
       end
 
+      def custom_method_validator
+        Definition::Validator::CustomMethod.new
+      end
+
       def holidays_by_month_repository
         @holidays_repo ||= Definition::Repository::HolidaysByMonth.new
       end
@@ -42,8 +74,12 @@ module Holidays
         @cache_repo ||= Definition::Repository::Cache.new
       end
 
-      def proc_cache_repository
-        @proc_cache_repo ||= Definition::Repository::ProcCache.new
+      def proc_result_cache_repository
+        @proc_result_cache_repo ||= Definition::Repository::ProcResultCache.new
+      end
+
+      def custom_methods_repository
+        @custom_methods_repository ||= Definition::Repository::CustomMethods.new
       end
     end
   end

data/lib/holidays/errors.rb

@@ -0,0 +1,6 @@
+module Holidays
+  class Error < StandardError; end
+
+  class FunctionNotFound < Error; end
+  class UnknownRegionError < Error ; end
+end

data/lib/holidays/load_all_definitions.rb

@@ -0,0 +1,57 @@
+module Holidays
+  class LoadAllDefinitions
+    class << self
+      def call
+        path = File.expand_path(File.dirname(__FILE__)) + "/../#{Holidays::DEFINITIONS_PATH}/"
+
+        Dir.foreach(path) do |item|
+          next if item == '.' or item == '..'
+
+          target = path+item
+          next if File.extname(target) != '.rb'
+
+          require target
+        end
+
+        #FIXME I need a better way to do this. I'm thinking of putting these 'common' methods
+        # into some kind of definition file so it can be loaded automatically but I'm afraid
+        # of making that big of a breaking API change since these are public. For the time
+        # being I'll load them manually like this.
+        global_methods = {
+          "easter(year)" => gregorian_easter.method(:calculate_easter_for).to_proc,
+          "orthodox_easter(year)" => gregorian_easter.method(:calculate_orthodox_easter_for).to_proc,
+          "orthodox_easter_julian(year)" => julian_easter.method(:calculate_orthodox_easter_for).to_proc,
+          "to_monday_if_sunday(date)" => weekend_modifier.method(:to_monday_if_sunday).to_proc,
+          "to_monday_if_weekend(date)" => weekend_modifier.method(:to_monday_if_weekend).to_proc,
+          "to_weekday_if_boxing_weekend(date)" => weekend_modifier.method(:to_weekday_if_boxing_weekend).to_proc,
+          "to_weekday_if_boxing_weekend_from_year(year)" => weekend_modifier.method(:to_weekday_if_boxing_weekend_from_year).to_proc,
+          "to_weekday_if_weekend(date)" => weekend_modifier.method(:to_weekday_if_weekend).to_proc,
+          "calculate_day_of_month(year, month, day, wday)" => day_of_month_calculator.method(:call).to_proc,
+          "to_weekday_if_boxing_weekend_from_year_or_to_tuesday_if_monday(year)" => weekend_modifier.method(:to_weekday_if_boxing_weekend_from_year_or_to_tuesday_if_monday).to_proc,
+          "xmas_to_weekday_if_weekend(year)" => weekend_modifier.method(:xmas_to_weekday_if_weekend).to_proc,
+          "to_tuesday_if_sunday_or_monday_if_saturday(date)" => weekend_modifier.method(:to_tuesday_if_sunday_or_monday_if_saturday).to_proc,
+        }
+
+        Holidays::DefinitionFactory.custom_methods_repository.add(global_methods)
+      end
+
+      private
+
+      def gregorian_easter
+        DateCalculatorFactory::Easter::Gregorian.easter_calculator
+      end
+
+      def julian_easter
+        DateCalculatorFactory::Easter::Julian.easter_calculator
+      end
+
+      def weekend_modifier
+        DateCalculatorFactory.weekend_modifier
+      end
+
+      def day_of_month_calculator
+        DateCalculatorFactory.day_of_month_calculator
+      end
+    end
+  end
+end

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

@@ -2,9 +2,10 @@ module Holidays
   module Option
     module Context
       class ParseOptions
-        def initialize(regions_repo, region_validator)
+        def initialize(regions_repo, region_validator, definition_merger)
           @regions_repo = regions_repo
           @region_validator = region_validator
+          @definition_merger = definition_merger
         end
 
         # Returns [(arr)regions, (bool)observed, (bool)informal]
@@ -23,12 +24,12 @@ module Holidays
 
         private
 
-        attr_reader :regions_repo, :region_validator
+        attr_reader :regions_repo, :region_validator, :definition_merger
 
         # 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
+        # If a wildcard region is found (e.g. :ca_) it is expanded into all
         # of its available sub regions.
         def parse_regions!(regions)
           regions = [regions] unless regions.kind_of?(Array)
@@ -49,20 +50,19 @@ module Holidays
 
           regions.flatten!
 
-          require "#{DEFINITIONS_PATH}/north_america" if regions.include?(:us) # special case for north_america/US cross-linking
+          load_definition_data("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}"
+            unless region == :any || regions_repo.exists?(region)
               begin
-                require region_definition #FIXME This is unacceptable, we can't be loading external files while parsing options
-              rescue LoadError
+                load_definition_data(region.to_s)
+              rescue NameError => 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}"
+                  raise UnknownRegionError.new(e), "Could not load #{region.to_s}"
                 end
               end
             end
@@ -81,15 +81,25 @@ module Holidays
         # 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
+
+          return if regions_repo.exists?(prefix.to_sym)
+
+          begin
+            load_definition_data(prefix)
+          rescue NameError => e
+            raise UnknownRegionError.new(e), "Could not load region prefix: #{prefix.to_s}, original subregion: #{sub_reg.to_s}"
           end
         end
+
+        def load_definition_data(region)
+          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,
+          )
+        end
       end
     end
   end

data/lib/holidays/option_factory.rb

@@ -7,6 +7,7 @@ module Holidays
         Option::Context::ParseOptions.new(
           DefinitionFactory.regions_repository,
           DefinitionFactory.region_validator,
+          DefinitionFactory.merger,
         )
       end
     end

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

@@ -2,10 +2,11 @@ module Holidays
   module UseCase
     module Context
       class Between
-        def initialize(holidays_by_month_repo, day_of_month_calculator, proc_cache_repo)
+        def initialize(holidays_by_month_repo, day_of_month_calculator, custom_methods_repo, proc_result_cache_repo)
           @holidays_by_month_repo = holidays_by_month_repo
           @day_of_month_calculator = day_of_month_calculator
-          @proc_cache_repo = proc_cache_repo
+          @custom_methods_repo = custom_methods_repo
+          @proc_result_cache_repo = proc_result_cache_repo
         end
 
         def call(start_date, end_date, dates_driver, regions, observed, informal)
@@ -18,9 +19,7 @@ module Holidays
               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
+                next if h[:type] == :informal && !informal
 
                 # range check feature.
                 if h[:year_ranges]
@@ -45,18 +44,42 @@ module Holidays
                   next unless valid_range_year
                 end
 
+                #FIXME I don't like this entire if/else. If it's a function, do something, else do some
+                # weird mday logic? Bollocks. I think this should be a refactor target.
                 if h[:function]
-                  # Holiday definition requires a calculation
-                  result = call_proc(h[:function], year)
+                  function_arguments = []
+
+                  #FIXME This is a refactor target. We should also allow 'date'. Right now these are the only
+                  # three things that we allow in. I think having a more testable, robust approach here is vital.
+                  if h[:function_arguments].include?(:year)
+                    function_arguments << year
+                  end
+
+                  if h[:function_arguments].include?(:month)
+                    function_arguments << month
+                  end
+
+                  if h[:function_arguments].include?(:day)
+                    function_arguments << h[:mday]
+                  end
+
+                  result = call_proc(h[:function], *function_arguments)
+
+                  #FIXME This is a dangerous assumption. We should raise an error or something
+                  #      if these procs return something unexpected.
+                  #
                   # Procs may return either Date or an integer representing mday
                   if result.kind_of?(Date)
+                    if h[:function_modifier]
+                      result = result + h[:function_modifier] # NOTE: This could be a positive OR negative number.
+                    end
+
                     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
 
@@ -65,9 +88,10 @@ module Holidays
                   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]
+                #FIXME We should be checking the function arguments and passing in what is specified.
+                # Right now all 'observed' functions require 'date' but that is by convention. Nothing
+                # is requiring that. We should be more explicit.
+                if observed && h[:observed]
                   date = call_proc(h[:observed], date)
                 end
 
@@ -83,7 +107,7 @@ module Holidays
 
         private
 
-        attr_reader :holidays_by_month_repo, :day_of_month_calculator, :proc_cache_repo
+        attr_reader :holidays_by_month_repo, :day_of_month_calculator, :custom_methods_repo, :proc_result_cache_repo
 
         def validate!(start_date, end_date, dates_driver, regions)
           raise ArgumentError unless start_date
@@ -98,8 +122,11 @@ module Holidays
           raise ArgumentError if regions.nil? || regions.empty?
         end
 
-        def call_proc(function, year)
-          proc_cache_repo.lookup(function, year)
+        def call_proc(function_id, *arguments)
+          function = custom_methods_repo.find(function_id)
+          raise Holidays::FunctionNotFound.new("Unable to find function with id '#{function_id}'") if function.nil?
+
+          proc_result_cache_repo.lookup(function, *arguments)
         end
 
         # Check sub regions.

data/lib/holidays/use_case_factory.rb

@@ -8,7 +8,8 @@ module Holidays
         UseCase::Context::Between.new(
           DefinitionFactory.holidays_by_month_repository,
           DateCalculatorFactory.day_of_month_calculator,
-          DefinitionFactory.proc_cache_repository,
+          DefinitionFactory.custom_methods_repository,
+          DefinitionFactory.proc_result_cache_repository,
         )
       end
 

data/lib/holidays/version.rb

@@ -1,3 +1,3 @@
 module Holidays
-  VERSION = '3.3.0'
+  VERSION = '4.0.0'
 end

data/test/data/test_single_custom_holiday_with_custom_procs.yaml

@@ -0,0 +1,24 @@
+months:
+  0:
+  - name: Custom Holiday
+    regions: [custom_single_file]
+    function: custom_method(year, month)
+    function_modifier: 5
+  6:
+  - name: Company Founding
+    regions: [custom_single_file]
+    mday: 20
+methods:
+  custom_method:
+    arguments: year, month
+    source: |
+      d = Date.civil(year, month, 1)
+      d + 2
+tests: |
+    {Date.civil(2013,6,20) => 'Company Founding'}.each do |date, name|
+      assert_equal name, (Holidays.on(date, :custom_single_file)[0] || {})[:name]
+    end
+
+    {Date.civil(2015, 1, 1) => 'Custom Holiday'}.each do |date, name|
+      assert_equal name, (Holidays.on(date, :custom_single_file)[0] || {}[:name]
+    end