opening_hours_converter 1.8.0 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50b769d524ea032bea248de2b6dded3bfd944f3f3402f4213ef160075f4c68e6
-  data.tar.gz: 64ca508b6a8d07c9354e22c3371a1a51d77452eba94d2d5826f133ce26591e37
+  metadata.gz: 8182729b4890b6c79b8173b5ed0722da103a4f82820ff62119d63f2d0ca2de72
+  data.tar.gz: bbbab689b9eddebb5dd17e715a15c940dd62cd0fa58b06b860c1234544c2bdf7
 SHA512:
-  metadata.gz: 2a86e27cd5699f95e1bd25559b22df74255f3efffbf9b7b5b4a1227a4a95bb80bf69f0249c9a76a283b9ae05697cb33aceafc47eec63477ffa95c8544274790e
-  data.tar.gz: 320f7a39295e8a9c29cf33f002e3cf03436a9b91d027320af3ce96114f8dbf9899a08b30b2e95fd2c6d423d6f1a68d8c516c5aa07bda2c58155b9323728415e2
+  metadata.gz: 241b74370dd846929cccb2fdde19960689d05ce6a7a31c863ea331b6450ce57ba0a88042abb2ecbc588cf38229356e82f43a3d16496513311445aa2787ff40e9
+  data.tar.gz: 528266324133acf97320be51b0f8f4f2b3e99907e2ff3a0c620b5d7e41cfa3339bb7d00bfeb3d915111fbfaa7a966100f20ee723f56ada32d0adf40572d67f0b

data/lib/opening_hours_converter/constants.rb

@@ -9,13 +9,13 @@ module OpeningHoursConverter
       VENDREDI: 4,
       SAMEDI: 5,
       DIMANCHE: 6
-    }
-    OSM_DAYS = [ "Mo", "Tu", "We", "Th", "Fr", "Sa", "Su" ]
-    IRL_DAYS = [ "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" ]
-    OSM_MONTHS = [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ]
-    IRL_MONTHS = [ "Janvier", "Fevrier", "Mars", "Avril", "Mai", "Juin", "Juillet", "Aout", "Septembre",
-      "Octobre", "Novembre", "Décembre" ]
-    MONTH_END_DAY = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]
+    }.freeze
+    OSM_DAYS = %w[Mo Tu We Th Fr Sa Su].freeze
+    IRL_DAYS = %w[Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche].freeze
+    OSM_MONTHS = %w[Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec].freeze
+    IRL_MONTHS = %W[Janvier Fevrier Mars Avril Mai Juin Juillet Aout Septembre
+                    Octobre Novembre D\u00E9cembre].freeze
+    MONTH_END_DAY = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze
     MINUTES_MAX = 1440
     DAYS_MAX = 6
     YEAR_DAYS_MAX = 365

data/lib/opening_hours_converter/interval.rb

@@ -5,7 +5,7 @@ module OpeningHoursConverter
     include Constants
     attr_reader :day_start, :day_end, :start, :end, :is_off
 
-    def initialize(day_start, min_start, day_end=0, min_end=0, is_off=false)
+    def initialize(day_start, min_start, day_end = 0, min_end = 0, is_off = false)
       @day_start = day_start
       @day_end = day_end
       @start = min_start

data/lib/opening_hours_converter/iterator.rb

@@ -23,9 +23,9 @@ module OpeningHoursConverter
                 year_start = year
                 month_start = month
                 day_start = day
-              elsif day_bool && year_start >= 0 && month == 11 && day == 30 && years[year+1].nil?
+              elsif day_bool && year_start >= 0 && month == 11 && day == 30 && years[year + 1].nil?
 
-                result << { start: DateTime.new(year_start, month_start+1, day_start+1), end: DateTime.new(year, 12, 31)}
+                result << { start: DateTime.new(year_start, month_start + 1, day_start + 1), end: DateTime.new(year, 12, 31) }
 
                 year_start = -1
                 month_start = -1
@@ -33,18 +33,18 @@ module OpeningHoursConverter
               elsif !day_bool && year_start >= 0
                 end_res = {}
 
-                if day == 0
-                  if month == 0
-                    end_res = DateTime.new(year-1, 12, 31)
-                  else
-                    end_res = DateTime.new(year, month, MONTH_END_DAY[month-1])
-                  end
-                else
+                end_res = if day == 0
+                            if month == 0
+                              DateTime.new(year - 1, 12, 31)
+                            else
+                              DateTime.new(year, month, MONTH_END_DAY[month - 1])
+                                      end
+                          else
 
