opening_hours_converter 0.0.6 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f1b50fd81f5356288f740d7d620466ce1b600fc
-  data.tar.gz: 1010e21324ee9f681a76e266dfe171d03d9f2fd1
+  metadata.gz: ce16e76b1a7b611c0b82c3416e9282df1638df76
+  data.tar.gz: d41e59d6d13771a1b18a8c3e4e1edc42b4ab8b8d
 SHA512:
-  metadata.gz: a0fb21373136426155b3b75951d9536ee93aa81003113ea2e519dbc8049b4f0279ffc048cf5f1c394b1056a035c241be42bb62e9f828a9b4d4ed515a0fe3614b
-  data.tar.gz: a34e90fdf38d357d5dd5338897442603e0ae47a75668252c9460d5be66ab59e2c7e32fb72ee82dd0993b641db23033526385a249eab8469afce9c801d58128c9
+  metadata.gz: 834a523ad7ebe902b4a857a9f77641cf8bad74f58a4188839c9a956f5ac73c780eefcf98bc2123af5542269f8e66d73e5d9e1a807e7140d395b21bf7c4f09fce
+  data.tar.gz: f91a6e6b1051a74c727676c7359801070a70bd9b6d551fa9a8ec323b1bd763121959b22bcdb621d844903feb9b36ddc211e141e7021963fd548a1d21348e20a3

data/lib/opening_hours_converter/constants.rb

