RubyGems - opening_hours_converter - Versions diffs - 1.8.1 → 1.9.0 - Mend

opening_hours_converter 1.8.1 → 1.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

checksums.yaml +4 -4
data/lib/opening_hours_converter.rb +6 -0
data/lib/opening_hours_converter/iterator.rb +3 -14
data/lib/opening_hours_converter/opening_hours_builder.rb +82 -21
data/lib/opening_hours_converter/opening_hours_date.rb +1 -1
data/lib/opening_hours_converter/opening_hours_parser.rb +185 -30
data/lib/opening_hours_converter/opening_hours_rule.rb +67 -38
data/lib/opening_hours_converter/wide_interval.rb +158 -9
data/lib/opening_hours_converter/year.rb +53 -1
metadata +3 -4

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8182729b4890b6c79b8173b5ed0722da103a4f82820ff62119d63f2d0ca2de72
-  data.tar.gz: bbbab689b9eddebb5dd17e715a15c940dd62cd0fa58b06b860c1234544c2bdf7
+  metadata.gz: 0421f6038fb3bcaae15b1e29d5a4bb90b08d829e4bd68d2d4c3501307fa8b8c7
+  data.tar.gz: '059ed79dab312bfa859028e9ec420ff99ae0e718a8723b98e61622fea8f85ae6'
 SHA512:
-  metadata.gz: 241b74370dd846929cccb2fdde19960689d05ce6a7a31c863ea331b6450ce57ba0a88042abb2ecbc588cf38229356e82f43a3d16496513311445aa2787ff40e9
-  data.tar.gz: 528266324133acf97320be51b0f8f4f2b3e99907e2ff3a0c620b5d7e41cfa3339bb7d00bfeb3d915111fbfaa7a966100f20ee723f56ada32d0adf40572d67f0b
+  metadata.gz: 9319c1fc314fe58bbad62abf9e59c3525069f7324189dda6f938dad328869cd6a5b63ba65ab6965b3e3286e8bce782777d4be88bbac541a87daba0568071e0cb
+  data.tar.gz: 26304defc99f58cceab36cf8bf0ae773651c2ab641b490601d1ff8b60446441af3c52234016e2a19ea73e1648ae05f014087eef9a8dcf5ce8ab1b16dcb5eea22

data/lib/opening_hours_converter.rb CHANGED

@@ -1,6 +1,11 @@
 module OpeningHoursConverter
   require 'date'
+  require 'pry'
+  require_relative './opening_hours_converter/utils'
   require_relative './opening_hours_converter/date_range'
+  require_relative './opening_hours_converter/token'
+  require_relative './opening_hours_converter/tokenizer'
+  require_relative './opening_hours_converter/tokens_handler'
   require_relative './opening_hours_converter/day'
   require_relative './opening_hours_converter/week'
   require_relative './opening_hours_converter/year'
@@ -13,4 +18,5 @@ module OpeningHoursConverter
   require_relative './opening_hours_converter/opening_hours_rule'
   require_relative './opening_hours_converter/opening_hours_time'
   require_relative './opening_hours_converter/wide_interval'
+  require_relative './opening_hours_converter/week_index'
 end

data/lib/opening_hours_converter/iterator.rb CHANGED

@@ -3,6 +3,7 @@ require 'opening_hours_converter/constants'
 module OpeningHoursConverter
   class Iterator
     include Constants
+    include Utils
     def get_iterator(date_ranges)
       date_ranges_array = []
@@ -78,7 +79,7 @@ module OpeningHoursConverter
             end
             date_ranges[index].typical.intervals.each do |i|
               next unless !i.nil? && !i.is_off
-              next unless (i.day_start..i.day_end).cover?(fix_datetime_wday(day.wday)) || (is_ph && year_ph.include?(Time.new(day.year, day.month, day.day)))
+              next unless (i.day_start..i.day_end).cover?(reindex_sunday_week_to_monday_week(day.wday)) || (is_ph && year_ph.include?(Time.new(day.year, day.month, day.day)))
               itr = { start: Time.new(day.year, day.month, day.day, i.start / 60, i.start % 60),
                       end: Time.new(day.year, day.month, day.day, i.end / 60, i.end % 60) }
               datetime_result << itr unless datetime_result.include?(itr)
@@ -98,7 +99,7 @@ module OpeningHoursConverter
         result.each do |interval|
           (interval[:start]..interval[:end]).each do |day|
             date_ranges[index].typical.intervals.each do |i|
-              if (i.day_start..i.day_end).cover?(fix_datetime_wday(day.wday))
+              if (i.day_start..i.day_end).cover?(reindex_sunday_week_to_monday_week(day.wday))
                 datetime_result << { start: DateTime.new(day.year, day.month, day.day, i.start / 60, i.start % 60),
                                      end: DateTime.new(day.year, day.month, day.day, i.end / 60, i.end % 60) }
               end
@@ -110,10 +111,6 @@ module OpeningHoursConverter
       datetime_result.sort_by { |a| a[:start] }
     end
-    def fix_datetime_wday(d)
-      d == 0 ? 6 : d - 1
-    end
     # A partir d'une string OH et d'une DateTime (= now par défaut), renvoyer le current state (début / fin / commentaire)
     def state(opening_hours_string, time = Time.now)
       date_ranges = OpeningHoursConverter::OpeningHoursParser.new.parse(opening_hours_string)
@@ -154,13 +151,5 @@ module OpeningHoursConverter
       end
       false
     end
-    def datetime_to_time(datetime)
-      Time.new(datetime.year, datetime.month, datetime.day, datetime.hour, datetime.min, datetime.sec, datetime.zone)
-    end
-    def time_to_datetime(time)
-      DateTime.new(time.year, time.month, time.day, time.hour, time.min, time.sec, Rational(time.gmt_offset / 3600, 24))
-    end
   end
 end

data/lib/opening_hours_converter/opening_hours_builder.rb CHANGED

@@ -10,21 +10,25 @@ module OpeningHoursConverter
       oh_rule_added = nil
       range_general = nil
       range_general_for = nil
-      day_ph = false
-      off_day_ph = false
       date_ranges.each_with_index do |date_range, date_range_index|
         next unless !date_range.nil?
