holidays 4.6.0 → 4.7.0

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,23 @@
+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|
+              r.to_s =~ /_/ ? [r, r.to_s.gsub(/_[\w]*$/, '').to_sym] : r
+            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,82 @@
+# Please note that only one condition needs to match in order for `call` to return `true.
+# See the test file for this class for specific examples.
+module Holidays
+  module Finder
+    module Rules
+      class YearRange
+        class << self
+          BEFORE = :before
+          AFTER = :after
+          LIMITED = :limited
+          BETWEEN = :between
+
+          #TODO Can we just accept symbols here? Why accept strings?
+          VALID_OPERATORS = [
+            BEFORE, BEFORE.to_s,
+            AFTER, AFTER.to_s,
+            LIMITED, LIMITED.to_s,
+            BETWEEN, BETWEEN.to_s
+          ]
+
+          def call(target_year, year_range_definitions)
+            validate!(target_year, year_range_definitions)
+
+            matched = false
+            year_range_definitions.each do |range_defs|
+              next unless range_defs.is_a?(Hash) && range_defs.length == 1
+
+              operator = range_defs.keys.first
+              year_range = range_defs.values.first
+
+              case operator
+              when BEFORE, BEFORE.to_s
+                matched = target_year <= year_range
+              when AFTER, AFTER.to_s
+                matched = target_year >= year_range
+              when LIMITED, LIMITED.to_s
+                if year_range.is_a?(Array)
+                  matched = year_range.include?(target_year)
+                else
+                  matched = year_range == target_year
+                end
+              when BETWEEN, BETWEEN.to_s
+                matched = year_range.cover?(target_year)
+              end
+
+              break if matched == true
+            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?
+
+            year_ranges.each do |range|
+              raise ArgumentError.new("year_ranges must include only hashes") unless range.is_a?(Hash)
+              raise ArgumentError.new("year_ranges cannot include empty hashes") if range.empty?
+              raise ArgumentError.new("year_ranges entries can only include one operator") unless range.count == 1
+
+              operator = range.keys.first
+              range = range.values.first
+
+              raise ArgumentError.new("Invalid operator found: '#{operator}'") unless VALID_OPERATORS.include?(operator)
+
+              case operator
+              when BEFORE, BEFORE.to_s, AFTER, AFTER.to_s
+                raise ArgumentError.new(":before and :after operator value must be a number, received: '#{range}'") unless range.is_a?(Integer)
+              when LIMITED, LIMITED.to_s
+                raise ArgumentError.new(":limited operator value must be an array, received: '#{range}'") unless range.is_a?(Array) || range.is_a?(Integer)
+              when BETWEEN, BETWEEN.to_s
+                raise ArgumentError.new(":between operator value must be a range, received: '#{range}'") unless range.is_a?(Range)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/holidays/load_all_definitions.rb

@@ -17,6 +17,8 @@ module Holidays
         # 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,
@@ -32,25 +34,25 @@ module Holidays
           "to_tuesday_if_sunday_or_monday_if_saturday(date)" => weekend_modifier.method(:to_tuesday_if_sunday_or_monday_if_saturday).to_proc,
         }
 
-        Holidays::DefinitionFactory.custom_methods_repository.add(global_methods)
+        Factory::Definition.custom_methods_repository.add(global_methods)
       end
 
       private
 
       def gregorian_easter
-        DateCalculatorFactory::Easter::Gregorian.easter_calculator
+        Factory::DateCalculator::Easter::Gregorian.easter_calculator
       end
 
       def julian_easter
-        DateCalculatorFactory::Easter::Julian.easter_calculator
+        Factory::DateCalculator::Easter::Julian.easter_calculator
       end
 
       def weekend_modifier
-        DateCalculatorFactory.weekend_modifier
+        Factory::DateCalculator.weekend_modifier
       end
 
       def day_of_month_calculator
-        DateCalculatorFactory.day_of_month_calculator
+        Factory::DateCalculator.day_of_month_calculator
       end
     end
   end

data/lib/holidays/version.rb

@@ -1,3 +1,3 @@
 module Holidays
-  VERSION = '4.6.0'
+  VERSION = '4.7.0'
 end

data/test/coverage_report.rb

@@ -0,0 +1,7 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+SimpleCov.start do
+  add_filter 'lib/generated_definitions/'
+end

data/test/defs/test_defs_au.rb

