opening_hours_converter 1.5.3 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 409f7e2aaf835c458739af6789add6a5b124779d
-  data.tar.gz: ccb1748b1c0f447a220b2f687468833d15382f78
+  metadata.gz: 55f6b611b6d6c7dee28596d842441e9201b69866
+  data.tar.gz: c20fa4d736826c39c4625ae2cac7a4497fa3ee24
 SHA512:
-  metadata.gz: 13bb10fe1ecd18ba1f2a6436cc2996162bc626a7b0d91e0e44ac984728f77fab58f96aa2491abd81a4e09844c9b0e5c0ee99da445321695cd54e1aafd3cea9a4
-  data.tar.gz: b14b6d859a4efabe586ff8c9d13dfb8ecc8bb6f66394ac7cbb959db21bd5a49523601d541e09c656095fab9165da9b9486c8b8506dde84d92b5caadd1dbf06f1
+  metadata.gz: ce5333e34fef43072928e868b3e66f92543acf80c5af99dc517dcb385b9d26597765cc18e4db60eeafca013b0bf927f365fedcf6144ed459d1bb36e95137ff29
+  data.tar.gz: 529acd00a440bdc7d3947cea333324a5f4a87acae235dfa1be4d811a1278a5cd29582b35f9d9961a297c4515e40a7fa35673dee3321330abc404511fbe83629a

data/lib/opening_hours_converter/day.rb

@@ -16,8 +16,12 @@ module OpeningHoursConverter
         if !interval.nil?
           start_minute = nil
           end_minute = nil
+          off = interval.is_off
 
-          if interval.day_start == interval.day_end || interval.day_end == DAYS_MAX && interval.end == MINUTES_MAX
+          if off
+            start_minute = 0
+            end_minute = MINUTES_MAX
+          elsif interval.day_start == interval.day_end || interval.day_end == DAYS_MAX && interval.end == MINUTES_MAX
             start_minute = interval.start
             end_minute = interval.end
           elsif interval.day_end == interval.day_start + 1 && interval.end == 0
@@ -27,7 +31,7 @@ module OpeningHoursConverter
 
           unless start_minute.nil? && end_minute.nil?
             for minute in start_minute..end_minute
-              minute_array[minute] = true
+              minute_array[minute] = off ? "off" : true
             end
           else
             raise "Invalid interval #{interval.inspect}"
@@ -44,18 +48,23 @@ module OpeningHoursConverter
         intervals = []
         minute_start = -1
         minute_end = nil
+        off = false
+
         minute_array.each_with_index do |minute, i|
           if i == 0 && minute
+            off = true if minute == "off"
             minute_start = i
           elsif i == minute_array.length - 1 && minute
-            intervals << OpeningHoursConverter::Interval.new(0, minute_start, 0, i - 1)
+            intervals << OpeningHoursConverter::Interval.new(0, minute_start, 0, i - 1, off)
             minute_start = -1
+            off = false
           else
             if minute && minute_start < 0
               minute_start = i
             elsif !minute && minute_start >= 0
-              intervals << OpeningHoursConverter::Interval.new(0, minute_start, 0, i - 1)
+              intervals << OpeningHoursConverter::Interval.new(0, minute_start, 0, i - 1, off)
               minute_start = -1
+              off = false
             end
           end
         end
@@ -85,7 +94,7 @@ module OpeningHoursConverter
     def copy_intervals(intervals)
       @intervals = []
       intervals.each do |interval|
-        if !interval.nil? && interval.day_start == 0 && interval.day_end == 0
+        if !interval.nil? && !interval.is_off && interval.day_start == 0 && interval.day_end == 0
           @intervals << interval.dup
         end
       end

data/lib/opening_hours_converter/interval.rb

@@ -3,13 +3,15 @@ require 'opening_hours_converter/constants'
 module OpeningHoursConverter
   class Interval
     include Constants
-    attr_reader :day_start, :day_end, :start, :end
+    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)
       @day_start = day_start
       @day_end = day_end
       @start = min_start
       @end = min_end
+      @is_off = is_off
 
       if @day_end == 0 && @end == 0
         @day_end = DAYS_MAX

data/lib/opening_hours_converter/opening_hours_builder.rb

@@ -14,10 +14,12 @@ module OpeningHoursConverter
 
       date_ranges.each_with_index do |date_range, date_range_index|
         if !date_range.nil?
