opening_hours_converter 1.16.0 → 1.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b633bae1e9cb5898370921f08cd07dc343b837c7139236883930769b91e3738
-  data.tar.gz: 675e149ec88ead4dee904967288dc36f9ea40708c3742f9afab291375c75f33b
+  metadata.gz: ecd7eb467184d013601216945d337758dd52b4824640a61fc5826e28f74c2e4f
+  data.tar.gz: 5804ea9f19e7d0f6f5f538cba377a8d7aa1b0700384588b8214aaf6c2634b933
 SHA512:
-  metadata.gz: 8348466a3dab6669c2b1ae059dabc1bf32c9ccb81161066f35118a01860e88be85b53e1446e035dfa2f12a76d9c6b3298c7f1b5556fec460feb24f34df850a65
-  data.tar.gz: a44a50c9bbc2080d8bc7c31e504149732a47277036ddcaec7e50e5700eb7357259d7e9921175e4508dc468ff25aed6785583fc90792a7346b712d3f97298d78b
+  metadata.gz: 2d697f34e86039dd4854e3e7dd0ab8332654d239971d3fcd12f69703ebf629ea2ab0380811bd460afde0ab06aceca1ae0ffac7eda30592c557e27c1ea76fdfef
+  data.tar.gz: 985cf1ab1967b7c7d69e4d1b593e83976ba4799bca329849fb26582d55d66ce10bba1a76de4d75cf206d4ff434f153628248b8dbb0d4640d3ea83b183b8a008e

data/lib/opening_hours_converter/constants.rb

@@ -11,6 +11,8 @@ module OpeningHoursConverter
       DIMANCHE: 6
     }.freeze
     OSM_DAYS = %w[Mo Tu We Th Fr Sa Su].freeze
+    # Not specification, but common enough in the data to be read.
+    OSM_DAYS_ABBREVIATIONS = %w[Mon Tue Wed Thu Fri Sat Sun].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
@@ -20,5 +22,6 @@ module OpeningHoursConverter
     DAYS_MAX = 6
     YEAR_DAYS_MAX = 365
     PH_WEEKDAY = -2
+    EASTER_WEEKDAY = -3
   end
 end

data/lib/opening_hours_converter/date_range.rb

@@ -1,11 +1,13 @@
 module OpeningHoursConverter
   class DateRange
-    attr_accessor :wide_interval, :typical, :comment
+    attr_accessor :wide_interval, :typical, :comment, :fallback_suffix, :fallback_ranges
 
     def initialize(wide_interval = nil)
       @wide_interval = nil
       @typical = nil
       @comment = ''
+      @fallback_suffix = nil
+      @fallback_ranges = []
       update_range(wide_interval)
     end
 

data/lib/opening_hours_converter/interval.rb

@@ -3,14 +3,28 @@ require 'opening_hours_converter/constants'
 module OpeningHoursConverter
   class Interval
     include Constants
-    attr_reader :day_start, :day_end, :start, :end, :is_off
+    attr_reader :day_start, :day_end, :start, :end, :is_off, :index, :is_unknown, :open_ended, :day_offset
 
-    def initialize(day_start, min_start, day_end = 0, min_end = 0, is_off = false)
+    # is_unknown is the OSM third state ("unknown", alongside open/off) and
+    # open_ended is a time with no known closing time ("18:00+"). Both are
+    # carried purely for round-trip serialization; for interval computation
+    # is_unknown behaves like is_off (not open) and open_ended is treated as
+    # running to the end of the day.
+    #
+    # day_offset is the OSM day offset ("easter +1 day"): the interval falls
+    # that many days after the date day_start selects.
+    def initialize(day_start, min_start, day_end = 0, min_end = 0, is_off = false, index = nil, is_unknown = false, open_ended = false, day_offset = 0)
       @day_start = day_start
       @day_end = day_end
       @start = min_start
       @end = min_end
       @is_off = is_off