-        if date_range.typical.intervals.length != 1
-          date_range.typical.intervals.each_with_index do |interval, interval_id|
-            next unless interval&.day_start == -2 && interval&.day_start == interval&.day_end
-            if interval.is_off
-              off_day_ph = true
-            else
-              day_ph = true
-            end
-            date_range.typical.remove_interval(interval_id)
+        day_ph = false
+        off_day_ph = false
+        phs = []
+        date_range.typical.intervals.each_with_index do |interval, interval_id|
+          next unless interval&.day_start == -2 && interval&.day_start == interval&.day_end
+          if interval.is_off
+            off_day_ph = true
+          else
+            day_ph = true
           end
+          phs << interval
+          date_range.typical.remove_interval(interval_id)
         end
         range_general = nil
@@ -44,9 +48,7 @@ module OpeningHoursConverter
         end
         next unless date_range_index == 0 || range_general.nil?
-        if date_range.typical&.intervals&.length == 1 && date_range.typical&.intervals[0].day_start == -2 && date_range.typical&.intervals[0].day_end == -2
-          oh_rules = build_holiday(date_range)
-        elsif date_range.defines_typical_week?
+        if date_range.defines_typical_week?
           oh_rules = if !range_general_for.nil?
                        build_week_diff(date_range, date_ranges[range_general_for])
                      else
@@ -72,7 +74,6 @@ module OpeningHoursConverter
                 end
                 oh_rule_added = true
               rescue Exception => e
-                puts e
                 if oh_rule.date[0].wide_interval.type == 'holiday' && oh_rule.date[0].wide_interval.get_time_selector == 'PH'
                   rules[rule_index].add_ph_weekday
                   oh_rule_added = true
@@ -89,12 +90,38 @@ module OpeningHoursConverter
             end
           end
-          oh_rule.add_ph_weekday if day_ph
+          if off_day_ph || day_ph
+            if date_range.typical.intervals.uniq == [nil]
+              oh_rule.date.first.weekdays = [-2]
+              if off_day_ph
+                oh_rule.is_defined_off = off_day_ph
+                phs = []
+              else
+                phs.reverse.each do |interval|
+                  oh_rule.add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, interval.end))
+                end
+              end
+            else
+              if times_are_compatible?(oh_rule, phs)
+                holiday_intervals = get_compatible_intervals(oh_rule, phs)
+                oh_rule.add_ph_weekday if holiday_intervals[:compatible].length > 0
+                rules << oh_rule if !oh_rule_added
+                oh_rule_added = true
+                holiday_intervals[:incompatible].each do |interval|
+                  rules += build_off_holiday(date_range) if off_day_ph
+                  rules += build_holiday(date_range) if day_ph
+                end
+              else
+                rules << oh_rule if !oh_rule_added
+                oh_rule_added = true
+                rules += build_off_holiday(date_range) if off_day_ph
+                rules += build_holiday(date_range) if day_ph
+              end
+            end
+          end
           rules << oh_rule if !oh_rule_added
-          rules += build_off_holiday(date_range) if off_day_ph
           next unless oh_rule == oh_rules.last && oh_rule.has_overwritten_weekday?
           oh_rule_over = OpeningHoursConverter::OpeningHoursRule.new
@@ -118,6 +145,34 @@ module OpeningHoursConverter
       result.strip
     end
+    def times_are_compatible?(oh_rule, phs)
+      if oh_rule.is_defined_off
+        phs.any?(&:is_off)
+      else
+        phs.any? do |ph_interval|
+          oh_rule.time.any? do |rule_time|
+            rule_time.start == ph_interval.start && rule_time.end == ph_interval.end
+          end
+        end
+      end
+    end
+    def get_compatible_intervals(oh_rule, phs)
+      compatibility = {
+        compatible: [],
+        incompatible: []
+      }
+      compatibility[:compatible] = phs.select do |ph_interval|
+        return false if ph_interval.is_off != oh_rule.is_defined_off
+        oh_rule.time.any? { |rule_time| rule_time.start == ph_interval.start && rule_time.end == ph_interval.end }
+      end
+      compatibility[:incompatible] = phs - compatibility[:compatible]
+      compatibility
+    end
     def build_off_holiday(date_range)
       start_year = date_range.wide_interval.start&.key?(:year) ? date_range.wide_interval.start[:year] : date_range.wide_interval.start
       end_year = date_range.wide_interval.end&.key?(:year) ? date_range.wide_interval.end[:year] : date_range.wide_interval.end
@@ -135,9 +190,15 @@ module OpeningHoursConverter
     def build_holiday(date_range)
       start_year = date_range.wide_interval.start&.key?(:year) ? date_range.wide_interval.start[:year] : date_range.wide_interval.start
       end_year = date_range.wide_interval.end&.key?(:year) ? date_range.wide_interval.end[:year] : date_range.wide_interval.end
       intervals = date_range.typical.get_intervals(true)
-      date_range = OpeningHoursConverter::DateRange.new(OpeningHoursConverter::WideInterval.new.holiday('PH', start_year, end_year))
+      if date_range.wide_interval.type == 'week'
+        intervals.each do |interval|
+          date_range.typical.add_interval(OpeningHoursConverter::Interval.new(-2, interval.start, -2, interval.end, interval.is_off))
+        end
+      else
+        date_range = OpeningHoursConverter::DateRange.new(OpeningHoursConverter::WideInterval.new.holiday('PH', start_year, end_year))
+      end
       for i in 0..6
         intervals.each do |interval|
@@ -156,7 +217,6 @@ module OpeningHoursConverter
           rule.is_defined_off = rule.is_defined_off || interval.is_off
         end
       end
       [rule]
     end
@@ -327,6 +387,7 @@ module OpeningHoursConverter
     def create_time_intervals(wide_interval, intervals)
       days = []
       for i in 0...7
         days << OpeningHoursConverter::OpeningHoursRule.new
         days[i].add_date(OpeningHoursConverter::OpeningHoursDate.new(wide_interval, [i]))

data/lib/opening_hours_converter/opening_hours_date.rb CHANGED

@@ -109,7 +109,7 @@ module OpeningHoursConverter
     end
     def add_overwritten_weekday(weekday)
-      return if @weekdays_over.include?(weekday) && @weekdays_over.include?(weekday)
+      return if @weekdays_over.include?(weekday)
       @weekdays_over << weekday
       @weekdays_over.sort!

