holidays 4.2.0 → 8.4.1

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

@@ -1,22 +1,14 @@
 module Holidays
+  #TODO This file should be renamed. It's no longer about definitions, really.
   class LoadAllDefinitions
     class << self
       def call
-        path = File.expand_path(File.dirname(__FILE__)) + "/../#{Holidays::DEFINITIONS_PATH}/"
-
-        Dir.foreach(path) do |item|
-          next if item == '.' or item == '..'
-
-          target = path+item
-          next if File.extname(target) != '.rb'
-
-          require target
-        end
-
         #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,
@@ -28,29 +20,36 @@ module Holidays
           "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,
-          "xmas_to_weekday_if_weekend(year)" => weekend_modifier.method(:xmas_to_weekday_if_weekend).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, 
         }
 
-        Holidays::DefinitionFactory.custom_methods_repository.add(global_methods)
+        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
-        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
+
+      def lunar_date
+        Factory::DateCalculator.lunar_date
       end
     end
   end

data/lib/holidays/version.rb

@@ -1,3 +1,3 @@
 module Holidays
-  VERSION = '4.2.0'
+  VERSION = '8.4.1'
 end

data/lib/holidays.rb

@@ -3,51 +3,12 @@ $:.unshift File.dirname(__FILE__)
 
 require 'date'
 require 'digest/md5'
-require 'holidays/definition_factory'
-require 'holidays/date_calculator_factory'
-require 'holidays/option_factory'
-require 'holidays/use_case_factory'
+require 'holidays/factory/definition'
+require 'holidays/factory/date_calculator'
+require 'holidays/factory/finder'
 require 'holidays/errors'
 require 'holidays/load_all_definitions'
 
-# == Region options
-# Holidays can be defined as belonging to one or more regions and sub regions.
-# The Holidays#on, Holidays#between, Date#holidays and Date#holiday? methods
-# each allow you to specify a specific region.
-#
-# There are several different ways that you can specify a region:
-#
-# [<tt>:region</tt>]
-#   By region. For example, return holidays in the Canada with <tt>:ca</tt>.
-# [<tt>:region_</tt>]
-#   By region and sub regions. For example, return holidays in Germany
-#   and all its sub regions with <tt>:de_</tt>.
-# [<tt>:region_sub</tt>]
-#   By sub region. Return national holidays in Spain plus holidays in Spain's
-#   Valencia region with <tt>:es_v</tt>.
-# [<tt>:any</tt>]
-#   Any region.  Return holidays from any loaded region.
-#
-#
-# You can load all the available holiday definition sets by running
-#   Holidays.load_all
-# == Other options
-# [<tt>:observed</tt>]    Return holidays on the day they are observed (e.g. on a Monday if they fall on a Sunday).
-# [<tt>:informal</tt>]    Include informal holidays (e.g. Valentine's Day)
-#
-# == Examples
-# Return all holidays in the <tt>:ca</tt> and <tt>:us</tt> regions on the day that they are
-# observed.
-#
-#   Holidays.between(from, to, :ca, :us, :observed)
-#
-# Return all holidays in <tt>:ca</tt> and any <tt>:ca</tt> sub-region.
-#
-#   Holidays.between(from, to, :ca_)
-#
-# Return all holidays in <tt>:ca_bc</tt> sub-region (which includes the <tt>:ca</tt>), including informal holidays.
-#
-#   Holidays.between(from, to, :ca_bc, :informal)
 module Holidays
   WEEKS = {:first => 1, :second => 2, :third => 3, :fourth => 4, :fifth => 5, :last => -1, :second_last => -2, :third_last => -3}
   MONTH_LENGTHS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
@@ -57,52 +18,19 @@ module Holidays
   FULL_DEFINITIONS_PATH = File.expand_path(File.dirname(__FILE__) + "/#{DEFINITIONS_PATH}")
 
   class << self