+      # The weekday index is an OSM nth_entry list ("Sa[1,3]"), so it is always
+      # held as an array; a lone index is wrapped rather than special-cased.
+      @index = index.nil? ? nil : Array(index)
+      @is_unknown = is_unknown
+      @open_ended = open_ended
+      @day_offset = day_offset || 0
 
       if @day_end == 0 && @end == 0
         @day_end = DAYS_MAX

data/lib/opening_hours_converter/open_intervals.rb

@@ -8,10 +8,19 @@ module OpeningHoursConverter
   # an earlier one on the minutes it selects, as the OpenStreetMap
   # specification requires: "Jul-Aug off; Mo-Fr 09:00-17:00" is open in July,
   # while "Mo-Fr 09:00-17:00; Jul-Aug off" is closed.
+  #
+  # A rule behind a "||" is the exception. It is a fallback: it speaks only for
+  # the minutes the rules before it leave closed, and never over the ones they
+  # open. "Mo-Fr 08:00-12:00 || Sa 10:00-12:00" opens on Saturday and changes
+  # nothing from Monday to Friday.
   class OpenIntervals
     include Constants
     include Utils
 
+    # The state of a minute an open-ended time covers, told apart from a plain
+    # open minute so that the two never run into a single interval.
+    OPEN_ENDED = :open_ended
+
     def self.call(opening_hours_string, from, to)
       date_ranges = OpeningHoursConverter::OpeningHoursParser.new.parse(opening_hours_string)
       new(from, to).apply(date_ranges).intervals
@@ -25,12 +34,20 @@ module OpeningHoursConverter
       @first_date = from.to_date - 1
       @last_date = to.to_date
       @masks = {}
+      @fallback = false
       @holidays = {}
     end
 
     def apply(date_ranges)
       expand(date_ranges).each { |date_range, bounds| apply_date_range(date_range, bounds) }
-      self
+
+      fallback = date_ranges.first&.fallback_ranges
+      return self if fallback.nil? || fallback.empty?
+
+      # Everything past a "||" is a fallback, and stays one: a chained
+      # "a || b || c" nests, c falling back on what a and b leave closed.
+      @fallback = true
+      apply(fallback)
     end
 
     def intervals
@@ -51,11 +68,24 @@ module OpeningHoursConverter
         case date_range.wide_interval.type
         when 'week' then expand_to_days(date_range, :get_weeks_for_year)
         when 'holiday' then expand_to_days(date_range, :get_public_holidays_for_year)
-        else [[date_range, nil]]
+        when 'variable_day' then expand_to_days(date_range, :get_variable_days_for_year)
+        else [[clamp_open_ended_year(date_range), nil]]
         end
       end
     end
 
+    # "2020+" applies from its start year through the end of the window:
+    # Year#build_day_array_from_date_range has no concept of an unbounded
+    # range, so it needs a concrete (if window-dependent) end year here.
+    def clamp_open_ended_year(date_range)
+      wide_interval = date_range.wide_interval
+      return date_range unless wide_interval.type == 'year' && wide_interval.open_ended && wide_interval.end.nil?
+
+      copy = date_range.dup
+      copy.update_range(OpeningHoursConverter::WideInterval.new.year(wide_interval.start[:year], @last_date.year))
+      copy
+    end
+
     # An ISO week declared with a year can start in the previous year or end in
     # the next one ("2025 week 1" starts on 2025-12-29), so the neighbouring
     # years are expanded too and their surplus days are cut back by the declared
@@ -119,9 +149,27 @@ module OpeningHoursConverter
     end
 
     def selects?(interval, date)
+      # A day offset shifts the date the selector names onto another one, so
+      # the selector is asked about the day it counts from rather than the day
+      # the interval is written on.
+      date -= interval.day_offset
       return public_holiday?(date) if interval.day_start == PH_WEEKDAY
+      return easter?(date) if interval.day_start == EASTER_WEEKDAY
+      return false unless interval.day_start == reindex_sunday_week_to_monday_week(date.wday)
+      return true if interval.index.nil?
 
