holidays 11.6.0 → 11.8.0

data/lib/holidays/definition/custom_methods/ma.rb

@@ -0,0 +1,48 @@
+require 'date'
+
+module Holidays
+  module Definition
+    module CustomMethods
+      # ma custom holiday calculations.
+      #
+      # Eid al-Fitr is 1 Shawwal and Eid al-Adha is 10 Dhul-Hijjah of the
+      # Hijri calendar. Both are derived from the arithmetic Islamic calendar
+      # (Holidays::DateCalculator::HijriDate). The civil holidays are
+      # proclaimed by Morocco's Ministry of Habous and Islamic Affairs and in
+      # some years land a day off from the arithmetic result; MINISTRY_OVERRIDES
+      # pins those years to the proclaimed date. Years with no entry fall back
+      # to the calculation. See holidays#392.
+      module MA
+        SHAWWAL = 10
+        DHU_AL_HIJJAH = 12
+
+        # Proclaimed first days that differ from the arithmetic calendar,
+        # keyed by [feast, gregorian_year]. Sourced from the Ministry of
+        # Habous and Islamic Affairs communiques reported via maroc.ma,
+        # Hespress, and Morocco World News.
+        MINISTRY_OVERRIDES = {
+          [:eid_al_fitr, 2022] => Date.new(2022, 5, 2),
+
+          [:eid_al_adha, 2021] => Date.new(2021, 7, 21),
+        }.freeze
+
+        class << self
+          def eid_al_fitr(year)
+            feast(:eid_al_fitr, year, SHAWWAL, 1)
+          end
+
+          def eid_al_adha(year)
+            feast(:eid_al_adha, year, DHU_AL_HIJJAH, 10)
+          end
+
+          private
+
+          def feast(name, year, hijri_month, hijri_day)
+            MINISTRY_OVERRIDES[[name, year]] ||
+              Holidays::Factory::DateCalculator.hijri_date.gregorian_year_occurrence(year, hijri_month, hijri_day)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition/custom_methods/my.rb

@@ -0,0 +1,55 @@
+require 'date'
+
+module Holidays
+  module Definition
+    module CustomMethods
+      # my custom holiday calculations.
+      #
+      # Hari Raya Puasa (Eid al-Fitr) is 1 Shawwal and Hari Raya Haji (Eid
+      # al-Adha) is 10 Dhul-Hijjah of the Hijri calendar. Both are derived
+      # from the arithmetic Islamic calendar (Holidays::DateCalculator::HijriDate).
+      # The civil holidays are fixed by the Yang di-Pertuan Agong (Conference
+      # of Rulers) on JAKIM's moon-sighting advice and in some years have
+      # landed a day before the arithmetic result; GAZETTE_OVERRIDES pins
+      # those years to the gazetted date. Years with no entry fall back to
+      # the calculation. See holidays#392.
+      module MY
+        SHAWWAL = 10
+        DHU_AL_HIJJAH = 12
+
+        # Gazetted first days that differ from the arithmetic calendar,
+        # keyed by [feast, gregorian_year]. Sourced from the official
+        # Malaysian public holiday gazette, cross-checked against
+        # definitions/sg.yaml (agrees in every overlapping year 2017-2026).
+        GAZETTE_OVERRIDES = {
+          [:hari_raya_puasa, 2014] => Date.new(2014, 7, 28),
+          [:hari_raya_puasa, 2015] => Date.new(2015, 7, 17),
+          [:hari_raya_puasa, 2016] => Date.new(2016, 7, 6),
+          [:hari_raya_puasa, 2017] => Date.new(2017, 6, 25),
+          [:hari_raya_puasa, 2026] => Date.new(2026, 3, 21),
+
+          [:hari_raya_haji, 2016] => Date.new(2016, 9, 12),
+          [:hari_raya_haji, 2017] => Date.new(2017, 9, 1),
+          [:hari_raya_haji, 2019] => Date.new(2019, 8, 11),
+        }.freeze
+
+        class << self
+          def hari_raya_puasa(year)
+            feast(:hari_raya_puasa, year, SHAWWAL, 1)
+          end
+
+          def hari_raya_haji(year)
+            feast(:hari_raya_haji, year, DHU_AL_HIJJAH, 10)
+          end
+
+          private
+
+          def feast(name, year, hijri_month, hijri_day)
+            GAZETTE_OVERRIDES[[name, year]] ||
+              Holidays::Factory::DateCalculator.hijri_date.gregorian_year_occurrence(year, hijri_month, hijri_day)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition/custom_methods/registry.rb