@@ -75,7 +75,7 @@ assert_equal 'Melbourne Cup Day', Holidays.on(Date.civil(2014,11,4), :au_vic_mel
 assert_equal 'Melbourne Cup Day', Holidays.on(Date.civil(2015,11,3), :au_vic_melbourne)[0][:name]
 
 assert_equal 'Friday before the AFL Grand Final', Date.civil(2015,10,2).holidays(:au_vic)[0][:name]
-assert_nil Date.civil(2016,10,2).holidays(:au_vic)[0]
+assert_equal 'Friday before the AFL Grand Final', Date.civil(2016,9, 30).holidays(:au_vic)[0][:name]
 
 assert_equal "May Public Holiday", Date.civil(2005, 5, 16).holidays(:au_sa)[0][:name]
 assert_equal [], Date.civil(2014, 5, 19).holidays(:au_sa)

data/test/defs/test_defs_ca.rb

@@ -15,7 +15,6 @@ class CaDefinitionTests < Test::Unit::TestCase  # :nodoc:
  Date.civil(2008,7,1) => 'Canada Day',
  Date.civil(2008,9,1) => 'Labour Day',
  Date.civil(2008,10,13) => 'Thanksgiving',
- Date.civil(2008,11,11) => 'Remembrance Day',
  Date.civil(2008,12,25) => 'Christmas Day',
  Date.civil(2008,12,26) => 'Boxing Day'}.each do |date, name|
   assert_equal name, (Holidays.on(date, :ca, :informal)[0] || {})[:name]
@@ -145,6 +144,22 @@ end
   end
 end
 
+# Remembrance Day in all Canadian provinces
+# except (Nova Scotia, Manitoba, Ontario, and Quebec)
+[
+  :ca_ab,
+  :ca_sk,
+  :ca_bc,
+  :ca_pe,
+  :ca_nf,
+  :ca_nt,
+  :ca_nu,
+  :ca_nb,
+  :ca_yk
+].each do |province|
+  assert_equal "Remembrance Day", Holidays.on(Date.civil(2016,11,11), province)[0][:name]
+end
+
 
 {Date.civil(2013,2,2) => 'Groundhog Day',
  Date.civil(2013,2,14) => 'Valentine\'s Day',

data/test/defs/test_defs_jp.rb

@@ -69,5 +69,9 @@ end
 # before 2016, there is no mountain holiday.
 assert_nil Holidays.on(Date.civil(2015,8,11), :jp)[0]
 
+# before 2003, there is no citizens holiday.
+# [note] citizens holiday requires that jp_national_culture_day is wednesday.
+#        Before 2003, the closest past year that mathches above condition is 1998.
+assert_nil Holidays.on(Date.civil(1998,9,22), :jp)[0]
   end
 end

data/test/defs/test_defs_kr.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+# This file is generated by the Ruby Holiday gem.
+#
+# Definitions loaded: definitions/kr.yaml
+class KrDefinitionTests < Test::Unit::TestCase  # :nodoc:
+
+  def test_kr
+{Date.civil(2016,2,8) => "Korean New Year",
+ Date.civil(2016,5,14) => "Buddah\'s Birthday",
+ Date.civil(2016,9,12) => "Korean Thanksgiving",
+ Date.civil(2016,1,1) => "New Year\'s Day", 
+ Date.civil(2016,3,1) => "Independence Movement Day",
+ Date.civil(2016,5,5) => "Children\'s Day",
+ Date.civil(2016,6,6) => "Memorial Day",
+ Date.civil(2016,7,17) => "Constitution Day",
+ Date.civil(2016,8,15) => "Liberation Day",
+ Date.civil(2016,10,3) => "National Foundation Day",
+ Date.civil(2016,10,9) => "Hangul Day",
+ Date.civil(2016,12,25) => "Christmas Day"}.each do |date, name|
+  assert_equal name, (Holidays.on(date, :kr, :informal)[0] || {})[:name]
+end
+
+  end
+end

data/test/defs/test_defs_lu.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+# This file is generated by the Ruby Holiday gem.
+#
+# Definitions loaded: definitions/lu.yaml
+class LuDefinitionTests < Test::Unit::TestCase  # :nodoc:
+
+  def test_lu
+{Date.civil(2008,1,1) => 'Neijoerschdag',
+Date.civil(2008,3,24) => 'Ouschterméindeg',
+Date.civil(2008,5,1) => 'Christi Himmelfaart', # Ascension, Easter+39
+Date.civil(2008,6,23) => 'Nationalfeierdag',
+Date.civil(2008,8,15) => 'Léiffrawëschdag',
+Date.civil(2008,11,1) => 'Allerhellgen',
+Date.civil(2008,12,25) => 'Chrëschtdag',
+Date.civil(2008,12,26) => 'Stiefesdag',
+Date.civil(2008,5,11) => 'Péngschtméindeg'
+}.each do |date, name|
+  assert_equal name, (Holidays.on(date, :lu, :informal)[0] || {})[:name]
+end
+
+  end
+end

data/test/defs/test_defs_my.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+
+# This file is generated by the Ruby Holiday gem.
+#
+# Definitions loaded: definitions/my.yaml
+class MyDefinitionTests < Test::Unit::TestCase  # :nodoc:
+
+  def test_my
+{Date.civil(2016,1,1) => "New Year's Day",
+ Date.civil(2016,5,1) => 'Labour Day',
+ Date.civil(2016,6,4) => "Agong's Birthday",
+ Date.civil(2016,8,31) => 'Independence Day',
+ Date.civil(2016,9,16) => 'Malaysia Day',
+ Date.civil(2016,12,25) => 'Christmas Day'}.each do |date, name|
+  assert_equal name, (Holidays.on(date, :my, :informal)[0] || {})[:name]
+end
+
+  end
+end

data/test/defs/test_defs_north_america.rb

@@ -15,7 +15,6 @@ class North_americaDefinitionTests < Test::Unit::TestCase  # :nodoc:
  Date.civil(2008,7,1) => 'Canada Day',
  Date.civil(2008,9,1) => 'Labour Day',
  Date.civil(2008,10,13) => 'Thanksgiving',
- Date.civil(2008,11,11) => 'Remembrance Day',
  Date.civil(2008,12,25) => 'Christmas Day',
  Date.civil(2008,12,26) => 'Boxing Day'}.each do |date, name|
   assert_equal name, (Holidays.on(date, :ca, :informal)[0] || {})[:name]