-                  end_res = DateTime.new(year, month+1, day)
-                end
+                            DateTime.new(year, month + 1, day)
+                          end
 
-                result << { start: DateTime.new(year_start, month_start+1, day_start+1), end: end_res }
+                result << { start: DateTime.new(year_start, month_start + 1, day_start + 1), end: end_res }
                 year_start = -1
                 month_start = -1
                 day_start = -1
@@ -56,8 +56,7 @@ module OpeningHoursConverter
         date_ranges_array << result
       end
 
-
-      return date_ranges_array
+      date_ranges_array
     end
 
     def get_time_iterator(date_ranges)
@@ -70,7 +69,6 @@ module OpeningHoursConverter
       date_ranges_array = get_iterator(date_ranges)
       datetime_result = []
 
-
       date_ranges_array.each_with_index do |result, index|
         result.each do |interval|
           (interval[:start]..interval[:end]).each do |day|
@@ -79,20 +77,17 @@ module OpeningHoursConverter
               year_ph = PublicHoliday.ph_for_year(year)
             end
             date_ranges[index].typical.intervals.each do |i|
-              if !i.nil? && !i.is_off
-                if (i.day_start..i.day_end).include?(fix_datetime_wday(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)
-                end
-              end
+              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)))
+              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)
             end
           end
         end
       end
 
-      datetime_result.sort {|a,b| a[:start] <=> b[:start]}
-
+      datetime_result.sort_by { |a| a[:start] }
     end
 
     def get_datetime_iterator(date_ranges)
@@ -103,67 +98,63 @@ 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).include?(fix_datetime_wday(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) }
+              if (i.day_start..i.day_end).cover?(fix_datetime_wday(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
             end
           end
         end
       end
 
-      datetime_result.sort {|a,b| a[:start] <=> b[:start]}
+      datetime_result.sort_by { |a| a[:start] }
     end
 
-
-
     def fix_datetime_wday(d)
-      d==0 ? 6 : d-1
+      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)
+    def state(opening_hours_string, time = Time.now)
       date_ranges = OpeningHoursConverter::OpeningHoursParser.new.parse(opening_hours_string)
       ti = get_time_iterator(date_ranges)
       ti.each do |interval|
         return interval if interval[:start] <= time && interval[:end] >= time
       end
-      return false
+      false
     end
 
     # A partir d'une string OH et d'une DateTime (= now par défaut), renvoyer le prochain state (début / fin / commentaire - nextState dans opening_hours.js) permettant d'afficher à l'utilisateur le prochain événement (ouverture/fermeture)
-    def next_state(opening_hours_string, time=Time.now)
+    def next_state(opening_hours_string, time = Time.now)
       date_ranges = OpeningHoursConverter::OpeningHoursParser.new.parse(opening_hours_string)
       ti = get_time_iterator(date_ranges)
       ti.each_with_index do |interval, index|
-        return {end: interval[:end]} if interval[:start] <= time && interval[:end] >= time
-        return {start: interval[:start]} if interval[:start] > time && ti[index-1][:end] <= time
+        return { end: interval[:end] } if interval[:start] <= time && interval[:end] >= time
+        return { start: interval[:start] } if interval[:start] > time && ti[index - 1][:end] <= time
       end
-      return false
+      false
     end
 
-
-    def next_period(opening_hours_string, time=Time.now)
+    def next_period(opening_hours_string, time = Time.now)
       date_ranges = OpeningHoursConverter::OpeningHoursParser.new.parse(opening_hours_string)
       ti = get_time_iterator(date_ranges)
       ti.each_with_index do |interval, index|
-        return ti[index+1] if interval[:start] <= time && interval[:end] >= time
-        return interval if interval[:start] > time && ti[index-1][:end] <= time
+        return ti[index + 1] if interval[:start] <= time && interval[:end] >= time
+        return interval if interval[:start] > time && ti[index - 1][:end] <= time
       end
-      return false
+      false
     end
 
     # A partir d'une string OH et d'une DateTime (= now par défaut), déterminer cela correspond à une période d'ouverture : renvoyer un boolean.
-    def is_opened?(opening_hours_string, time=Time.now)
+    def is_opened?(opening_hours_string, time = Time.now)
       date_ranges = OpeningHoursConverter::OpeningHoursParser.new.parse(opening_hours_string)
       ti = get_time_iterator(date_ranges)
       ti.each do |interval|
         return true if interval[:start] <= time && interval[:end] >= time
       end
-      return false
+      false
     end
 
-
     def datetime_to_time(datetime)
       Time.new(datetime.year, datetime.month, datetime.day, datetime.hour, datetime.min, datetime.sec, datetime.zone)
     end
@@ -171,6 +162,5 @@ module OpeningHoursConverter
     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

@@ -14,115 +14,100 @@ module OpeningHoursConverter
       off_day_ph = false
 
       date_ranges.each_with_index do |date_range, date_range_index|
-        if !date_range.nil?
-          if date_range.typical.intervals.length != 1
-            date_range.typical.intervals.each_with_index do |interval, interval_id|
-              if 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)
-              end
+        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)
           end