@@ -1,3 +1,4 @@
+require 'date'
 module OpeningHoursConverter
   module Constants
     DAYS = {
@@ -18,5 +19,7 @@ module OpeningHoursConverter
     MINUTES_MAX = 1440
     DAYS_MAX = 6
     YEAR_DAYS_MAX = 365
+    YEAR_MIN = DateTime.now.year - 1
+    YEAR_MAX = DateTime.now.year + 5
   end
 end

data/lib/opening_hours_converter/date_range.rb

@@ -27,11 +27,7 @@ module OpeningHoursConverter
           else
             @typical = OpeningHoursConverter::Week.new
           end
-        when "week"
-          @typical = OpeningHoursConverter::Week.new
-        when "month"
-          @typical = OpeningHoursConverter::Week.new
-        when "always"
+        when "week", "month", "year", "always"
           @typical = OpeningHoursConverter::Week.new
         end
       end

data/lib/opening_hours_converter/opening_hours_builder.rb

@@ -27,7 +27,7 @@ module OpeningHoursConverter
             end
             range_general_id -= 1
           end
-
+          # binding.pry
           if date_range_index == 0 || range_general.nil?
             if date_range.defines_typical_week?
               if !range_general_for.nil?
@@ -38,72 +38,53 @@ module OpeningHoursConverter
             else
               oh_rules = build_day(date_range)
             end
-          end
-
-          oh_rule_index = 0
-
-          while oh_rule_index < oh_rules.length
-            oh_rule = oh_rules[oh_rule_index]
-            oh_rule_added = false
-            rule_index = 0
 
-            while !oh_rule_added && rule_index < rules.length
-              if rules[rule_index].same_time?(oh_rule)
-                begin
-                  for date_id in 0...oh_rule.date.length
-                    rules[rule_index].add_date(oh_rule.date[date_id])
+            # oh_rule_index = 0
+            # for oh_rule_index in 0...oh_rules.length
+            oh_rules.map do |oh_rule|
+            # while oh_rule_index < oh_rules.length
+
+              # oh_rule = oh_rules[oh_rule_index]
+              oh_rule_added = false
+              rule_index = 0
+
+              while !oh_rule_added && rule_index < rules.length
+                if rules[rule_index].same_time?(oh_rule) && !rules[rule_index].equals(oh_rule)
+                  begin
+                    for date_id in 0...oh_rule.date.length
+                      rules[rule_index].add_date(oh_rule.date[date_id])
+                    end
+                    oh_rule_added = true
+                  rescue Exception => e
+                    puts e
+                    rule_index += 1
                   end
-                  oh_rule_added = true
-                rescue Exception => e
-                  puts e
-                  # if(
-                  #   ohrule.getDate()[0].getWideType() == "holiday"
-                  #   && ohrule.getDate()[0].getWideValue() == "PH"
-                  #   && rules[ruleId].getDate()[0].getWideType() == "always"
-                  # ) {
-                  #   rules[ruleId].addPhOpeningHoursConverter::Weekday();
-                  #   ohruleAdded = true;
-                  # }
-                  # else if(
-                  #   rules[ruleId].getDate()[0].getWideType() == "holiday"
-                  #   && rules[ruleId].getDate()[0].getWideValue() == "PH"
-                  #   && ohrule.getDate()[0].getWideType() == "always"
-                  # ) {
-                  #   ohrule.addPhOpeningHoursConverter::Weekday();
-                  #   rules[ruleId] = ohrule;
-                  #   ohruleAdded = true;
-                  # }
-                  # else {
-                  #   ruleId++;
-                  # }
-                  rule_index += 1
+                else
+                  rule_index+=1
                 end
-              else
-                rule_index+=1
-              end
 
-            end
+              end
 
-            if !oh_rule_added
-              rules << oh_rule
-            end
+              if !oh_rule_added
+                rules << oh_rule
+              end
 
-            if oh_rule_index == oh_rules.length - 1 && oh_rule.has_overwritten_weekday?
-              oh_rule_over = OpeningHoursConverter::OpeningHoursRule.new
+              if oh_rule == oh_rules.last && oh_rule.has_overwritten_weekday?
+                oh_rule_over = OpeningHoursConverter::OpeningHoursRule.new
 
-              oh_rule.date.each do |date|
-                oh_rule_over.add_date(OpeningHoursConverter::OpeningHoursDate.new(date.wide, date.wide_type, date.weekdays_over))
+                oh_rule.date.each do |date|
+                  oh_rule_over.add_date(OpeningHoursConverter::OpeningHoursDate.new(date.wide, date.wide_type, date.weekdays_over))
+                end
+                oh_rule_over.add_time(OpeningHoursConverter::OpeningHoursTime.new)
+                oh_rules << oh_rule_over
               end
-              oh_rule_over.add_time(OpeningHoursConverter::OpeningHoursTime.new)
-              oh_rules << oh_rule_over
-              oh_rule_index += 1
-            else
-              oh_rule_index += 1
             end
           end
         end
       end
 
+      # binding.pry
+
 
       result = ""
       rules.each_with_index do |rule, rule_index|
@@ -120,7 +101,7 @@ module OpeningHoursConverter
       intervals = date_range.typical.get_intervals(true)
 
       rule = OpeningHoursConverter::OpeningHoursRule.new
-      date = OpeningHoursConverter::OpeningHoursDate.new(date_range.wide_interval.get_time_selector, date_range.wide_interval.type, [-1])
+      date = OpeningHoursConverter::OpeningHoursDate.new(date_range.wide_interval, date_range.wide_interval.type, [-1])
       rule.add_date(date)
 
       intervals.each do |interval|
@@ -133,9 +114,10 @@ module OpeningHoursConverter
     end
 
     def build_week(date_range)
+      # binding.pry
       result = []
       intervals = date_range.typical.get_intervals(true)
-      time_intervals = create_time_intervals(date_range.wide_interval.get_time_selector, date_range.wide_interval.type, intervals)
+      time_intervals = create_time_intervals(date_range.wide_interval, date_range.wide_interval.type, intervals)
 
       monday0 = time_intervals[0]
       sunday24 = time_intervals[1]
@@ -203,7 +185,7 @@ module OpeningHoursConverter
       intervals = date_range.typical.get_intervals_diff(general_date_range.typical)
 
       time_intervals = create_time_intervals(
-        date_range.wide_interval.get_time_selector,
+        date_range.wide_interval,
         date_range.wide_interval.type,
         intervals[:open])
       monday0 = time_intervals[0]
@@ -306,14 +288,15 @@ module OpeningHoursConverter
       return result
     end
 
-    def create_time_intervals(time_selector, type, intervals)
+    def create_time_intervals(wide_interval, type, intervals)
+      # binding.pry
       monday0 = -1
       sunday24 = -1
 
       days = []
-      for i in 0...7 do
+      for i in 0...7
         days << OpeningHoursConverter::OpeningHoursRule.new
-        days[i].add_date(OpeningHoursConverter::OpeningHoursDate.new(time_selector, type, [ i ]))
+        days[i].add_date(OpeningHoursConverter::OpeningHoursDate.new(wide_interval, type, [ i ]))
       end
 
       intervals.each do |interval|
@@ -335,7 +318,7 @@ module OpeningHoursConverter
                 days[interval.day_end].add_time(OpeningHoursConverter::OpeningHoursTime.new(0, interval.end))
               end
             else
-              for j in interval.day_start..interval.day_end do
+              for j in interval.day_start..interval.day_end
                 if j == interval.day_start
                   days[j].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, MINUTES_MAX))
                 elsif j == interval.day_end

