revised_holidays 9.0.0

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.loader,
+          )
+        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,45 @@
+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)
+
+          #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)
+
+          @definition_search
+            .call(dates_driver, regions, opts)
+            .select { |holiday| holiday[:date].between?(start_date, end_date) }
+            .sort_by { |a| a[: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
+          opts << :informal if informal
+
+          opts
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# This context builds a hash that contains {:year => [<array of months>]}. The idea is that
+# 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 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 Finder
+    module Context
+      class DatesDriverBuilder
+        def call(start_date, end_date)
+          dates_driver = {}
+
+          (start_date..end_date).each do |date|
+            dates_driver[date.year] = [] unless dates_driver[date.year]
+            dates_driver[date.year] << date.month
+            dates_driver = add_border_months(date, dates_driver)
+          end
+          clean(dates_driver)
+        end
+
+        private
+
+        # As part of https://github.com/holidays/holidays/issues/146 I am returning
+        # additional months in an attempt to catch month-spanning date situations (i.e.
+        # dates falling on 2/1 but being observed on 1/31). By including the additional months
+        # we are increasing runtimes slightly but improving accuracy, which is more important
+        # to me at this stage.
+        def add_border_months(current_date, dates_driver)
+          if current_date.month == 1
+            dates_driver[current_date.year] << 2
+
+            prev_year = current_date.year - 1
+            dates_driver[prev_year] = [] unless dates_driver[prev_year]
+            dates_driver[prev_year] << 12
+          elsif current_date.month == 12
+            dates_driver[current_date.year] << 11
+
+            next_year = current_date.year + 1
+            dates_driver[next_year] = [] unless dates_driver[next_year]
+            dates_driver[next_year] << 1
+          else
+            dates_driver[current_date.year] << current_date.month - 1 << current_date.month + 1
+          end
+
+          dates_driver
+        end
+
+        def clean(dates_driver)
+          dates_driver.each do |year, months|
+            # 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!
+          end
+
+          dates_driver
+        end
+      end
+    end
+  end
+end

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 = []
+          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)
+
+          @definition_search
+            .call(dates_driver, regions, opts)
+            .sort_by { |a| a[:date] }
+            .each do |holiday|
+              if holiday[:date] >= from_date
+                holidays << holiday
+                holidays_count -= 1
+                break if holidays_count == 0
+              end
+            end
+
+          holidays.sort_by { |a| a[: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
+          opts << :informal if informal
+
+          opts
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+module Holidays
+  module Finder
+    module Context
+      class ParseOptions
+        def initialize(regions_repo, region_validator, definition_loader)
+          @regions_repo = regions_repo
+          @region_validator = region_validator
+          @definition_loader = definition_loader
+        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
+
+        # Check regions against list of supported regions and return an array of
+        # symbols.
+        #
+        # 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)
+
+          if regions.empty?
+            regions = [:any]
+          else
+            regions = regions.collect { |r| r.to_sym }
+          end
+
+          validate!(regions)
+
+          loaded_regions = []
+
+          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
+
+          loaded_regions.flatten.compact.uniq
+        end
+
+        def validate!(regions)
+          regions.each do |r|
+            raise InvalidRegion unless @region_validator.valid?(r)
+          end
+        end
+
+        def is_wildcard?(r)
+          r.to_s =~ /_$/
+        end
+
+        def load_wildcard_parent!(wildcard_region)
+          prefix = wildcard_region.to_s.split('_').first.to_sym
+          load_region!(prefix)
+        end
+
+        def load_region!(r)
+          @definition_loader.call(r)
+        rescue NameError, LoadError => e
+          raise UnknownRegionError.new(e), "Could not load region: #{r}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+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 informal_type?(h[:type]) && !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
+
+                date = build_date(year, month, h)
+                next unless date
+
+                if observed_set?(options) && h[:observed]
+                  date = build_observed_date(date, regions, h)
+                end
+
+                holidays << {:date => date, :name => h[:name], :regions => h[:regions]}
+              end
+            end
+          end
+
+          holidays
+        end
+
+        private
+
+        def validate!(dates_driver)
+          #FIXME This should give some kind of error message that indicates the
+          #      problem.
+          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_type?(type)
+          type && [:informal, 'informal'].include?(type)
+        end
+
+        def informal_set?(options)
+          options && options.include?(:informal) == true
+        end
+
+        def observed_set?(options)
+          options && options.include?(:observed) == true
+        end
+
+        def build_date(year, month, h)
+          if h[:function]
+            holiday = custom_holiday(year, month, h)
+            #FIXME The result should always be present, see https://github.com/holidays/holidays/issues/204 for more information
+            current_month = holiday&.month
+            current_day = holiday&.mday
+          else
+            current_month = month
+            current_day = 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?
+          Date.civil(year, current_month, current_day) rescue nil
+        end
+
+        def custom_holiday(year, month, h)
+          @custom_method_processor.call(
+            #FIXME This seems like a bug, we seem to expect the day in here in the au defs?
+            build_custom_method_input(year, month, h[:mday], h[:regions]),
+            h[:function], h[:function_arguments], h[:function_modifier],
+          )
+        end
+
+        def build_custom_method_input(year, month, day, regions)
+          {
+            year: year,
+            month: month,
+            day: day,
+            region: regions.first, #FIXME This isn't ideal but will work for our current use case...
+          }
+        end
+
+        def build_observed_date(date, regions, h)
+          @custom_method_processor.call(
+            build_custom_method_input(date.year, date.month, date.day, regions),
+            h[:observed],
+            [:date],
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Holidays
+  module Finder
+    module Context
+      class YearHoliday
+        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(from_date, options)
+          validate!(from_date)
+
+          regions, observed, informal = @options_parser.call(options)
+
+          # 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.
+          #
+          #FIXME Could this be until the to_date instead? Save us some processing?
+          #      This is matching what was in holidays.rb currently so I'm keeping it. -pp
+          dates_driver = @dates_driver_builder.call(from_date, from_date >> 12)
+
+          to_date = Date.civil(from_date.year, 12, 31)
+          holidays = []
+          ret_holidays = []
+          opts = gather_options(observed, informal)
+
+          ret_holidays = @definition_search.call(dates_driver, regions, opts)
+
+          ret_holidays.each do |holiday|
+            if holiday[:date] >= from_date && holiday[:date] <= to_date
+              holidays << holiday
+            end
+          end
+
+          holidays.sort{|a, b| a[:date] <=> b[:date] }
+        end
+
+        private
+
+        def validate!(from_date)
+          raise ArgumentError unless from_date && from_date.is_a?(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/finder/rules/in_region.rb

@@ -0,0 +1,31 @@
+module Holidays
+  module Finder
+    module Rules
+      class InRegion
+        class << self
+          def call(requested, available)
+            return true if requested.include?(:any)
+
+            # When an underscore is encountered, derive the parent regions
+            # symbol and check for both.
+            requested = requested.collect do |r|
+              if r.to_s =~ /_/
+                chunks = r.to_s.split('_')
+
+                chunks.length.downto(1).map do |num|
+                  chunks[0..-num].join('_').to_sym
+                end
+              else
+                r
+              end
+            end
+
+            requested = requested.flatten.uniq
+
+            available.any? { |avail| requested.include?(avail) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/holidays/finder/rules/year_range.rb

@@ -0,0 +1,58 @@
+module Holidays
+  module Finder
+    module Rules
+      class YearRange
+        class << self
+          UNTIL = :until
+          FROM = :from
+          LIMITED = :limited
+          BETWEEN = :between
+
+          def call(target_year, year_range_defs)
+            validate!(target_year, year_range_defs)
+
+            operator = year_range_defs.keys.first
+            rule_value = year_range_defs[operator]
+
+            case operator
+            when UNTIL
+              matched = target_year <= rule_value
+            when FROM
+              matched = target_year >= rule_value
+            when LIMITED
+              matched = rule_value.include?(target_year)
+            when BETWEEN
+              matched = rule_value.cover?(target_year)
+            else
+              matched = false
+            end
+
+            matched
+          end
+
+          private
+
+          def validate!(target_year, year_ranges)
+            raise ArgumentError.new("target_year must be a number") unless target_year.is_a?(Integer)
+            raise ArgumentError.new("year_ranges cannot be missing") if year_ranges.nil? || year_ranges.empty?
+            raise ArgumentError.new("year_ranges must contain a hash with a single operator") unless year_ranges.is_a?(Hash) && year_ranges.size == 1
+
+            operator = year_ranges.keys.first
+            value = year_ranges[operator]
+
+            raise ArgumentError.new("Invalid operator found: '#{operator}'") unless [UNTIL, FROM, LIMITED, BETWEEN].include?(operator)
+
+            case operator
+            when UNTIL, FROM
+              raise ArgumentError.new("#{UNTIL} and #{FROM} operator value must be a number, received: '#{value}'") unless value.is_a?(Integer)
+            when LIMITED
+              raise ArgumentError.new(":limited operator value must be an array containing at least one integer value, received: '#{value}'") unless value.is_a?(Array) && value.size >= 1 && value.all? { |v| v.is_a?(Integer) }
+            when BETWEEN
+              raise ArgumentError.new(":between operator value must be a range, received: '#{value}'") unless value.is_a?(Range)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/holidays/load_all_definitions.rb

@@ -0,0 +1,56 @@
+module Holidays
+  #TODO This file should be renamed. It's no longer about definitions, really.
+  class LoadAllDefinitions
+    class << self
+      def call
+        #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.
+        #
+        # NOTE: These are no longer public! We can do whatever we want here!
+        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,
+          "to_tuesday_if_sunday_or_monday_if_saturday(date)" => weekend_modifier.method(:to_tuesday_if_sunday_or_monday_if_saturday).to_proc,
+          "lunar_to_solar(year, month, day, region)" => lunar_date.method(:to_solar).to_proc, 
+        }
+
+        Factory::Definition.custom_methods_repository.add(global_methods)
+
+        static_regions_definition = "#{Holidays::DEFINITIONS_PATH}/REGIONS.rb"
+        require static_regions_definition
+      end
+
+      private
+
+      def gregorian_easter
+        Factory::DateCalculator::Easter::Gregorian.easter_calculator
+      end
+
+      def julian_easter
+        Factory::DateCalculator::Easter::Julian.easter_calculator
+      end
+
+      def weekend_modifier
+        Factory::DateCalculator.weekend_modifier
+      end
+
+      def day_of_month_calculator
+        Factory::DateCalculator.day_of_month_calculator
+      end
+
+      def lunar_date
+        Factory::DateCalculator.lunar_date
+      end
+    end
+  end
+end

data/lib/holidays/version.rb

@@ -0,0 +1,3 @@
+module Holidays
+  VERSION = '9.0.0'
+end