holidays 2.2.0 → 3.0.0

data/lib/holidays/core_extensions/date.rb

@@ -0,0 +1,39 @@
+module Holidays
+  module CoreExtensions
+    module Date
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Get holidays on the current date.
+      #
+      # Returns an array of hashes or nil. See Holidays#between for options
+      # and the output format.
+      #
+      #   Date.civil('2008-01-01').holidays(:ca_)
+      #   => [{:name => 'New Year\'s Day',...}]
+      #
+      # Also available via Holidays#on.
+      def holidays(*options)
+        Holidays.on(self, options)
+      end
+
+      # Check if the current date is a holiday.
+      #
+      # Returns true or false.
+      #
+      #   Date.civil('2008-01-01').holiday?(:ca)
+      #   => true
+      def holiday?(*options)
+        holidays = self.holidays(options)
+        holidays && !holidays.empty?
+      end
+
+      module ClassMethods
+        def calculate_mday(year, month, week, wday)
+          Holidays::DateCalculatorFactory.day_of_month_calculator.call(year, month, week, wday)
+        end
+      end
+    end
+  end
+end

data/lib/holidays/date_calculator/day_of_month.rb

@@ -0,0 +1,68 @@
+module Holidays
+  module DateCalculator
+    # Calculate day of the month based on the week number and the day of the
+    # week.
+    #
+    # ==== Parameters
+    # [<tt>year</tt>]  Integer.
+    # [<tt>month</tt>] Integer from 1-12.
+    # [<tt>week</tt>]  One of <tt>:first</tt>, <tt>:second</tt>, <tt>:third</tt>,
+    #                  <tt>:fourth</tt>, <tt>:fifth</tt> or <tt>:last</tt>.
+    # [<tt>wday</tt>]  Day of the week as an integer from 0 (Sunday) to 6
+    #                  (Saturday) or as a symbol (e.g. <tt>:monday</tt>).
+    #
+    # Returns an integer.
+    #
+    # ===== Examples
+    # First Monday of January, 2008:
+    #   Date.calculate_mday(2008, 1, :first, :monday)
+    #   => 7
+    #
+    # Third Thursday of December, 2008:
+    #   Date.calculate_mday(2008, 12, :third, :thursday)
+    #   => 18
+    #
+    # Last Monday of January, 2008:
+    #   Date.calculate_mday(2008, 1, :last, 1)
+    #   => 28
+    #--
+    # see http://www.irt.org/articles/js050/index.htm
+    class DayOfMonth
+      def call(year, month, week, wday)
+        raise ArgumentError, "Week parameter must be one of Holidays::WEEKS (provided #{week})." unless weeks.include?(week) or weeks.has_value?(week)
+
+        unless wday.kind_of?(Numeric) and wday.between?(0,6) or day_symbols.index(wday)
+          raise ArgumentError, "Wday parameter must be an integer between 0 and 6 or one of Holidays::DAY_SYMBOLS."
+        end
+
+        week = weeks[week] if week.kind_of?(Symbol)
+        wday = day_symbols.index(wday) if wday.kind_of?(Symbol)
+
+        # :first, :second, :third, :fourth or :fifth
+        if week > 0
+          return ((week - 1) * 7) + 1 + ((wday - Date.civil(year, month,(week-1)*7 + 1).wday) % 7)
+        end
+
+        days = month_lengths[month-1]
+
+        days = 29 if month == 2 and Date.leap?(year)
+
+        return days - ((Date.civil(year, month, days).wday - wday + 7) % 7) - (7 * (week.abs - 1))
+      end
+
+      private
+
+      def weeks
+        Holidays::WEEKS
+      end
+
+      def day_symbols
+        Holidays::DAY_SYMBOLS
+      end
+
+      def month_lengths
+        Holidays::MONTH_LENGTHS
+      end
+    end
+  end
+end

data/lib/holidays/date_calculator/easter.rb