data/lib/opening_hours_converter/opening_hours_date.rb

@@ -17,7 +17,6 @@ module OpeningHoursConverter
     end
 
     def get_weekdays
-
       result = ""
       wd = @weekdays.concat(@weekdays_over).sort.uniq
 

data/lib/opening_hours_converter/opening_hours_parser.rb

@@ -14,6 +14,9 @@ module OpeningHoursConverter
       @RGX_WEEKDAY = /^(((Mo|Tu|We|Th|Fr|Sa|Su)(\-(Mo|Tu|We|Th|Fr|Sa|Su))?)|(PH|SH|easter))(,(((Mo|Tu|We|Th|Fr|Sa|Su)(\-(Mo|Tu|We|Th|Fr|Sa|Su))?)|(PH|SH|easter)))*$/
       @RGX_HOLIDAY = /^(PH|SH|easter)$/
       @RGX_WD = /^(Mo|Tu|We|Th|Fr|Sa|Su)(\-(Mo|Tu|We|Th|Fr|Sa|Su))?$/
+      @RGX_YEAR = /^(\d{4})(\-(\d{4}))?$/
+      @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)))?\:?$/
     end
 
     def parse(oh)
@@ -30,18 +33,7 @@ module OpeningHoursConverter
       weekdays = nil
       weeks = nil
       months = nil
-
-      single_time = nil
-      from = nil
-      to = nil
-
-      single_month = nil
-      month_from = nil
-      month_to = nil
-
-      single_week = nil
-      week_from = nil
-      week_to = nil
+      years = nil
 
       date_ranges = nil
       date_range = nil
@@ -61,29 +53,10 @@ module OpeningHoursConverter
           current_token -= 1
         end
 
-
-        # get time selector
-        from = nil
-        to = nil
         times = []
         if current_token >= 0 && is_time?(tokens[current_token])
           time_selector = tokens[current_token]
-
-          if time_selector == "24/7"
-            times << {from: 0, to: 24*60}
-          else
-            time_selector = time_selector.split(',')
-            time_selector.each do |ts|
-              single_time = ts.split('-')
-              from = as_minutes(single_time[0])
-              if single_time.length > 1
-                to = as_minutes(single_time[1])
-              else
-                to = from
-              end
-              times << {from: from, to: to}
-            end
-          end
+          times = get_times(time_selector)
           current_token -= 1
         end
 
@@ -93,147 +66,108 @@ module OpeningHoursConverter
           weekdays << {from: 0, to: 6}
         elsif current_token >= 0 && is_weekday?(tokens[current_token])
           weekday_selector = tokens[current_token]
-          weekday_selector = weekday_selector.split(',')
-          weekday_selector.each do |wd|
-            if !(@RGX_HOLIDAY =~ wd).nil?
-            elsif !(@RGX_WD =~ wd).nil?
-              single_weekday = wd.split('-')
-              wd_from = OSM_DAYS.find_index(single_weekday[0])
-              if single_weekday.length > 1
-                wd_to = OSM_DAYS.find_index(single_weekday[1])
-              else
-                wd_to = wd_from
-              end
-
-              weekdays << {from: wd_from, to: wd_to}
-            else
-              raise ArgumentError, "Invalid weekday interval : #{wd}"
-            end
-          end
+          weekdays = get_weekdays(weekday_selector)
           current_token -= 1
         end
 
-        weeks = []
+        # years = []
+        # if current_token >= 0 && is_year?(tokens[current_token])
+        #   year_selector = tokens[current_token]
+        #   year_selector = year_selector.split(',')
+        #   year_selector.each do |y|
+        #     single_year = y.gsub(/\:$/, '').split('-')
+        #     year_from = single_year[0]
+        #     if single_year.length > 1
+        #       year_to = single_year[1]
+        #     else
+        #       year_to = year_from
+        #     end
+
+        #     years << {from: year_from, to: year_to}
+        #   end
+        #   current_token -= 1
+        # end
+
         months = []
