revised_holidays 9.0.0

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

@@ -0,0 +1,86 @@
+require 'holidays/definition/entity/test'
+
+module Holidays
+  module Definition
+    module Parser
+      class Test
+        def initialize(validator)
+          @validator = validator
+        end
+
+        def call(tests)
+          return [] if tests.nil?
+
+          validate!(tests)
+
+          tests.map do |t|
+            given = t["given"]
+            expect = t["expect"]
+
+            Entity::Test.new(
+              dates: parse_dates(given["date"]),
+              regions: parse_regions(given["regions"]),
+              options: parse_options(given["options"]),
+              name: expect["name"],
+              holiday?: is_holiday?(expect["holiday"]),
+            )
+          end
+        end
+
+        private
+
+        def validate!(tests)
+          raise ArgumentError unless tests.all? do |t|
+            dates = t["given"]["date"]
+            unless dates.is_a?(Array)
+              dates = [ dates ]
+            end
+
+            @validator.valid?(
+              {
+                :dates => dates,
+                :regions => t["given"]["regions"],
+                :options => t["given"]["options"],
+                :name => t["expect"]["name"],
+                :holiday => t["expect"]["holiday"],
+              }
+            )
+          end
+        end
+
+        def parse_dates(dates)
+          unless dates.is_a?(Array)
+            dates = [ dates ]
+          end
+
+          dates.map do |d|
+            DateTime.parse(d)
+          end
+        end
+
+        def parse_regions(regions)
+          regions.map do |r|
+            r.to_sym
+          end
+        end
+
+        def parse_options(options)
+          if options
+            if options.is_a?(Array)
+              options.map do |o|
+                o.to_sym
+              end
+            else
+              [ options.to_sym ]
+            end
+          end
+        end
+
+        # If flag is not present then default to 'true'
+        def is_holiday?(flag)
+          flag.nil? ? true : !!flag
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Holidays
+  module Definition
+    module Repository
+      class Cache
+        def initialize
+          reset!
+        end
+
+        def cache_between(start_date, end_date, cache_data, options)
+          raise ArgumentError unless cache_data
+          raise ArgumentError unless start_date && end_date
+
+          @cache_range[options] = start_date..end_date
+          @cache[options] = cache_data.group_by { |holiday| holiday[:date] }
+        end
+
+        def find(start_date, end_date, options)
+          return nil unless in_cache_range?(start_date, end_date, options)
+
+          if start_date == end_date
+            @cache[options].fetch(start_date, [])
+          else
+            @cache[options].select do |date, holidays|
+              date >= start_date && date <= end_date
+            end.flat_map { |date, holidays| holidays }
+          end
+        end
+
+        def reset!
+          @cache = {}
+          @cache_range = {}
+        end
+
+        private
+
+        def in_cache_range?(start_date, end_date, options)
+          range = @cache_range[options]
+          if range
+            range.begin <= start_date && range.end >= end_date
+          else
+            false
+          end
+        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

