opening_hours_converter 1.15.0 → 1.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7659377f7e7ef73af1ca26a915754cbef93f4a4e2658c3cbc462cbfa3e2c971b
-  data.tar.gz: 35a9a9c602b4c6384d77d18d80bfa7b037974aec26df132c69f0811ad1cdc0a5
+  metadata.gz: 3b633bae1e9cb5898370921f08cd07dc343b837c7139236883930769b91e3738
+  data.tar.gz: 675e149ec88ead4dee904967288dc36f9ea40708c3742f9afab291375c75f33b
 SHA512:
-  metadata.gz: 34714ed65dd7b9050b1ca7efd2a9500659b19e1628e0b4acf6568528f17657a3f7ab17a02f5edb4d69bd9648144c8161352f8c849b4d9746071bbc2c61dd1676
-  data.tar.gz: 17ea0e6894eb017bac3ff00ee64c2972c6322108b522ead40587f4efb46090b7b498eca884f9049450327b81382e9904dba8d430dfa334c01aa7c29b3929ae2d
+  metadata.gz: 8348466a3dab6669c2b1ae059dabc1bf32c9ccb81161066f35118a01860e88be85b53e1446e035dfa2f12a76d9c6b3298c7f1b5556fec460feb24f34df850a65
+  data.tar.gz: a44a50c9bbc2080d8bc7c31e504149732a47277036ddcaec7e50e5700eb7357259d7e9921175e4508dc468ff25aed6785583fc90792a7346b712d3f97298d78b

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,193 @@
+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.
+  class OpenIntervals
+    include Constants
+    include Utils
+
+    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 = {}
+      @holidays = {}
+    end
+
+    def apply(date_ranges)
+      expand(date_ranges).each { |date_range, bounds| apply_date_range(date_range, bounds) }
+      self
+    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)
+        else [[date_range, nil]]
+        end
+      end
+    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)
+      return public_holiday?(date) if interval.day_start == PH_WEEKDAY
+
+      interval.day_start == reindex_sunday_week_to_monday_week(date.wday)
+    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.
+    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)
+        ([first_minute, 0].max...[remaining, MINUTES_MAX].min).each { |minute| mask[minute] = open } unless mask.nil?
+        remaining -= MINUTES_MAX
+        first_minute = 0
+        current += 1
+      end
+    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.
+    def runs
+      result = []
+      start = 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
+          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
+        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/tokenizer.rb

@@ -62,7 +62,7 @@ module OpeningHoursConverter
     def handle_string
       type = :string
       start_index = @index
-      value = ''
+      value = String.new
 
       while string? && current_character?
         value << current_character
@@ -75,7 +75,7 @@ module OpeningHoursConverter
     def handle_integer
       type = :integer
       start_index = @index
-      value = ''
+      value = String.new
 
       while integer? && current_character?
         value << current_character

data/lib/opening_hours_converter/wide_interval.rb

@@ -680,25 +680,17 @@ module OpeningHoursConverter
       weeks_as_days = []
       @indexes.each do |week_index|
         if week_index.is_a?(Integer)
-          week = OpeningHoursConverter::WeekIndex.week_from_index(week_index, year)
-          weeks_as_days << OpeningHoursConverter::WideInterval.new.day(week[:from].day, week[:from].month, week[:from].year,
-                week[:to].day, week[:to].month, week[:to].year)
+          week_as_day(week_index, year, weeks_as_days)
         else
           if week_index.key?(:modifier)
             i = 0
             (week_index[:from]..week_index[:to]).map do |index|
-              if i % week_index[:modifier] == 0
-                week = OpeningHoursConverter::WeekIndex.week_from_index(index, year)
-                weeks_as_days << OpeningHoursConverter::WideInterval.new.day(week[:from].day, week[:from].month, week[:from].year,
-                  week[:to].day, week[:to].month, week[:to].year)
-              end
+              week_as_day(index, year, weeks_as_days) if i % week_index[:modifier] == 0
               i += 1
             end
           else
             (week_index[:from]..week_index[:to]).map do |index|
-              week = OpeningHoursConverter::WeekIndex.week_from_index(index, year)
-              weeks_as_days << OpeningHoursConverter::WideInterval.new.day(week[:from].day, week[:from].month, week[:from].year,
-                week[:to].day, week[:to].month, week[:to].year)
+              week_as_day(index, year, weeks_as_days)
             end
           end
         end
@@ -706,6 +698,16 @@ module OpeningHoursConverter
 
       weeks_as_days
     end