+        years = []
         if current_token >= 0
+
           wide_range_selector = tokens[0]
           for i in 1..current_token
             wide_range_selector += " #{tokens[i]}"
           end
           if wide_range_selector.length > 0
-            wide_range_selector = wide_range_selector.gsub(/\:$/, '').split('week')
-            month_selector = wide_range_selector[0].strip
-            if month_selector.length == 0
-              month_selector = nil
-            end
-
-            if wide_range_selector.length > 1
-              week_selector = wide_range_selector[1].strip
-              if week_selector.length == 0
-                week_selector = nil
-              end
-            else
-              week_selector = nil
-            end
-
-            if (!month_selector.nil? && !week_selector.nil?)
-              raise ArgumentError, "unsupported simultaneous month and week selector"
-            elsif !month_selector.nil?
-              month_selector = month_selector.split(',')
-
-              month_selector.each do |ms|
-                if ms == "SH"
-                elsif !(@RGX_MONTH =~ ms).nil?
-                  single_month = ms.split('-')
-                  month_from = OSM_MONTHS.find_index(single_month[0]) + 1
-                  if month_from < 1
-                    raise ArgumentError, "Invalid month : #{single_month[0]}"
-                  end
-
-                  if single_month.length > 1
-                    month_to = OSM_MONTHS.find_index(single_month[1]) + 1
-                    if month_to < 1
-                      raise ArgumentError, "Invalid month : #{single_month[1]}"
-                    end
-                  else
-                    month_to = month_from
-                  end
-                  months << {from: month_from, to: month_to}
-                elsif !(@RGX_MONTHDAY =~ ms).nil?
-                  single_month = ms.gsub(/\:$/, '').split('-')
-
-                  month_from = single_month[0].split(' ')
-                  month_from = { day: month_from[1].to_i, month: OSM_MONTHS.find_index(month_from[0]) + 1 }
-                  if month_from[:month] < 1
-                    raise ArgumentError, "Invalid month : #{month_from.inspect}"
-                  end
-
-                  if single_month.length > 1
-                    month_to = single_month[1].split(' ')
-                    month_to = { day: month_to[1].to_i, month: OSM_MONTHS.find_index(month_to[0]) + 1 }
-                    if month_to[:month] < 1
-                      raise ArgumentError, "Invalid month : #{month_to.inspect}"
-                    end
-                  else
-                    month_to = nil
-                  end
-                  months << {from_day: month_from, to_day: month_to}
-                else
-                  raise ArgumentError, "Unsupported month selector #{ms}"
-                end
-              end
-            elsif !week_selector.nil?
-              week_selector = week_selector.split(',')
-              week_selector.each do |ws|
-                single_week = ws.split('-')
-                week_from = single_week[0].to_i
-                if single_week.length > 1
-                  week_to = single_week[1].to_i
-                else
-                  week_to = nil
-                end
-                weeks << {from: week_from, to: week_to}
+            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
-            else
-              raise ArgumentError, "Invalid date selector"
             end
           end
         end
+
         if current_token == tokens.length - 1
           raise ArgumentError, "Unreadable string"
         end
         # puts "months : #{months}"
-        # puts "weeks : #{weeks}"
         # puts "weekdays : #{weekdays}"
         # puts "times : #{times}"
+        # puts "years : #{years}"
         # puts "rule_modifier : #{rule_modifier}"
 
         date_ranges = []
-
         if months.length > 0
           months.each do |month|
             if !month[:from_day].nil?
               if !month[:to_day].nil?
-                date_range = OpeningHoursConverter::WideInterval.new.day(month[:from_day][:day], month[:from_day][:month], month[:to_day][:day], month[:to_day][:month])
+                date_range = OpeningHoursConverter::WideInterval.new.day(month[:from_day][:day], month[:from_day][:month], month[:from_day][:year],
+                  month[:to_day][:day], month[:to_day][:month], month[:to_day][:year])
               else
-                date_range = OpeningHoursConverter::WideInterval.new.day(month[:from_day][:day], month[:from_day][:month])
+                date_range = OpeningHoursConverter::WideInterval.new.day(month[:from_day][:day], month[:from_day][:month], month[:from_day][:year])
               end
               date_ranges << date_range
             else
               if !month[:to].nil?