-          date_range.typical.intervals.each_with_index do |interval, interval_id|
-            if interval&.day_start == -2 && interval&.day_start == interval&.day_end
-              date_range.typical.remove_interval(interval_id)
-              day_ph = true
+          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
+                date_range.typical.remove_interval(interval_id)
+                day_ph = true
+              end
             end
           end
 
@@ -38,7 +40,7 @@ module OpeningHoursConverter
           end
 
           if date_range_index == 0 || range_general.nil?
-            if date_range.wide_interval.type == "holiday"
+            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?
@@ -104,8 +106,8 @@ module OpeningHoursConverter
           end
         end
       end
-      result = ""
 
+      result = ""
       if rules.length == 0
         date_ranges.each do |dr|
           result += "#{dr.wide_interval.get_time_selector} off"
@@ -123,18 +125,33 @@ module OpeningHoursConverter
     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))
 
+      for i in 0..6
+        intervals.each do |interval|
+          if !interval.nil?
+            date_range.typical.add_interval(OpeningHoursConverter::Interval.new(i, interval.start, i, interval.end, interval.is_off))
+          end
+        end
+      end
       rule = OpeningHoursConverter::OpeningHoursRule.new
       date = OpeningHoursConverter::OpeningHoursDate.new(date_range.wide_interval, date_range.wide_interval.type, [-1])
       rule.add_date(date)
 
-      intervals.each do |interval|
+      date_range.typical.intervals.each do |interval|
         if !interval.nil?
           rule.add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, interval.end))
+          rule.is_defined_off = rule.is_defined_off || interval.is_off
         end
       end
 
+
       return [ rule ]
     end
 
@@ -148,6 +165,7 @@ module OpeningHoursConverter
       intervals.each do |interval|
         if !interval.nil?
           rule.add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, interval.end))
+          rule.is_defined_off = rule.is_defined_off ? true : interval.is_off
         end
       end
 
@@ -158,7 +176,6 @@ module OpeningHoursConverter
       result = []
 
       intervals = date_range.typical.get_intervals(true)
-
       days = create_time_intervals(date_range.wide_interval, date_range.wide_interval.type, intervals)
 
       days_status = Array.new(OSM_DAYS.length, 0)
@@ -205,6 +222,7 @@ module OpeningHoursConverter
           end
         end
       end
+
       result = merge_days(result)
 
       return result
@@ -212,13 +230,13 @@ module OpeningHoursConverter
 
     def build_week_diff(date_range, general_date_range)
       intervals = date_range.typical.get_intervals_diff(general_date_range.typical)
-
-      time_intervals =
       days = create_time_intervals(
         date_range.wide_interval,
         date_range.wide_interval.type,
         intervals[:open])
 
+
+
       intervals[:closed].each do |interval|
         for i in interval.day_start..interval.day_end do
           days[i].add_time(OpeningHoursConverter::OpeningHoursTime.new)
@@ -326,11 +344,15 @@ module OpeningHoursConverter
           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

data/lib/opening_hours_converter/opening_hours_parser.rb

@@ -4,6 +4,7 @@ require 'json'
 module OpeningHoursConverter
   class OpeningHoursParser
     include Constants
+
     def initialize
       @RGX_RULE_MODIFIER = /^(open|closed|off)$/i
       @RGX_WEEK_KEY = /^week$/
@@ -31,9 +32,7 @@ module OpeningHoursConverter
       wide_range_selector = nil
       month_selector = nil
 
-      times = nil
       weekdays = nil
-      weeks = nil
       months = nil
       years = nil
 
@@ -43,51 +42,68 @@ module OpeningHoursConverter
       res_dr_id = nil
 
       blocks.each do |block|
-        rule_modifier = nil
         block.strip!
         next if block.length == 0
 
         tokens = tokenize(block)
-        current_token = tokens.length - 1
-
-        # get comment
-        if current_token >= 0 && is_comment?(tokens[current_token])
-          comment = tokens[current_token]
-          current_token -= 1
-        end
+        @current_token = tokens.length - 1
 
+        weekdays = {}
 
-        # get state
-        if current_token >= 0 && is_rule_modifier?(tokens[current_token])
-          rule_modifier = tokens[current_token].downcase
-          current_token -= 1
+        # get comment
+        if @current_token >= 0 && is_comment?(tokens[@current_token])
+          comment = tokens[@current_token]
+          @current_token -= 1
         end
 
