holidays 4.6.0 → 4.7.0

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

@@ -30,11 +30,9 @@ module Holidays
 
         private
 
-        attr_reader :validator
-
         def validate!(methods)
           raise ArgumentError unless methods.all? do |name, pieces|
-            validator.valid?(
+            @validator.valid?(
               {
                 :name => name,
                 :arguments => pieces["arguments"],

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

@@ -33,7 +33,7 @@ module Holidays
                 end
               end
 
-              @holidays_by_month[month] << holiday_def  unless exists
+              @holidays_by_month[month] << holiday_def unless exists
             end
           end
         end

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

@@ -12,14 +12,12 @@ module Holidays
           region = find_wildcard_base(r)
 
           (region == :any ||
-           regions_repo.exists?(region) ||
+           @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

data/lib/holidays/errors.rb

@@ -2,5 +2,6 @@ module Holidays
   class Error < StandardError; end
 
   class FunctionNotFound < Error; end
+  class InvalidFunctionResponse < Error; end
   class UnknownRegionError < Error ; end
 end

data/lib/holidays/factory/date_calculator.rb

@@ -0,0 +1,37 @@
+require 'holidays/date_calculator/easter'
+require 'holidays/date_calculator/weekend_modifier'
+require 'holidays/date_calculator/day_of_month'
+
+module Holidays
+  module Factory
+    module DateCalculator
+      module Easter
+        module Gregorian
+          class << self
+            def easter_calculator
+              Holidays::DateCalculator::Easter::Gregorian.new
+            end
+          end
+        end
+
+        module Julian
+          class << self
+            def easter_calculator
+              Holidays::DateCalculator::Easter::Julian.new
+            end
+          end
+        end
+      end
+
+      class << self
+        def weekend_modifier
+          Holidays::DateCalculator::WeekendModifier.new
+        end
+
+        def day_of_month_calculator
+          Holidays::DateCalculator::DayOfMonth.new
+        end
+      end
+    end
+  end
+end

data/lib/holidays/factory/definition.rb

@@ -0,0 +1,96 @@
+require 'holidays/definition/context/generator'
+require 'holidays/definition/context/merger'
+require 'holidays/definition/context/function_processor'
+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_result_cache'
+require 'holidays/definition/repository/custom_methods'
+require 'holidays/definition/validator/custom_method'
+require 'holidays/definition/validator/region'
+
+module Holidays
+  module Factory
+    module Definition
+      class << self
+        def file_parser
+          Holidays::Definition::Context::Generator.new(
+            custom_method_parser,
+            custom_method_source_decorator,
+            custom_methods_repository,
+          )
+        end
+
+        def source_generator
+          Holidays::Definition::Context::Generator.new(
+            custom_method_parser,
+            custom_method_source_decorator,
+            custom_methods_repository,
+          )
+        end
+
+        def function_processor
+          Holidays::Definition::Context::FunctionProcessor.new(
+            custom_methods_repository,
+            proc_result_cache_repository,
+          )
+        end
+
+        def merger
+          Holidays::Definition::Context::Merger.new(
+            holidays_by_month_repository,
+            regions_repository,
+            custom_methods_repository,
+          )
+        end
+
+        def custom_method_parser
+          Holidays::Definition::Parser::CustomMethod.new(
+            custom_method_validator,
+          )
+        end
+
+        def custom_method_proc_decorator
+          Holidays::Definition::Decorator::CustomMethodProc.new
+        end
+
+        def custom_method_source_decorator
+          Holidays::Definition::Decorator::CustomMethodSource.new
+        end
+
+        def region_validator
+          Holidays::Definition::Validator::Region.new(
+            regions_repository
+          )
+        end
+
+        def custom_method_validator
+          Holidays::Definition::Validator::CustomMethod.new
+        end
+
+        def holidays_by_month_repository
+          @holidays_repo ||= Holidays::Definition::Repository::HolidaysByMonth.new
+        end
+
+        def regions_repository
+          @regions_repo ||= Holidays::Definition::Repository::Regions.new
+        end
+
+        def cache_repository
+          @cache_repo ||= Holidays::Definition::Repository::Cache.new
+        end
+
+        def proc_result_cache_repository
+          @proc_result_cache_repo ||= Holidays::Definition::Repository::ProcResultCache.new
+        end
+
+        def custom_methods_repository
+          @custom_methods_repository ||= Holidays::Definition::Repository::CustomMethods.new
+        end
+      end
+    end
+  end
+end

data/lib/holidays/factory/finder.rb

@@ -0,0 +1,70 @@
+require 'holidays/finder/context/between'
+require 'holidays/finder/context/dates_driver_builder'
+require 'holidays/finder/context/next_holiday'
+require 'holidays/finder/context/parse_options'
+require 'holidays/finder/context/search'
+require 'holidays/finder/context/year_holiday'
+require 'holidays/finder/rules/in_region'
+require 'holidays/finder/rules/year_range'
+
+module Holidays
+  module Factory
+    module Finder
+      class << self
+        def search
+          Holidays::Finder::Context::Search.new(
+            Factory::Definition.holidays_by_month_repository,
+            Factory::Definition.function_processor,
+            Factory::DateCalculator.day_of_month_calculator,
+            rules,
+          )
+        end
+
+        def between
+          Holidays::Finder::Context::Between.new(
+            search,
+            dates_driver_builder,
+            parse_options,
+          )
+        end
+
+        def next_holiday
+          Holidays::Finder::Context::NextHoliday.new(
+            search,
+            dates_driver_builder,
+            parse_options,
+          )
+        end
+
+        def year_holiday
+          Holidays::Finder::Context::YearHoliday.new(
+            search,
+            dates_driver_builder,
+            parse_options,
+          )
+        end
+
+        def parse_options
+          Holidays::Finder::Context::ParseOptions.new(
+            Factory::Definition.regions_repository,
+            Factory::Definition.region_validator,
+            Factory::Definition.merger,
+          )
+        end
+
+        private
+
+        def dates_driver_builder
+          Holidays::Finder::Context::DatesDriverBuilder.new
+        end
+
+        def rules
+          {
+            :in_region => Holidays::Finder::Rules::InRegion,
+            :year_range => Holidays::Finder::Rules::YearRange,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Holidays
+  module Finder
+    module Context
+      class Between
+        def initialize(definition_search, dates_driver_builder, options_parser)
+          @definition_search = definition_search
+          @dates_driver_builder = dates_driver_builder
+          @options_parser = options_parser
+        end
+
+        def call(start_date, end_date, options)
+          validate!(start_date, end_date)
+
+          regions, observed, informal = @options_parser.call(options)
+          dates_driver = @dates_driver_builder.call(start_date, end_date)
+
+          holidays = []
+          opts = gather_options(observed, informal)
+
+          holidays = @definition_search.call(dates_driver, regions, opts)
+          holidays = holidays.select{|holiday|holiday[:date].between?(start_date, end_date)}
+          holidays.sort{|a, b| a[:date] <=> b[:date] }
+        end
+
+        private
+
+        def validate!(start_date, end_date)
+          raise ArgumentError unless start_date
+          raise ArgumentError unless end_date
+        end
+
+        def gather_options(observed, informal)
+          opts = []
+
+          opts << :observed if observed == true
+          opts << :informal if informal == true
+
+          opts
+        end
+      end
+    end
+  end
+end

data/lib/holidays/{use_case → finder}/context/dates_driver_builder.rb

@@ -2,10 +2,10 @@
 # we will iterate over each year and then over each month internally and check to see if the
 # supplied dates match any holidays for the region and date. So if we supply start_date of 2015/1/1
 # and end_date of 2015/6/1 then we will return a date driver of {:2015 => [0, 1, 2, 5, 6, 7]}.
-# In the  logic in the 'between' use case we will iterate over this and compare dates in these
-# months to the supplied range to determine whether they should be returned to the user.
+# In the logic in the various other 'finder' contexts we will iterate over this and compare dates
+# in these months to the supplied range to determine whether they should be returned to the user.
 module Holidays
-  module UseCase
+  module Finder
     module Context
       class DatesDriverBuilder
         def call(start_date, end_date)
@@ -54,7 +54,9 @@ module Holidays
 
         def clean(dates_driver)
           dates_driver.each do |year, months|
-            dates_driver[year] << 0 # Always add variable month '0' for proc calc purposes
+            # Always add variable month '0' for proc calc purposes. For example, 'easter' lives in
+            # 'month 0' but is vital to calculating a lot of easter-related dates.
+            dates_driver[year] << 0
 
             dates_driver[year].uniq!
             dates_driver[year].sort!

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

@@ -0,0 +1,57 @@
+module Holidays
+  module Finder
+    module Context
+      class NextHoliday
+        def initialize(definition_search, dates_driver_builder, options_parser)
+          @definition_search = definition_search
+          @dates_driver_builder = dates_driver_builder
+          @options_parser = options_parser
+        end
+
+        def call(holidays_count, from_date, options)
+          validate!(holidays_count, from_date)
+
+          regions, observed, informal = @options_parser.call(options)
+
+          holidays = []
+          ret_holidays = []
+          opts = gather_options(observed, informal)
+
+          # This could be smarter but I don't have any evidence that just checking for
+          # the next 12 months will cause us issues. If it does we can implement something
+          # smarter here to check in smaller increments.
+          dates_driver = @dates_driver_builder.call(from_date, from_date >> 12)
+
+          ret_holidays = @definition_search.call(dates_driver, regions, opts)
+
+          ret_holidays.sort{|a, b| a[:date] <=> b[:date] }.each do |holiday|
+            if holiday[:date] >= from_date
+              holidays << holiday
+              holidays_count -= 1
+              break if holidays_count == 0
+            end
+          end
+
+          holidays.sort{|a, b| a[:date] <=> b[:date] }
+        end
+
+        private
+
+        def validate!(holidays_count, from_date)
+          raise ArgumentError unless holidays_count
+          raise ArgumentError if holidays_count <= 0
+          raise ArgumentError unless from_date
+        end
+
+        def gather_options(observed, informal)
+          opts = []
+
+          opts << :observed if observed == true
+          opts << :informal if informal == true
+
+          opts
+        end
+      end
+    end
+  end
+end

data/lib/holidays/{option → finder}/context/parse_options.rb

@@ -1,5 +1,5 @@
 module Holidays
-  module Option
+  module Finder
     module Context
       class ParseOptions
         def initialize(regions_repo, region_validator, definition_merger)
@@ -24,8 +24,6 @@ module Holidays
 
         private
 
-        attr_reader :regions_repo, :region_validator, :definition_merger
-
         # Check regions against list of supported regions and return an array of
         # symbols.
         #
@@ -43,7 +41,7 @@ module Holidays
           regions.delete_if do |r|
             if r.to_s =~ /_$/
               load_containing_region(r.to_s)
-              regions << regions_repo.search(r.to_s)
+              regions << @regions_repo.search(r.to_s)
               true
             end
           end
@@ -53,7 +51,7 @@ module Holidays
           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)
+            unless region == :any || @regions_repo.exists?(region)
               begin
                 load_definition_data(region.to_s)
               rescue NameError => e
@@ -73,7 +71,7 @@ module Holidays
 
         def validate!(regions)
           regions.each do |r|
-            raise UnknownRegionError unless region_validator.valid?(r)
+            raise UnknownRegionError unless @region_validator.valid?(r)
           end
         end
 
@@ -82,7 +80,7 @@ module Holidays
         def load_containing_region(sub_reg)
           prefix = sub_reg.split('_').first
 
-          return if regions_repo.exists?(prefix.to_sym)
+          return if @regions_repo.exists?(prefix.to_sym)
 
           begin
             load_definition_data(prefix)
@@ -94,7 +92,7 @@ module Holidays
         def load_definition_data(region)
           target_region_module = Module.const_get("Holidays").const_get(region.upcase)
 
-          definition_merger.call(
+          @definition_merger.call(
             target_region_module.defined_regions,
             target_region_module.holidays_by_month,
             target_region_module.custom_methods,

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

@@ -0,0 +1,86 @@
+module Holidays
+  module Finder
+    module Context
+      class Search
+        def initialize(holidays_by_month_repo, custom_method_processor, day_of_month_calculator, rules)
+          @holidays_by_month_repo = holidays_by_month_repo
+          @custom_method_processor = custom_method_processor
+          @day_of_month_calculator = day_of_month_calculator
+          @rules = rules
+        end
+
+        def call(dates_driver, regions, options)
+          validate!(dates_driver)
+
+          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 if (h[:type] == :informal) && !informal_set?(options)
+                next unless @rules[:in_region].call(regions, h[:regions])
+
+                if h[:year_ranges]
+                  next unless @rules[:year_range].call(year, h[:year_ranges])
+                end
+
+                if h[:function]
+                  result = @custom_method_processor.call(
+                    year, month, h[:mday],
+                    h[:function], h[:function_arguments], h[:function_modifier],
+                  )
+
+                  #FIXME The result should always be present, see https://github.com/holidays/holidays/issues/204 for more information
+                  if result
+                    month = result.month
+                    mday = result.mday
+                  end
+                else
+                  mday = h[:mday] || @day_of_month_calculator.call(year, month, h[:week], h[:wday])
+                end
+
+                # Silently skip bad mdays
+                #TODO Should we be doing something different here? We have no concept of logging right now. Maybe we should add it?
+                begin
+                  date = Date.civil(year, month, mday)
+                rescue; next; end
+
+                if observed_set?(options) && h[:observed]
+                  date = @custom_method_processor.call(
+                    date.year, date.month, date.day,
+                    h[:observed],
+                    [:date],
+                  )
+                end
+
+                holidays << {:date => date, :name => h[:name], :regions => h[:regions]}
+              end
+            end
+          end
+
+          holidays
+        end
+
+        private
+
+        def validate!(dates_driver)
+          raise ArgumentError if dates_driver.nil? || dates_driver.empty?
+
+          dates_driver.each do |year, months|
+            months.each do |month|
+              raise ArgumentError unless month >= 0 && month <= 12
+            end
+          end
+        end
+
+        def informal_set?(options)
+          options && options.include?(:informal) == true
+        end
+
+        def observed_set?(options)
+          options && options.include?(:observed) == true
+        end
+      end
+    end
+  end
+end