+        end
 
-          range_general = nil
-          range_general_for = nil
-          range_general_id = date_range_index - 1
-
-          while range_general_id >= 0 && range_general.nil?
-            if !date_range.nil?
-              general_for = date_ranges[range_general_id].is_general_for?(date_range)
-              if date_ranges[range_general_id].has_same_typical?(date_range) && (date_ranges[range_general_id].wide_interval.equals(date_range.wide_interval) || general_for)
-                range_general = range_general_id
-              elsif general_for && date_ranges[range_general_id].defines_typical_week? && date_range.defines_typical_week?
-                range_general_for = range_general_id
-              end
+        range_general = nil
+        range_general_for = nil
+        range_general_id = date_range_index - 1
+
+        while range_general_id >= 0 && range_general.nil?
+          if !date_range.nil?
+            general_for = date_ranges[range_general_id].is_general_for?(date_range)
+            if date_ranges[range_general_id].has_same_typical?(date_range) && (date_ranges[range_general_id].wide_interval.equals(date_range.wide_interval) || general_for)
+              range_general = range_general_id
+            elsif general_for && date_ranges[range_general_id].defines_typical_week? && date_range.defines_typical_week?
+              range_general_for = range_general_id
             end
-            range_general_id -= 1
           end
+          range_general_id -= 1
+        end
 
-          if 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 !range_general_for.nil?
-                oh_rules = build_week_diff(date_range, date_ranges[range_general_for])
-              else
-                oh_rules = build_week(date_range)
-              end
-            else
-              oh_rules = build_day(date_range)
-            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?
+          oh_rules = if !range_general_for.nil?
+                       build_week_diff(date_range, date_ranges[range_general_for])
+                     else
+                       build_week(date_range)
+                     end
+        else
+          oh_rules = build_day(date_range)
+        end
 
-            oh_rules.each_with_index do |rule, i|
-              oh_rules[i].add_comment(date_range.comment)
-            end
+        oh_rules.each_with_index do |_rule, i|
+          oh_rules[i].add_comment(date_range.comment)
+        end
 
+        oh_rules.map do |oh_rule|
+          oh_rule_added = false
+          rule_index = 0
 
-            oh_rules.map do |oh_rule|
-              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) && rules[rule_index].comment == oh_rule.comment
-                  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
-                    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
-                    elsif rules[rule_index].date[0].wide_interval.type == "holiday" && rules[rule_index].date[0].wide_interval.get_time_selector == "PH"
-                      oh_rule.add_ph_weekday
-                      rules[rule_index] = oh_rule
-                      oh_rule_added = true
-                    else
-                      rule_index += 1
-                    end
-                  end
+          while !oh_rule_added && rule_index < rules.length
+            if rules[rule_index].same_time?(oh_rule) && !rules[rule_index].equals(oh_rule) && rules[rule_index].comment == oh_rule.comment
+              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
+                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
+                elsif rules[rule_index].date[0].wide_interval.type == 'holiday' && rules[rule_index].date[0].wide_interval.get_time_selector == 'PH'
+                  oh_rule.add_ph_weekday
+                  rules[rule_index] = oh_rule
+                  oh_rule_added = true
                 else
-                  rule_index+=1
+                  rule_index += 1
                 end
               end
+            else
+              rule_index += 1
+            end
+          end
 
-              if day_ph
-                oh_rule.add_ph_weekday
-              end
-
+          oh_rule.add_ph_weekday if day_ph
 