@@ -0,0 +1,58 @@
+module Holidays
+  module DateCalculator
+    class Easter
+      # Get the date of Easter Sunday in a given year.  From Easter Sunday, it is
+      # possible to calculate many traditional holidays in Western countries.
+      # Returns a Date object.
+      def calculate_easter_for(year)
+        y = year
+        a = y % 19
+        b = y / 100
+        c = y % 100
+        d = b / 4
+        e = b % 4
+        f = (b + 8) / 25
+        g = (b - f + 1) / 3
+        h = (19 * a + b - d - g + 15) % 30
+        i = c / 4
+        k = c % 4
+        l = (32 + 2 * e + 2 * i - h - k) % 7
+        m = (a + 11 * h + 22 * l) / 451
+
+        month = (h + l - 7 * m + 114) / 31
+        day = ((h + l - 7 * m + 114) % 31) + 1
+
+        Date.civil(year, month, day)
+      end
+
+      # A method to calculate the orthodox easter date, returns date in the Gregorian (western) calendar
+      # Safe until appr. 4100 AD, when one leap day will be removed.
+      # Returns a Date object.
+      def calculate_orthodox_easter_for(year)
+        y = year
+        g = y % 19
+        i = (19 * g + 15) % 30
+        j = (year + year/4 + i) % 7
+        j_month = 3 + (i - j + 40) / 44
+        j_day = i - j + 28 - 31 * (j_month / 4)
+        j_date = Date.civil(year, j_month, j_day)
+
+        case
+          # up until 1582, julian and gregorian easter dates were identical
+        when year <= 1582
+          offset = 0
+          # between the years 1583 and 1699 10 days are added to the julian day count
+        when (year >= 1583 and year <= 1699)
+          offset = 10
+          # after 1700, 1 day is added for each century, except if the century year is exactly divisible by 400 (in which case no days are added).
+          # Safe until 4100 AD, when one leap day will be removed.
+        when year >= 1700
+          offset = (year - 1700).divmod(100)[0] + ((year - year.divmod(100)[1]).divmod(400)[1] == 0 ? 0 : 1) - (year - year.divmod(100)[1] - 1700).divmod(400)[0] + 10
+        end
+
+        # add offset to the julian day
+        return Date.jd(j_date.jd + offset)
+      end
+    end
+  end
+end

data/lib/holidays/date_calculator/weekend_modifier.rb

@@ -0,0 +1,49 @@
+require 'date'
+
+module Holidays
+  module DateCalculator
+    class WeekendModifier
+      # Move date to Monday if it occurs on a Saturday on Sunday.
+      # Used as a callback function.
+      def to_monday_if_weekend(date)
+        date += 1 if date.wday == 0
+        date += 2 if date.wday == 6
+        date
+      end
+
+      # Move date to Monday if it occurs on a Sunday.
+      # Used as a callback function.
+      def to_monday_if_sunday(date)
+        date += 1 if date.wday == 0
+        date
+      end
+
+      # Move Boxing Day if it falls on a weekend, leaving room for Christmas.
+      # Used as a callback function.
+      def to_weekday_if_boxing_weekend(date)
+        if date.wday == 6 || date.wday == 0
+          date += 2
+        elsif date.wday == 1
+          date += 1
+        end
+
+        date
+      end
+
+      # Call to_weekday_if_boxing_weekend but first get date based on year
+      # Used as a callback function.
+      def to_weekday_if_boxing_weekend_from_year(year)
+        to_weekday_if_boxing_weekend(Date.civil(year, 12, 26))
+      end
+
+      # Move date to Monday if it occurs on a Sunday or to Friday if it occurs on a
+      # Saturday.
+      # Used as a callback function.
+      def to_weekday_if_weekend(date)
+        date += 1 if date.wday == 0
+        date -= 1 if date.wday == 6
+        date
+      end
+    end
+  end
+end

data/lib/holidays/date_calculator_factory.rb

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

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