@@ -145,6 +144,22 @@ end
   end
 end
 
+# Remembrance Day in all Canadian provinces
+# except (Nova Scotia, Manitoba, Ontario, and Quebec)
+[
+  :ca_ab,
+  :ca_sk,
+  :ca_bc,
+  :ca_pe,
+  :ca_nf,
+  :ca_nt,
+  :ca_nu,
+  :ca_nb,
+  :ca_yk
+].each do |province|
+  assert_equal "Remembrance Day", Holidays.on(Date.civil(2016,11,11), province)[0][:name]
+end
+
 
 {Date.civil(2007,1,1) => 'Año nuevo',
  Date.civil(2007,2,5) => 'Día de la Constitución',

data/test/holidays/core_extensions/test_date_time.rb

@@ -7,16 +7,16 @@ class Date
   include Holidays::CoreExtensions::Date
 end
 
-class Time 
+class Time
   include Holidays::CoreExtensions::Time
-end 
+end
 
 class CoreExtensionDateTimeTests < Test::Unit::TestCase
   def setup
     @date = Date.civil(2008,1,1)
   end
 
-  def test_change_method 
+  def test_change_method
     actual = @date.change(day: 5)
     assert_equal Date.civil(2008,1,5), actual
 
@@ -28,7 +28,7 @@ class CoreExtensionDateTimeTests < Test::Unit::TestCase
 
     actual = @date.change(year: 2015, month: 5, day: 3)
     assert_equal Date.civil(2015,5,3), actual
-  end 
+  end
 
   def test_end_of_month_method
     # Works for month with 31 days
@@ -41,7 +41,7 @@ class CoreExtensionDateTimeTests < Test::Unit::TestCase
 
     # Works for leap year
     actual = Date.civil(2016,2,1).end_of_month
-    assert_equal = Date.civil(2016,2,29), actual
+    assert_equal Date.civil(2016,2,29), actual
   end
 
   def test_days_in_month_method
@@ -56,5 +56,5 @@ class CoreExtensionDateTimeTests < Test::Unit::TestCase
     # Works for leap year
     actual = Time.days_in_month(2, 2016)
     assert_equal 29, actual
-  end    
-end 
+  end
+end

data/test/holidays/definition/context/test_function_processor.rb

@@ -0,0 +1,175 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../../../test_helper'
+
+require 'holidays/definition/context/function_processor'
+
+class FunctionProcessorTests < Test::Unit::TestCase
+  def setup
+    @year = 2016
+    @month = 1
+    @day = 15
+    @func_id = "custom_function_id"
+    @func_args = [:year]
+    @func_modifier = 1
+
+    @custom_methods_repo = mock()
+    @proc_result_cache_repo = mock()
+
+    @custom_func = mock()
+
+    @custom_methods_repo.expects(:find).at_most_once.with(@func_id).returns(@custom_func)
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @year).returns(Date.civil(@year, @month, @day))
+
+    @subject = Holidays::Definition::Context::FunctionProcessor.new(
+      @custom_methods_repo,
+      @proc_result_cache_repo,
+    )
+  end
+
+  def test_no_function_arguments_returns_error
+    assert_raises ArgumentError do
+      @subject.call(@year, @month, @day, @func_id, nil, @func_modifier)
+    end
+
+    assert_raises ArgumentError do
+      @subject.call(@year, @month, @day, @func_id, [], @func_modifier)
+    end
+  end
+
+  def test_unknown_function_argument_returns_error
+    assert_raises ArgumentError do
+      @subject.call(@year, @month, @day, @func_id, [:something], @func_modifier)
+    end
+  end
+
+  def test_unknown_function_id_returns_error
+    bad_id = "some-bad-id"
+    @custom_methods_repo.expects(:find).at_most_once.with(bad_id).returns(nil)
+
+    assert_raises Holidays::FunctionNotFound do
+      @subject.call(@year, @month, @day, bad_id, @func_args, @func_modifier)
+    end
+  end
+
+  def test_year_arg_passed_to_func_call
+    @func_args = [:year]
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @year).returns(Date.civil(2016, 1, 15))
+
+    @subject.call(@year, @month, @day, @func_id, @func_args, @func_modifier)
+  end
+
+  def test_month_arg_passed_to_func_call
+    @func_args = [:month]
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @month).returns(Date.civil(2016, 1, 15))
+
+    @subject.call(@year, @month, @day, @func_id, @func_args, @func_modifier)
+  end
+
+  def test_day_arg_passed_to_func_call
+    @func_args = [:day]
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @day).returns(Date.civil(2016, 1, 15))
+
+    @subject.call(@year, @month, @day, @func_id, @func_args, @func_modifier)
+  end
+
+  def test_date_arg_passed_to_func_call
+    @func_args = [:date]
+    date = Date.civil(@year, @month, @day)
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, date).returns(date)
+
+    @subject.call(@year, @month, @day, @func_id, @func_args, @func_modifier)
+  end
+
+  def test_multiple_args_passed_to_func_call
+    @func_args = [:month, :day]
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @month, @day).returns(Date.civil(2016, 1, 15))
+
+    @subject.call(@year, @month, @day, @func_id, @func_args, @func_modifier)
+  end
+
+  def test_call_returns_error_if_target_function_returns_unknown_value
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @year).returns("bad-response")
+
+    assert_raises Holidays::InvalidFunctionResponse do
+      @subject.call(@year, @month, @day, @func_id, @func_args, @func_modifier)
+    end
+  end
+
+  def test_call_returns_date_with_modifier
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @year).returns(Date.civil(2016, 3, 10))
+
+    result = @subject.call(@year, @month, @day, @func_id, @func_args, @func_modifier)
+
+    assert_equal(Date.civil(2016, 3, 10) + @func_modifier, result)
+  end
+
+  def test_call_returns_date_no_modifier
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @year).returns(Date.civil(2016, 3, 10))
+
+    result = @subject.call(@year, @month, @day, @func_id, @func_args, nil)
+
+    assert_equal(Date.civil(2016, 3, 10), result)
+  end
+
+  def test_call_returns_errors_when_custom_function_returns_non_date
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @year).returns("bad")
+
+    assert_raises Holidays::InvalidFunctionResponse do
+      @subject.call(@year, @month, @day, @func_id, @func_args, nil)
+    end
+  end
+
+  def test_call_returns_error_when_custom_function_returns_mday_but_resulting_date_is_invalid
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @year).returns(32)
+
+    assert_raises Holidays::InvalidFunctionResponse do
+      @subject.call(@year, @month, @day, @func_id, @func_args, nil)
+    end
+  end
+
+  def test_call_returns_integer_returns_modified_date
+    @proc_result_cache_repo.expects(:lookup).at_most_once.with(@custom_func, @year).returns(7)
+
+    result = @subject.call(@year, @month, @day, @func_id, @func_args, nil)
+
+    assert_equal(Date.civil(2016, 1, 7), result)
+  end
+
+  def test_func_modifier_not_required
+    result = @subject.call(@year, @month, @day, @func_id, @func_args)
+    assert_equal(Date.civil(2016, 1, 15), result)
+  end
+
+  def test_validate_returns_error_if_year_not_a_number
+    assert_raises ArgumentError do
+      @subject.call("bad-year", @month, @day, @func_id, @func_args)
+    end
+  end
+
+  def test_validate_returns_error_if_month_not_valid
+    assert_raises ArgumentError do
+      @subject.call(@year, "bad-month", @day, @func_id, [:month])
+    end
+
+    assert_raises ArgumentError do
+      @subject.call(@year, -1, @day, @func_id, [:month])
+    end
+
+    assert_raises ArgumentError do
+      @subject.call(@year, 13, @day, @func_id, [:month])
+    end
+  end
+
+  def test_validate_returns_error_if_day_is_not_valid
+    assert_raises ArgumentError do
+      @subject.call(@year, @month, 0, @func_id, [:day])
+    end
+
+    assert_raises ArgumentError do
+      @subject.call(@year, @month, 32, @func_id, [:day])
+    end
+
+    assert_raises ArgumentError do
+      @subject.call(@year, @month, "bad-day", @func_id, [:day])
+    end
+  end
+end