@@ -13,6 +13,8 @@ require 'holidays/definition/custom_methods/is'
 require 'holidays/definition/custom_methods/jp'
 require 'holidays/definition/custom_methods/kr'
 require 'holidays/definition/custom_methods/lv'
+require 'holidays/definition/custom_methods/ma'
+require 'holidays/definition/custom_methods/my'
 require 'holidays/definition/custom_methods/nz'
 require 'holidays/definition/custom_methods/ph'
 require 'holidays/definition/custom_methods/se'
@@ -46,14 +48,19 @@ module Holidays
           "columbus_day_cl(year)" => CL.method(:columbus_day_cl).to_proc,
           "day_after_thanksgiving(year)" => FEDEX.method(:day_after_thanksgiving).to_proc,
           "de_buss_und_bettag(year)" => DE.method(:de_buss_und_bettag).to_proc,
+          "eid_al_adha(year)" => MA.method(:eid_al_adha).to_proc,
+          "eid_al_fitr(year)" => MA.method(:eid_al_fitr).to_proc,
           "election_day(year)" => US.method(:election_day).to_proc,
           "even_year_election_day(year)" => US.method(:even_year_election_day).to_proc,
           "fi_juhannusaatto(year)" => FI.method(:fi_juhannusaatto).to_proc,
           "fi_juhannuspaiva(year)" => FI.method(:fi_juhannuspaiva).to_proc,
           "fi_pyhainpaiva(year)" => FI.method(:fi_pyhainpaiva).to_proc,
           "georgia_state_holiday(year, month)" => US.method(:georgia_state_holiday).to_proc,
+          "hari_raya_haji(year)" => MY.method(:hari_raya_haji).to_proc,
+          "hari_raya_puasa(year)" => MY.method(:hari_raya_puasa).to_proc,
           "hobart_show_day(year)" => AU.method(:hobart_show_day).to_proc,
           "ie_st_brigids_day(year)" => IE.method(:ie_st_brigids_day).to_proc,
+          "indigenous_peoples_day_cl(year)" => CL.method(:indigenous_peoples_day_cl).to_proc,
           "independence_day(region, date)" => US.method(:independence_day).to_proc,
           "is_sumardagurinn_fyrsti(year)" => IS.method(:is_sumardagurinn_fyrsti).to_proc,
           "jp_citizens_holiday(year)" => JP.method(:jp_citizens_holiday).to_proc,
@@ -87,6 +94,7 @@ module Holidays
           "qld_queens_bday_october(year)" => AU.method(:qld_queens_bday_october).to_proc,
           "qld_queens_birthday_june(year)" => AU.method(:qld_queens_birthday_june).to_proc,
           "ramadan_feast(year)" => TR.method(:ramadan_feast).to_proc,
+          "ramadan_feast_second_in_year(year)" => TR.method(:ramadan_feast_second_in_year).to_proc,
           "rosh_hashanah(year)" => US.method(:rosh_hashanah).to_proc,
           "sacrifice_feast(year)" => TR.method(:sacrifice_feast).to_proc,
           "se_alla_helgons_dag(year)" => SE.method(:se_alla_helgons_dag).to_proc,

data/lib/holidays/definition/custom_methods/tr.rb

@@ -12,6 +12,10 @@ module Holidays
       # day (2016 Ramazan Bayramı, two days) before the arithmetic result;
       # DIYANET_OVERRIDES pins those years to the proclaimed date. Years with
       # no entry fall back to the calculation. See definitions#377.