-        times = []
-        if current_token >= 0 && is_time?(tokens[current_token])
-          time_selector = tokens[current_token]
-          times = get_times(time_selector)
-          current_token -= 1
-        end
 
-        # get weekdays selector
-        weekdays = []
-        holidays = []
-        if time_selector == "24/7"
-          weekdays << {from: 0, to: 6}
-        elsif current_token >= 0 && is_weekday?(tokens[current_token]) && (@RGX_YEAR_PH =~ "#{tokens[current_token-1]} #{tokens[current_token]}").nil?
-          weekday_selector = tokens[current_token]
-          weekdays_and_holidays = get_weekdays(weekday_selector)
-          weekdays = weekdays_and_holidays[:weekdays]
-          holidays = weekdays_and_holidays[:holidays]
-          current_token -= 1
+        # get state and time associated with weekdays
+        while @current_token >= 0 && (is_rule_modifier?(tokens[@current_token]) || is_time?(tokens[@current_token]))
+          if is_rule_modifier?(tokens[@current_token])
+            local_modifier = tokens[@current_token].downcase
+            @current_token -= 1
+            begin
+              weekday_selector = tokens[@current_token]
+              weekdays_and_holidays = get_weekdays(weekday_selector)
+            rescue
+              weekdays[[{from: 0, to: 6}]] ||= {}
+              weekdays[[{from: 0, to: 6}]][:modifiers] ||= []
+              weekdays[[{from: 0, to: 6}]][:modifiers] << local_modifier
+            else
+              weekdays[weekdays_and_holidays] ||= {}
+              weekdays[weekdays_and_holidays][:modifiers] ||= []
+              weekdays[weekdays_and_holidays][:modifiers] << local_modifier
+              @current_token -= 1
+            end
+          else
+            local_times = []
+            while @current_token >= 0 && is_time?(tokens[@current_token])
+              time_selector = tokens[@current_token]
+              local_times.concat get_times(time_selector)
+              @current_token -= 1
+            end
+            begin
+              weekday_selector = tokens[@current_token]
+              weekdays_and_holidays = get_weekdays(weekday_selector)
+            rescue
+              weekdays[[{from: 0, to: 6}]] ||= {}
+              weekdays[[{from: 0, to: 6}]][:times] ||= []
+              weekdays[[{from: 0, to: 6}]][:times].concat(local_times)
+            else
+              weekdays[weekdays_and_holidays] ||= {}
+              weekdays[weekdays_and_holidays][:times] ||= []
+              weekdays[weekdays_and_holidays][:times].concat(local_times)
+              @current_token -= 1
+            end
+          end
         end
 
         months = []
         years = []
-        if current_token >= 0
+        holidays = []
+        if @current_token >= 0
           wide_range_selector = tokens[0]
-          for i in 1..current_token
+          for i in 1..@current_token
             wide_range_selector += " #{tokens[i]}"
           end
           if wide_range_selector.length > 0
@@ -100,8 +116,6 @@ module OpeningHoursConverter
                 years << get_year_month(wrs)
               elsif !(@RGX_MONTHDAY =~ wrs).nil?
                 months << get_month_day(wrs)
-              elsif !(@RGX_YEAR_PH =~ wrs).nil?
-                holidays << get_year_holiday(wrs)
               elsif !(@RGX_MONTH =~ wrs).nil?
                 months << get_month(wrs)
               elsif !(@RGX_YEAR =~ wrs).nil?
@@ -113,14 +127,14 @@ module OpeningHoursConverter
           end
         end
 
-        if current_token == tokens.length - 1
+        if @current_token == tokens.length - 1
           raise ArgumentError, "Unreadable string"
         end
-        # puts "months : #{months}"
+
         # puts "weekdays : #{weekdays}"
-        # puts "times : #{times}"
+        # puts "months : #{months}"
         # puts "years : #{years}"
-        # puts "rule_modifier : #{rule_modifier}"
+
         date_ranges = []
         if months.length > 0
           months.each do |month|
@@ -141,14 +155,6 @@ module OpeningHoursConverter
               date_ranges << date_range
             end
           end