data/lib/opening_hours_converter/opening_hours_parser.rb CHANGED

@@ -1,23 +1,31 @@
 require 'opening_hours_converter/constants'
+require 'opening_hours_converter/utils'
 require 'json'
 module OpeningHoursConverter
   class OpeningHoursParser
     include Constants
+    include Utils
     def initialize
       @RGX_RULE_MODIFIER = /^(open|closed|off)$/i
       @RGX_WEEK_KEY = /^week$/
-      @RGX_WEEK_VAL = /^([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123]))?(,([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123]))?)*\:?$/
+      @RGX_WEEK = /^week ([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123]))?(, ?([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123]))?)*$/
+      @RGX_WEEK_VAL = /^([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123]))?(, ?([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123]))?)*$/
+      @RGX_WEEK_WITH_MODIFIER = /^week ([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123])(\/[1-9])?)?(, ?([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123])(\/[1-9])?)?)*$/
+      @RGX_WEEK_VAL_WITH_MODIFIER = /^([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123])(\/[1-9])?)?(, ?([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123])(\/[1-9])?)?)*$/
       @RGX_MONTH = /^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)(\-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec))?\:?$/
       @RGX_MONTHDAY = /^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ([012]?[0-9]|3[01])(\-((Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) )?([012]?[0-9]|3[01]))?\:?$/
       @RGX_TIME = /^((([01]?[0-9]|2[01234])\:[012345][0-9](\-([01]?[0-9]|2[01234])\:[012345][0-9])?(,([01]?[0-9]|2[01234])\:[012345][0-9](\-([01]?[0-9]|2[01234])\:[012345][0-9])?)*)|(24\/7))$/
       @RGX_WEEKDAY = /^(((Mo|Tu|We|Th|Fr|Sa|Su)(\-(Mo|Tu|We|Th|Fr|Sa|Su))?)|(PH))(,(((Mo|Tu|We|Th|Fr|Sa|Su)(\-(Mo|Tu|We|Th|Fr|Sa|Su))?)|(PH)))*$/
       @RGX_HOLIDAY = /^(PH|SH|easter)$/
       @RGX_WD = /^(Mo|Tu|We|Th|Fr|Sa|Su)(\-(Mo|Tu|We|Th|Fr|Sa|Su))?$/
+      @RGX_WD_WITH_MODIFIER = /^(Mo|Tu|We|Th|Fr|Sa|Su)\[([1-5]|\-1)\]$/
       @RGX_DAY = /^([012]?[0-9]|3[01])(\-[012]?[0-9]|3[01])?$/
       @RGX_YEAR = /^(\d{4})(\-(\d{4}))?$/
       @RGX_YEAR_PH = /^(\d{4})( PH|(\-(\d{4}) PH))\:?$/
