holidays 3.3.0 → 4.0.0

data/lib/holidays/date_calculator/weekend_modifier.rb

@@ -2,18 +2,19 @@ module Holidays
   module DateCalculator
     class WeekendModifier
       # Move date to Monday if it occurs on a Saturday on Sunday.
+      # Does not modify date if it is not a weekend.
       # Used as a callback function.
       def to_monday_if_weekend(date)
-        date += 1 if date.wday == 0
-        date += 2 if date.wday == 6
-        date
+        return date unless date.wday == 6 || date.wday == 0
+        to_next_weekday(date)
       end
 
       # Move date to Monday if it occurs on a Sunday.
+      # Does not modify the date if it is not a Sunday.
       # Used as a callback function.
       def to_monday_if_sunday(date)
-        date += 1 if date.wday == 0
-        date
+        return date unless date.wday == 0
+        to_next_weekday(date)
       end
 
       # if Christmas falls on a Sunday, move it to the next Tuesday (Boxing Day will go on Monday)
@@ -65,6 +66,22 @@ module Holidays
         date -= 1 if date.wday == 6
         date
       end
+
+      # Finds the next weekday. For example, if a 'Friday' date is received
+      # it will return the following Monday. If Sunday then return Monday,
+      # if Saturday return Monday, if Tuesday return Wednesday, etc.
+      def to_next_weekday(date)
+        case date.wday
+        when 6
+          date += 2
+        when 5
+          date += 3
+        else
+          date += 1
+        end
+
+        date
+      end
     end
   end
 end

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

@@ -4,6 +4,11 @@ module Holidays
   module Definition
     module Context
       class Generator
+        def initialize(custom_method_parser, custom_method_source_decorator, custom_methods_repository)
+          @custom_method_parser = custom_method_parser
+          @custom_method_source_decorator = custom_method_source_decorator
+          @custom_methods_repository = custom_methods_repository
+        end
 
         def parse_definition_files(files)
           raise ArgumentError, "Must have at least one file to parse" if files.nil? || files.empty?
@@ -18,7 +23,9 @@ module Holidays
           files.each do |file|
             definition_file = YAML.load_file(file)
 
-            regions, rules_by_month = parse_month_definitions(definition_file['months'])
+            custom_methods = custom_method_parser.call(definition_file['methods'])
+
+            regions, rules_by_month = parse_month_definitions(definition_file['months'], custom_methods)
 
             all_regions << regions.flatten
 
@@ -27,7 +34,10 @@ module Holidays
               existing.flatten!
             }
 
-            custom_methods = parse_method_definitions(definition_file['methods'])
+            #FIXME This is a problem. We will have a 'global' list of methods. That's always bad. What effects will this have?
+            # This is an existing problem (just so we are clear). An issue would be extremely rare because we are generally parsing
+            # single files/custom files. But it IS possible that we would parse a bunch of things at the same time and step
+            # on each other so we need a solution.
             all_custom_methods.merge!(custom_methods)
 
             all_tests << parse_test_definitions(definition_file['tests'])
@@ -39,12 +49,12 @@ module Holidays
         end
 
         def generate_definition_source(module_name, files, regions, rules_by_month, custom_methods, tests)
-          month_strings = generate_month_definition_strings(rules_by_month)
+          month_strings = generate_month_definition_strings(rules_by_month, custom_methods)
 
           # Build the custom methods string
           custom_method_string = ''
           custom_methods.each do |key, code|
-            custom_method_string << code + "\n\n"
+            custom_method_string << custom_method_source_decorator.call(code) + ",\n\n"
           end
 
           module_src = generate_module_src(module_name, files, regions, month_strings, custom_method_string)
@@ -55,7 +65,10 @@ module Holidays
 
         private
 
-        def parse_month_definitions(month_definitions)
+        attr_reader :custom_method_parser, :custom_method_source_decorator, :custom_methods_repository
+
+        #FIXME This should be a 'month_definitions_parser' like the above parser
+        def parse_month_definitions(month_definitions, parsed_custom_methods)
           regions = []
           rules_by_month = {}
 
@@ -82,6 +95,12 @@ module Holidays
                 end
 
                 unless exists
+                  # This will add in the custom method arguments so they are immediately
+                  # available for 'on the fly' def loading.
+                  if rule[:function]
+                    rule[:function_arguments] = get_function_arguments(rule[:function], parsed_custom_methods)
+                  end
+
                   rules_by_month[month] << rule
                 end
               end