+      #
+      # ramadan_feast only returns the first occurrence of a Gregorian year;
+      # ramadan_feast_second_in_year returns the second one in the rare years
+      # that have two (2033), and nil otherwise.
       module TR
         SHAWWAL = 10
         DHU_AL_HIJJAH = 12
@@ -19,7 +23,7 @@ module Holidays
         # Proclaimed first days that differ from the arithmetic calendar,
         # keyed by [feast, gregorian_year]. Sourced from the Diyanet dates
         # that the definition file previously carried as a fixed table, plus
-        # https://vakithesaplama.diyanet.gov.tr/resmitatiller.php for 2021-2030.
+        # https://vakithesaplama.diyanet.gov.tr/resmitatiller.php for 2021-2035.
         DIYANET_OVERRIDES = {
           [:ramadan_feast, 2014] => Date.new(2014, 7, 28),
           [:ramadan_feast, 2015] => Date.new(2015, 7, 17),
@@ -32,6 +36,9 @@ module Holidays
           [:ramadan_feast, 2027] => Date.new(2027, 3, 9),
           [:ramadan_feast, 2028] => Date.new(2028, 2, 26),
           [:ramadan_feast, 2030] => Date.new(2030, 2, 4),
+          [:ramadan_feast, 2031] => Date.new(2031, 1, 24),
+          [:ramadan_feast, 2033] => Date.new(2033, 1, 2),
+          [:ramadan_feast, 2035] => Date.new(2035, 12, 1),
 
           [:sacrifice_feast, 2014] => Date.new(2014, 10, 4),
           [:sacrifice_feast, 2016] => Date.new(2016, 9, 12),
@@ -44,6 +51,8 @@ module Holidays
           [:sacrifice_feast, 2025] => Date.new(2025, 6, 6),
           [:sacrifice_feast, 2027] => Date.new(2027, 5, 16),
           [:sacrifice_feast, 2030] => Date.new(2030, 4, 13),
+          [:sacrifice_feast, 2031] => Date.new(2031, 4, 2),
+          [:sacrifice_feast, 2033] => Date.new(2033, 3, 11),
         }.freeze
 
         class << self
@@ -51,6 +60,11 @@ module Holidays
             feast(:ramadan_feast, year, SHAWWAL, 1)
           end
 
+          def ramadan_feast_second_in_year(year)
+            occurrences = hijri.gregorian_year_occurrences(year, SHAWWAL, 1)
+            occurrences.last if occurrences.size > 1
+          end
+
           def sacrifice_feast(year)
             feast(:sacrifice_feast, year, DHU_AL_HIJJAH, 10)
           end
@@ -59,7 +73,11 @@ module Holidays
 
           def feast(name, year, hijri_month, hijri_day)
             DIYANET_OVERRIDES[[name, year]] ||
-              Holidays::Factory::DateCalculator.hijri_date.gregorian_year_occurrence(year, hijri_month, hijri_day)
+              hijri.gregorian_year_occurrence(year, hijri_month, hijri_day)
+          end
+
+          def hijri
+            Holidays::Factory::DateCalculator.hijri_date
           end
         end
       end

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

@@ -38,7 +38,7 @@ module Holidays
 
     def self.holidays_by_month
       {
-          #{month_strings.join(",\n")}
+#{month_strings.join(",\n")}
       }
     end
 

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

@@ -49,7 +49,8 @@ module Holidays
           existing_def[:function_modifier] == target_def[:function_modifier] &&
           existing_def[:type] == target_def[:type] &&
           existing_def[:observed] == target_def[:observed] &&
-          existing_def[:year_ranges] == target_def[:year_ranges]
+          existing_def[:year_ranges] == target_def[:year_ranges] &&
+          existing_def[:excluded_regions] == target_def[:excluded_regions]
         end
       end
     end

data/lib/holidays/errors.rb

@@ -8,4 +8,9 @@ module Holidays
   class InvalidRegion < Error; end
 
   class DefinitionTestError < Error; end