+      @RGX_YEAR_WEEK = /^(\d{4})(\-(\d{4}))? week ([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123]))?(, ?([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123]))?)*\:?$/
+      @RGX_YEAR_WEEK_WITH_MODIFIER = /^(\d{4})(\-(\d{4}))? week ([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123])(\/[1-9])?)?(, ?([01234]?[0-9]|5[0123])(\-([01234]?[0-9]|5[0123])(\/[1-9])?)?)*$/
       @RGX_YEAR_MONTH_DAY = /^(\d{4}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ([012]?[0-9]|3[01])(\-((\d{4}) )?((Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) )?([012]?[0-9]|3[01]))?\:?$/
       @RGX_YEAR_MONTH = /^(\d{4}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)(\-((\d{4}) )?((Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)))?\:?$/
       @RGX_COMMENT = /^\"[^\"]*\"$/
@@ -45,7 +53,9 @@ module OpeningHoursConverter
         block.strip!
         next if block.empty?
-        tokens = tokenize(block)
+        tokenizer = OpeningHoursConverter::Tokenizer.new(block)
+        tokens = tokenizer.tokens
+        # tokens = tokenize(block)
         @current_token = tokens.length - 1
         weekdays = {}
@@ -66,9 +76,9 @@ module OpeningHoursConverter
               weekday_selector = tokens[@current_token]
               weekdays_and_holidays = get_weekdays(weekday_selector)
             rescue StandardError
-              weekdays[[{ from: 0, to: 6 }]] ||= {}
-              weekdays[[{ from: 0, to: 6 }]][:modifiers] ||= []
-              weekdays[[{ from: 0, to: 6 }]][:modifiers] << local_modifier
+              weekdays[[{ from: 0, to: 6, index: nil }]] ||= {}
+              weekdays[[{ from: 0, to: 6, index: nil }]][:modifiers] ||= []
+              weekdays[[{ from: 0, to: 6, index: nil }]][:modifiers] << local_modifier
             else
               weekdays[weekdays_and_holidays] ||= {}
               weekdays[weekdays_and_holidays][:modifiers] ||= []
@@ -86,9 +96,9 @@ module OpeningHoursConverter
               weekday_selector = tokens[@current_token]
               weekdays_and_holidays = get_weekdays(weekday_selector)
             rescue StandardError
-              weekdays[[{ from: 0, to: 6 }]] ||= {}
-              weekdays[[{ from: 0, to: 6 }]][:times] ||= []
-              weekdays[[{ from: 0, to: 6 }]][:times].concat(local_times)
+              weekdays[[{ from: 0, to: 6, index: nil }]] ||= {}
+              weekdays[[{ from: 0, to: 6, index: nil }]][:times] ||= []
+              weekdays[[{ from: 0, to: 6, index: nil }]][:times].concat(local_times)
             else
               weekdays[weekdays_and_holidays] ||= {}
               weekdays[weekdays_and_holidays][:times] ||= []
@@ -98,6 +108,7 @@ module OpeningHoursConverter
           end
         end
+        weeks = []
         months = []
         years = []
         holidays = []
@@ -108,21 +119,27 @@ module OpeningHoursConverter
           end
           if !wide_range_selector.empty?
             wide_range_selector = wide_range_selector.strip
-            wide_range_selector = wide_range_selector.split(',')
-            wide_range_selector.each do |wrs|
-              if !(@RGX_YEAR_MONTH_DAY =~ wrs).nil?
-                years << get_year_month_day(wrs)
-              elsif !(@RGX_YEAR_MONTH =~ wrs).nil?
-                years << get_year_month(wrs)
-              elsif !(@RGX_MONTHDAY =~ wrs).nil?
-                months << get_month_day(wrs)
-              elsif !(@RGX_MONTH =~ wrs).nil?
-                months << get_month(wrs)
-              elsif !(@RGX_YEAR =~ wrs).nil?
-                years << get_year(wrs)
-              else
-                raise ArgumentError, "Unsupported selector #{wrs}"
-              end
+            # wide_range_selector = wide_range_selector.split(',')
+            if !(@RGX_YEAR_MONTH_DAY =~ wide_range_selector).nil?
+              years << get_year_month_day(wide_range_selector)
+            elsif !(@RGX_YEAR_MONTH =~ wide_range_selector).nil?
+              years << get_year_month(wide_range_selector)
+            elsif !(@RGX_MONTHDAY =~ wide_range_selector).nil?
+              months << get_month_day(wide_range_selector)
+            elsif !(@RGX_MONTH =~ wide_range_selector).nil?
+              months << get_month(wide_range_selector)
+            elsif !(@RGX_YEAR =~ wide_range_selector).nil?
+              years << get_year(wide_range_selector)
+            elsif !(@RGX_YEAR_WEEK_WITH_MODIFIER =~ wide_range_selector).nil?
+              weeks << get_year_week_with_modifier(wide_range_selector)
+            elsif !(@RGX_YEAR_WEEK =~ wide_range_selector).nil?
+              weeks << get_year_week(wide_range_selector)
+            elsif !(@RGX_WEEK_WITH_MODIFIER =~ wide_range_selector).nil?
+              weeks << get_week_with_modifier(wide_range_selector)
+            elsif !(@RGX_WEEK =~ wide_range_selector).nil?
+              weeks << get_week(wide_range_selector)
+            else
+              raise ArgumentError, "Unsupported selector #{wide_range_selector}"
             end
           end
         end
@@ -130,6 +147,7 @@ module OpeningHoursConverter
         raise ArgumentError, 'Unreadable string' if @current_token == tokens.length - 1
         # puts "weekdays : #{weekdays}"
+        # puts "weeks : #{weeks}"
         # puts "months : #{months}"
         # puts "years : #{years}"
@@ -152,6 +170,12 @@ module OpeningHoursConverter
             end
             date_ranges << date_range
           end
+        elsif !weeks.empty?
+          weeks.each do |week|
+            date_ranges << OpeningHoursConverter::WideInterval.new.week(week[:week_indexes], week[:year_from], week[:year_to])
+          end
         elsif !years.empty?
           years.each do |year|
             if !year[:from_day].nil?
@@ -182,8 +206,8 @@ module OpeningHoursConverter
         end
         if weekdays.empty?
-          weekdays[[{ from: 0, to: 6 }]] = {}
-          weekdays[[{ from: 0, to: 6 }]][:times] = [{ from: 0, to: 24 * 60 }]
+          weekdays[[{ from: 0, to: 6, index: nil }]] = {}
+          weekdays[[{ from: 0, to: 6, index: nil }]][:times] = [{ from: 0, to: 24 * 60 }]
         end
         date_ranges.each do |dr|
@@ -280,7 +304,14 @@ module OpeningHoursConverter
           if end_interval.day == start_interval.day + 1 && end_interval.hour == 0 && end_interval.min == 0
             end_interval -= (1 / 1440.0)
           end
-          date_range.last.typical.add_interval(OpeningHoursConverter::Interval.new(((start_interval.wday + 6) % 7), (start_interval.hour * 60 + start_interval.min), ((end_interval.wday + 6) % 7), (end_interval.hour * 60 + end_interval.min)))
+          date_range.last.typical.add_interval(
+            OpeningHoursConverter::Interval.new(
+              reindex_sunday_week_to_monday_week(start_interval.wday),
+              (start_interval.hour * 60 + start_interval.min),
+              reindex_sunday_week_to_monday_week(end_interval.wday),
+              (end_interval.hour * 60 + end_interval.min)
+            )
+          )
         end
       end
       date_range
@@ -300,6 +331,86 @@ module OpeningHoursConverter
       { from: year_from, to: year_to }
     end
+    def get_year_week_with_modifier(wrs)
+      year, weeks = wrs.split(' week ')
+      years = year.split('-')
+      indexes = weeks.split(',').map { |week_index|
+        if week_index.include?('-')
+          if week_index.include?('/')
+            from, to = week_index.split('-')
+            to, modifier = to.split('/')
+            { from: from.to_i, to: to.to_i, modifier: modifier.to_i }
+          else
+            from, to = week_index.split('-').map(&:to_i)
+            { from: from, to: to }
+          end
+        else
+          week_index.to_i
+        end
+      }
+      { year_from: years[0].to_i, week_indexes: indexes }.tap do |hsh|
+        hsh[:year_to] = years.length > 1 ? years[1].to_i : nil
+      end
+    end
+    def get_year_week(wrs)
+      year, weeks = wrs.split(' week ')
+      # does not handle 2018,2019
+      years = year.split('-')
+      # does not handle week 1,2,3
+      indexes = weeks.split(',').map { |week_index|
+        if week_index.include?('-')
+          from, to = week_index.split('-').map(&:to_i)
+          { from: from, to: to }
+        else
+          week_index.to_i
+        end
+      }
+      { week_indexes: indexes, year_from: year[0].to_i }.tap do |hsh|
+        hsh[:year_to] = years.length > 1 ? year[1].to_i : nil
+      end
+    end
+    def get_week_with_modifier(wrs)
+      weeks = wrs.gsub('week ', '').split(',')
+      indexes = weeks.map { |week_index|
+        if week_index.include?('-')
+          if week_index.include?('/')
+            from, to = week_index.split('-')
+            to, modifier = to.split('/')
+            { from: from.to_i, to: to.to_i, modifier: modifier.to_i }
+          else
+            from, to = week_index.split('-').map(&:to_i)
+            { from: from, to: to }
+          end
+        else
+          week_index.to_i
+        end
+      }
+      { week_indexes: indexes }
+    end
+    def get_week(wrs)
+      weeks = wrs.gsub('week ', '').split(',')
+      indexes = weeks.map { |week_index|
+        if week_index.include?('-')
+          from, to = week_index.split('-').map(&:to_i)
+          { from: from, to: to }
+        else
+          week_index.to_i
+        end
+      }
+      { week_indexes: indexes }
+    end
     def get_month(wrs)
       single_month = wrs.gsub(/\:$/, '').split('-')
       month_from = OSM_MONTHS.find_index(single_month[0]) + 1
@@ -429,9 +540,10 @@ module OpeningHoursConverter
       wd_to = nil
       weekday_selector = weekday_selector.split(',')
       weekday_selector.each do |wd|
         if !(@RGX_HOLIDAY =~ wd).nil?
-          weekdays << { from: -2, to: -2 }
+          weekdays << { from: -2, to: -2, index: nil }
         elsif !(@RGX_WD =~ wd).nil?
           single_weekday = wd.split('-')
@@ -442,7 +554,16 @@ module OpeningHoursConverter
                     wd_from
                   end
-          weekdays << { from: wd_from, to: wd_to }
+          weekdays << { from: wd_from, to: wd_to, index: nil }
+        elsif !(@RGX_WD_WITH_MODIFIER =~ wd).nil?
+          from, to = wd[0...wd.index('[')].split('-')
+          index = wd[wd.index('[') + 1...wd.index(']')]
+          wd_from = OSM_DAYS.find_index(from)
+          wd_to = OSM_DAYS.find_index(to)
+          weekdays << { from: wd_from, to: wd_from, index: index.to_i }
         else
           raise ArgumentError, "Invalid weekday interval : #{wd}"
         end
@@ -564,6 +685,7 @@ module OpeningHoursConverter
       weekday_merge = []
       wide_interval_merge = []
       merged_wide_interval = []
       groups.each_with_index do |group, group_index|
         if !wide_interval_merge.empty?
           merged_wide_interval += [wide_interval_merge.join(' ')]
@@ -575,7 +697,7 @@ module OpeningHoursConverter
             wide_interval_merge = []
             new_tokens << merged_wide_interval.join(',')
           end
-          if is_weekday?(token)
+          if is_weekday?(token) || is_weekday_with_modifier?(token)
             weekday_merge << token
             if token_index == group.length - 1 && group_index == groups.length - 1
               new_tokens << weekday_merge.join(',')
@@ -606,7 +728,10 @@ module OpeningHoursConverter
     def is_part_of_wide_interval?(string)
       is_wide_interval = false
       string.split('-').each do |str|
-        if (!(@RGX_YEAR =~ str).nil? || !(@RGX_YEAR_MONTH =~ str).nil? || !(@RGX_YEAR_MONTH_DAY =~ str).nil? || !(@RGX_DAY =~ str).nil? || !(@RGX_MONTHDAY =~ str).nil? || !(@RGX_MONTH =~ str).nil?) && ((@RGX_TIME =~ str).nil? && (@RGX_WEEKDAY =~ str).nil?)
+        if (!(@RGX_YEAR =~ str).nil? || !(@RGX_YEAR_MONTH =~ str).nil? || !(@RGX_YEAR_MONTH_DAY =~ str).nil? ||
+            !(@RGX_DAY =~ str).nil? || !(@RGX_MONTHDAY =~ str).nil? || !(@RGX_MONTH =~ str).nil? ||
+            !(@RGX_WEEK_KEY =~ str).nil? || !(@RGX_WEEK_VAL =~ str).nil? || !(@RGX_WEEK_VAL_WITH_MODIFIER =~ str).nil?) &&
+            ((@RGX_TIME =~ str).nil? && (@RGX_WEEKDAY =~ str).nil?)
           is_wide_interval = true
         else
           return false
@@ -635,8 +760,38 @@ module OpeningHoursConverter
       !(@RGX_WEEKDAY =~ token).nil?
     end
+    def is_weekday_with_modifier?(token)
+      !(@RGX_WD_WITH_MODIFIER =~ token).nil?
+    end
     def is_year?(token)
       !(@RGX_YEAR =~ token).nil?
     end
+    def is_week_key?(token)
+      !(@RGX_WEEK_KEY =~ token).nil?
+    end
+    def is_week_val?(token)
+      !(@RGX_WEEK_VAL =~ token).nil?
+    end
+    def is_week_with_modifier?(token)
+      !(@RGX_WEEK_WITH_MODIFIER =~ token).nil?
+    end
+    def is_week_val_with_modifier?(token)
+      !(@RGX_WEEK_VAL_WITH_MODIFIER =~ token).nil?
+    end
+    def is_year_week?(token)
+      !(@RGX_YEAR_WEEK =~ token).nil?
+    end
+    def is_year_week_with_modifier?(token)
+      !(@RGX_YEAR_WEEK_WITH_MODIFIER =~ token).nil?
+    end
   end
 end

data/lib/opening_hours_converter/opening_hours_rule.rb CHANGED

@@ -61,6 +61,8 @@ module OpeningHoursConverter
       month_start = -1
       day_start = -1
+      return result_to_string(years) if is_only_week_interval?(years)
       result = {}
       if !years['always'].nil?
@@ -120,7 +122,7 @@ module OpeningHoursConverter
                             { day: 30, month: 11 }
                           else
                             { day: MONTH_END_DAY[month - 1] - 1, month: month - 1 }
-                                    end
+                          end
                         else
                           { day: day - 1, month: month }
                         end
@@ -148,63 +150,90 @@ module OpeningHoursConverter
     def result_to_string(result)
       str_result = ''
-      result.each do |selector, intervals|
-        if selector == 'always'
-          intervals.each do |interval|
-            str_result += ',' if !str_result.empty?
-            if is_full_year?(interval)
-            elsif is_full_month?(interval)
-              str_result += (OSM_MONTHS[interval[:start][:month]]).to_s
-            elsif starts_month?(interval) && ends_month?(interval)
-              str_result += "#{OSM_MONTHS[interval[:start][:month]]}-#{OSM_MONTHS[interval[:end][:month]]}"
-            elsif is_same_month?(interval)
-              if is_same_day?(interval)
-                str_result += "#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}"
+      if is_only_week_interval?(result)
+        local_str = result.keys == ['always'] ? 'week ' : result.keys.length == 1 ? result.keys.first.to_s + ' week ' : result.keys.min.to_s + '-' + result.keys.max.to_s + ' week '
+        intervals = result[result.keys.first]
+        intervals.each do |interval|
+          local_str += "," if !(local_str[local_str.length - 1] =~ /^[0-9]$/).nil?
+          local_str +=
+            if interval[:modifier].nil?
+              if interval[:start][:week] == interval[:end][:week]
+                interval[:start][:week].to_s
               else
-                str_result += "#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}-#{interval[:end][:day] + 1 < 10 ? "0#{interval[:end][:day] + 1}" : interval[:end][:day] + 1}"
+                "#{interval[:start][:week].to_s + '-' + interval[:end][:week].to_s}"
               end
             else
-              str_result += "#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}-#{OSM_MONTHS[interval[:end][:month]]} #{interval[:end][:day] + 1 < 10 ? "0#{interval[:end][:day] + 1}" : interval[:end][:day] + 1}"
+              "#{interval[:start][:week].to_s + '-' + interval[:end][:week].to_s}/#{interval[:modifier].to_s}"
             end
-          end
-        elsif selector == 'multi_year'
-          intervals.each do |_years, intervals|
+        end
+        str_result += local_str
+      else
+        result.each do |selector, intervals|
+          if selector == 'always'
             intervals.each do |interval|
               str_result += ',' if !str_result.empty?
-              if starts_year?(interval) && ends_year?(interval)
+              if is_full_year?(interval)
+              elsif starts_year?(interval) && ends_year?(interval)
                 str_result += "#{interval[:start][:year]}-#{interval[:end][:year]}"
-              # elsif starts_month?(interval) && ends_month?(interval)
-              #   str_result += "#{interval[:start][:year]} #{OSM_MONTHS[interval[:start][:month]]}-#{interval[:end][:year]} #{OSM_MONTHS[interval[:end][:month]]}"
+              elsif is_full_month?(interval)
+                str_result += (OSM_MONTHS[interval[:start][:month]]).to_s
+              elsif is_same_month?(interval)
+                if is_same_day?(interval)
+                  str_result += "#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}"
+                else
+                  str_result += "#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}-#{interval[:end][:day] + 1 < 10 ? "0#{interval[:end][:day] + 1}" : interval[:end][:day] + 1}"
+                end
+              elsif starts_month?(interval) && ends_month?(interval)
+                str_result += "#{OSM_MONTHS[interval[:start][:month]]}-#{OSM_MONTHS[interval[:end][:month]]}"
               else
-                str_result += "#{interval[:start][:year]} #{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}-#{interval[:end][:year]} #{OSM_MONTHS[interval[:end][:month]]} #{interval[:end][:day] + 1 < 10 ? "0#{interval[:end][:day] + 1}" : interval[:end][:day] + 1}"
+                str_result += "#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}-#{OSM_MONTHS[interval[:end][:month]]} #{interval[:end][:day] + 1 < 10 ? "0#{interval[:end][:day] + 1}" : interval[:end][:day] + 1}"
               end
             end
-          end
-        else
-          local_str = "#{selector} "
-          intervals.each do |interval|
-            if is_full_year?(interval)
-              # elsif
-              # local_str += "#{local_str.length > 5 ? "," : ""}#{OSM_MONTHS[interval[:start][:month]]}"
-              # elsif
-              # local_str += "#{local_str.length > 5 ? "," : ""}#{OSM_MONTHS[interval[:start][:month]]}-#{OSM_MONTHS[interval[:end][:month]]}"
-            elsif is_same_month?(interval)
-              if is_same_day?(interval)
-                local_str += "#{local_str.length > 5 ? ',' : ''}#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}"
+          elsif selector == 'multi_year'
+            intervals.each do |_years, intervals|
+              intervals.each do |interval|
+                str_result += ',' if !str_result.empty?
+                if starts_year?(interval) && ends_year?(interval)
+                  str_result += "#{interval[:start][:year]}-#{interval[:end][:year]}"
+                else
+                  str_result += "#{interval[:start][:year]} #{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}-#{interval[:end][:year]} #{OSM_MONTHS[interval[:end][:month]]} #{interval[:end][:day] + 1 < 10 ? "0#{interval[:end][:day] + 1}" : interval[:end][:day] + 1}"
+                end
+              end
+            end
+          else
+            local_str = "#{selector} "
+            intervals.each do |interval|
+              if is_full_year?(interval)
+              elsif is_same_month?(interval)
+                if is_same_day?(interval)
+                  local_str += "#{local_str.length > 5 ? ',' : ''}#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}"
+                else
+                  local_str += "#{local_str.length > 5 ? ',' : ''}#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}-#{interval[:end][:day] + 1 < 10 ? "0#{interval[:end][:day] + 1}" : interval[:end][:day] + 1}"
+                end
               else
-                local_str += "#{local_str.length > 5 ? ',' : ''}#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}-#{interval[:end][:day] + 1 < 10 ? "0#{interval[:end][:day] + 1}" : interval[:end][:day] + 1}"
+                local_str += "#{local_str.length > 5 ? ',' : ''}#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}-#{selector} #{OSM_MONTHS[interval[:end][:month]]} #{interval[:end][:day] + 1 < 10 ? "0#{interval[:end][:day] + 1}" : interval[:end][:day] + 1}"
               end
-            else
-              local_str += "#{local_str.length > 5 ? ',' : ''}#{OSM_MONTHS[interval[:start][:month]]} #{interval[:start][:day] + 1 < 10 ? "0#{interval[:start][:day] + 1}" : interval[:start][:day] + 1}-#{selector} #{OSM_MONTHS[interval[:end][:month]]} #{interval[:end][:day] + 1 < 10 ? "0#{interval[:end][:day] + 1}" : interval[:end][:day] + 1}"
+              str_result += "#{!str_result.empty? ? ',' : ''}#{local_str}"
             end
           end
-          str_result += "#{!str_result.empty? ? ',' : ''}#{local_str}"
         end
       end
       str_result.strip
     end
+    def is_only_week_interval?(r)
+      r.all? do |year, intervals|
+        intervals.all? do |interval|
+          is_week_interval?(interval)
+        end
+      end
+    end
+    def is_week_interval?(interval)
+      !interval.is_a?(Array) && interval.key?(:start) && interval[:start].key?(:week)
+    end
     def is_full_year?(r)
       starts_year?(r) && ends_year?(r)
     end

data/lib/opening_hours_converter/wide_interval.rb CHANGED

@@ -3,11 +3,12 @@ require 'opening_hours_converter/constants'
 module OpeningHoursConverter
   class WideInterval
     include Constants
-    attr_accessor :start, :end, :type
+    attr_accessor :start, :end, :type, :indexes
     def initialize
       @start = nil
       @end = nil
+      @indexes = nil
       @type = nil
     end
@@ -87,13 +88,11 @@ module OpeningHoursConverter
                      'jours fériés'
                    else
                      "les jours fériés de #{@start[:year]} à #{@end[:year]}"
-                            end
+                   end
+                 elsif !@start[:year]
+                   'jours fériés'
                  else
-                   if !@start[:year]
-                     'jours fériés'
-                   else
-                     "les jours fériés de #{@start[:year]}"
-                            end
+                   "les jours fériés de #{@start[:year]}"
                  end
       when 'always'
         result = 'tout le temps'
@@ -135,6 +134,17 @@ module OpeningHoursConverter
       self
     end
+    def week(week_indexes, start_year = nil, end_year = nil)
+      raise(ArgumentError, 'weeks are required (array of ints)') if week_indexes.nil? || !week_indexes.is_a?(Array)
+      @start = { year: start_year }
+      @indexes = week_indexes
+      if !start_year.nil? && !end_year.nil? && end_year != start_year
+        @end = { year: end_year }
+      end
+      @type = 'week'
+      self
+    end
     def year(start_year, end_year = nil)
       raise(ArgumentError, 'start_year is required') if start_year.nil?
       @start = { year: start_year }
@@ -212,6 +222,17 @@ module OpeningHoursConverter
       else
         my = to_day
         o = o.to_day
+        if my.is_a?(Array)
+          if o.is_a?(Array)
+            return false
+          else
+            return my.all? { |day| day.contains?(o) }
+          end
+        elsif o.is_a?(Array)
+          return o.all? { |day| contains?(day) }
+        end
         result = has_superior_or_equal_start_day?(my, o) && has_inferior_or_equal_end_day?(my, o)
       end
       result
@@ -227,6 +248,22 @@ module OpeningHoursConverter
         my = to_day
         o = o.to_day
+        if my.is_a?(Array)
+          if o.is_a?(Array)
+            return my.any? do |day|
+              o.any? do |o_day|
+                day.touch?(o_day)
+              end
+            end
+          else
+            return my.any? { |day| day.touch?(o) }
+          end
+        elsif o.is_a?(Array)
+          return o.any? { |day| day.touch?(my) }
+        end
+# solution poour les weeks, on peut convertir un wide interval week en array de wide interval days et comparer les wide interval week
+  # un par un (long si deux wide interval multiweek)
+# problem : comment calculer les weeks always ? comparer sur l'année en cours si o est always, les années de o sinon
         result = ((my_start_is_before_o_end?(my, o) && my_start_is_after_o_start?(my, o)) ||
           (my_end_is_before_o_end?(my, o) && my_end_is_after_o_start?(my, o))) ||
                  ((my_start_is_before_o_end?(o, my) && my_start_is_after_o_start?(o, my)) ||
@@ -390,10 +427,33 @@ module OpeningHoursConverter
           o.start[:day] >= my.start[:day]))
     end