-      interval.day_start == reindex_sunday_week_to_monday_week(date.wday)
+      interval.index.any? { |index| nth_weekday_of_month?(index, interval.day_start, date) }
+    end
+
+    def easter?(date)
+      OpeningHoursConverter::PublicHoliday.easter(date.year).to_date == date
+    end
+
+    def nth_weekday_of_month?(index, weekday, date)
+      target = OpeningHoursConverter::WeekIndex.nth_wday_of_month(index, weekday, date.month, date.year)
+      target == date
+    rescue ArgumentError
+      false
     end
 
     def public_holiday?(date)
@@ -133,6 +181,10 @@ module OpeningHoursConverter
     # An interval runs from (day_start, start) to (day_end, end). Only midnight
     # crossings give day_end > day_start, and their remaining minutes are
     # written on the dates that follow.
+    #
+    # A fallback rule skips the minutes that are already open: what the rules
+    # before the "||" leave closed is what it answers for, whether they were
+    # silent about it or closed it with an "off".
     def write(date, interval)
       remaining = (interval.day_end - interval.day_start) * MINUTES_MAX + interval.end
       first_minute = interval.start
@@ -141,11 +193,25 @@ module OpeningHoursConverter
 
       while remaining > 0
         mask = mask_for(current)
-        ([first_minute, 0].max...[remaining, MINUTES_MAX].min).each { |minute| mask[minute] = open } unless mask.nil?
+        minutes = [first_minute, 0].max...[remaining, MINUTES_MAX].min
+        minutes.each { |minute| mask[minute] = open unless @fallback && mask[minute] } unless mask.nil?
         remaining -= MINUTES_MAX
         first_minute = 0
         current += 1
       end
+
+      write_open_end(date, interval) if interval.open_ended && !interval.is_off
+    end
+
+    # An open end names no closing time ("10:00-12:00+"), so the rest of the
+    # day stays open without being certain. It is written as a state of its
+    # own, which keeps it from merging with the hours the string does name:
+    # the reference reports the two as two intervals.
+    def write_open_end(date, interval)
+      mask = mask_for(date + (interval.day_end - interval.day_start))
+      return if mask.nil?
+
+      (interval.end...MINUTES_MAX).each { |minute| mask[minute] = OPEN_ENDED }
     end
 
     def mask_for(date)
@@ -155,10 +221,13 @@ module OpeningHoursConverter
     end
 
     # Walks the window as a continuous timeline, so a run of open minutes that
-    # spans midnight comes out as a single interval.
+    # spans midnight comes out as a single interval. A minute carries the state
+    # that opened it rather than a plain flag, so an open end closes the
+    # interval before it instead of extending it.
     def runs
       result = []
       start = nil
+      state = nil
 
       (@first_date..(@last_date + 1)).each do |date|
         mask = @masks[date]
@@ -168,16 +237,16 @@ module OpeningHoursConverter
 
           result << { start: start, end: time_at(date, 0) }
           start = nil
+          state = nil
           next
         end
 
         (0...MINUTES_MAX).each do |minute|
-          if mask[minute]
-            start ||= time_at(date, minute)
-          elsif start
-            result << { start: start, end: time_at(date, minute) }
-            start = nil
-          end
+          next if mask[minute] == state
+
+          result << { start: start, end: time_at(date, minute) } if start
+          start = mask[minute] ? time_at(date, minute) : nil
+          state = mask[minute]
         end
       end
 

data/lib/opening_hours_converter/opening_hours_builder.rb

@@ -19,7 +19,7 @@ module OpeningHoursConverter
         phs = []
 
         date_range.typical.intervals.each_with_index do |interval, interval_id|
-          next unless interval&.day_start == -2 && interval&.day_start == interval&.day_end
+          next unless interval&.day_start == PH_WEEKDAY && interval&.day_start == interval&.day_end
 
           if interval.is_off
             off_day_ph = true
