opening_hours_converter 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3d01e4f3c1f4306964ee63ade1bb6e018722446a
+  data.tar.gz: 5671d033a5182245b46ff12838c2ccb11de8f7e5
+SHA512:
+  metadata.gz: 99ec2ff1a1232f5ff42a6f0c015c4211fdf0a0a801b98c42d448e3b0828dfe0275e5e3246bd39403c716def6c3cbb241b35ad13a4a2114db592c12a0f6b38cb7
+  data.tar.gz: 4438647b1676e08b941159403631eefbc873e90970e24176006c30cb10406822b65a978e93d930fea8486c6b3c4b9f86ca40af42d5910484a633890a70ca9a4c

data/lib/opening_hours_converter/constants.rb

@@ -0,0 +1,22 @@
+module OpeningHoursConverter
+  module Constants
+    DAYS = {
+      LUNDI: 0,
+      MARDI: 1,
+      MERCREDI: 2,
+      JEUDI: 3,
+      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 ]
+    MINUTES_MAX = 1440
+    DAYS_MAX = 6
+    YEAR_DAYS_MAX = 365
+  end
+end

data/lib/opening_hours_converter/date_range.rb

@@ -0,0 +1,48 @@
+module OpeningHoursConverter
+  class DateRange
+    attr_accessor :wide_interval, :typical
+
+    def initialize(w=nil)
+      @wide_interval = nil
+      @typical = nil
+      update_range(w)
+    end
+
+    def defines_typical_day?
+      @typical.instance_of?(OpeningHoursConverter::Day)
+    end
+
+    def defines_typical_week?
+      @typical.instance_of?(OpeningHoursConverter::Week)
+    end
+
+    def update_range(wide)
+      @wide_interval = !wide.nil? ? wide : OpeningHoursConverter::WideInterval.new.always
+
+      if @typical.nil?
+        case @wide_interval.type
+        when "day"
+          if @wide_interval.end.nil?
+            @typical = OpeningHoursConverter::Day.new
+          else
+            @typical = OpeningHoursConverter::Week.new
+          end
+        when "week"
+          @typical = OpeningHoursConverter::Week.new
+        when "month"
+          @typical = OpeningHoursConverter::Week.new
+        when "always"
+          @typical = OpeningHoursConverter::Week.new
+        end
+      end
+    end
+
+    def has_same_typical?(date_range)
+      defines_typical_day? == date_range.defines_typical_day? && @typical.same_as?(date_range.typical)
+    end
+
+    def is_general_for?(date_range)
+      defines_typical_day? == date_range.defines_typical_day? && @wide_interval.contains?(date_range.wide_interval)
+    end
+  end
+end

data/lib/opening_hours_converter/day.rb

@@ -0,0 +1,100 @@
+require 'opening_hours_converter/constants'
+
+module OpeningHoursConverter
+  class Day
+    include Constants
+    attr_accessor :intervals
+
+    def initialize
+      @intervals = []
+    end
+
+    def get_as_minute_array
+      minute_array = Array.new(MINUTES_MAX + 1, false)
+
+      @intervals.each do |interval|
+        if !interval.nil?
+          start_minute = nil
+          end_minute = nil
+
+          if interval.day_start == interval.day_end || interval.day_end == DAYS_MAX && interval.end == MINUTES_MAX
+            start_minute = interval.start
+            end_minute = interval.end
+          end
+
+          unless start_minute.nil? && end_minute.nil?
+            for minute in start_minute..end_minute
+              minute_array[minute] = true
+            end
+          else
+            raise "Invalid interval #{interval.inspect}"
+          end
+        end
+      end
+
+      minute_array
+    end
+
+    def get_intervals(clean=false)
+      if clean
+        minute_array = get_as_minute_array
+        intervals = []
+        minute_start = -1
+        minute_end = nil
+        minute_array.each_with_index do |minute, i|
+          if i == 0
+            if minute
+              minute_start = i
+            end
+          elsif i == minute_array.length - 1
+            if minute
+              intervals << OpeningHoursConverter::Interval.new(0, minute_start, 0, i - 1)
+              minute_start = -1
+            end
+          else
+            if minute && minute_start < 0
+              minute_start = i
+            elsif !minute && minute_start >= 0
+              intervals << OpeningHoursConverter::Interval.new(0, minute_start, 0, i - 1)
+              minute_start = -1
+            end
+          end
+        end
+        intervals
+      else
+        @intervals
+      end
+    end
+
+    def add_interval(interval)
+      @intervals << interval
+      return @intervals.length - 1
+    end
+
+    def edit_interval(id, interval)
+      @intervals[id] = interval
+    end
+
+    def remove_interval(id)
+      @intervals[id] = nil
+    end
+
+    def clear_intervals
+      @intervals = []
+    end
+
+    def copy_intervals(intervals)
+      @intervals = []
+      intervals.each do |interval|
+        if !interval.nil? && interval.day_start == 0 && interval.day_end == 0
+          @intervals << interval.dup
+        end
+      end
+      @intervals = get_intervals(true)
+    end
+
+    def same_as?(day)
+      day.get_as_minute_array == get_as_minute_array
+    end
+  end
+end