@@ -0,0 +1,216 @@
+require 'yaml'
+
+module Holidays
+  module Definition
+    module Context
+      class Generator
+
+        def parse_definition_files(files)
+          raise ArgumentError, "Must have at least one file to parse" if files.nil? || files.empty?
+
+          all_regions = []
+          all_rules_by_month = {}
+          all_custom_methods = {}
+          all_tests = []
+
+          files.flatten!
+
+          files.each do |file|
+            definition_file = YAML.load_file(file)
+
+            regions, rules_by_month = parse_month_definitions(definition_file['months'])
+
+            all_regions << regions.flatten
+
+            all_rules_by_month.merge!(rules_by_month) { |month, existing, new|
+              existing << new
+              existing.flatten!
+            }
+
+            custom_methods = parse_method_definitions(definition_file['methods'])
+            all_custom_methods.merge!(custom_methods)
+
+            all_tests << parse_test_definitions(definition_file['tests'])
+          end
+
+          all_regions.flatten!.uniq!
+
+          [all_regions, all_rules_by_month, all_custom_methods, all_tests]
+        end
+
+        def generate_definition_source(module_name, files, regions, rules_by_month, custom_methods, tests)
+          month_strings = generate_month_definition_strings(rules_by_month)
+
+          # Build the custom methods string
+          custom_method_string = ''
+          custom_methods.each do |key, code|
+            custom_method_string << code + "\n\n"
+          end
+
+          module_src = generate_module_src(module_name, files, regions, month_strings, custom_method_string)
+          test_src = generate_test_src(module_name, files, tests)
+
+          return module_src, test_src || ''
+        end
+
+        private
+
+        def parse_month_definitions(month_definitions)
+          regions = []
+          rules_by_month = {}
+
+          if month_definitions
+            month_definitions.each do |month, definitions|
+              rules_by_month[month] = [] unless rules_by_month[month]
+              definitions.each do |definition|
+                rule = {}
+
+                definition.each do |key, val|
+                  rule[key.to_sym] = val
+                end
+
+                rule[:regions] = rule[:regions].collect { |r| r.to_sym }
+
+                regions << rule[:regions]
+
+                exists = false
+                rules_by_month[month].each do |ex|
+                  if ex[:name] == rule[:name] and ex[:wday] == rule[:wday] and ex[:mday] == rule[:mday] and ex[:week] == rule[:week] and ex[:type] == rule[:type] and ex[:function] == rule[:function] and ex[:observed] == rule[:observed]
+                    ex[:regions] << rule[:regions].flatten
+                    exists = true
+                  end
+                end
+
+                unless exists
+                  rules_by_month[month] << rule
+                end
+              end
+            end
+          end
+
+          [regions, rules_by_month]
+        end
+
+        def parse_method_definitions(methods)
+          custom_methods = {}
+
+          if methods
+            methods.each do |name, code|
+              custom_methods[name] = code
+            end
+          end
+
+          custom_methods
+        end
+
+        def parse_test_definitions(tests)
+          test_strings = []
+
+          if tests
+            test_strings << tests
+          end
+
+          test_strings
+        end
+
+        def generate_month_definition_strings(rules_by_month)
+          month_strings = []
+
+          rules_by_month.each do |month, rules|
+            month_string = "      #{month.to_s} => ["
+            rule_strings = []
+            rules.each do |rule|
+              string = '{'
+              if rule[:mday]
+                string << ":mday => #{rule[:mday]}, "
+              elsif rule[:function]
+                string << ":function => lambda { |year| Holidays.#{rule[:function]} }, "
+                string << ":function_id => \"#{rule[:function].to_s}\", "
+              else
+                string << ":wday => #{rule[:wday]}, :week => #{rule[:week]}, "
+              end
+
+              if rule[:observed]
+                string << ":observed => lambda { |date| Holidays.#{rule[:observed]}(date) }, "
+                string << ":observed_id => \"#{rule[:observed].to_s}\", "
+              end
+
+              if rule[:type]
+                string << ":type => :#{rule[:type]}, "
+              end
+
+              # shouldn't allow the same region twice
+              string << ":name => \"#{rule[:name]}\", :regions => [:" + rule[:regions].uniq.join(', :') + "]}"
+              rule_strings << string
+            end
+            month_string << rule_strings.join(",\n            ") + "]"
+            month_strings << month_string
+          end
+
+          return month_strings
+        end
+
+        def generate_module_src(module_name, files, regions, month_strings, custom_methods)
+          module_src = ""
+
+          module_src =<<-EOM
+# encoding: utf-8
+module Holidays
+  # This file is generated by the Ruby Holidays gem.
+  #
+  # Definitions loaded: #{files.join(', ')}
+  #
+  # To use the definitions in this file, load it right after you load the
+  # Holiday gem:
+  #
+  #   require 'holidays'
+  #   require '#{DEFINITIONS_PATH}/#{module_name.to_s.downcase}'
+  #
+  # All the definitions are available at https://github.com/alexdunae/holidays
+  module #{module_name.to_s.upcase} # :nodoc:
+    def self.defined_regions
+      [:#{regions.join(', :')}]
+    end
+
+    def self.holidays_by_month
+      {
+        #{month_strings.join(",\n")}
+      }
+    end
+  end
+
+#{custom_methods}
+end
+
+Holidays.merge_defs(Holidays::#{module_name.to_s.upcase}.defined_regions, Holidays::#{module_name.to_s.upcase}.holidays_by_month)
+        EOM
+
+          return module_src
+        end
+
+        def generate_test_src(module_name, files, tests)
+          unless tests.empty?
+            test_src = ""
+
+            test_src =<<-EndOfTests
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+# This file is generated by the Ruby Holiday gem.
+#
+# Definitions loaded: #{files.join(', ')}
+class #{module_name.to_s.capitalize}DefinitionTests < Test::Unit::TestCase  # :nodoc:
+
+  def test_#{module_name.to_s.downcase}
+#{tests.join("\n\n")}
+  end
+end
+  EndOfTests
+          end
+
+          return test_src
+        end
+      end
+    end
+  end
+end