-    # Get all holidays on a given date.
-    #
-    # [<tt>date</tt>]     A Date object.
-    # [<tt>:options</tt>] One or more region symbols, <tt>:informal</tt> and/or <tt>:observed</tt>.
-    #
-    # Returns an array of hashes or nil. See Holidays#between for the output
-    # format.
-    #
-    # Also available via Date#holidays.
-    def on(date, *options)
-      between(date, date, options)
+    def any_holidays_during_work_week?(date, *options)
+      monday = date - (date.wday - 1)
+      friday = date + (5 - date.wday)
+
+      holidays = between(monday, friday, *options)
+
+      holidays && holidays.count > 0
     end
 
-    # Does the given work-week have any holidays?
-    #
-    # [<tt>date</tt>]   A Date object.
-    # [<tt>:options</tt>] One or more region symbols, and/or <tt>:informal</tt>. Automatically includes <tt>:observed</tt>. If you don't want this, pass <tt>:no_observed</tt>
-    #
-    # The given Date can be any day of the week.
-    # Returns true if any holidays fall on Monday - Friday of the given week.
-    def any_holidays_during_work_week?(date, *options)
-      days_to_monday = date.wday - 1
-      days_to_friday = 5 - date.wday
-      start_date = date - days_to_monday
-      end_date = date + days_to_friday
-      options += [:observed] unless options.include?(:no_observed)
-      options.delete(:no_observed)
-      between(start_date, end_date, options).empty?
+    def on(date, *options)
+      between(date, date, *options)
     end
 
-    # Get all holidays occuring between two dates, inclusively.
-    #
-    # Returns an array of hashes or nil.
-    #
-    # Each holiday is returned as a hash with the following fields:
-    # [<tt>start_date</tt>]  Ruby Date object.
-    # [<tt>end_date</tt>]    Ruby Date object.
-    # [<tt>options</tt>]     One or more region symbols, <tt>:informal</tt> and/or <tt>:observed</tt>.
-    #
-    # ==== Example
-    #   from = Date.civil(2008,7,1)
-    #   to   = Date.civil(2008,7,31)
-    #
-    #   Holidays.between(from, to, :ca, :us)
-    #   => [{:name => 'Canada Day', :regions => [:ca]...}
-    #       {:name => 'Independence Day'', :regions => [:us], ...}]
     def between(start_date, end_date, *options)
       raise ArgumentError unless start_date && end_date
 
@@ -112,35 +40,18 @@ module Holidays
 
       start_date, end_date = get_date(start_date), get_date(end_date)
 
-      if cached_holidays = definition_cache_repository.find(start_date, end_date, options)
+      raise ArgumentError if end_date < start_date
+
+      if cached_holidays = Factory::Definition.cache_repository.find(start_date, end_date, options)
         return cached_holidays
       end
 
-      regions, observed, informal = OptionFactory.parse_options.call(options)
-      date_driver_hash = UseCaseFactory.dates_driver_builder.call(start_date, end_date)
-
-      UseCaseFactory.between.call(start_date, end_date, date_driver_hash, regions, observed, informal)
+      Factory::Finder.between.call(start_date, end_date, options)
     end
 
-    # Get next holidays occuring from date, inclusively.
-    #
-    # Returns an array of hashes or nil.
-    #
-    # Incoming arguments are below:
-    # [<tt>holidays_count</tt>]  Ruby Numeric object. This is the number of holidays to return
-    # [<tt>options</tt>]     One or more region symbols, <tt>:informal</tt> and/or <tt>:observed</tt>.
-    # [<tt>from_date</tt>]    Ruby Date object. This is an optional param, defaulted today.
-    #
-    # ==== Example
-    #   Date.today
-    #   => Tue, 23 Feb 2016
-    #
-    #   regions = [:us, :informal]
-    #
-    #   Holidays.next_holidays(3, regions)
-    #   => [{:name => "St. Patrick's Day",...},
-    #       {:name => "Good Friday",...},
-    #       {:name => "Easter Sunday",...}]
+    #FIXME All other methods start with a date and require a date. For the next
+    #      major version bump we should take the opportunity to change this
+    #      signature to match, e.g. next_holidays(from_date, count, options)
     def next_holidays(holidays_count, options, from_date = Date.today)
       raise ArgumentError unless holidays_count
       raise ArgumentError if options.empty?
