opening_hours_converter 1.15.0 → 1.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7659377f7e7ef73af1ca26a915754cbef93f4a4e2658c3cbc462cbfa3e2c971b
-  data.tar.gz: 35a9a9c602b4c6384d77d18d80bfa7b037974aec26df132c69f0811ad1cdc0a5
+  metadata.gz: ecd7eb467184d013601216945d337758dd52b4824640a61fc5826e28f74c2e4f
+  data.tar.gz: 5804ea9f19e7d0f6f5f538cba377a8d7aa1b0700384588b8214aaf6c2634b933
 SHA512:
-  metadata.gz: 34714ed65dd7b9050b1ca7efd2a9500659b19e1628e0b4acf6568528f17657a3f7ab17a02f5edb4d69bd9648144c8161352f8c849b4d9746071bbc2c61dd1676
-  data.tar.gz: 17ea0e6894eb017bac3ff00ee64c2972c6322108b522ead40587f4efb46090b7b498eca884f9049450327b81382e9904dba8d430dfa334c01aa7c29b3929ae2d
+  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/iterator.rb

@@ -112,6 +112,16 @@ module OpeningHoursConverter
       datetime_result.sort_by { |a| a[:start] }
     end
 
+    # Open intervals of an opening hours string inside a concrete window, as
+    # [{ start: Time, end: Time }], sorted and clamped to [from, to].
+    #
+    # Unlike get_time_iterator, this applies "off" rules and intervals crossing
+    # midnight, and covers every year the window touches rather than the
+    # current one.
+    def get_open_intervals(opening_hours_string, from, to)
+      OpeningHoursConverter::OpenIntervals.call(opening_hours_string, from, to)
+    end
+
     def get_datetime_iterator(date_ranges)
       result = get_iterator(date_ranges)
       datetime_result = []

data/lib/opening_hours_converter/open_intervals.rb

@@ -0,0 +1,262 @@
+require 'opening_hours_converter/constants'
+
+module OpeningHoursConverter
+  # Projects parsed date ranges onto a concrete window and returns the open
+  # intervals it contains.
+  #
+  # Rules are applied in the order they were parsed, and a later rule overrides
+  # 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
+    end
+
+    def initialize(from, to)
+      @from = from
+      @to = to
+      # One day before the window, so an interval crossing midnight into it is
+      # not lost.
+      @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) }
+
+      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
+      runs.select { |run| run[:end] > @from && run[:start] < @to }
+          .map { |run| { start: [run[:start], @from].max, end: [run[:end], @to].min } }
+    end
+
+    private
+
+    # Week and holiday selectors carry several date ranges rather than one, and
+    # WideInterval#to_day resolves them for Time.now.year only. They are
+    # expanded here for every year the window touches instead.
+    #
+    # Returns [date_range, bounds] pairs, bounds being the dates the range is
+    # allowed to cover (nil for the whole window).
+    def expand(date_ranges)
+      date_ranges.flat_map do |date_range|
+        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)
+        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
+    # years. Without a declared year the window itself selects the years.
+    def expand_to_days(date_range, builder)
+      wide_interval = date_range.wide_interval
+      bounds = declared_bounds(wide_interval)
+      years = if bounds
+                (bounds.first.year - 1)..(bounds.last.year + 1)
+              else
+                @first_date.year..@last_date.year
+              end
+
+      years.flat_map { |year| wide_interval.send(builder, year) }
+           .map { |day| [with_range(date_range, day), bounds] }
+    end
+
+    def declared_bounds(wide_interval)
+      return nil if wide_interval.start.nil? || wide_interval.start[:year].nil?
+
+      last_year = wide_interval.end && wide_interval.end[:year] || wide_interval.start[:year]
+      Date.new(wide_interval.start[:year], 1, 1)..Date.new(last_year, 12, 31)
+    end
+
+    def with_range(date_range, wide_interval)
+      copy = date_range.dup
+      copy.update_range(wide_interval)
+      copy
+    end
+
+    def apply_date_range(date_range, bounds = nil)
+      intervals = date_range.typical.intervals.compact
+      return if intervals.empty?
+
+      weekly = date_range.typical.is_a?(OpeningHoursConverter::Week)
+      days = covered_days(date_range)
+      days = days.select { |date| bounds.cover?(date) } if bounds
+
+      days.each do |date|
+        intervals.each do |interval|
+          next if weekly && !selects?(interval, date)
+
+          write(date, interval)
+        end
+      end
+    end
+
+    # A day array keyed by "always" is a yearly pattern and applies to every
+    # year of the window; one keyed by a year applies to that year only.
+    def covered_days(date_range)
+      years = OpeningHoursConverter::Year.build_day_array_from_date_range(date_range, false)
+
+      (@first_date..@last_date).select do |date|
+        months = years[date.year] || years['always']
+        next false if months.nil?
+
+        days = months[date.month - 1]
+        # February rows are MONTH_END_DAY long, so Feb 29 follows Feb 28.
+        !days.nil? && days[[date.day, days.size].min - 1]
+      end
+    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.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)
+      @holidays[date.year] ||= OpeningHoursConverter::PublicHoliday.ph_for_year(date.year)
+                                                                  .map { |holiday| [holiday.month, holiday.day] }
+      @holidays[date.year].include?([date.month, date.day])
+    end
+
+    # 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
+      current = date
+      open = !interval.is_off
+
+      while remaining > 0
+        mask = mask_for(current)
+        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)
+      return nil unless (@first_date..@last_date).cover?(date)
+
+      @masks[date] ||= Array.new(MINUTES_MAX, false)
+    end
+
+    # Walks the window as a continuous timeline, so a run of open minutes that
+    # 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]
+
+        if mask.nil?
+          next if start.nil?
+
+          result << { start: start, end: time_at(date, 0) }
+          start = nil
+          state = nil
+          next
+        end
+
+        (0...MINUTES_MAX).each do |minute|
+          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
+
+      result
+    end
+
+    # Built from wall clock components rather than by adding seconds, so a
+    # daylight saving change does not shift the time of day.
+    def time_at(date, minute)
+      Time.new(date.year, date.month, date.day, minute / 60, minute % 60)
+    end
+  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)