-        elsif holidays.length > 0 && weekdays.length == 0
-          holidays.each do |holiday|
-            if holiday == "PH"
-              date_ranges << WideInterval.new.holiday(holiday)
-            elsif holiday[:holiday] == "PH"
-              date_ranges << WideInterval.new.holiday(holiday[:holiday], holiday[:start], holiday[:end])
-            end
-          end
         elsif years.length > 0
           years.each do |year|
             if !year[:from_day].nil?
@@ -178,22 +184,14 @@ module OpeningHoursConverter
           date_ranges << OpeningHoursConverter::WideInterval.new.always
         end
 
-
-        if weekdays.length > 0 && holidays.length > 0
-          weekdays << {from: -2, to: -2}
-          holidays = []
-        end
         if weekdays.length == 0
-          weekdays << {from: 0, to: OSM_DAYS.length - 1}
-        end
-        if times.length == 0
-          times << {from: 0, to: 24*60}
+          weekdays[[{from: 0, to: 6}]] = {}
+          weekdays[[{from: 0, to: 6}]][:times] = [{from: 0, to: 24*60}]
         end
 
         date_ranges.each do |dr|
           found_date_range = false
           res_dr_id = 0
-
           while res_dr_id < result.length && !found_date_range
             if result[res_dr_id].wide_interval.equals(dr) && result[res_dr_id].comment == comment
               found_date_range = true
@@ -222,37 +220,46 @@ module OpeningHoursConverter
             result << dr_obj
           end
 
-          for wd_id in 0...weekdays.length
-            if weekdays[wd_id][:from] <= weekdays[wd_id][:to]
-              for wd_rm in weekdays[wd_id][:from]..weekdays[wd_id][:to]
-                if dr_obj.defines_typical_week?
-                  dr_obj.typical.remove_intervals_during_day(wd_rm)
-                else
-                  dr_obj.typical.clear_intervals
+          weekdays.each do |weekday_ranges, weekday_object|
+            weekday_ranges.each do |weekday_range|
+              if weekday_range[:from] <= weekday_range[:to]
+                for wd_rm in weekday_range[:from]..weekday_range[:to]
+                  if dr_obj.defines_typical_week?
+                    dr_obj.typical.remove_intervals_during_day(wd_rm)
+                  else
+                    dr_obj.typical.clear_intervals
+                  end
                 end
-              end
-            else
-              for wd_rm in weekdays[wd_id][:from]..6
-                if dr_obj.defines_typical_week?
-                  dr_obj.typical.remove_intervals_during_day(wd_rm)
-                else
-                  dr_obj.typical.clear_intervals
+              else
+                for wd_rm in weekday_range[:from]..6
+                  if dr_obj.defines_typical_week?
+                    dr_obj.typical.remove_intervals_during_day(wd_rm)
+                  else
+                    dr_obj.typical.clear_intervals
+                  end
+                end
+                for wd_rm in 0..weekday_range[:to]
+                  if dr_obj.defines_typical_week?
+                    dr_obj.typical.remove_intervals_during_day(wd_rm)
+                  else
+                    dr_obj.typical.clear_intervals
+                  end
                 end
               end
-              for wd_rm in 0..weekdays[wd_id][:to]
-                if dr_obj.defines_typical_week?
-                  dr_obj.typical.remove_intervals_during_day(wd_rm)
-                else
-                  dr_obj.typical.clear_intervals
+
+              if weekday_object[:modifiers]
+                weekday_object[:modifiers].each do |modifier|
+                  if modifier == "closed" || modifier == "off"
+                    remove_interval(dr_obj, weekday_range)
+                    add_off_interval(dr_obj, weekday_range)
+                  end
                 end
               end
-            end
 
-            for t_id in 0...times.length
-              if rule_modifier == "closed" || rule_modifier == "off"
-                remove_interval(dr_obj, weekdays[wd_id], times[t_id])
-              else
-                add_interval(dr_obj.typical, weekdays[wd_id], times[t_id])
+              if weekday_object[:times]
+                weekday_object[:times].each do |time_range|
+                  add_interval(dr_obj.typical, weekday_range, time_range)
+                end
               end
             end
           end
@@ -443,7 +450,6 @@ module OpeningHoursConverter
     end
 
     def get_weekdays(weekday_selector)
-      holidays = []
       weekdays = []
       wd_from = nil
       wd_to = nil
@@ -451,7 +457,7 @@ module OpeningHoursConverter
       weekday_selector = weekday_selector.split(',')
       weekday_selector.each do |wd|
         if !(@RGX_HOLIDAY =~ wd).nil?