@@ -150,42 +61,60 @@ module Holidays
       from_date = from_date.new_offset(0) + from_date.offset if from_date.respond_to?(:new_offset)
 
       from_date = get_date(from_date)
-      regions, observed, informal = OptionFactory.parse_options.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.
-      date_driver_hash = UseCaseFactory.dates_driver_builder.call(from_date, from_date >> 12)
+      Factory::Finder.next_holiday.call(holidays_count, from_date, options)
+    end
+
+    #FIXME All other methods start with a date and require a date. For the next
+    #      major version bump we should take the opportunity to change this
+    #      signature to match, e.g. year_holidays(from_date, options)
+    def year_holidays(options, from_date = Date.today)
+      raise ArgumentError if options.empty?
+      raise ArgumentError unless options.is_a?(Array)
+
+      # remove the timezone
+      from_date = from_date.new_offset(0) + from_date.offset if from_date.respond_to?(:new_offset)
+      from_date = get_date(from_date)
 
-      UseCaseFactory.next_holiday.call(holidays_count, from_date, date_driver_hash, regions, observed, informal)
+      Factory::Finder.year_holiday.call(from_date, options)
     end
 
-    # Allows a developer to explicitly calculate and cache holidays within a given period
     def cache_between(start_date, end_date, *options)
       start_date, end_date = get_date(start_date), get_date(end_date)
       cache_data = between(start_date, end_date, *options)
 
-      definition_cache_repository.cache_between(start_date, end_date, cache_data, options)
+      Factory::Definition.cache_repository.cache_between(start_date, end_date, cache_data, options)
     end
 
-    # Returns an array of symbols of all the available holiday regions.
     def available_regions
       Holidays::REGIONS
     end
 
-    # Parses provided holiday definition file(s) and loads them so that they are immediately available.
     def load_custom(*files)
-      regions, rules_by_month, custom_methods, tests = DefinitionFactory.file_parser.parse_definition_files(files)
+      regions, rules_by_month, custom_methods, _ = Factory::Definition.file_parser.parse_definition_files(files)
 
       custom_methods.each do |method_key, method_entity|
-        custom_methods[method_key] = Holidays::DefinitionFactory.custom_method_proc_decorator.call(method_entity)
+        custom_methods[method_key] = Factory::Definition.custom_method_proc_decorator.call(method_entity)
       end
 
-      DefinitionFactory.merger.call(regions, rules_by_month, custom_methods)
+      Factory::Definition.merger.call(regions, rules_by_month, custom_methods)
 
       rules_by_month
     end
 
+    def load_all
+      path = FULL_DEFINITIONS_PATH + "/"
+
+      Dir.foreach(path) do |item|
+        next if item == '.' or item == '..'
+
+        target = path+item
+        next if File.extname(target) != '.rb'
+
+        require target
+      end
+    end
+
     private
 
     def get_date(date)
@@ -195,10 +124,6 @@ module Holidays
         Date.civil(date.year, date.mon, date.mday)
       end
     end
-
-    def definition_cache_repository
-      DefinitionFactory.cache_repository
-    end
   end
 end
 

data/test/coverage_report.rb