+    def sort_days_array(days_array, by = :start)
+      if days_array.all? { |day| day.start && !day.start[:year].nil? }
+        days_array.sort_by { |day| [day.send(by)[:year], day.send(by)[:month], day.send(by)[:day]] }
+      else
+        days_array.sort_by { |day| [day.send(by)[:month], day.send(by)[:day]] }
+      end
+    end
     def has_superior_or_equal_start_day?(my, o)
       result = false
       if has_start_year?(o) && has_start_year?(my)
-        result = o.start[:year] > my.start[:year] || (o.start[:year] == my.start[:year] && has_superior_start_month?(my, o))
+        if o.is_a?(Array)
+          if my.is_a?(Array)
+            o = sort_days_array o
+            my = sort_days_array my
+            has_superior_or_equal_start_day?(my.first, o.first)
+          else
+            o = sort_days_array o
+            has_superior_or_equal_start_day?(my, o.first)
+          end
+        elsif my.is_a?(Array)
+          my = sort_days_array my
+          has_superior_or_equal_start_day?(my.first, o)
+        else
+          result = o.start[:year] > my.start[:year] || (o.start[:year] == my.start[:year] && has_superior_start_month?(my, o))
+        end
       elsif !has_start_year?(my)
         result = has_superior_start_month?(my, o)
       end
