holidays 11.7.0 → 11.8.0

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/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.7.0'
+  VERSION = '11.8.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: holidays
 version: !ruby/object:Gem::Version
-  version: 11.7.0
+  version: 11.8.0
 platform: ruby
 authors:
 - Alex Dunae