opening_hours_converter 1.8.1 → 1.9.0

checksums.yaml

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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