data/lib/opening_hours_converter/interval.rb

@@ -0,0 +1,20 @@
+require 'opening_hours_converter/constants'
+
+module OpeningHoursConverter
+  class Interval
+    include Constants
+    attr_accessor :day_start, :day_end, :start, :end
+
+    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
+
+      if @day_end == 0 && @end == 0
+        @day_end = DAYS_MAX
+        @end = MINUTES_MAX
+      end
+    end
+  end
+end

data/lib/opening_hours_converter/opening_hours_builder.rb

@@ -0,0 +1,368 @@
+require 'opening_hours_converter/constants'
+
+module OpeningHoursConverter
+  class OpeningHoursBuilder
+    include Constants
+    def build(date_ranges)
+      rules = []
+
+      oh_rules = nil
+      oh_rule_added = nil
+      range_general = nil
+      range_general_for = nil
+
+      date_ranges.each_with_index do |date_range, date_range_index|
+        if !date_range.nil?
+          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
+            end
+            range_general_id -= 1
+          end
+
+          if date_range_index == 0 || range_general.nil?
+            if 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
+          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])
+                  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
+                end
+              else
+                rule_index+=1
+              end
+
+            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
+
+              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
+              oh_rule_index += 1
+            else
+              oh_rule_index += 1
+            end
+          end
+        end
+      end
+
+
+      result = ""
+      rules.each_with_index do |rule, rule_index|
+        if rule_index > 0
+          result += "; "
+        end
+        result += rule.get
+      end
+
+      return result
+    end
+
+    def build_day(date_range)
+      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])
+      rule.add_date(date)
+
+      intervals.each do |interval|
+        if !interval.nil?
+          rule.add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, interval.end))
+        end
+      end
+
+      return [ rule ]
+    end
+
+    def build_week(date_range)
+      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)
+
+      monday0 = time_intervals[0]
+      sunday24 = time_intervals[1]
+      days = time_intervals[2]
+
+      days = night_monday_sunday(days, monday0, sunday24)
+
+
+      days_status = Array.new(OSM_DAYS.length, 0)
+
+      days.each_with_index do |day, index|
+        if day.is_off? && days_status[index] == 0
+          days_status[index] = 8
+        elsif day.is_off? && days_status[index] < 0 && days_status[index] > -8
+          days_status[index] = -8
+          merged = false
+          md_off = 0
+          while !merged && md_off < index
+            if days[md_off].is_off?
+              days[md_off].add_weekday(index)
+              merged = true
+            else
+              md_off += 1
+            end
+            if !merged
+              result << days[index]
+            end
+          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
+          end
+          if same_day_count == 1
+            result << day
+          elsif same_day_count == 2
+            day.add_weekday(last_same_day)
+            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
+                day.add_overwritten_weekday(j)
+              end
+            end
+            day.add_weekday(last_same_day)
+            result << day
+          end
+        end
+      end
+      result = merge_days(result)
+
+      return result
+    end
+
+    def build_week_diff(date_range, general_date_range)
+      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.type,
+        intervals[:open])
+      monday0 = time_intervals[0]
+      sunday24 = time_intervals[1]
+      days = time_intervals[2]
+      intervals[:closed].each do |interval|
+        for i in interval.day_start..interval.day_end do
+          days[i].add_time(OpeningHoursConverter::OpeningHoursTime.new)
+        end
+      end
+
+      days = night_monday_sunday(days, monday0, sunday24)
+
+      days_status = Array.new(OSM_DAYS.length, 0)
+      result = []
+
+      days.each_with_index do |day, index|
+        if day.is_off? && day.time.length == 1
+          days_status[index] = -8
+          merged = false
+          md_off = 0
+
+          while !merged && md_off < index
+            if days[md_off].is_off? && days[md_off].time.length == 1
+              days[md_off].add_weekday(index)
+              merged = true
+            else
+              md_off += 1
+            end
+          end
+
+          if !merged
+            result << day
+          end
+        elsif day.is_off? && day.time.length == 0
+          days_status[index] = 8
+        elsif days_status[index] <= 0 && days_status[index] > -8
+          days_status[index] = index + 1
+          same_day_count = 1
+          last_same_day = 1
+          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
+          end
+
+          if same_day_count == 1
+            result << day
+          elsif same_day_count == 2
+            day.add_weekday(last_same_day)
+            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
+            end
+            day.add_weekday(last_same_day)
+            result << day
+          end
+
+        end
+      end
+      result = merge_days(result)
+      return result
+    end
+
+    def merge_days(rules)
+      return rules if rules.length == 0
+      result = []
+      result << rules[0]
+      dm = 0
+
+      for d in 1...rules.length do
+        date_merged = false
+        dm = 0
+        while !date_merged && dm < d
+          if rules[dm].same_time?(rules[d])
+            wds = rules[d].date[0].weekdays
+            wds.each do |wd|
+              rules[dm].add_weekday(wd)
+            end
+            date_merged = true
+          end
+          dm += 1
+        end
+        if !date_merged
+          result << rules[d]
+        end
+      end
+
+      return result
+    end
+
+    def create_time_intervals(time_selector, type, intervals)
+      monday0 = -1
+      sunday24 = -1
+
+      days = []
+      for i in 0...7 do
+        days << OpeningHoursConverter::OpeningHoursRule.new
+        days[i].add_date(OpeningHoursConverter::OpeningHoursDate.new(time_selector, type, [ i ]))
+      end
+
+      intervals.each do |interval|
+        if !interval.nil?
+          if interval.day_start == DAYS_MAX && interval.day_end == DAYS_MAX && interval.end == MINUTES_MAX
+            sunday24 = interval.start
+          end
+          if interval.day_start == 0 && interval.day_end == 0 && interval.start == 0
+            monday0 = interval.end
+          end
+          begin
+            if interval.day_start == interval.day_end
+              days[interval.day_start].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, interval.end))
+            elsif interval.day_end - interval.day_start == 1
+              if interval.start > interval.end
+                days[interval.day_start].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, interval.end))
+              else
+                days[interval.day_start].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, MINUTES_MAX))
+                days[interval.day_end].add_time(OpeningHoursConverter::OpeningHoursTime.new(0, interval.end))
+              end
+            else
+              for j in interval.day_start..interval.day_end do
+                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
+            end
+          rescue Exception => e
+            puts e
+          end
+        end
+      end
+
+      return [ monday0, sunday24, days ]
+    end
+
+    def night_monday_sunday(days, monday0, sunday24)
+      if monday0 >= 0 && sunday24 >= 0 && monday0 < sunday24
+        days[0].time.sort! { |a, b| a.start <=> b.start }
+        days[6].time.sort! { |a, b| a.start <=> b.start }
+
+        days[6].time[days[6].time.length - 1] = OpeningHoursConverter::OpeningHoursTime.new(sunday24, monday0)
+        days[0].time.shift
+      end
+      return days
+    end
+  end
+end