@@ -0,0 +1,26 @@
+require 'simplecov'
+
+# For reasons I don't understand jruby implementations report lower coverage
+# than other ruby versions. Ruby 2.5.3, for instance, is at 92%.
+#
+# We set the floor based on jruby so that all automated tests pass on Travis CI.
+SimpleCov.minimum_coverage 89
+
+SimpleCov.add_filter [
+  # Apparently simplecov doesn't automatically filter 'spec' or 'test' so we
+  # have to do it manually.
+  'test',
+
+  # Only filtered because I tend to not see value in testing factories.
+  'lib/holidays/factory/',
+
+  # jruby coverage flips out here and doesn't count much of the large date
+  # arrays used by this class. This results in an extremely low reported
+  # coverage for this specific file but only in jruby, not other ruby versions.
+  # Since it obliterates coverage percentages I'll filter it until I can come
+  # up with a solution.
+  'lib/holidays/date_calculator/lunar_date.rb',
+]
+
+SimpleCov.coverage_dir 'reports/coverage'
+SimpleCov.start

data/test/data/test_custom_informal_holidays_defs.yaml

@@ -0,0 +1,11 @@
+---
+months:
+  1:
+  - name: informal day with type as string
+    regions: [custom_informal]
+    mday: 1
+    type: informal
+  - name: informal day with type as symbol
+    regions: [custom_informal]
+    mday: 5
+    type: :informal

data/test/data/test_custom_year_range_holiday_defs.yaml

@@ -4,25 +4,28 @@ months:
     regions: [custom_year_range_file]
     mday: 1
     year_ranges:
-      - after: 2016
+      from: 2016
   - name: before_year
     regions: [custom_year_range_file]
     mday: 2
     year_ranges:
-      - before: 2017
+      until: 2017
   - name: between_year
     regions: [custom_year_range_file]
     mday: 3
     year_ranges:
-      - between: 2016..2018
+      between:
+        start: 2016
+        end: 2018
   - name: limited_year
     regions: [custom_year_range_file]
     mday: 4
     year_ranges:
-      - limited: [2016,2018,2019]
-  - name: multiple_conditions
-    regions: [custom_year_range_file]
-    mday: 5
-    year_ranges:
-      - before: 2015
-      - after: 2017
+      limited: [2016,2018,2019]
+
+tests:
+  - given:
+      date: '2017-01-01'
+      regions: [custom_year_range_file]
+    expect:
+      name: "after_year"

data/test/data/test_invalid_region.rb

@@ -0,0 +1,15 @@
+module Holidays
+  module BAD_REGION_NAME
+    def self.defined_regions
+      [:test_region]
+    end
+
+    def self.holidays_by_month
+      {}
+    end
+
+    def self.custom_methods
+      {}
+    end
+  end
+end

data/test/data/test_multiple_custom_holiday_defs.yaml

@@ -3,7 +3,10 @@ months:
   - name: Company Founding!
     regions: [custom_multiple_files]
     mday: 5
-tests: |
-    {Date.civil(2013,10,5) => 'Company Founding!'}.each do |date, name|
-      assert_equal name, (Holidays.on(date, :custom_multiple_files)[0] || {})[:name]
-    end
+
+tests:
+  - given:
+      date: "2013-10-5"
+      regions: ["custom_multiple_files"]
+    expect:
+      name: "Company Founding!"

data/test/data/test_multiple_regions_with_conflicts_region_1.yaml

@@ -0,0 +1,38 @@
+months:
+  0:
+  - name: With Function Modifier
+    regions: [multiple_with_conflict_1]
+    function: easter(year)
+    function_modifier: 60
+  - name: With Function Only Different Function Name
+    regions: [multiple_with_conflict_1]
+    function: conflict_custom_method_1(year)
+  - name: With Function Only Same Function Name
+    regions: [multiple_with_conflict_1]
+    function: conflict_custom_method_identical_name_between_regions(year)
+  - name: With Function Only Same Function Name - Region 1
+    regions: [multiple_with_conflict_1]
+    function: conflict_custom_method_identical_name_between_regions_but_different_holiday_names(year)
+  1:
+  - name: New Year's Day
+    regions: [multiple_with_conflict_1]
+    mday: 1
+    observed: to_monday_if_weekend(date)
+  10:
+  - name: Testing Conflict Month 10
+    regions: [multiple_with_conflict_1]
+    mday: 5
+
+methods:
+  conflict_custom_method_1:
+    arguments: year
+    ruby: |
+      Date.civil(year, 8, 1)
+  conflict_custom_method_identical_name_between_regions:
+    arguments: year
+    ruby: |
+      Date.civil(year, 9, 1)
+  conflict_custom_method_identical_name_between_regions_but_different_holiday_names:
+    arguments: year
+    ruby: |
+      Date.civil(year, 9, 15)