-          holidays << wd
+          weekdays << {from: -2, to: -2}
         elsif !(@RGX_WD =~ wd).nil?
           single_weekday = wd.split('-')
 
@@ -468,10 +474,10 @@ module OpeningHoursConverter
         end
       end
 
-      { weekdays: weekdays, holidays: holidays }
+      weekdays
     end
 
-    def remove_interval(date_range, weekdays, times)
+    def remove_interval(date_range, weekdays)
       if date_range.typical.instance_of?(OpeningHoursConverter::Day)
         date_range.typical.clear_intervals
       else
@@ -530,6 +536,33 @@ module OpeningHoursConverter
       end
     end
 
+    def add_off_interval(date_range, weekdays)
+      if date_range.typical.instance_of?(OpeningHoursConverter::Day)
+        if weekdays[:from] != 0
+          weekdays = weekdays.dup
+          weekdays[:from] = 0
+          if times[:from] <= times[:to]
+            weekdays[:to] = 0
+          else
+            weekdays[:to] = 1
+          end
+        end
+      end
+
+      if weekdays[:from] <= weekdays[:to]
+        for wd in weekdays[:from]..weekdays[:to]
+          date_range.typical.add_interval(OpeningHoursConverter::Interval.new(wd, 0, wd, 24*60, true))
+        end
+      else
+        for wd in weekdays[:from]..6
+          date_range.typical.add_interval(OpeningHoursConverter::Interval.new(wd, 0, wd, 24*60, true))
+        end
+        for wd in 0..weekdays[:to]
+          date_range.typical.add_interval(OpeningHoursConverter::Interval.new(wd, 0, wd, 24*60, true))
+        end
+      end
+    end
+
     def add_interval_wd(typical, times, wd)
       if times[:to] >= times[:from]
         typical.add_interval(OpeningHoursConverter::Interval.new(wd, times[:from], wd, times[:to]))
@@ -546,11 +579,32 @@ module OpeningHoursConverter
     def tokenize(block)
       if block.split('"').length > 1
         comment = block.split('"')[1]
-        tokens = block.split('"')[0].split(' ')
+        tokens = block.split('"')[0].split(/\s|,/)
         tokens << "\"#{comment}\""
+        merge_weekdays_tokens(tokens)
       else
-        block.split(' ')
+        merge_weekdays_tokens(block.split(/\s|,/))
+      end
+    end
+
+    def merge_weekdays_tokens(tokens)
+      new_tokens = []
+      to_merge = []
+      tokens.each_with_index do |token, index|
+        if is_weekday?(token)
+          to_merge << token
+          if index == tokens.length - 1
+            new_tokens << to_merge.join(',')
+          end
+        elsif !to_merge.empty?
+          new_tokens << to_merge.join(',')
+          new_tokens << token
+          to_merge = []
+        else
+          new_tokens << token
+        end
       end
+      new_tokens
     end
 
     def as_minutes(time)

data/lib/opening_hours_converter/opening_hours_rule.rb

@@ -3,25 +3,18 @@ require 'opening_hours_converter/constants'
 module OpeningHoursConverter
   class OpeningHoursRule
     include Constants
-    attr_accessor :date, :time, :comment
+    attr_accessor :date, :time, :comment, :is_defined_off
 
     def initialize
       @date = []
       @time = []
+      @is_defined_off = false
       @comment = ""
     end
 
     def get
       result = ""
-      if @date.length == 1 && @date[0].wide_type == "holiday"
-        if !@date[0].wide.start[:year].nil?
-          result += @date[0].wide.start[:year].to_s
-        end
-        if !@date[0].wide.end.nil?
-          result += "-#{@date[0].wide.end[:year].to_s}"
-        end
-        result += " PH"
-      elsif @date.length > 0
+      if @date.length > 0
         result += get_wide_selector
       end
 
@@ -31,7 +24,9 @@ module OpeningHoursConverter
           result += " #{wd}"
         end
       end
-      if @time.length > 0
+      if @is_defined_off
+        result += " off"
+      elsif @time.length > 0
         result += " "
         @time.uniq.each_with_index do |t, i|
           if (i > 0)
@@ -57,8 +52,18 @@ module OpeningHoursConverter
     end
 
     def get_wide_selector