@@ -433,7 +493,11 @@ module OpeningHoursConverter
     end
     def has_start_year?(date)
-      !date.start[:year].nil?
+      if date.is_a?(Array)
+        date.all? { |d| !d.start[:year].nil? }
+      else
+        !date.start[:year].nil?
+      end
     end
     def has_end_year?(date)
@@ -450,6 +514,23 @@ module OpeningHoursConverter
       return false if @type == 'always'
       self_to_day = to_day
       o_to_day = o.to_day
+      return false if self_to_day.is_a?(Array) != o_to_day.is_a?(Array)
+      if self_to_day.is_a?(Array)
+        if o_to_day.is_a?(Array)
+          return false unless o_to_day.length == self_to_day.length
+          return self_to_day.all? do |self_day|
+            o_to_day.any? do |o_day|
+              self_day.equals(o_day)
+            end
+          end
+        else
+          return self_to_day.all? { |day| self_to_day.equals(o_to_day) }
+        end
+      elsif o_to_day.is_a?(Array)
+        return o_to_day.all? { |day| equals(day) }
+      end
       (self_to_day.start[:year] == o_to_day.start[:year] &&
         self_to_day.start[:month] == o_to_day.start[:month] &&
         self_to_day.start[:day] == o_to_day.start[:day]) &&