+
+    # A year has 52 or 53 ISO weeks, so an index past the last one selects
+    # nothing rather than a week borrowed from the next year.
+    def week_as_day(index, year, weeks_as_days)
+      return if index > OpeningHoursConverter::WeekIndex.week_count(year)
+
+      week = OpeningHoursConverter::WeekIndex.week_from_index(index, year)
+      weeks_as_days << OpeningHoursConverter::WideInterval.new.day(week[:from].day, week[:from].month, week[:from].year,
+                                                                  week[:to].day, week[:to].month, week[:to].year)
+    end
     def get_public_holidays_for_year(year = Time.now.year)
       OpeningHoursConverter::PublicHoliday.ph_for_year(year).map do |holiday|
         OpeningHoursConverter::WideInterval.new.day(holiday.day, holiday.month, holiday.year)

data/lib/opening_hours_converter/year.rb

@@ -371,6 +371,21 @@ module OpeningHoursConverter
               years[wide_interval.start[:year]][wide_interval.start[:month]-1][day] = true
             end
           end
+        elsif wide_interval.end[:month] < wide_interval.start[:month]
+          # A range such as "2025 Dec 26-2025 Jan 13" wraps around New Year and
+          # covers both ends of the same year.
+          for month in wide_interval.start[:month]-1..11
+            first_day = month == wide_interval.start[:month]-1 ? wide_interval.start[:day]-1 : 0
+            for day in first_day...MONTH_END_DAY[month]
+              years[wide_interval.start[:year]][month][day] = true
+            end
+          end
+          for month in 0..wide_interval.end[:month]-1
+            last_day = month == wide_interval.end[:month]-1 ? wide_interval.end[:day]-1 : MONTH_END_DAY[month]-1
+            for day in 0..last_day
+              years[wide_interval.start[:year]][month][day] = true
+            end
+          end
         else
           for month in wide_interval.start[:month]-1..wide_interval.end[:month]-1
             if month == wide_interval.start[:month]-1

data/lib/opening_hours_converter.rb

@@ -12,6 +12,7 @@ module OpeningHoursConverter
   require_relative './opening_hours_converter/year'
   require_relative './opening_hours_converter/public_holiday'
   require_relative './opening_hours_converter/interval'
+  require_relative './opening_hours_converter/open_intervals'
   require_relative './opening_hours_converter/iterator'
   require_relative './opening_hours_converter/opening_hours_builder'
   require_relative './opening_hours_converter/opening_hours_date'

data/readme.md

@@ -21,6 +21,34 @@ parsed_oh = OpeningHoursConverter::OpeningHoursParser.new.parse('Mo 10:00-12:00'
 oh_string = OpeningHoursConverter::OpeningHoursBuilder.new.build(parsed_oh)
 ```
 
+### Open intervals over a period
+
+`get_open_intervals` returns the concrete opening periods of an opening hours
+string inside a window, as `[{ start: Time, end: Time }]`, sorted by start and
+clamped to `[from, to]`. It is the equivalent of `getOpenIntervals` in
+[opening_hours.js](https://github.com/opening-hours/opening_hours.js).
+
+```ruby
+OpeningHoursConverter::Iterator.new.get_open_intervals(
+  'Mo-Fr 08:00-12:00; Tu off',
+  Time.new(2026, 6, 1),
+  Time.new(2026, 6, 8)
+)
+# => [{ start: 2026-06-01 08:00, end: 2026-06-01 12:00 },
+#     { start: 2026-06-03 08:00, end: 2026-06-03 12:00 },
+#     { start: 2026-06-04 08:00, end: 2026-06-04 12:00 },
+#     { start: 2026-06-05 08:00, end: 2026-06-05 12:00 }]
+```
+
+Rules are applied in the order they were written, so a later one overrides an
+earlier one: `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. Intervals crossing midnight end on
+the following day, and `Time` values are built from wall clock components, so a
+daylight saving change does not shift the time of day.
+
+Unlike `get_time_iterator`, it applies `off` rules, handles midnight crossings
+and covers every year the window touches rather than the current one.
+
 ## Test
 
 Install the dependencies with:

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opening_hours_converter
 version: !ruby/object:Gem::Version
-  version: 1.15.0
+  version: 1.16.0
 platform: ruby
 authors:
 - Publidata
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-28 00:00:00.000000000 Z
+date: 2026-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -80,6 +80,7 @@ files:
 - lib/opening_hours_converter/errors.rb
 - lib/opening_hours_converter/interval.rb
 - lib/opening_hours_converter/iterator.rb
+- lib/opening_hours_converter/open_intervals.rb
 - lib/opening_hours_converter/opening_hours_builder.rb
 - lib/opening_hours_converter/opening_hours_date.rb
 - lib/opening_hours_converter/opening_hours_parser.rb