data/lib/opening_hours_converter/opening_hours_date.rb

@@ -0,0 +1,126 @@
+require 'opening_hours_converter/constants'
+
+module OpeningHoursConverter
+  class OpeningHoursDate
+    include Constants
+    attr_accessor :wide_type, :wide, :weekdays, :weekdays_over
+
+    def initialize(wide, wide_type, weekdays)
+      if wide.nil? || wide_type.nil? || weekdays.nil?
+        raise ArgumentError
+      end
+
+      @wide = wide
+      @wide_type = wide_type
+      @weekdays = weekdays.sort
+      @weekdays_over = []
+    end
+
+    def get_weekdays
+
+      result = ""
+      wd = @weekdays.concat(@weekdays_over).sort.uniq
+
+      if wd.length > 0 && wd.include?(6) && wd.include?(0) && (wd.include?(5) || wd.include?(1))
+        start_we = 6
+        i = wd.length - 2
+        stop_looking = false
+
+        while !stop_looking && i >= 0
+          if wd[i] == wd[i+1] - 1
+            start_we = wd[i]
+            i -= 1
+          else
+            stop_looking = true
+          end
+        end
+
+        i = 1
+        stop_looking = false
+        end_we = 0
+
+        while !stop_looking && i < wd.length
+          if wd[i-1] == wd[i] - 1
+            end_we = wd[i]
+            i += 1
+          else
+            stop_looking = true
+          end
+        end
+
+        length = 7 - start_we + end_we + 1
+
+        if length >= 3 && start_we > end_we
+          if result.length > 0
+            result += ","
+          end
+          result += "#{OSM_DAYS[start_we]}-#{OSM_DAYS[end_we]}"
+
+          j=0
+          while j < wd.length
+            if wd[j] <= end_we || wd[j] >= start_we
+              wd.slice!(j, 1)
+            else
+              j+=1
+            end
+          end
+        end
+      end
+
+      if wd.length > 1 || (wd.length == 1 && wd[0] != -1)
+        result += result.length > 0 ? ",#{OSM_DAYS[wd[0]]}" : OSM_DAYS[wd[0]]
+        first_in_row = wd[0]
+        for i in 1...wd.length
+          if wd[i-1] != wd[i] - 1
+            if first_in_row != wd[i-1]
+              if wd[i-1] - first_in_row == 1
+                result += ",#{OSM_DAYS[wd[i-1]]}"
+              else
+                result += "-#{OSM_DAYS[wd[i-1]]}"
+              end
+            end
+            result += ",#{OSM_DAYS[wd[i]]}"
+            first_in_row = wd[i]
+          elsif i == wd.length - 1
+            if wd[i] - first_in_row == 1
+              result += ",#{OSM_DAYS[wd[i]]}"
+            else
+              result += "-#{OSM_DAYS[wd[i]]}"
+            end
+          end
+        end
+      end
+
+      if result == "Mo-Su"
+        result = ""
+      end
+      return result
+    end
+
+    def add_weekday(weekday)
+      if !@weekdays.include?(weekday) && !@weekdays_over.include?(weekday)
+        @weekdays << weekday
+        @weekdays.sort!
+      end
+    end
+
+    def add_overwritten_weekday(weekday)
+      unless @weekdays_over.include?(weekday) && @weekdays_over.include?(weekday)
+        @weekdays_over << weekday
+        @weekdays_over.sort!
+      end
+    end
+
+    def same_kind_as?(date)
+      @wide_type == date.wide_type && date.same_weekdays?(@weekdays)
+    end
+
+    def same_weekdays?(weekdays)
+      weekdays == @weekdays
+    end
+
+    def equals(o)
+      o.instance_of?(OpeningHoursConverter::OpeningHoursDate) && @wide_type == o.wide_type && @wide == o.wide && o.same_weekdays?(@weekdays)
+    end
+  end
+end