@@ -0,0 +1,57 @@
+module Holidays
+  module Definition
+    module Repository
+      class HolidaysByMonth
+        def initialize
+          @holidays_by_month = {}
+        end
+
+        def all
+          @holidays_by_month
+        end
+
+        def find_by_month(month)
+          raise ArgumentError unless month >= 0 && month <= 12
+          @holidays_by_month[month]
+        end
+
+        def add(new_holidays)
+          new_holidays.each do |month, holiday_defs|
+            @holidays_by_month[month] = [] unless @holidays_by_month[month]
+
+            holiday_defs.each do |holiday_def|
+              exists = false
+              @holidays_by_month[month].each do |existing_def|
+                if definition_exists?(existing_def, holiday_def)
+                  # append regions
+                  existing_def[:regions] << holiday_def[:regions]
+
+                  # Should do this once we're done
+                  existing_def[:regions].flatten!
+                  existing_def[:regions].uniq!
+                  exists = true
+                end
+              end
+
+              @holidays_by_month[month] << holiday_def unless exists
+            end
+          end
+        end
+
+        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] == target_def[:function] &&
+          existing_def[:function_modifier] == target_def[:function_modifier] &&
+          existing_def[:type] == target_def[:type] &&
+          existing_def[:observed] == target_def[:observed] &&
+          existing_def[:year_ranges] == target_def[:year_ranges]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Holidays
+  module Definition
+    module Repository
+      # ==== Benchmarks
+      #
+      # Lookup Easter Sunday, with caching, by number of iterations:
+      #
+      #       user     system      total        real
+      # 0001  0.000000   0.000000   0.000000 (  0.000000)
+      # 0010  0.000000   0.000000   0.000000 (  0.000000)
+      # 0100  0.078000   0.000000   0.078000 (  0.078000)
+      # 1000  0.641000   0.000000   0.641000 (  0.641000)
+      # 5000  3.172000   0.015000   3.187000 (  3.219000)
+      #
+      # Lookup Easter Sunday, without caching, by number of iterations:
+      #
+      #       user     system      total        real
+      # 0001  0.000000   0.000000   0.000000 (  0.000000)
+      # 0010  0.016000   0.000000   0.016000 (  0.016000)
+      # 0100  0.125000   0.000000   0.125000 (  0.125000)
+      # 1000  1.234000   0.000000   1.234000 (  1.234000)
+      # 5000  6.094000   0.031000   6.125000 (  6.141000)
+      class ProcResultCache
+        def initialize
+          @proc_cache = {}
+        end
+
+        def lookup(function, *function_arguments)
+          validate!(function, function_arguments)
+
+          proc_key = build_proc_key(function, function_arguments)
+          @proc_cache[proc_key] = function.call(*function_arguments) unless @proc_cache[proc_key]
+          @proc_cache[proc_key]
+        end
+
+        private
+
+        def validate!(function, function_arguments)
+          raise ArgumentError.new("function must be a proc") unless function.is_a?(Proc)
+          function_arguments.each do |arg|
+            raise ArgumentError.new("function arguments '#{function_arguments}' must contain either integers or dates") unless arg.is_a?(Integer) || arg.is_a?(Date) || arg.is_a?(Symbol)
+          end
+        end
+
+        def build_proc_key(function, function_arguments)
+          Digest::MD5.hexdigest("#{function.to_s}_#{function_arguments.join('_')}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Holidays
+  module Definition
+    module Repository
+      class Regions
+        def initialize(all_generated_regions, parent_region_lookup)
+          @loaded_regions = []
+          @all_generated_regions = all_generated_regions
+          @parent_region_lookup = parent_region_lookup
+        end
+
+        def all_generated
+          @all_generated_regions
+        end
+
+        def parent_region_lookup(r)
+          @parent_region_lookup[r]
+        end
+
+        def all_loaded
+          @loaded_regions
+        end
+
+        def loaded?(region)
+          raise ArgumentError unless region.is_a?(Symbol)
+          @loaded_regions.include?(region)
+        end
+
+        def add(regions)
+          regions = [regions] unless regions.is_a?(Array)
+
+          regions.each do |region|
+            raise ArgumentError unless region.is_a?(Symbol)
+          end
+
+          @loaded_regions = @loaded_regions | regions
+          @loaded_regions.uniq!
+        end
+
+        def search(prefix)
+          raise ArgumentError unless prefix.is_a?(Symbol)
+          @loaded_regions.select { |region| region.to_s =~ Regexp.new("^#{prefix}") }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Holidays
+  module Definition
+    module Validator
+      class CustomMethod
+        VALID_ARGUMENTS = ["date", "year", "month", "day", "region"]
+
+        def valid?(m)
+          valid_name?(m[:name]) &&
+            valid_arguments?(m[:arguments]) &&
+            valid_source?(m[:source])
+        end
+
+        private
+
+        def valid_name?(name)
+          !name.nil? && !name.empty?
+        end
+
+        def valid_arguments?(arguments)
+          arguments.split(",").all? { |arg|
+            arg == arg.chomp && VALID_ARGUMENTS.include?(arg.strip)
+          }
+        end
+
+        def valid_source?(source)
+          !source.nil? && !source.empty?
+        end
+      end
+    end
+  end
+end

data/lib/holidays/definition/validator/region.rb

@@ -0,0 +1,36 @@
+module Holidays
+  module Definition
+    module Validator
+      class Region
+        def initialize(regions_repo)
+          @regions_repo = regions_repo
+        end
+
+        def valid?(r)
+          return false unless r.is_a?(Symbol)
+
+          region = find_wildcard_base(r)
+
+          (region == :any ||
+           @regions_repo.loaded?(region) ||
+           @regions_repo.all_generated.include?(region))
+        end
+
+        private
+
+        # Ex: :gb_ transformed to :gb
+        def find_wildcard_base(region)
+          r = region.to_s
+
+          if r =~ /_$/
+            base = r.split('_').first
+          else
+            base = r
+          end
+
+          base.to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Holidays
+  module Definition
+    module Validator
+      class Test
+        def valid?(t)
+          valid_dates?(t[:dates]) &&
+            valid_regions?(t[:regions]) &&
+            valid_name?(t[:name]) &&
+            valid_holiday?(t[:holiday]) &&
+            valid_options?(t[:options]) &&
+            required_fields?(t)
+        end
+
+        private
+
+        def valid_dates?(dates)
+          return false unless dates
+
+          dates.all? do |d|
+            begin
+              DateTime.parse(d)
+              true
+            rescue TypeError, ArgumentError
+              false
+            end
+          end
+        end
+
+        def valid_regions?(regions)
+          return false unless regions
+
+          regions.all? do |r|
+            r.is_a?(String)
+          end
+        end
+
+        # Can be missing
+        def valid_name?(n)
+          return true unless n
+          n.is_a?(String)
+        end
+
+        # Can be missing
+        def valid_holiday?(h)
+          return true unless h
+          h.is_a?(TrueClass)
+        end
+
+        # Okay to be missing and can be either string or array of strings
+        def valid_options?(options)
+          return true unless options
+
+          if options.is_a?(Array)
+            options.all? do |o|
+              o.is_a?(String)
+            end
+          elsif options.is_a?(String)
+            true
+          else
+            false
+          end
+        end
+
+        def required_fields?(t)
+          return false if t[:name].nil? && t[:holiday].nil?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/holidays/errors.rb

@@ -0,0 +1,11 @@
+module Holidays
+  class Error < StandardError; end
+
+  class FunctionNotFound < Error; end
+  class InvalidFunctionResponse < Error; end
+
+  class UnknownRegionError < Error ; end
+  class InvalidRegion < Error; end
+
+  class DefinitionTestError < Error; end
+end

data/lib/holidays/factory/date_calculator.rb

@@ -0,0 +1,42 @@
+require 'holidays/date_calculator/easter'
+require 'holidays/date_calculator/weekend_modifier'
+require 'holidays/date_calculator/day_of_month'
+require 'holidays/date_calculator/lunar_date'
+
+module Holidays
+  module Factory
+    module DateCalculator
+      module Easter
+        module Gregorian
+          class << self
+            def easter_calculator
+              Holidays::DateCalculator::Easter::Gregorian.new
+            end
+          end
+        end
+
+        module Julian
+          class << self
+            def easter_calculator
+              Holidays::DateCalculator::Easter::Julian.new
+            end
+          end
+        end
+      end
+
+      class << self
+        def lunar_date 
+          Holidays::DateCalculator::LunarDate.new
+        end
+
+        def weekend_modifier
+          Holidays::DateCalculator::WeekendModifier.new
+        end
+
+        def day_of_month_calculator
+          Holidays::DateCalculator::DayOfMonth.new
+        end
+      end
+    end
+  end
+end

data/lib/holidays/factory/definition.rb

@@ -0,0 +1,143 @@
+require 'holidays/definition/context/generator'
+require 'holidays/definition/context/merger'
+require 'holidays/definition/context/function_processor'
+require 'holidays/definition/context/load'
+require 'holidays/definition/decorator/custom_method_proc'
+require 'holidays/definition/decorator/custom_method_source'
+require 'holidays/definition/decorator/test'
+require 'holidays/definition/generator/module'
+require 'holidays/definition/generator/regions'
+require 'holidays/definition/generator/test'
+require 'holidays/definition/parser/custom_method'
+require 'holidays/definition/parser/test'
+require 'holidays/definition/repository/holidays_by_month'
+require 'holidays/definition/repository/regions'
+require 'holidays/definition/repository/cache'
+require 'holidays/definition/repository/proc_result_cache'
+require 'holidays/definition/repository/custom_methods'
+require 'holidays/definition/validator/custom_method'
+require 'holidays/definition/validator/region'
+require 'holidays/definition/validator/test'
+
+module Holidays
+  module Factory
+    module Definition
+      class << self
+        def file_parser
+          Holidays::Definition::Context::Generator.new(
+            custom_method_parser,
+            custom_method_source_decorator,
+            custom_methods_repository,
+            test_parser,
+            test_generator,
+            module_generator,
+          )
+        end
+
+        def source_generator
+          Holidays::Definition::Context::Generator.new(
+            custom_method_parser,
+            custom_method_source_decorator,
+            custom_methods_repository,
+            test_parser,
+            test_generator,
+            module_generator,
+          )
+        end
+
+        def function_processor
+          Holidays::Definition::Context::FunctionProcessor.new(
+            custom_methods_repository,
+            proc_result_cache_repository,
+          )
+        end
+
+        def merger
+          Holidays::Definition::Context::Merger.new(
+            holidays_by_month_repository,
+            regions_repository,
+            custom_methods_repository,
+          )
+        end
+
+        def custom_method_parser
+          Holidays::Definition::Parser::CustomMethod.new(
+            custom_method_validator,
+          )
+        end
+
+        def custom_method_proc_decorator
+          Holidays::Definition::Decorator::CustomMethodProc.new
+        end
+
+        def custom_method_source_decorator
+          Holidays::Definition::Decorator::CustomMethodSource.new
+        end
+
+        def region_validator
+          Holidays::Definition::Validator::Region.new(
+            regions_repository
+          )
+        end
+
+        def custom_method_validator
+          Holidays::Definition::Validator::CustomMethod.new
+        end
+
+        def holidays_by_month_repository
+          @holidays_repo ||= Holidays::Definition::Repository::HolidaysByMonth.new
+        end
+
+        def regions_repository
+          @regions_repo ||= Holidays::Definition::Repository::Regions.new(
+            Holidays::REGIONS,
+            Holidays::PARENT_REGION_LOOKUP,
+          )
+        end
+
+        def cache_repository
+          @cache_repo ||= Holidays::Definition::Repository::Cache.new
+        end
+
+        def proc_result_cache_repository
+          @proc_result_cache_repo ||= Holidays::Definition::Repository::ProcResultCache.new
+        end
+
+        def custom_methods_repository
+          @custom_methods_repository ||= Holidays::Definition::Repository::CustomMethods.new
+        end
+
+        def regions_generator
+          Holidays::Definition::Generator::Regions.new
+        end
+
+        def loader
+          Holidays::Definition::Context::Load.new(
+            merger,
+            Holidays::FULL_DEFINITIONS_PATH,
+          )
+        end
+
+        def module_generator
+          Holidays::Definition::Generator::Module.new
+        end
+
+        def test_generator
+          Holidays::Definition::Generator::Test.new(
+            test_decorator,
+          )
+        end
+
+        def test_decorator
+          Holidays::Definition::Decorator::Test.new
+        end
+
+        def test_parser
+          Holidays::Definition::Parser::Test.new(
+            Holidays::Definition::Validator::Test.new,
+          )
+        end
+      end
+    end
+  end
+end