revised_holidays 9.0.0

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

@@ -0,0 +1,209 @@
+require 'yaml'
+
+#FIXME This whole file is my next refactor target. We do wayyyyy too much by
+#      convention here. We need hard and fast rules and explicit errors when you
+#      try to parse something that isn't allowed. So if you are a dev recognize
+#      that a lot of the guard statements in here are to codify existing legacy
+#      logic. The fact is that we already require these guards, we just don't
+#      enforce it explicitly. Now we will. And by doing so things will begin
+#      to look very, very messy.
+module Holidays
+  module Definition
+    module Context
+      class Generator
+        def initialize(custom_method_parser, custom_method_source_decorator, custom_methods_repository, test_parser, test_source_generator, module_source_generator)
+          @custom_method_parser = custom_method_parser
+          @custom_method_source_decorator = custom_method_source_decorator
+          @custom_methods_repository = custom_methods_repository
+          @test_parser = test_parser
+          @test_source_generator = test_source_generator
+          @module_source_generator = module_source_generator
+        end
+
+        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)
+
+            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
+
+            all_rules_by_month.merge!(rules_by_month) { |month, existing, new|
+              existing << new
+              existing.flatten!
+            }
+
+            #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 += @test_parser.call(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, custom_methods)
+
+          # Build the custom methods string
+          custom_method_string = ''
+          custom_methods.each do |key, code|
+            custom_method_string << @custom_method_source_decorator.call(code) + ",\n\n"
+          end
+
+          module_src = @module_source_generator.call(module_name, files, regions, month_strings, custom_method_string)
+          test_src = @test_source_generator.call(module_name, files, tests)
+
+          return module_src, test_src || ''
+        end
+
+        private
+
+        #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 = {}
+
+          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|
+                  # Ruby 2.4 doesn't have the `transform_keys` method. Once we drop 2.4 support we can
+                  # use `val.transform_keys!(&:to_sym) if val.is_a?(Hash)` instead of this `if` statement.
+                  if val.is_a?(Hash)
+                    val = val.keys.each_with_object({}) do |k, result|
+                      result[k.to_sym] = val[k]
+                    end
+                  end
+
+                  rule[key.to_sym] = val
+                end
+
+                if rule[:year_ranges] && rule[:year_ranges].key?(:between)
+                  start_year = rule[:year_ranges][:between]["start"].to_i
+                  end_year = rule[:year_ranges][:between]["end"].to_i
+
+                  rule[:year_ranges][:between] = Range.new(start_year, end_year)
+                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] and ex[:year_ranges] == rule[:year_ranges]
+                    ex[:regions] << rule[:regions].flatten
+                    exists = true
+                  end
+                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
+            end
+          end
+
+          [regions, rules_by_month]
+        end
+
+        #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|
+            month_string = "      #{month.to_s} => ["
+            rule_strings = []
+            rules.each do |rule|
+              string = '{'
+              if rule[:mday]
+                string << ":mday => #{rule[:mday]}, "
+              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
+
+              if rule[:year_ranges] && rule[:year_ranges].is_a?(Hash)
+                selector = rule[:year_ranges].keys.first
+                value = rule[:year_ranges][selector]
+
+                string << ":year_ranges => { :#{selector} => #{value} },"
+              end
+
+              if rule[:observed]
+                string << ":observed => \"#{rule[:observed].to_s}\", "
+                string << ":observed_arguments => #{get_function_arguments(rule[:observed], parsed_custom_methods)}, "
+              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
+
+        # 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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Holidays
+  module Definition
+    module Context
+      class Load
+        def initialize(definition_merger, full_definitions_path)
+          @definition_merger = definition_merger
+          @full_definitions_path = full_definitions_path
+        end
+
+        def call(region)
+          region_definition_file = "#{@full_definitions_path}/#{region}"
+          require region_definition_file
+
+          target_region_module = Module.const_get("Holidays").const_get(region.upcase)
+
+          @definition_merger.call(
+            region,
+            target_region_module.holidays_by_month,
+            target_region_module.custom_methods,
+          )
+
+          target_region_module.defined_regions
+        rescue  NameError, LoadError => e
+          raise UnknownRegionError.new(e), "Could not load region prefix: #{region.to_s}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Holidays
+  module Definition
+    module Context
+      # Merge a new set of definitions into the Holidays module.
+      class Merger
+        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, 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
+      end
+    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/decorator/test.rb

@@ -0,0 +1,37 @@
+module Holidays
+  module Definition
+    module Decorator
+      class Test
+        def call(t)
+          src = ""
+
+          t.dates.each do |d|
+            date = "Date.civil(#{d.year}, #{d.month}, #{d.day})"
+
+            holiday_call = "Holidays.on(#{date}, #{t.regions}"
+
+            if t.options
+              holiday_call += ", #{decorate_options(t.options)}"
+            end
+
+            if t.holiday?
+              src += "assert_equal \"#{t.name}\", (#{holiday_call})[0] || {})[:name]\n"
+            else
+              src += "assert_nil (#{holiday_call})[0] || {})[:name]\n"
+            end
+          end
+
+          src
+        end
+
+        private
+
+        def decorate_options(options)
+          options.map do |o|
+            o.to_sym
+          end
+        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/entity/test.rb