+
+  # Raised when a calculation needs data for a year outside the range its
+  # tables or formula support, e.g. a lunar date past the end of the lunar
+  # calendar tables.
+  class UnsupportedYearError < Error; end
 end

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

@@ -2,6 +2,11 @@ module Holidays
   module Finder
     module Context
       class NextHoliday
+        # Holidays are searched one 12 month window at a time. The search widens until
+        # enough holidays are found or this many years have been searched, which stops
+        # a region with no upcoming holidays from being searched forever.
+        MAX_YEARS = 50
+
         def initialize(definition_search, dates_driver_builder, options_parser)
           @definition_search = definition_search
           @dates_driver_builder = dates_driver_builder
@@ -12,31 +17,36 @@ module Holidays
           validate!(holidays_count, from_date)
 
           regions, observed, informal = @options_parser.call(options)
+          opts = gather_options(observed, informal)
 
           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)
+          1.upto(MAX_YEARS) do |year|
+            holidays.concat(search_window(from_date, year, regions, opts))
+            break if holidays.size >= holidays_count
+          end
 
-          @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] }
+          holidays.first(holidays_count)
         end
 
         private
 
+        # Windows are contiguous: each starts the day after the previous one ended. The
+        # search only looks at the months around a window (plus month 0, which covers the
+        # whole year), so dates past the window end are incomplete. They are discarded here
+        # and found by the next window instead.
+        def search_window(from_date, year, regions, opts)
+          window_start = year == 1 ? from_date : (from_date >> 12 * (year - 1)) + 1
+          window_end = from_date >> 12 * year
+
+          dates_driver = @dates_driver_builder.call(window_start, window_end)
+
+          @definition_search
+            .call(dates_driver, regions, opts)
+            .select { |holiday| (window_start..window_end).cover?(holiday[:date]) }
+            .sort_by { |holiday| holiday[:date] }
+        end
+
         def validate!(holidays_count, from_date)
           raise ArgumentError unless holidays_count
           raise ArgumentError if holidays_count <= 0

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

@@ -1,3 +1,5 @@
+require 'holidays/errors'
+
 module Holidays
   module Finder
     module Context
@@ -14,29 +16,11 @@ module Holidays
 
           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
-
-                dates = if h[:function]
-                  custom_holidays(year, month, h, regions)
-                else
-                  date = build_date(year, month, h, regions)
-                  date ? [date] : []
-                end
-
-                dates.each do |d|
-                  if observed_set?(options) && h[:observed]
-                    d = build_observed_date(d, regions, h)
-                  end
-                  holidays << {:date => d, :name => h[:name], :regions => h[:regions]}
-                end
+            candidates(months).each do |month, h|
+              next unless applicable?(year, h, regions, options)
+
+              year_dates(year, months, month, h, regions, options).each do |d|
+                holidays << {:date => d, :name => h[:name], :regions => h[:regions]}
               end
             end
           end
@@ -61,6 +45,66 @@ module Holidays
           end
         end
 