@@ -31,6 +31,23 @@ module OpeningHoursConverter
           date_range.typical.remove_interval(interval_id)
         end
 
+        day_easter = false
+        off_day_easter = false
+        easters = []
+
+        date_range.typical.intervals.each_with_index do |interval, interval_id|
+          next unless interval&.day_start == EASTER_WEEKDAY && interval&.day_start == interval&.day_end
+
+          if interval.is_off
+            off_day_easter = true
+          else
+            day_easter = true
+          end
+
+          easters << interval
+          date_range.typical.remove_interval(interval_id)
+        end
+
         range_general = nil
         range_general_for = nil
         range_general_id = date_range_index - 1
@@ -120,6 +137,36 @@ module OpeningHoursConverter
             end
           end
 
+          if off_day_easter || day_easter
+            if date_range.typical.intervals.uniq == [nil]
+              oh_rule.date.first.weekdays = [EASTER_WEEKDAY]
+              if off_day_easter
+                oh_rule.is_defined_off = off_day_easter
+                easters = []
+              else
+                easters.reverse.each do |interval|
+                  oh_rule.add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, interval.end))
+                end
+              end
+            else
+              if times_are_compatible?(oh_rule, easters)
+                easter_intervals = get_compatible_intervals(oh_rule, easters)
+                oh_rule.add_easter_weekday if easter_intervals[:compatible].length > 0
+                rules << oh_rule if !oh_rule_added
+                oh_rule_added = true
+                easter_intervals[:incompatible].each do |interval|
+                  rules += build_off_easter(date_range) if off_day_easter
+                  rules += build_easter(date_range) if day_easter
+                end
+              else
+                rules << oh_rule if !oh_rule_added
+                oh_rule_added = true
+                rules += build_off_easter(date_range) if off_day_easter
+                rules += build_easter(date_range) if day_easter
+              end
+            end
+          end
+
           rules << oh_rule if !oh_rule_added
 
           next unless oh_rule == oh_rules.last && oh_rule.has_overwritten_weekday?
@@ -142,7 +189,9 @@ module OpeningHoursConverter
         result += rules.map(&:get).join('; ')
       end
 
-      result.strip
+      result = result.strip
+      result += " || #{date_ranges.first.fallback_suffix}" if date_ranges.first&.fallback_suffix
+      result
     end
 
     def times_are_compatible?(oh_rule, phs)
@@ -220,6 +269,53 @@ module OpeningHoursConverter
       [rule]
     end
 
+    def build_off_easter(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('easter', 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
+
+      [rule]
+    end
+
+    def build_easter(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)
+
+      if date_range.wide_interval.type == 'week'
+        intervals.each do |interval|
+          date_range.typical.add_interval(OpeningHoursConverter::Interval.new(EASTER_WEEKDAY, interval.start, EASTER_WEEKDAY, interval.end, interval.is_off))
+        end
+      else
+        date_range = OpeningHoursConverter::DateRange.new(OpeningHoursConverter::WideInterval.new.holiday('easter', start_year, end_year))
+      end
+
+      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, [-1])
+      rule.add_date(date)
+
+      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
+      [rule]
+    end
+
     def build_day(date_range)
       intervals = date_range.typical.get_intervals(true)
 
@@ -240,7 +336,7 @@ module OpeningHoursConverter
     def build_week(date_range)
       result = []
 
-      intervals = date_range.typical.get_intervals(true)
+      intervals = clean_intervals_keeping_index(date_range.typical)
       days = create_time_intervals(date_range.wide_interval, intervals)
 
       days_status = Array.new(OSM_DAYS.length, 0)
@@ -385,6 +481,26 @@ module OpeningHoursConverter
       result
     end
 
+    # An index ("We[1]"), the "unknown" state, and an open-ended time
+    # ("18:00+") don't survive Week#get_intervals(true), which rebuilds
+    # intervals from a per-minute true/false/"off" grid that has no room for
+    # any of them. All three are pulled out first and passed through
+    # untouched instead; none of them can collide with anything the grid
+    # pass produces (an index never applies to more than a single day, and
+    # "unknown"/open-ended are only ever full-interval markers here).
+    def clean_intervals_keeping_index(typical)
+      special = typical.intervals.compact.select { |interval| carries_metadata?(interval) }
+      return typical.get_intervals(true) if special.empty?
+
+      plain = OpeningHoursConverter::Week.new
+      typical.intervals.compact.each { |interval| plain.add_interval(interval) unless carries_metadata?(interval) }
+      plain.get_intervals(true) + special
+    end
+
+    def carries_metadata?(interval)
+      !interval.index.nil? || interval.is_unknown || interval.open_ended
+    end
+
     def create_time_intervals(wide_interval, intervals)
       days = []
 
@@ -398,16 +514,26 @@ 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].add_time(OpeningHoursConverter::OpeningHoursTime.new(interval.start, interval.end, interval.open_ended))
             days[interval.day_start].is_defined_off = days[interval.day_start].is_defined_off ? true : interval.is_off