@@ -91,18 +110,6 @@ module Holidays
           [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 = []
 
@@ -113,7 +120,8 @@ module Holidays
           test_strings
         end
 
-        def generate_month_definition_strings(rules_by_month)
+        #FIXME This should really be split out and tested with its own unit tests.
+        def generate_month_definition_strings(rules_by_month, parsed_custom_methods)
           month_strings = []
 
           rules_by_month.each do |month, rules|
@@ -123,13 +131,28 @@ module Holidays
               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
+              end
+
+              if rule[:function]
+                string << ":function => \"#{rule[:function].to_s}\", "
+
+                # We need to add in the arguments so we can know what to send in when calling the custom proc during holiday lookups.
+                # NOTE: the allowed arguments are enforced in the custom methods parser.
+                string << ":function_arguments => #{get_function_arguments(rule[:function], parsed_custom_methods)}, "
+
+                if rule[:function_modifier]
+                  string << ":function_modifier => #{rule[:function_modifier].to_s}, "
+                end
+              end
+
+              # This is the 'else'. It is possible for mday AND function
+              # to be set but this is the fallback. This whole area
+              # needs to be reworked!
+              if string == '{'
                 string << ":wday => #{rule[:wday]}, :week => #{rule[:week]}, "
               end
 
+              #FIXME I think this should be split out into its own file.
               if rule[:year_ranges] && rule[:year_ranges].kind_of?(Array)
                 year_string = " :year_ranges => ["
                 len = rule[:year_ranges].length
@@ -145,8 +168,8 @@ module Holidays
               end
 
               if rule[:observed]
-                string << ":observed => lambda { |date| Holidays.#{rule[:observed]}(date) }, "
-                string << ":observed_id => \"#{rule[:observed].to_s}\", "
+                string << ":observed => \"#{rule[:observed].to_s}\", "
+                string << ":observed_arguments => #{get_function_arguments(rule[:observed], parsed_custom_methods)}, "
               end
 
               if rule[:type]
@@ -164,6 +187,19 @@ module Holidays
           return month_strings
         end
 
+        # This method sucks. The issue here is that the custom methods repo has the 'general' methods (like easter)
+        # but the 'parsed_custom_methods' have the recently parsed stuff. We don't load those until they are needed later.
+        # This entire file is a refactor target so I am adding some tech debt to get me over the hump.
+        # What we should do is ensure that all custom methods are loaded into the repo as soon as they are parsed
+        # so we only have one place to look.
+        def get_function_arguments(function_id, parsed_custom_methods)
+          if method = custom_methods_repository.find(function_id)
+            method.parameters.collect { |arg| arg[1] }
+          elsif method = parsed_custom_methods[function_id]
+            method.arguments.collect { |arg| arg.to_sym }
+          end
+        end
+
         def generate_module_src(module_name, files, regions, month_strings, custom_methods)
           module_src = ""
 
@@ -180,7 +216,7 @@ module Holidays
   #   require 'holidays'
   #   require '#{DEFINITIONS_PATH}/#{module_name.to_s.downcase}'
   #
-  # All the definitions are available at https://github.com/alexdunae/holidays
+  # All the definitions are available at https://github.com/holidays/holidays
   module #{module_name.to_s.upcase} # :nodoc:
     def self.defined_regions
       [:#{regions.join(', :')}]
@@ -191,12 +227,14 @@ module Holidays
         #{month_strings.join(",\n")}
       }
     end
-  end
 
-#{custom_methods}
+    def self.custom_methods
+      {
+        #{custom_methods}
+      }
+    end
+  end
 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

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

@@ -7,19 +7,19 @@ module Holidays
       # files. This is accomplished because the Generator class generates the
       # definition source with this class explicitly.
       class Merger
-        def initialize(holidays_by_month_repo, regions_repo)
+        def initialize(holidays_by_month_repo, regions_repo, custom_methods_repo)
           @holidays_repo = holidays_by_month_repo
           @regions_repo = regions_repo
+          @custom_methods_repo = custom_methods_repo
         end
 
-        def call(target_regions, target_holidays)
-          regions_repo.add(target_regions)
-          holidays_repo.add(target_holidays)
+        def call(target_regions, target_holidays, target_custom_methods)
+          #FIXME Does this need to come in this exact order? God I hope not.
+          # If not then we should swap the order so it matches the init.
+          @regions_repo.add(target_regions)
+          @holidays_repo.add(target_holidays)
+          @custom_methods_repo.add(target_custom_methods)
         end
-
-        private
-
-        attr_reader :holidays_repo, :regions_repo
       end
     end
   end

data/lib/holidays/definition/decorator/custom_method_proc.rb

@@ -0,0 +1,28 @@
+module Holidays
+  module Definition
+    module Decorator
+      class CustomMethodProc
+        def call(proc)
+          validate!(proc)
+
+          eval("Proc.new { |#{parse_arguments(proc.arguments)}|
+               #{proc.source}
+          }")
+        end
+
+        private
+
+        def validate!(proc)
+          raise ArgumentError if proc.name.nil? || proc.name.empty?
+          raise ArgumentError if proc.arguments.nil? || proc.arguments.empty?
+          raise ArgumentError if proc.source.nil? || proc.source.empty?
+        end
+
+        def parse_arguments(args)
+          a = args.join(", ")
+          a[0..-1]
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition/decorator/custom_method_source.rb

@@ -0,0 +1,30 @@
+module Holidays
+  module Definition
+    module Decorator
+      class CustomMethodSource
+        def call(proc)
+          validate!(proc)
+
+          method_name = proc.name
+          args = args_string(proc.arguments)
+          source = proc.source
+
+          "\"#{method_name.to_s}(#{args})\" => Proc.new { |#{args}|\n#{source}}"
+        end
+
+        private
+
+        def validate!(proc)
+          raise ArgumentError if proc.name.nil? || proc.name == ""
+          raise ArgumentError if proc.arguments.nil? || !proc.arguments.is_a?(Array) || proc.arguments.empty?
+          raise ArgumentError if proc.source.nil? || proc.source == ""
+        end
+
+        def args_string(args)
+          a = args.join(", ")
+          a[0..-1]
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition/entity/custom_method.rb

@@ -0,0 +1,11 @@
+module Holidays
+  module Definition
+    module Entity
+      CustomMethod = Struct.new(:name, :arguments, :source) do
+        def initialize(fields = {})
+          super(*fields.values_at(*members))
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition/parser/custom_method.rb

@@ -0,0 +1,69 @@
+require 'holidays/definition/entity/custom_method'
+
+module Holidays
+  module Definition
+    module Parser
+      class CustomMethod
+        def initialize(validator)
+          @validator = validator
+        end
+
+        def call(methods)
+          return {} if methods.nil? || methods.empty?
+
+          validate!(methods)
+
+          custom_methods = {}
+
+          methods.each do |name, pieces|
+            arguments = parse_arguments!(pieces["arguments"])
+
+            custom_methods[method_key(name, arguments)] = Entity::CustomMethod.new({
+              name: name,
+              arguments: arguments,
+              source: pieces["source"],
+            })
+          end
+
+          custom_methods
+        end
+
+        private
+
+        attr_reader :validator
+
+        def validate!(methods)
+          raise ArgumentError unless methods.all? do |name, pieces|
+            validator.valid?(
+              {
+                :name => name,
+                :arguments => pieces["arguments"],
+                :source => pieces["source"]
+              }
+            )
+          end
+        end
+
+        def parse_arguments!(arguments)
+          splitArgs = arguments.split(",")
+          parsedArgs = []
+
+          splitArgs.each do |arg|
+            parsedArgs << arg.strip
+          end
+
+          parsedArgs
+        end
+
+        def method_key(name, args)
+          "#{name.to_s}(#{args_string(args)})"
+        end
+
+        def args_string(args)
+          a = args.join(", ")
+          a[0..-1]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Holidays
+  module Definition
+    module Repository
+      class CustomMethods
+        def initialize
+          @custom_methods = {}
+        end
+
+        # This performs a merge that overwrites any conflicts.
+        # While this is not ideal I'm leaving it as-is since I have no
+        # evidence of any current definitions that will cause an issue.
+        #
+        # FIXME: this should probably return an error if a method with the
+        # same ID already exists.
+        def add(new_custom_methods)
+          raise ArgumentError if new_custom_methods.nil?
+          @custom_methods.merge!(new_custom_methods)
+        end
+
+        def find(method_id)
+          raise ArgumentError if method_id.nil? || method_id.empty?
+          @custom_methods[method_id]
+        end
+      end
+    end
+  end
+end

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

@@ -41,7 +41,7 @@ module Holidays
         private
 
         def definition_exists?(existing_def, target_def)
-          existing_def[:name] == target_def[:name] && existing_def[:wday] == target_def[:wday] && existing_def[:mday] == target_def[:mday] && existing_def[:week] == target_def[:week] && existing_def[:function_id] == target_def[:function_id] && existing_def[:type] == target_def[:type] && existing_def[:observed_id] == target_def[:observed_id] && existing_def[:year_ranges] == target_def[:year_ranges]
+          existing_def[:name] == target_def[:name] && existing_def[:wday] == target_def[:wday] && existing_def[:mday] == target_def[:mday] && existing_def[:week] == target_def[:week] && existing_def[:function] == target_def[:function] && existing_def[:type] == target_def[:type] && existing_def[:observed] == target_def[:observed] && existing_def[:year_ranges] == target_def[:year_ranges]
         end
       end
     end