+      if @date.length == 1 && @date[0].wide.type == "holiday"
+        if @date[0].wide.start[:year].nil?
+          return "PH"
+        else
+          if @date[0].wide.end && @date[0].wide.end[:year]
+            return "#{@date[0].wide.start[:year]}-#{@date[0].wide.end[:year]} PH"
+          else
+            return "#{@date[0].wide.start[:year]} PH"
+          end
+        end
+      end
       years = OpeningHoursConverter::Year.build_day_array_from_dates(@date)
-
       year_start = -1
       month_start = -1
       day_start = -1

data/lib/opening_hours_converter/opening_hours_time.rb

@@ -1,6 +1,6 @@
 module OpeningHoursConverter
   class OpeningHoursTime
-    attr_reader :start, :end
+    attr_reader :start, :end, :priority
 
     def initialize(minute_start=nil, minute_end=nil)
       @start = minute_start

data/lib/opening_hours_converter/week.rb

@@ -17,14 +17,26 @@ module OpeningHoursConverter
           for day in interval.day_start..interval.day_end
             start_minute = (day == interval.day_start) ? interval.start : 0
             end_minute = (day == interval.day_end) ? interval.end : MINUTES_MAX
-            if start_minute && end_minute
-              for minute in start_minute..end_minute
-                minute_array[day][minute] = true
+            if interval.is_off
+              if start_minute && end_minute
+                for minute in 0..MINUTES_MAX
+                  minute_array[day][minute] = "off"
+                end
+              end
+            else
+              if start_minute && end_minute
+                if minute_array[day][0] == "off"
+                  minute_array[day] = Array.new(MINUTES_MAX + 1, false)
+                end
+                for minute in start_minute..end_minute
+                  minute_array[day][minute] = true
+                end
               end
             end
           end
         end
       end
+
       minute_array
     end
 
@@ -35,37 +47,41 @@ module OpeningHoursConverter
         day_start = -1
         minute_start = -1
         minute_end = nil
-
-
+        off = false
         minute_array.each_with_index do |day, day_index|
           day.each_with_index do |minute, minute_index|
             if day_index == 0 && minute_index == 0
               if minute
+                off = true if minute == "off"
                 day_start = day_index
                 minute_start = minute_index
               end
             elsif minute && day_index == DAYS_MAX && minute_index == day.length - 1
+              off = true if minute == "off"
               if day_start >= 0
-                intervals << OpeningHoursConverter::Interval.new(day_start, minute_start, day_index, minute_index)
+                intervals << OpeningHoursConverter::Interval.new(day_start, minute_start, day_index, minute_index, off)
               else
-                intervals << OpeningHoursConverter::Interval.new(6, minute_index, 6, minute_index)
+                intervals << OpeningHoursConverter::Interval.new(6, minute_index, 6, minute_index, off)
               end
             else
               if minute && day_start < 0
+                off = true if minute == "off"
                 day_start = day_index
                 minute_start = minute_index
               elsif !minute && day_start >= 0
                 if minute_index == 0
-                  intervals << OpeningHoursConverter::Interval.new(day_start, minute_start, day_index - 1, MINUTES_MAX)
+                  intervals << OpeningHoursConverter::Interval.new(day_start, minute_start, day_index - 1, MINUTES_MAX, off)
                 else
-                  intervals << OpeningHoursConverter::Interval.new(day_start, minute_start, day_index, minute_index - 1)
+                  intervals << OpeningHoursConverter::Interval.new(day_start, minute_start, day_index, minute_index - 1, off)
                 end
+                off = false
                 day_start = -1
                 minute_start = - 1
               end
             end
           end
         end
+
         return intervals
       else
         return @intervals
@@ -76,16 +92,19 @@ module OpeningHoursConverter
       self_minutes_array = get_as_minute_array
       other_minutes_array = week.get_as_minute_array
 
+
       intervals = { open: [], closed: [] }
       day_start = -1
       min_start = -1
 
-
       for d in 0..DAYS_MAX
         diff_day = false
         m = 0
+        off = false
         intervals_length = intervals[:open].length
         while m <= MINUTES_MAX
+          off = self_minutes_array[d][m] == "off"
+          break if off
           # Copy entire day
           if diff_day
             # first minute of monday
@@ -97,7 +116,7 @@ module OpeningHoursConverter
             # last minute of sunday
             elsif d == DAYS_MAX && m == MINUTES_MAX
               if day_start >= 0 && self_minutes_array[d][m]
