on_calendar 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2c57fa5ccc8be0efadca1c9ada15ffd43a3de7e67fb2dbbc16537459aff80387
+  data.tar.gz: 9dfc9ecf972a21f98ba3f91c6b0cfc73a0689a6d4e58faf952c3594d6f5b870f
+SHA512:
+  metadata.gz: 0f306dc43ba739c83a2a4f557cb6b04316cf5f3f7d3cee6dbd7166b19fb61a7a86334265ef651c9e83a9f41c4e8e2014fa4e99fb583b777b94dae6fd2c1d16f5
+  data.tar.gz: 604225b8e299e52a50867821e295a3aa216b8118da982f790ff2174d5980709f72572f40b519d58f2bc995ba84614eefc37c18c0c8667b2f569a4e7089a83e83

data/README.md

@@ -0,0 +1,93 @@
+# OnCalendar
+
+Provides a library to parse [Systemd.Time calendar expressions](https://www.freedesktop.org/software/systemd/man/latest/systemd.time.html#Calendar%20Events) and determine future iterations. 
+
+## Getting started
+
+Add OnCalendar to your project:
+
+```bash
+gem install on_calendar
+```
+```ruby
+require "on_calendar"
+```
+Or using bundler:
+
+```bash
+bundle add on_calendar
+```
+
+Parse your expression, should your expression be invalid a `OnCalendar::Parser::Error` will be raised:
+
+```ruby
+OnCalendar::Parser.new("Mon,Wed,Fri 10:23")
+=> #<OnCalendar::Parser:0x00007f4725b55978
+
+OnCalendar::Parser.new("00")
+=> # Exception: OnCalendar::Parser::Error
+```
+
+Determine the next future iteration of this expression:
+
+```ruby
+OnCalendar::Parser.new("Mon,Wed,Fri 10:23").next
+=> [2025-09-01 10:23:00.000000000 AEST +10:00]
+```
+
+If you need to find multiple iterations, supply a count argument:
+
+```ruby
+OnCalendar::Parser.new("Mon,Wed,Fri 10:23").next(10)
+=>
+[2025-09-01 10:23:00.000000000 AEST +10:00,
+ 2025-09-03 10:23:00.000000000 AEST +10:00,
+ 2025-09-05 10:23:00.000000000 AEST +10:00,
+ 2025-09-08 10:23:00.000000000 AEST +10:00,
+ 2025-09-10 10:23:00.000000000 AEST +10:00,
+ 2025-09-12 10:23:00.000000000 AEST +10:00,
+ 2025-09-15 10:23:00.000000000 AEST +10:00,
+ 2025-09-17 10:23:00.000000000 AEST +10:00,
+ 2025-09-19 10:23:00.000000000 AEST +10:00,
+ 2025-09-22 10:23:00.000000000 AEST +10:00]
+```
+
+By default `next` will use the current time and zone, but you can time travel using the `clamp` argument to pin the starting time:
+
+```ruby
+OnCalendar::Parser.new("Mon,Wed,Fri 10:23").next(10, clamp: Time.now - 20.years)
+=>
+[2005-08-31 10:23:00.000000000 AEST +10:00,
+ 2005-09-02 10:23:00.000000000 AEST +10:00,
+ 2005-09-05 10:23:00.000000000 AEST +10:00,
+ 2005-09-07 10:23:00.000000000 AEST +10:00,
+ 2005-09-09 10:23:00.000000000 AEST +10:00,
+ 2005-09-12 10:23:00.000000000 AEST +10:00,
+ 2005-09-14 10:23:00.000000000 AEST +10:00,
+ 2005-09-16 10:23:00.000000000 AEST +10:00,
+ 2005-09-19 10:23:00.000000000 AEST +10:00,
+ 2005-09-21 10:23:00.000000000 AEST +10:00]
+```
+
+Timezones are supported in expressions and the `clamp` argument. However all calculated iterations will default to the timezone set in the expression. The local timezone will be used if nothing is specified.
+
+## Limitations
+
+A few limitations do exist at this stage:
+
+* No support for the `~` operator.
+* Time can only be specified to seconds and not sub-second level.
+* Timezones must be specified as IANA TZ identifiers (ie: Australia/Brisbane, not +1000)
+* Determining past iterations of an expression.
+
+## Support
+
+Should you find a bug or have ideas, feel free to open an issue and I'll do my best to get back to you.
+
+## License
+
+This gem is available as open source under the terms of the [MIT License](LICENSE.txt).
+
+## Contribution guide
+
+Pull requests are welcome! Please make sure you include tests for any changes.

data/lib/on_calendar/condition/base.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  module Condition
+    class Base
+      attr_reader :base, :step, :wildcard
+
+      def initialize(base: nil, step: nil, wildcard: false)
+        @base = base
+        @step = step
+        @wildcard = wildcard
+
+        raise OnCalendar::Condition::Error, "Must supply base or wildcard=true" if
+          base.nil? && !wildcard
+        raise OnCalendar::Condition::Error, "Condition base value #{base} outside of allowed range #{range}" unless
+          valid?
+        raise OnCalendar::Condition::Error, "Condition step value #{step} must be > 0 and < than #{range.max}" if
+          !step.nil? && (step == 0 || step > range.max)
+      end
+
+      # Some subclasses need more context for RANGE
+      def range
+        self.class::RANGE
+      end
+
+      # Match this condition
+      # - If wild card return true
+      # No step:
+      #   - If within range true
+      #   - Otherwise if base == argument
+      # With step:
+      #   - Expand possible options to range.max
+      #     does our argument match
+      def match?(part)
+        return true if wildcard
+
+        if step.nil?
+          return base.cover?(part) if base.is_a?(Range)
+
+          base == part
+        else
+          (base.is_a?(Range) ? base : (base..range.max)).step(step).to_a.include?(part)
+        end
+      end
+
+      # Validates whether value (if passed otherwise base) is acceptable
+      # Note: This is not context aware so you can pass it day 31 for a 30 day month and it will return true
+      def valid?(value: nil)
+        # Always yes for wildcard when value isn't supplied
+        return true if wildcard && value.nil?
+
+        value ||= base
+        case value
+        when Range
+          # Check range is within RANGE
+          return true if range.cover?(value)
+        else
+          # Check value is within RANGE
+          return true if range.include?(value)
+        end
+        false
+      end
+
+      # Get next distance to valid base, if we rotate through range we get distance to min
+      # Note: We need to pass range_args becaue some subclasses need the context (ie: day_of_month)
+      def distance_to_next(current, range_args: nil)
+        # If we have an invalid value no point continuing
+        return nil unless valid?(value: current)
+        # Wild card return +1
+        return 1 if wildcard
+
+        # Build array to find needle_index
+        arr = range_args.nil? ? range.to_a : range(**range_args).to_a
+        needle_index = arr.index(current)
+
+        return nil if needle_index.nil?
+
+        distance = 0
+
+        if step.nil?
+          # If we are dealing with a range and the current and current+1 within range
+          if base.is_a?(Range)
+            if base.cover?(current) &&
+               base.cover?(arr.fetch(needle_index + 1, nil))
+              # Set +1 index
+              target_index = needle_index + 1
+            else
+              # Otherwise set the index of the minimum acceptable value
+              target_index = arr.index(base.min)
+            end
+          else
+            # Set index of base value
+            target_index = arr.index(base)
+          end
+        # We have a step, we have to compare stepped array to get next distance otherwise min
+        else
+          # If base is range - we find the next value in base
+          if base.is_a?(Range)
+            stepped_arr = base.step(step).to_a
+            next_value = stepped_arr.bsearch { |x| x > current } || base.min
+          # Else we find next value in full RANGE
+          else
+            stepped_arr = (base..arr.max).step(step).to_a
+            next_value = stepped_arr.bsearch { |x| x > current } || arr.min
+          end
+          target_index = arr.index(next_value)
+        end
+
+        unless target_index.nil?
+          # Lets work out distance between target_index and needle_index
+          if needle_index < target_index
+            # If the needle is before target get how many steps we need to step
+            distance = target_index - needle_index
+          else
+            # If is in front of us loop over until start of array
+            # Note: This sounds counter intuitive - why not give the distance until the next value
+            #       However this forces us to re-evaluate all other date parts otherwise we might jump forward too far
+            distance = arr.length - needle_index
+          end
+        end
+        distance
+      end
+    end
+  end
+end

data/lib/on_calendar/condition/day_of_month.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  module Condition
+    class DayOfMonth < Base
+      RANGE = (1..31)
+
+      # NOTE: by default we validate number in default range but this needs to be context aware
+      # because not all months have the same number of days
+      def range(year: nil, month: nil)
+        if year.nil? || month.nil?
+          RANGE
+        else
+          (RANGE.min..Time.days_in_month(month, year))
+        end
+      end
+    end
+  end
+end

data/lib/on_calendar/condition/day_of_week.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  module Condition
+    class DayOfWeek < Base
+      RANGE = (0..6)
+
+      # Utility function to pass our min,max range to the segment parser
+      # this helps dealing with when the parser comes back with 6..0
+      def self.range_bounds
+        RANGE.minmax
+      end
+    end
+  end
+end

data/lib/on_calendar/condition/hour.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  module Condition
+    class Hour < Base
+      RANGE = (0..23)
+    end
+  end
+end

data/lib/on_calendar/condition/minute.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  module Condition
+    class Minute < Base
+      RANGE = (0..59)
+    end
+  end
+end

data/lib/on_calendar/condition/month.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  module Condition
+    class Month < Base
+      RANGE = (1..12)
+    end
+  end
+end

data/lib/on_calendar/condition/second.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  module Condition
+    class Second < Base
+      RANGE = (0..59)
+    end
+  end
+end

data/lib/on_calendar/condition/year.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  module Condition
+    class Year < Base
+      RANGE = (1970..2200)
+
+      def initialize(base: nil, step: nil, wildcard: false)
+        # Translate short year to long
+        unless base.nil?
+          if (0..69).cover?(base)
+            base += 2000
+          elsif (70..99).cover?(base)
+            base += 1900
+          end
+        end
+        super
+      end
+    end
+  end
+end

data/lib/on_calendar/condition.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  module Condition
+    class Error < StandardError; end
+
+    autoload :Base, "on_calendar/condition/base"
+    autoload :Hour, "on_calendar/condition/hour"
+    autoload :Minute, "on_calendar/condition/minute"
+    autoload :Second, "on_calendar/condition/second"
+    autoload :Year, "on_calendar/condition/year"
+    autoload :Month, "on_calendar/condition/month"
+    autoload :DayOfMonth, "on_calendar/condition/day_of_month"
+    autoload :DayOfWeek, "on_calendar/condition/day_of_week"
+  end
+end

data/lib/on_calendar/parser.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  class Parser
+    class Error < StandardError; end
+
+    MAX_ITERATIONS = 100
+    TIME_SEP_CHAR = ":"
+    DATE_SEP_CHAR = "-"
+    DATETIME_SEP_CHAR = "T"
+    DATETIME_SEP_REGEX = /\d|\*#{DATETIME_SEP_CHAR}\d|\*/
+    SPECIAL_EXPRESSIONS = {
+      minutely: "*-*-* *:*:00",
+      hourly: "*-*-* *:00:00",
+      daily: "*-*-* 00:00:00",
+      monthly: "*-*-01 00:00:00",
+      weekly: "Mon *-*-* 00:00:00",
+      yearly: "*-01-01 00:00:00",
+      quarterly: "*-01,04,07,10-01 00:00:00",
+      semiannually: "*-01,07-01 00:00:00"
+    }.freeze
+
+    attr_reader :expression, :timezone, :years, :months, :days_of_month,
+                :days_of_week, :hours, :minutes, :seconds
+
+    def initialize(expression)
+      parse(expression)
+      @expression = expression
+    end
+
+    def next(count=1, clamp: timezone.now)
+      raise OnCalendar::Parser::Error, "Clamp must be instance of Time" unless clamp.is_a?(Time)
+
+      # Translate to correct timezone
+      clamp = clamp.in_time_zone(timezone)
+
+      results = []
+      count.times do
+        result = iterate(clamp: clamp)
+        break if result.nil?
+
+        clamp = result + 1.second
+        results << result
+      end
+      results.empty? ? nil : results
+    end
+
+    def matches_any_conditions?(field:, base:)
+      send(field).each do |condition|
+        return true if condition.match?(base)
+      end
+      false
+    end
+
+    private
+
+    def iterate(clamp:)
+      iterations = 0
+
+      while true
+        # Fail safe
+        if iterations >= MAX_ITERATIONS
+          raise OnCalendar::Parser::Error, "Too many iterations: #{MAX_ITERATIONS}. Something has gone wrong."
+        end
+
+        iterations += 1
+
+        # Loop over segments:
+        # a) If we don't match any condition for that segment
+        # b) Find all the next distances for a possible match
+        #    if only nil distances return nil - not possible to compute
+        # c) Advance clamp by the minimum distance found while resetting child segments
+        field_manipulation = false
+        {
+          years: {
+            base_method: :year,
+            changes: { month: 1, day: 1, hour: 0, min: 0, sec: 0 }
+          },
+          months: {
+            base_method: :month,
+            changes: { day: 1, hour: 0, min: 0, sec: 0 }
+          },
+          days_of_month: {
+            base_method: :day,
+            changes: { hour: 0, min: 0, sec: 0 },
+            increment_method: :days,
+            range_args: ->(clamp) { { year: clamp.year, month: clamp.month } }
+          },
+          days_of_week: {
+            base_method: :wday,
+            changes: { hour: 0, min: 0, sec: 0 },
+            increment_method: :days
+          },
+          hours: {
+            base_method: :hour,
+            changes: { min: 0, sec: 0 }
+          },
+          minutes: {
+            base_method: :min,
+            changes: { sec: 0 }
+          },
+          seconds: {
+            base_method: :sec
+          }
+        }.each do |field, values|
+          # Do we miss all condition matches - thus increment
+          next if matches_any_conditions?(field: field, base: clamp.send(values[:base_method]))
+
+          # Do we need any range arguments? If so calculate
+          range_args = values[:range_args].call(clamp) if values.key?(:range_args) || nil
+          # Determine distances required to jump to next match
+          distances = send(field).map do |condition|
+            condition.distance_to_next(clamp.send(values[:base_method]), range_args: range_args)
+          end.sort!
+          # Check for only nil - if so impossible to compute bail
+          return nil if distances.compact.empty?
+
+          # Increment by field method
+          method = values[:increment_method] || field
+          clamp = (clamp + distances.min.send(method))
+          # Reset desired fields
+          clamp = clamp.change(**values[:changes]) if values.key?(:changes)
+          # Force re-check everything by marking manipulation
+          field_manipulation = true
+          break
+        end
+
+        # If we have manipulated a field - we need to re-check, re-loop
+        # otherwise we break out because we have a result
+        field_manipulation ? next : break
+      end
+
+      clamp
+    end
+
+    def parse(expression)
+      # Split string on white space and reverse
+      segments = expression.split.reverse
+
+      # Detect if we have time zone
+      @timezone = parse_timezone(segments.first)
+      # Default timezone if no result - otherwise remove first segment
+      if @timezone.nil?
+        @timezone = ActiveSupport::TimeZone[Time.now.gmt_offset].tzinfo
+      else
+        segments.shift
+      end
+
+      # Detect if expression is special and override segments
+      if segments.length == 1
+        special = segments.first.downcase
+        SPECIAL_EXPRESSIONS.each do |k, v|
+          segments = v.split.reverse if special == k.to_s
+        end
+      end
+
+      # Split on 'T' separator if it exists
+      segments.prepend(*segments.shift.split(DATETIME_SEP_CHAR).reverse) if
+        segments.first.match?(DATETIME_SEP_REGEX)
+
+      # Check and parse time (default 00:00:00 otherwise)
+      time_expression = segments.first.include?(TIME_SEP_CHAR) ? segments.shift : "00:00:00"
+      @hours, @minutes, @seconds = parse_time(time_expression)
+
+      # Check we have more segments, with date separator and start with number or wildcard
+      if !segments.empty? && segments.first.include?(DATE_SEP_CHAR) && segments.first =~ /\A\d|\*/
+        @years, @months, @days_of_month = parse_date(segments.shift)
+      else
+        @years, @months, @days_of_month = parse_date("*-*-*")
+      end
+
+      # Parse days of week
+      @days_of_week = parse_day_of_week(segments.empty? ? "*" : segments.shift)
+
+      # If we have remaining parts something went wrong
+      raise OnCalendar::Parser::Error, "Expression parts not parsed: #{segments}" unless segments.empty?
+    end
+
+    def parse_time(expression)
+      # Split and check we have enough parts
+      segments = expression.split(TIME_SEP_CHAR)
+      raise Error, "Time component is malformed" unless
+        (2..3).cover?(segments.length)
+
+      # If seconds do not exist default to 00
+      segments << "00" if segments.length == 2
+
+      # Build conditions
+      build_conditions(
+        items: %i[Hour Minute Second],
+        segments: segments
+      )
+    end
+
+    def parse_date(expression)
+      # Split and check we have enough parts
+      segments = expression.split(DATE_SEP_CHAR)
+      raise Error, "Date component is malformed" unless
+        (2..3).cover?(segments.length)
+
+      # If year do not exist default to *
+      segments.unshift "*" if segments.length == 2
+
+      # Build conditions
+      build_conditions(
+        items: %i[Year Month DayOfMonth],
+        segments: segments
+      )
+    end
+
+    def parse_day_of_week(expression)
+      conditions = build_conditions(
+        items: [:DayOfWeek],
+        segments: [expression]
+      )
+      # NOTE: We cheat here and flatten array due to single field
+      conditions.first if conditions.is_a?(Array)
+    end
+
+    def parse_timezone(expression)
+      TZInfo::Timezone.get(expression)
+    rescue TZInfo::InvalidTimezoneIdentifier
+      nil
+    end
+
+    def build_conditions(items:, segments:)
+      conditions = []
+      items.each_with_index do |klass, idx|
+        # Help work with special ranges 6..0
+        min, max = OnCalendar::Condition.const_get(klass).try(:range_bounds) || nil
+        # Parse this segment
+        begin
+          parsed = OnCalendar::Segment.parse(segments.shift, max: max, min: min)
+        rescue OnCalendar::Segment::Error => e
+          raise Error, e
+        end
+        if parsed.nil?
+          # We are a wild card
+          conditions[idx] = [OnCalendar::Condition.const_get(klass).new(wildcard: true)]
+        else
+          # Lets build conditions with parsed
+          conditions[idx] = []
+          parsed.each do |c|
+            conditions[idx] << OnCalendar::Condition.const_get(klass).new(**c)
+          end
+        end
+      end
+      conditions
+    end
+  end
+end

data/lib/on_calendar/segment.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  module Segment
+    class Error < StandardError; end
+
+    module_function
+
+    WILDCARD_CHAR = "*"
+    LIST_CHAR = ","
+    RANGE_CHAR = ".."
+    STEP_CHAR = "/"
+    CHARS_REGEX = /\A[a-zA-Z]+\z/
+    NUMERIC_REGEX = /\A\d+\z/
+
+    # Take complex segment expressions and break it down into an array of bases (integer||range) and steps (integer)
+    def parse(expression, max: nil, min: nil)
+      # Any Value
+      return nil if expression == WILDCARD_CHAR || expression.nil? || expression.empty?
+
+      # Check if we have a list and break into segments
+      segments = []
+      if expression.include?(LIST_CHAR)
+        segments.concat(expression.split(LIST_CHAR))
+      else
+        segments << expression
+      end
+
+      # Lets parse each segment
+      results = []
+      segments.each do |segment|
+        step, bases = nil
+
+        # Parse step (if present)
+        segment, step = parse_step(segment) if segment.include?(STEP_CHAR)
+
+        # Parse range (if present)
+        if segment.include?(RANGE_CHAR)
+          bases = parse_range(segment, max: max, min: min)
+        else
+          # Default to 0 if wild card present
+          segment = "0" if segment == WILDCARD_CHAR
+          bases = [cast(segment)]
+        end
+
+        # We may end up with multiple bases so lets add each
+        bases&.each do |b|
+          results << { base: b, step: step }
+        end
+      end
+      results
+    end
+
+    # First weekday name to integer conversion, otherwise numerical to integer
+    def cast(expression)
+      # If only characters lets try day_of_week
+      if expression.match?(CHARS_REGEX)
+        begin
+          return Date.parse(expression).wday
+        rescue Date::Error
+          # We need to try parse weekday here - otherwise try for integer
+        end
+      end
+
+      # Otherwise try numerical
+      unless expression.match?(NUMERIC_REGEX)
+        raise OnCalendar::Segment::Error, "Character not allowed in expression: #{expression}"
+      end
+
+      expression.to_i
+    end
+
+    # Parse string range to real range (also deal with desc ranges - only weekdays)
+    def parse_range(expression, max: nil, min: nil)
+      start_val, end_val = expression.split(RANGE_CHAR)
+      raise OnCalendar::Segment::Error, "Invalid range detected #{expression}" if start_val.nil? || end_val.nil?
+
+      results = [(cast(start_val)..cast(end_val))]
+      # If we have a range like 6..0 we need to split these out
+      if results.first.first > results.first.last
+        # Only transform if we intended to
+        raise OnCalendar::Segment::Error, "Invalid range: #{results.first}" unless !max.nil? && !min.nil?
+
+        old_range = results.pop
+        # Add from start of range to max || max
+        results << (old_range.first == max ? max : (old_range.first..max))
+        # Add from min to end of range || min
+        results << (old_range.last == min ? min : (min..old_range.last))
+      end
+      results
+    end
+
+    # Parse a step out of a segment 1/5 = ["1", 5]
+    def parse_step(expression)
+      base, step = expression.split(STEP_CHAR)
+      step = cast(step) unless step.nil?
+      [base, step]
+    end
+  end
+end

data/lib/on_calendar/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OnCalendar
+  VERSION = "0.1.0"
+end

data/lib/on_calendar.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+
+module OnCalendar
+  autoload :Version, "on_calendar/version"
+  autoload :Parser, "on_calendar/parser"
+  autoload :Condition, "on_calendar/condition"
+  autoload :Segment, "on_calendar/segment"
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: on_calendar
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ben Passmore
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+email:
+- contact@passbe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/on_calendar.rb
+- lib/on_calendar/condition.rb
+- lib/on_calendar/condition/base.rb
+- lib/on_calendar/condition/day_of_month.rb
+- lib/on_calendar/condition/day_of_week.rb
+- lib/on_calendar/condition/hour.rb
+- lib/on_calendar/condition/minute.rb
+- lib/on_calendar/condition/month.rb
+- lib/on_calendar/condition/second.rb
+- lib/on_calendar/condition/year.rb
+- lib/on_calendar/parser.rb
+- lib/on_calendar/segment.rb
+- lib/on_calendar/version.rb
+homepage: https://github.com/passbe/on_calendar
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/passbe/on_calendar/issues
+  changelog_uri: https://github.com/passbe/on_calendar/releases
+  source_code_uri: https://github.com/passbe/on_calendar
+  homepage_uri: https://github.com/passbe/on_calendar
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Parser for OnCalendar expressions used by systemd time.
+test_files: []