+            days[interval.day_start].is_defined_unknown = days[interval.day_start].is_defined_unknown ? true : interval.is_unknown
+            if interval.index
+              # One weekday can carry several intervals, one per entry of its
+              # index list ("Sa[2],Sa[4]"), and the list is their union.
+              date = days[interval.day_start].date.first
+              date.weekday_index = Array(date.weekday_index) | interval.index
+            end
           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_start].is_defined_unknown = days[interval.day_start].is_defined_unknown ? true : interval.is_unknown
             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
+            days[interval.day_end].is_defined_unknown = days[interval.day_end].is_defined_unknown ? true : interval.is_unknown
           else
             for j in interval.day_start..interval.day_end
               days[j].is_defined_off = days[j].is_defined_off ? true : interval.is_off
+              days[j].is_defined_unknown = days[j].is_defined_unknown ? true : interval.is_unknown
               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

@@ -3,10 +3,10 @@ require 'opening_hours_converter/constants'
 module OpeningHoursConverter
   class OpeningHoursDate
     include Constants
-    attr_accessor :weekdays, :weekdays_over
+    attr_accessor :weekdays, :weekdays_over, :weekday_index
     attr_reader :wide_interval
 
-    def initialize(wide_interval, weekdays)
+    def initialize(wide_interval, weekdays, weekday_index = nil)
       if wide_interval.nil? || weekdays.nil? || !wide_interval.is_a?(OpeningHoursConverter::WideInterval)
         raise ArgumentError
       end
@@ -14,14 +14,15 @@ module OpeningHoursConverter
       @wide_interval = wide_interval
       @weekdays = weekdays.sort
       @weekdays_over = []
+      @weekday_index = weekday_index
     end
 
     def get_weekdays
       result = ''
       weekdays = @weekdays.concat(@weekdays_over).sort.uniq
 
-      if !weekdays.empty? && weekdays[0] == -2
-        result = 'PH'
+      if !weekdays.empty? && (weekdays[0] == PH_WEEKDAY || weekdays[0] == EASTER_WEEKDAY)
+        result = weekdays[0] == PH_WEEKDAY ? 'PH' : 'easter'
         weekdays.shift
       end
 
@@ -94,6 +95,7 @@ module OpeningHoursConverter
       end
 
       result = '' if result == 'Mo-Su'
+      result += "[#{Array(@weekday_index).join(',')}]" if weekdays.length == 1 && !@weekday_index.nil?
       result
     end
 
@@ -105,7 +107,11 @@ module OpeningHoursConverter
     end
 
     def add_ph_weekday
-      add_weekday(-2)
+      add_weekday(PH_WEEKDAY)
+    end
+
+    def add_easter_weekday
+      add_weekday(EASTER_WEEKDAY)
     end
 
     def add_overwritten_weekday(weekday)