-                intervals[:open] << OpeningHoursConverter::Interval.new(day_start, min_start, d, m)
+                intervals[:open] << OpeningHoursConverter::Interval.new(day_start, min_start, d, m, off)
               end
             #  other days and minutes
             else
@@ -108,9 +127,9 @@ module OpeningHoursConverter
               # end interval
               elsif !self_minutes_array[d][m] && day_start >= 0
                 if m == 0
-                  intervals[:open] << OpeningHoursConverter::Interval.new(day_start, min_start, d - 1, MINUTES_MAX)
+                  intervals[:open] << OpeningHoursConverter::Interval.new(day_start, min_start, d - 1, MINUTES_MAX, off)
                 else
-                  intervals[:open] << OpeningHoursConverter::Interval.new(day_start, min_start, d, m - 1)
+                  intervals[:open] << OpeningHoursConverter::Interval.new(day_start, min_start, d, m - 1, off)
                 end
                 day_start = -1
                 min_start = -1
@@ -119,7 +138,12 @@ module OpeningHoursConverter
             m += 1
           # check diff
           else
-            diff_day = self_minutes_array[d][m] ? !other_minutes_array[d][m] : other_minutes_array[d][m]
+            if !self_minutes_array[d][m]
+              diff_day = other_minutes_array[d][m] != "off" && other_minutes_array[d][m]
+            else
+              diff_day = other_minutes_array[d][m] == "off" || !other_minutes_array[d][m]
+            end
+
             if diff_day
               m = 0
             else
@@ -127,19 +151,20 @@ module OpeningHoursConverter
             end
           end
         end
-        if !diff_day && day_start > -1
-          intervals[:open] << OpeningHoursConverter::Interval.new(day_start, min_start, d-1, MINUTES_MAX)
+        if !diff_day && day_start > -1 && !off
+          intervals[:open] << OpeningHoursConverter::Interval.new(day_start, min_start, d-1, MINUTES_MAX, off)
           day_start = -1
           min_start = -1
         end
-        if diff_day && day_start == -1 && intervals_length == intervals[:open].length
+        if diff_day && day_start == -1 && intervals_length == intervals[:open].length || off
           if intervals[:closed].length > 0 && intervals[:closed][intervals[:closed].length - 1].day_end == d - 1
-            intervals[:closed][intervals[:closed].length - 1] = OpeningHoursConverter::Interval.new(intervals[:closed][intervals[:closed].length - 1].day_start, 0, d, MINUTES_MAX)
+            intervals[:closed][-1] = OpeningHoursConverter::Interval.new(intervals[:closed].last.day_start, 0, d, MINUTES_MAX, off)
           else
-            intervals[:closed] << OpeningHoursConverter::Interval.new(d, 0, d, MINUTES_MAX)
+            intervals[:closed] << OpeningHoursConverter::Interval.new(d, 0, d, MINUTES_MAX, off)
           end
         end
       end
+
       return intervals
     end
 
@@ -165,10 +190,10 @@ module OpeningHoursConverter
             if day_diff > 1 || day_diff == 0 || interval.day_start == day || interval.start <= interval.end
               if interval.day_end - interval.day_start >= 1 && interval.start <= interval.end
                 if interval.day_start < day
-                  add_interval(OpeningHoursConverter::Interval.new(interval.day_start, interval.start, day - 1, 24*60))
+                  add_interval(OpeningHoursConverter::Interval.new(interval.day_start, interval.start, day - 1, 24*60, interval.is_off))
                 end
                 if interval.day_end > day
-                  add_interval(OpeningHoursConverter::Interval.new(day + 1, 0, interval.day_end, interval.end))
+                  add_interval(OpeningHoursConverter::Interval.new(day + 1, 0, interval.day_end, interval.end, interval.is_off))
                 end
               end
               remove_interval(i)
@@ -184,8 +209,9 @@ module OpeningHoursConverter
 
     def copy_intervals(intervals)
       @intervals = []
+
       intervals.each do |interval|
-        unless interval.nil?
+        if !interval.nil? && !interval.is_off
           @intervals << interval.dup
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opening_hours_converter
 version: !ruby/object:Gem::Version
-  version: 1.5.3
+  version: 1.6.0
 platform: ruby
 authors:
 - Ziserman Martin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-21 00:00:00.000000000 Z
+date: 2017-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json