data/test/data/test_multiple_regions_with_conflicts_region_2.yaml

@@ -0,0 +1,38 @@
+months:
+  0:
+  - name: With Function Modifier
+    regions: [multiple_with_conflict_2]
+    function: easter(year)
+    function_modifier: 64
+  - name: With Function Only Different Function Name
+    regions: [multiple_with_conflict_2]
+    function: conflict_custom_method_2(year)
+  - name: With Function Only Same Function Name
+    regions: [multiple_with_conflict_2]
+    function: conflict_custom_method_identical_name_between_regions(year)
+  - name: With Function Only Same Function Name - Region 2
+    regions: [multiple_with_conflict_2]
+    function: conflict_custom_method_identical_name_between_regions_but_different_holiday_names(year)
+  1:
+  - name: New Year's Day
+    regions: [multiple_with_conflict_2]
+    mday: 1
+    observed: to_tuesday_if_sunday_or_monday_if_saturday(date)
+  10:
+  - name: Testing Conflict Month 10
+    regions: [multiple_with_conflict_2]
+    mday: 7
+
+methods:
+  conflict_custom_method_2:
+    arguments: year
+    ruby: |
+      Date.civil(year, 12, 1)
+  conflict_custom_method_identical_name_between_regions:
+    arguments: year
+    ruby: |
+      Date.civil(year, 11, 1)
+  conflict_custom_method_identical_name_between_regions_but_different_holiday_names:
+    arguments: year
+    ruby: |
+      Date.civil(year, 11, 15)

data/test/data/test_region.rb

@@ -0,0 +1,15 @@
+module Holidays
+  module TEST_REGION
+    def self.defined_regions
+      [:test_region, :test_region2]
+    end
+
+    def self.holidays_by_month
+      {}
+    end
+
+    def self.custom_methods
+      {}
+    end
+  end
+end

data/test/data/test_single_custom_holiday_defs.yaml

@@ -3,7 +3,10 @@ months:
   - name: Company Founding
     regions: [custom_single_file]
     mday: 20
-tests: |
-    {Date.civil(2013,6,20) => 'Company Founding'}.each do |date, name|
-      assert_equal name, (Holidays.on(date, :custom_single_file)[0] || {})[:name]
-    end
+
+tests:
+  - given:
+      date: '2013-06-20'
+      regions: [custom_single_file]
+    expect:
+      name: "Company Founding"

data/test/data/test_single_custom_holiday_with_custom_procs.yaml

@@ -14,11 +14,15 @@ methods:
     source: |
       d = Date.civil(year, month, 1)
       d + 2
-tests: |
-    {Date.civil(2013,6,20) => 'Company Founding'}.each do |date, name|
-      assert_equal name, (Holidays.on(date, :custom_single_file)[0] || {})[:name]
-    end
 
-    {Date.civil(2015, 1, 1) => 'Custom Holiday'}.each do |date, name|
-      assert_equal name, (Holidays.on(date, :custom_single_file)[0] || {}[:name]
-    end
+tests:
+  - given:
+      date: '2013-06-20'
+      regions: [custom_single_file]
+    expect:
+      name: "Company Founding"
+  - given:
+      date: '2015-01-01'
+      regions: [custom_single_file]
+    expect:
+      name: "Custom Holiday"