-                date_range = OpeningHoursConverter::WideInterval.new.month(month[:from], month[:to])
+                date_range = OpeningHoursConverter::WideInterval.new.month(month[:from], nil, month[:to])
               else
                 date_range = OpeningHoursConverter::WideInterval.new.month(month[:from])
               end
               date_ranges << date_range
             end
           end
-        elsif weeks.length > 0
-          weeks.each do |week|
-            if !week[:to].nil?
-              date_range = OpeningHoursConverter::WideInterval.new.week(week[:from], week[:to])
-            else
-              date_range = OpeningHoursConverter::WideInterval.new.week(week[:from])
+        elsif years.length > 0
+          years.each do |year|
+            if !year[:from_day].nil?
+              if !year[:to_day].nil?
+                date_range = OpeningHoursConverter::WideInterval.new.day(year[:from_day][:day], year[:from_day][:month], year[:from_day][:year],
+                  year[:to_day][:day], year[:to_day][:month], year[:to_day][:year])
+              else
+                date_range = OpeningHoursConverter::WideInterval.new.day(year[:from_day][:day], year[:from_day][:month], year[:from_day][:year])
+              end
+            elsif !year[:from_month].nil?
+              if !year[:to_month].nil?
+                date_range = OpeningHoursConverter::WideInterval.new.month(year[:from_month][:month], year[:from_month][:year],
+                  year[:to_month][:month], year[:to_month][:year])
+              else
+                date_range = OpeningHoursConverter::WideInterval.new.month(year[:from_month][:month], year[:from_month][:year])
+              end
+            elsif !year[:from].nil?
+              if !year[:to].nil?
+                date_range = OpeningHoursConverter::WideInterval.new.year(year[:from], year[:to])
+              else
+                date_range = OpeningHoursConverter::WideInterval.new.year(year[:from])
+              end
             end
             date_ranges << date_range
           end
@@ -318,6 +252,168 @@ module OpeningHoursConverter
       return result
     end
 