-              if !oh_rule_added
-                rules << oh_rule
-              end
+          rules << oh_rule if !oh_rule_added
 
-              if off_day_ph
-                rules += build_off_holiday(date_range)
-              end
+          rules += build_off_holiday(date_range) if off_day_ph
 
-              if oh_rule == oh_rules.last && oh_rule.has_overwritten_weekday?
-                oh_rule_over = OpeningHoursConverter::OpeningHoursRule.new
+          next unless 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_interval, date.weekdays_over))
-                end
-                oh_rule_over.add_time(OpeningHoursConverter::OpeningHoursTime.new)
-                oh_rules << oh_rule_over
-              end
-            end
+          oh_rule.date.each do |date|
+            oh_rule_over.add_date(OpeningHoursConverter::OpeningHoursDate.new(date.wide_interval, date.weekdays_over))
           end
+          oh_rule_over.add_time(OpeningHoursConverter::OpeningHoursTime.new)
+          oh_rules << oh_rule_over
         end
       end
 
-
-      result = ""
-      if rules.length == 0
+      result = ''
+      if rules.empty?
         date_ranges.each do |dr|
           result += "#{dr.wide_interval.get_time_selector} off"
         end
@@ -130,32 +115,29 @@ module OpeningHoursConverter
         result += rules.map(&:get).join('; ')
       end
 
-      return result.strip
+      result.strip
     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
 
-      date_range = OpeningHoursConverter::DateRange.new(OpeningHoursConverter::WideInterval.new.holiday("PH", start_year, end_year))
+      date_range = OpeningHoursConverter::DateRange.new(OpeningHoursConverter::WideInterval.new.holiday('PH', start_year, end_year))
 
       rule = OpeningHoursConverter::OpeningHoursRule.new
       date = OpeningHoursConverter::OpeningHoursDate.new(date_range.wide_interval, [-1])
       rule.add_date(date)
       rule.is_defined_off = true
 
-      return [ rule ]
+      [rule]
     end
 
     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))
+      date_range = OpeningHoursConverter::DateRange.new(OpeningHoursConverter::WideInterval.new.holiday('PH', start_year, end_year))
 
       for i in 0..6
         intervals.each do |interval|
@@ -175,8 +157,7 @@ module OpeningHoursConverter
         end
       end
 
-
-      return [ rule ]
+      [rule]
     end
 
     def build_day(date_range)
@@ -193,7 +174,7 @@ module OpeningHoursConverter
         end
       end
 
-      return [ rule ]
+      [rule]
     end
 
     def build_week(date_range)
@@ -218,22 +199,19 @@ module OpeningHoursConverter
             else
               md_off += 1
             end
-            if !merged
-              result << days[index]
-            end
+            result << days[index] if !merged
           end
         elsif days_status[index] <= 0 && days_status[index] > -8
           days_status[index] = index + 1
           last_same_day = index
           same_day_count = 1
 
-          for j in (index+1)...days.length do
-            if day.same_time?(days[j])
-              days_status[j] = index + 1
-              day.add_weekday(j)
-              last_same_day = j
-              same_day_count += 1
-            end
+          for j in (index + 1)...days.length do
+            next unless day.same_time?(days[j])
+            days_status[j] = index + 1
+            day.add_weekday(j)
+            last_same_day = j
+            same_day_count += 1
           end
           if same_day_count == 1
             result << day
@@ -246,22 +224,19 @@ module OpeningHoursConverter
           end
         end
       end
-      if result == [] && days_status == [8, 8, 8, 8, 8, 8, 8]
-        result = days
-      end
+      result = days if result == [] && days_status == [8, 8, 8, 8, 8, 8, 8]
 
       result = merge_days(result)
 
-      return result
+      result
     end
 
     def build_week_diff(date_range, general_date_range)
       intervals = date_range.typical.get_intervals_diff(general_date_range.typical)
       days = create_time_intervals(
         date_range.wide_interval,
-        intervals[:open])
-
-
+        intervals[:open]
+      )
 
       intervals[:closed].each do |interval|
         for i in interval.day_start..interval.day_end do
@@ -287,10 +262,8 @@ module OpeningHoursConverter
             end
           end
 
-          if !merged
-            result << day
-          end
-        elsif day.is_off? && day.time.length == 0
+          result << day if !merged
+        elsif day.is_off? && day.time.empty?
           days_status[index] = 8
         elsif days_status[index] <= 0 && days_status[index] > -8
           days_status[index] = index + 1