@@ -461,8 +542,11 @@ module OpeningHoursConverter
     def width
       return Float::INFINITY if @type == 'always'
       in_day = to_day
       days_count = 0
+      return in_day.map(&:width).sum if in_day.is_a?(Array)
       if in_day.end
         if in_day.start[:year] && in_day.end[:year]
           if in_day.start[:year] != in_day.end[:year]
@@ -541,6 +625,7 @@ module OpeningHoursConverter
     end
     def to_day
+      #  les semaines rentrent en opposition avec cette maniere de faire : il n'y a pas un debut et une fin il y en a plusieurs (1-53/2)
       case @type
       when 'day'
         if @end.nil?
@@ -560,6 +645,70 @@ module OpeningHoursConverter
         else
           OpeningHoursConverter::WideInterval.new.day(1, 1, @start[:year], 31, 12, @end[:year])
         end
+      when 'holiday'
+        if @start && @start[:year]
+          if @end && @end[:year]
+            weeks = []
+            (@start[:year]..@end[:year]).each do |year|
+              weeks += get_public_holidays_for_year(year)
+            end
+            weeks
+          else
+            get_public_holidays_for_year(@start[:year])
+          end
+        else
+          get_public_holidays_for_year
+        end
+      when 'week'
+        if @start && @start[:year]
+          if @end && @end[:year]
+            weeks = []
+            (@start[:year]..@end[:year]).each do |year|
+              weeks += get_weeks_for_year(year)
+            end
+            weeks
+          else
+            get_weeks_for_year(@start[:year])
+          end
+        else
+          get_weeks_for_year
+        end
+      end
+    end
+    def get_weeks_for_year(year = Time.now.year)
+      weeks_as_days = []
+      @indexes.each do |week_index|
+        if week_index.is_a?(Integer)
+          week = OpeningHoursConverter::WeekIndex.week_from_index(week_index, year)
+          weeks_as_days << OpeningHoursConverter::WideInterval.new.day(week[:from].day, week[:from].month, week[:from].year,
+                week[:to].day, week[:to].month, week[:to].year)
+        else
+          if week_index.key?(:modifier)
+            i = 0
+            (week_index[:from]..week_index[:to]).map do |index|
+              if i % week_index[:modifier] == 0
+                week = OpeningHoursConverter::WeekIndex.week_from_index(index, year)
+                weeks_as_days << OpeningHoursConverter::WideInterval.new.day(week[:from].day, week[:from].month, week[:from].year,
+                  week[:to].day, week[:to].month, week[:to].year)
+              end
+              i += 1
+            end
+          else
+            (week_index[:from]..week_index[:to]).map do |index|
+              week = OpeningHoursConverter::WeekIndex.week_from_index(index, year)
+              weeks_as_days << OpeningHoursConverter::WideInterval.new.day(week[:from].day, week[:from].month, week[:from].year,
+                week[:to].day, week[:to].month, week[:to].year)
+            end
+          end
+        end
+      end
+      weeks_as_days
+    end
+    def get_public_holidays_for_year(year = Time.now.year)
+      OpeningHoursConverter::PublicHoliday.ph_for_year(year).map do |holiday|
+        OpeningHoursConverter::WideInterval.new.day(holiday.day, holiday.month, holiday.year)
       end
     end
   end