+        # Returns [month, definition] pairs to evaluate for one year of the dates
+        # driver. Fixed-date definitions only matter in the driver's months, but a
+        # function (e.g. a lunar date filed under its lunar month) can land several
+        # months away from the month it is filed under, so every function definition
+        # is evaluated, once, regardless of its month.
+        # See https://github.com/holidays/holidays/issues/519
+        def candidates(months)
+          by_month = @holidays_by_month_repo.all
+
+          in_driver = months.flat_map do |month|
+            (by_month[month] || []).map { |h| [month, h] }
+          end
+
+          outside_driver = (by_month.keys - months).sort.flat_map do |month|
+            by_month[month].select { |h| h[:function] }.map { |h| [month, h] }
+          end
+
+          in_driver + outside_driver
+        end
+
+        # A year that only pads the query with a border month (see
+        # DatesDriverBuilder#add_border_months) may lie past the data a
+        # calculation supports, e.g. lunar year 2101. Dates of such a year are
+        # outside the query anyway, so they are skipped rather than failing
+        # the query. A year the query actually covers still raises.
+        def year_dates(year, months, month, h, regions, options)
+          holiday_dates(year, month, h, regions, options)
+        rescue Holidays::UnsupportedYearError
+          raise unless border_padding?(months)
+
+          []
+        end
+
+        # Every date in the query adds its own month and a neighbouring one to
+        # its year, so a year holding a single month (besides the variable
+        # month 0) is only there as border padding.
+        def border_padding?(months)
+          (months - [0]).size == 1
+        end
+
+        def applicable?(year, h, regions, options)
+          return false if informal_type?(h[:type]) && !informal_set?(options)
+          return false unless @rules[:in_region].call(regions, h[:regions], h[:excluded_regions])
+          return true unless h[:year_ranges]
+
+          @rules[:year_range].call(year, h[:year_ranges])
+        end
+
+        def holiday_dates(year, month, h, regions, options)
+          dates = if h[:function]
+            custom_holidays(year, month, h, regions)
+          else
+            [build_date(year, month, h, regions)].compact
+          end
+
+          return dates unless observed_set?(options) && h[:observed]
+
+          dates.map { |d| build_observed_date(d, regions, h) }
+        end
+
         def informal_type?(type)
           type && [:informal, 'informal'].include?(type)
         end

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

@@ -13,15 +13,13 @@ module Holidays
 
           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)
-
+          # The driver stops at to_date; the dates driver still adds January of
+          # the next year as a border month. Searching a full 12 months from
+          # from_date would make the next year a searched year rather than
+          # border padding, so e.g. year_holidays for 2100 would need lunar
+          # data for 2101.
           to_date = Date.civil(from_date.year, 12, 31)
+          dates_driver = @dates_driver_builder.call(from_date, to_date)
           holidays = []
           ret_holidays = []
           opts = gather_options(observed, informal)

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

@@ -3,26 +3,31 @@ module Holidays
     module Rules
       class InRegion
         class << self
-          def call(requested, available)
+          # Each requested region is checked on its own. It qualifies when one
+          # of the available regions is the region itself or one of its
+          # ancestors (us for us_ca) and none of the excluded regions is. The
+          # rule matches when any requested region qualifies. :any always
+          # matches, whatever is excluded.
+          def call(requested, available, excluded = nil)
             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.include?('_')
-                chunks = r.to_s.split('_')
+            excluded ||= []
 
-                chunks.length.downto(1).map do |num|
-                  chunks[0..-num].join('_').to_sym
-                end
-              else
-                r
-              end
+            requested.any? do |region|
+              lineage = lineage(region)
+
+              (available & lineage).any? && (excluded & lineage).empty?
             end
+          end
+
+          private
 
-            requested = requested.flatten.uniq
+          # The region and all of its parents, e.g. :us_ca_xx gives
+          # [:us, :us_ca, :us_ca_xx].
+          def lineage(region)
+            chunks = region.to_s.split('_')
 
-            available.any? { |avail| requested.include?(avail) }
+            1.upto(chunks.length).map { |n| chunks.first(n).join('_').to_sym }
           end
         end
       end

data/lib/holidays/version.rb

@@ -1,3 +1,3 @@
 module Holidays
-  VERSION = '11.6.0'
+  VERSION = '11.8.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: holidays
 version: !ruby/object:Gem::Version
-  version: 11.6.0
+  version: 11.8.0
 platform: ruby
 authors:
 - Alex Dunae
@@ -219,6 +219,8 @@ files:
 - lib/holidays/definition/custom_methods/jp.rb
 - lib/holidays/definition/custom_methods/kr.rb
 - lib/holidays/definition/custom_methods/lv.rb
+- lib/holidays/definition/custom_methods/ma.rb
+- lib/holidays/definition/custom_methods/my.rb
 - lib/holidays/definition/custom_methods/nz.rb
 - lib/holidays/definition/custom_methods/ph.rb
 - lib/holidays/definition/custom_methods/registry.rb