@@ -299,12 +272,11 @@ module OpeningHoursConverter
           result << day
 
           for j in (index + 1)...days.length do
-            if day.same_time?(days[j])
-              days_status[j] = index + 1
-              day.add_weekday(j)
-              last_same_day = j
-              same_day_count += 1
-            end
+            next unless day.same_time?(days[j])
+            days_status[j] = index + 1
+            day.add_weekday(j)
+            last_same_day = j
+            same_day_count += 1
           end
 
           if same_day_count == 1
@@ -314,12 +286,9 @@ module OpeningHoursConverter
             result << day
           elsif same_day_count > 2
             for j in (index + 1)...last_same_day do
-              if days_status[j] == 0
-                days_status[j] = -index - 1
-                if days[j].time.length > 0
-                  day.add_overwritten_weekday(j)
-                end
-              end
+              next unless days_status[j] == 0
+              days_status[j] = -index - 1
+              day.add_overwritten_weekday(j) if !days[j].time.empty?
             end
             day.add_weekday(last_same_day)
             result << day
@@ -328,11 +297,11 @@ module OpeningHoursConverter
         end
       end
       result = merge_days(result)
-      return result
+      result
     end
 
     def merge_days(rules)
-      return rules if rules.length == 0
+      return rules if rules.empty?
       result = []
       result << rules[0]
       dm = 0
@@ -350,51 +319,49 @@ module OpeningHoursConverter
           end
           dm += 1
         end
-        if !date_merged
-          result << rules[d]
-        end
+        result << rules[d] if !date_merged
       end
 
-      return result
+      result
     end
 
     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 ]))
+        days[i].add_date(OpeningHoursConverter::OpeningHoursDate.new(wide_interval, [i]))
       end
 
       intervals.each do |interval|
-        if !interval.nil?
-          begin
-            if interval.day_start == interval.day_end
-              days[interval.day_start].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, interval.end))
-              days[interval.day_start].is_defined_off = days[interval.day_start].is_defined_off ? true : interval.is_off
-            elsif interval.day_end - interval.day_start == 1
-              days[interval.day_start].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, MINUTES_MAX))
-              days[interval.day_start].is_defined_off = days[interval.day_start].is_defined_off ? true : interval.is_off
-              days[interval.day_end].add_time(OpeningHoursConverter::OpeningHoursTime.new(0, interval.end))
-              days[interval.day_end].is_defined_off = days[interval.day_end].is_defined_off ? true : interval.is_off
-            else
-              for j in interval.day_start..interval.day_end
-                days[j].is_defined_off = days[j].is_defined_off ? true : interval.is_off
-                if j == interval.day_start
-                  days[j].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, MINUTES_MAX))
-                elsif j == interval.day_end
-                  days[j].add_time(OpeningHoursConverter::OpeningHoursTime.new(0, interval.end))
-                else
-                  days[j].add_time(OpeningHoursConverter::OpeningHoursTime.new(0, MINUTES_MAX))
-                end
+        next if interval.nil?
+
+        begin
+          if interval.day_start == interval.day_end
+            days[interval.day_start].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, interval.end))
+            days[interval.day_start].is_defined_off = days[interval.day_start].is_defined_off ? true : interval.is_off
+          elsif interval.day_end - interval.day_start == 1
+            days[interval.day_start].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, MINUTES_MAX))
+            days[interval.day_start].is_defined_off = days[interval.day_start].is_defined_off ? true : interval.is_off
+            days[interval.day_end].add_time(OpeningHoursConverter::OpeningHoursTime.new(0, interval.end))
+            days[interval.day_end].is_defined_off = days[interval.day_end].is_defined_off ? true : interval.is_off
+          else
+            for j in interval.day_start..interval.day_end
+              days[j].is_defined_off = days[j].is_defined_off ? true : interval.is_off
+              if j == interval.day_start
+                days[j].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, MINUTES_MAX))
+              elsif j == interval.day_end
+                days[j].add_time(OpeningHoursConverter::OpeningHoursTime.new(0, interval.end))
+              else
+                days[j].add_time(OpeningHoursConverter::OpeningHoursTime.new(0, MINUTES_MAX))
               end
             end
-          rescue Exception => e
-            puts e
           end
+        rescue Exception => e
+          puts e
         end
       end
 
-      return days
+      days
     end
   end
 end