@@ -0,0 +1,11 @@
+module Holidays
+  module Definition
+    module Entity
+      Test = Struct.new(:dates, :regions, :options, :name, :holiday?) do
+        def initialize(fields = {})
+          super(*fields.values_at(*members))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'holidays/errors'
+
+module Holidays
+  module Definition
+    module Generator
+      class Module
+        def call(module_name, files, regions, month_strings, custom_methods)
+          raise ArgumentError.new("module name cannot be nil") if module_name.nil?
+          raise ArgumentError.new("module name cannot be blank") if module_name.empty?
+
+          raise ArgumentError.new("files cannot be nil") if files.nil?
+          raise ArgumentError.new("files cannot be empty") if files.empty?
+          raise ArgumentError.new("files must all be strings") unless files.all? { |f| f.is_a?(String) }
+
+          raise ArgumentError.new("regions cannot be nil") if regions.nil?
+          raise ArgumentError.new("regions cannot be empty") if regions.empty?
+
+          raise ArgumentError.new("month strings cannot be nil") if month_strings.nil?
+          raise ArgumentError.new("month strings cannot be empty") if month_strings.empty?
+
+          module_src =<<-EOM
+# encoding: utf-8
+module Holidays
+  # This file is generated by the Ruby Holidays gem.
+  #
+  # Definitions loaded: #{files.join(', ')}
+  #
+  # All the definitions are available at https://github.com/holidays/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
+
+    def self.custom_methods
+      {
+          #{custom_methods}
+      }
+    end
+  end
+end
+          EOM
+
+          module_src
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Holidays
+  module Definition
+    module Generator
+      class Regions
+        # The "ca", "mx", and "us" holiday definitions include the "northamericainformal"
+        # holiday definitions, but that does not make these countries subregions of one another.
+        NORTH_AMERICA_REGIONS = %i[ca mx us].freeze
+
+        def call(regions)
+          validate!(regions)
+
+          <<-EOF
+# encoding: utf-8
+module Holidays
+  REGIONS = #{to_array(regions)}
+
+  PARENT_REGION_LOOKUP = #{generate_parent_lookup(regions)}
+end
+EOF
+        end
+
+        private
+
+        def validate!(regions)
+          raise ArgumentError.new("regions cannot be missing") if regions.nil?
+          raise ArgumentError.new("regions must be a hash") unless regions.is_a?(Hash)
+          raise ArgumentError.new("regions cannot be empty") if regions.empty?
+        end
+
+        def to_array(regions)
+          all_regions = []
+
+          regions.each do |region, subregions|
+            all_regions << subregions
+          end
+
+          all_regions.flatten.uniq
+        end
+
+        def generate_parent_lookup(regions)
+          lookup = {}
+
+          regions.each do |region, subregions|
+            subregions.each do |subregion|
+              parent_region = NORTH_AMERICA_REGIONS.include?(subregion) ? subregion : region
+              lookup[subregion] = parent_region unless lookup.has_key?(subregion)
+            end
+          end
+
+          lookup
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'holidays/errors'
+
+module Holidays
+  module Definition
+    module Generator
+      class Test
+        def initialize(decorator)
+          @decorator = decorator
+        end
+
+        def call(module_name, file_names, tests)
+          validate!(module_name, file_names, tests)
+
+          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: #{file_names.join(', ')}
+class #{module_name.to_s.capitalize}DefinitionTests < Test::Unit::TestCase  # :nodoc:
+
+  def test_#{module_name.to_s.downcase}#{decorate(tests)}
+  end
+end
+EndOfTests
+
+        test_src
+        end
+
+        private
+
+        def validate!(module_name, file_names, tests)
+          raise ArgumentError.new("module_name cannot be missing") if module_name.nil? || module_name.empty?
+          raise ArgumentError.new("file_names for '#{module_name}' cannot be missing") if file_names.nil? || file_names.empty?
+          raise ArgumentError.new("tests for '#{module_name}' cannot be missing") if tests.nil?
+        end
+
+        def decorate(tests)
+          out = ""
+
+          tests.each do |t|
+            out << "\n    " + @decorator.call(t)
+          end
+
+          out
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+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["ruby"],
+            })
+          end
+
+          custom_methods
+        end
+
+        private
+
+        def validate!(methods)
+          raise ArgumentError unless methods.all? do |name, pieces|
+            @validator.valid?(
+              {
+                :name => name,
+                :arguments => pieces["arguments"],
+                :source => pieces["ruby"]
+              }
+            )
+          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