+    def get_year(wrs)
+      single_year = wrs.gsub(/\:$/, '').split('-')
+      year_from = single_year[0].to_i
+      if year_from < 1
+        raise ArgumentError, "Invalid year : #{single_year[0]}"
+      end
+
+      if single_year.length > 1
+        year_to = single_year[1].to_i
+        if year_to < 1
+          raise ArgumentError, "Invalid year : #{single_year[1]}"
+        end
+      else
+        year_to = nil
+      end
+      { from: year_from, to: year_to }
+    end
+
+    def get_month(wrs)
+      single_month = wrs.gsub(/\:$/, '').split('-')
+      month_from = OSM_MONTHS.find_index(single_month[0]) + 1
+      if month_from < 1
+        raise ArgumentError, "Invalid month : #{single_month[0]}"
+      end
+
+      if single_month.length > 1
+        month_to = OSM_MONTHS.find_index(single_month[1]) + 1
+        if month_to < 1
+          raise ArgumentError, "Invalid month : #{single_month[1]}"
+        end
+      else
+        month_to = month_from
+      end
+      { from: month_from, to: month_to}
+    end
+
+    def get_month_day(wrs)
+      single_month = wrs.gsub(/\:$/, '').split('-')
+
+      month_from = single_month[0].split(' ')
+      month_from = { day: month_from[1].to_i, month: OSM_MONTHS.find_index(month_from[0]) + 1 }
+      if month_from[:month] < 1
+        raise ArgumentError, "Invalid month : #{month_from.inspect}"
+      end
+
+      if single_month.length > 1
+        month_to = single_month[1].split(' ')
+        month_to = { day: month_to[1].to_i, month: OSM_MONTHS.find_index(month_to[0]) + 1 }
+        if month_to[:month] < 1
+          raise ArgumentError, "Invalid month : #{month_to.inspect}"
+        end
+      else
+        month_to = nil
+      end
+      { from_day: month_from, to_day: month_to }
+    end
+
+    def get_year_month(wrs)
+      single_year_month = wrs.gsub(/\:$/, '').split('-')
+      year_month_from = single_year_month[0].split(' ')
+      year_month_from = { month: OSM_MONTHS.find_index(year_month_from[1]) + 1, year: year_month_from[0].to_i }
+      if year_month_from.length < 1
+        raise ArgumentError, "Invalid year_month : #{year_month_from.inspect}"
+      end
+      if single_year_month.length > 1
+        year_month_to = single_year_month[1].split(' ')
+        if year_month_to.length == 2
+          year_month_to = { month: OSM_MONTHS.find_index(year_month_to[1]) + 1, year: year_month_to[0].to_i }
+        elsif year_month_to.length == 1
+          year_month_to = { month: OSM_MONTHS.find_index(year_month_to[0]) + 1, year: year_month_from[:year] }
+        end
+        if year_month_to.length < 1
+          raise ArgumentError, "Invalid year_month : #{year_month_to.inspect}"
+        end
+      else
+        year_month_to = nil
+      end
+      { from_month: year_month_from, to_month: year_month_to }
+    end
+
+    def get_year_month_day(wrs)
+      single_year_month_day = wrs.gsub(/\:$/, '').split('-')
+      year_month_day_from = single_year_month_day[0].split(' ')
+      year_month_day_from = { day: year_month_day_from[2].to_i,
+        month: OSM_MONTHS.find_index(year_month_day_from[1]) + 1,
+        year: year_month_day_from[0].to_i }
+      if year_month_day_from.length < 1
+        raise ArgumentError, "Invalid year_month_day : #{year_month_day_from.inspect}"
+      end
+      if single_year_month_day.length > 1
+        year_month_day_to = single_year_month_day[1].split(' ')
+        if year_month_day_to.length == 3
+          year_month_day_to = { day: year_month_day_to[2].to_i,
+            month: OSM_MONTHS.find_index(year_month_day_to[1]) + 1,
+            year: year_month_day_to[0].to_i }
+        elsif year_month_day_to.length == 2
+          year_month_day_to = { day: year_month_day_to[1].to_i,
+            month: OSM_MONTHS.find_index(year_month_day_to[0]) + 1,
+            year: year_month_day_from[:year] }
+        elsif year_month_day_to.length == 1
+          year_month_day_to = { day: year_month_day_to[0].to_i,
+            month: year_month_day_from[:month],
+            year: year_month_day_from[:year] }
+        end
+        if year_month_day_to.length < 1
+          raise ArgumentError, "Invalid year_month_day : #{year_month_day_to.inspect}"
+        end
+      else
+        year_month_day_to = nil
+      end
+
+      { from_day: year_month_day_from, to_day: year_month_day_to }
+    end
+
+    def get_times(time_selector)
+      times = []
+      from = nil
+      to = nil
+      if time_selector == "24/7"
+        times << {from: 0, to: 24*60}
+      else
+        time_selector = time_selector.split(',')
+        time_selector.each do |ts|
+          single_time = ts.split('-')
+          from = as_minutes(single_time[0])
+          if single_time.length > 1
+            to = as_minutes(single_time[1])
+          else
+            to = from
+          end
+          times << {from: from, to: to}
+        end
+      end
+      times
+    end
+
+    def get_weekdays(weekday_selector)
+      weekdays = []
+      wd_from = nil
+      wd_to = nil
+
+      weekday_selector = weekday_selector.split(',')
+      weekday_selector.each do |wd|
+        if !(@RGX_HOLIDAY =~ wd).nil?
+        elsif !(@RGX_WD =~ wd).nil?
+          single_weekday = wd.split('-')
+          wd_from = OSM_DAYS.find_index(single_weekday[0])
+          if single_weekday.length > 1
+            wd_to = OSM_DAYS.find_index(single_weekday[1])
+          else
+            wd_to = wd_from
+          end
+
+          weekdays << {from: wd_from, to: wd_to}
+        else
+          raise ArgumentError, "Invalid weekday interval : #{wd}"
+        end
+      end
+
+      weekdays
+    end
+
     def remove_interval(typical, weekdays, times)
       if weekdays[:from] <= weekdays[:to]
         for wd in weekdays[:from]..weekdays[:to]
@@ -327,7 +423,7 @@ module OpeningHoursConverter
         for wd in weekdays[:from]..6
           typical.remove_intervals_during_day(wd)
         end
-        for wd in 0..weekdays[:from]
+        for wd in 0..weekdays[:to]
           typical.remove_intervals_during_day(wd)
         end
       end
@@ -404,5 +500,8 @@ module OpeningHoursConverter
     def is_weekday?(token)
       !(@RGX_WEEKDAY =~ token).nil?
     end
+    def is_year?(token)
+      !(@RGX_YEAR =~ token).nil?
+    end
   end
 end