data/lib/opening_hours_converter/year.rb CHANGED

@@ -82,7 +82,59 @@ module OpeningHoursConverter
     def self.build_day_array_from_dates(dates, get_iterator=false)
       years = {}
       dates.each do |date|
-        if !date.wide_interval.start.nil? && !date.wide_interval.start[:year].nil?
+        if date.wide_interval.type == 'week'
+          if date.wide_interval.start.nil? || date.wide_interval.start[:year].nil?
+            date.wide_interval.indexes.each do |week_index|
+              if week_index.is_a? Integer
+                years["always"] ||= []
+                years["always"] << { start: { week: week_index }, end: { week: week_index } }
+              elsif week_index.is_a?(Hash) && week_index.key?(:modifier)
+                # week range with modifier
+                years["always"] ||= []
+                years["always"] << { start: { week: week_index[:from] }, end: { week: week_index[:to] }, modifier: week_index[:modifier] }
+              else
+                # week range
+                years["always"] ||= []
+                years["always"] << { start: { week: week_index[:from] }, end: { week: week_index[:to] } }
+              end
+            end
+          else
+            if date.wide_interval.end.nil? || date.wide_interval.end[:year].nil?
+              date.wide_interval.indexes.each do |week_index|
+                if week_index.is_a? Integer
+                  years[date.wide_interval.start[:year]] ||= []
+                  years[date.wide_interval.start[:year]] << { start: { week: week_index }, end: { week: week_index } }
+                elsif week_index.is_a?(Hash) && week_index.key?(:modifier)
+                  # week range with modifier
+                  years[date.wide_interval.start[:year]] ||= []
+                  years[date.wide_interval.start[:year]] << { start: { week: week_index[:from] }, end: { week: week_index[:to] }, modifier: week_index[:modifier] }
+                else
+                  # week range
+                  years[date.wide_interval.start[:year]] ||= []
+                  years[date.wide_interval.start[:year]] << { start: { week: week_index[:from] }, end: { week: week_index[:to] } }
+                end
+              end
+            else
+              date.wide_interval.start[:year].upto(date.wide_interval.end[:year]) do |year|
+                date.wide_interval.indexes.each do |week_index|
+                  if week_index.is_a? Integer
+                    years[year] ||= []
+                    years[year] << { start: { week: week_index }, end: { week: week_index } }
+                  elsif week_index.is_a?(Hash) && week_index.key?(:modifier)
+                    # week range with modifier
+                    years[year] ||= []
+                    years[year] << { start: { week: week_index[:from] }, end: { week: week_index[:to] }, modifier: week_index[:modifier] }
+                  else
+                    # week range
+                    years[year] ||= []
+                    years[year] << { start: { week: week_index[:from] }, end: { week: week_index[:to] } }
+                  end
+                end
+              end
+            end
+          end
+        elsif !date.wide_interval.start.nil? && !date.wide_interval.start[:year].nil?
           if date.wide_interval.end.nil? || date.wide_interval.end[:year].nil? || date.wide_interval.start[:year] == date.wide_interval.end[:year]
             if !years[date.wide_interval.start[:year]].nil?
               years = process_single_year(date.wide_interval, years)

metadata CHANGED

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opening_hours_converter
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.9.0
 platform: ruby
 authors:
 - Ziserman Martin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-05-21 00:00:00.000000000 Z
+date: 2019-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -79,8 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.7.3
+rubygems_version: 3.0.3
 signing_key:
 specification_version: 4
 summary: Datetime range to openinghours, openinghours to datetime range