montrose 0.12.0 → 0.14.0

data/gemfiles/activesupport_6.1.gemfile.lock

@@ -0,0 +1,108 @@
+PATH
+  remote: ..
+  specs:
+    montrose (0.13.0)
+      activesupport (>= 5.2, < 7.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.1.7.6)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    ast (2.4.2)
+    base64 (0.1.1)
+    concurrent-ruby (1.2.2)
+    coveralls (0.8.23)
+      json (>= 1.8, < 3)
+      simplecov (~> 0.16.1)
+      term-ansicolor (~> 1.3)
+      thor (>= 0.19.4, < 2.0)
+      tins (~> 1.6)
+    docile (1.4.0)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.1.0)
+    m (1.6.1)
+      method_source (>= 0.6.7)
+      rake (>= 0.9.2.2)
+    method_source (1.0.0)
+    minitest (5.19.0)
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    racc (1.7.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.1)
+    rexml (3.2.6)
+    rubocop (1.56.1)
+      base64 (~> 0.1.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-performance (1.19.0)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.13.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    standard (1.31.0)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.56.0)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.2)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.2.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.19.0)
+    sync (0.5.0)
+    term-ansicolor (1.7.1)
+      tins (~> 1.0)
+    thor (1.2.2)
+    timecop (0.9.8)
+    tins (1.32.1)
+      sync
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.4.2)
+    yard (0.9.34)
+    zeitwerk (2.6.11)
+
+PLATFORMS
+  arm64-darwin-22
+
+DEPENDENCIES
+  activesupport (~> 6.1)
+  coveralls
+  m
+  minitest
+  montrose!
+  rake (>= 12.3.3)
+  standard
+  timecop
+  yard
+
+BUNDLED WITH
+   2.4.10

data/gemfiles/activesupport_7.0.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activesupport", "~> 7.0"
+
+gemspec path: "../"

data/gemfiles/activesupport_7.0.gemfile.lock

@@ -0,0 +1,106 @@
+PATH
+  remote: ..
+  specs:
+    montrose (0.13.0)
+      activesupport (>= 5.2, < 7.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.0.7.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    base64 (0.1.1)
+    concurrent-ruby (1.2.2)
+    coveralls (0.8.23)
+      json (>= 1.8, < 3)
+      simplecov (~> 0.16.1)
+      term-ansicolor (~> 1.3)
+      thor (>= 0.19.4, < 2.0)
+      tins (~> 1.6)
+    docile (1.4.0)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.1.0)
+    m (1.6.1)
+      method_source (>= 0.6.7)
+      rake (>= 0.9.2.2)
+    method_source (1.0.0)
+    minitest (5.19.0)
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    racc (1.7.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.1)
+    rexml (3.2.6)
+    rubocop (1.56.1)
+      base64 (~> 0.1.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-performance (1.19.0)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.13.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    standard (1.31.0)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.56.0)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.2)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.2.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.19.0)
+    sync (0.5.0)
+    term-ansicolor (1.7.1)
+      tins (~> 1.0)
+    thor (1.2.2)
+    timecop (0.9.8)
+    tins (1.32.1)
+      sync
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.4.2)
+    yard (0.9.34)
+
+PLATFORMS
+  arm64-darwin-22
+
+DEPENDENCIES
+  activesupport (~> 7.0)
+  coveralls
+  m
+  minitest
+  montrose!
+  rake (>= 12.3.3)
+  standard
+  timecop
+  yard
+
+BUNDLED WITH
+   2.4.10

data/lib/montrose/chainable.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "montrose/options"
 require "montrose/refinements/array_concat"
 
 module Montrose

data/lib/montrose/clock.rb

@@ -10,32 +10,32 @@ module Montrose
       @every = @options.fetch(:every) { fail ConfigurationError, "Required option :every not provided" }
       @interval = @options.fetch(:interval)
       @start_time = @options.fetch(:start_time)
-      @at = @options.fetch(:at, nil)
+      @at = @options.fetch(:at, []).sort
     end
 
     # Advances time to new unit by increment and sets
     # new time as "current" time for next tick
     #
     def tick
-      @time = peek
+      @time = next_time(true)
     end
 
     def peek
-      return @start_time if @time.nil?
+      next_time(false)
+    end
 
-      if @at
-        times = @at.map { |hour, min, sec = 0| @time.change(hour: hour, min: min, sec: sec) }
+    private
 
-        (min_next = times.select { |t| t > @time }.min) && (return min_next)
+    def next_time(tick)
+      return @start_time if @time.nil?
 
-        advance_step(times.min || @time)
+      if @at.present?
+        next_time_at(@time, tick)
       else
         advance_step(@time)
       end
     end
 
-    private
-
     def advance_step(time)
       time.advance(step)
     end
@@ -54,6 +54,51 @@ module Montrose
         unit_step(:year)
     end
 
+    # @private
+    #
+    # Returns next time using :at option. Tries to calculate
+    # a time for the current date by incrementing the index
+    # of the :at option. Once all items have been exhausted
+    # the minimum time is generated for the current date and
+    # we advance to the next date based on interval
+    #
+    def next_time_at(time, tick)
+      if current_at_index && (next_time = time_at(time, current_at_index + 1))
+        @current_at_index += 1 if tick
+
+        next_time
+      else
+        min_time = time_at(time, 0)
+        @current_at_index = 0 if tick
+
+        advance_step(min_time)
+      end
+    end
+
+    # @private
+    #
+    # Returns time with hour, minute and second from :at option
+    # at specified index
+    #
+    def time_at(time, index)
+      parts = @at[index]
+
+      return unless parts
+
+      hour, min, sec = parts
+      time.change(hour: hour, min: min, sec: sec || 0)
+    end
+
+    # @private
+    #
+    # Keep track of which index we are currently at for :at option.
+    #
+    def current_at_index
+      @current_at_index ||= @at.index do |hour, min, sec = 0|
+        @start_time.hour == hour && @start_time.min == min && @start_time.sec == sec
+      end
+    end
+
     # @private
     #
     # Returns hash representing unit and amount to advance time

data/lib/montrose/day.rb

@@ -0,0 +1,83 @@
+module Montrose
+  class Day
+    extend Montrose::Utils
+
+    NAMES = ::Date::DAYNAMES
+    TWO_LETTER_ABBREVIATIONS = %w[SU MO TU WE TH FR SA].freeze
+    THREE_LETTER_ABBREVIATIONS = %w[SUN MON TUE WED THU FRI SAT]
+    NUMBERS = NAMES.map.with_index { |_n, i| i.to_s }
+
+    ICAL_MATCH = /(?<ordinal>[+-]?\d+)?(?<day>[A-Z]{2})/ # e.g. 1FR
+
+    class << self
+      def parse(arg)
+        case arg
+        when Hash
+          parse_entries(arg.entries)
+        when String
+          parse(arg.split(","))
+        else
+          parse_entries(map_arg(arg) { |value| parse_value(value) })
+        end
+      end
+
+      def parse_entries(entries)
+        hash = Hash.new { |h, k| h[k] = [] }
+        result = entries.each_with_object(hash) { |(k, v), hash|
+          index = number!(k)
+          hash[index] = hash[index] + [*v]
+        }
+        result.values.all?(&:empty?) ? result.keys : result
+      end
+
+      def parse_value(value)
+        parse_ical(value) || [number!(value), nil]
+      end
+
+      def parse_ical(value)
+        (match = ICAL_MATCH.match(value.to_s)) || (return nil)
+        index = number!(match[:day])
+        ordinal = match[:ordinal]&.to_i
+        [index, ordinal]
+      end
+
+      def map_arg(arg, &block)
+        return nil unless arg.present?
+
+        Array(arg).map(&block)
+      end
+
+      def names
+        NAMES
+      end
+
+      def number(name)
+        case name
+        when 0..6
+          name
+        when Symbol, String
+          string = name.to_s.downcase
+          NAMES.index(string.titleize) ||
+            TWO_LETTER_ABBREVIATIONS.index(string.upcase) ||
+            THREE_LETTER_ABBREVIATIONS.index(string.upcase) ||
+            number(to_index(string))
+        when Array
+          number name.first
+        end
+      end
+
+      def number!(name)
+        number(name) || raise(ConfigurationError,
+          "Did not recognize day #{name}, must be one of #{(names + abbreviations + numbers).inspect}")
+      end
+
+      def numbers
+        NUMBERS
+      end
+
+      def abbreviations
+        TWO_LETTER_ABBREVIATIONS + THREE_LETTER_ABBREVIATIONS
+      end
+    end
+  end
+end

data/lib/montrose/frequency.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
-require "montrose/errors"
-require "montrose/options"
-
 module Montrose
   # Abstract class for special recurrence rule required
   # in all instances of Recurrence. Frequency describes
   # the base recurrence interval.
   #
   class Frequency
+    autoload :Daily, "montrose/frequency/daily"
+    autoload :Hourly, "montrose/frequency/hourly"
+    autoload :Minutely, "montrose/frequency/minutely"
+    autoload :Monthly, "montrose/frequency/monthly"
+    autoload :Secondly, "montrose/frequency/secondly"
+    autoload :Weekly, "montrose/frequency/weekly"
+    autoload :Yearly, "montrose/frequency/yearly"
+
     include Montrose::Rule
 
     FREQUENCY_TERMS = {
@@ -25,24 +30,60 @@ module Montrose
 
     attr_reader :time, :starts
 
-    # Factory method for instantiating the appropriate Frequency
-    # subclass.
-    #
-    def self.from_options(opts)
-      frequency = opts.fetch(:every) { fail ConfigurationError, "Please specify the :every option" }
-      class_name = FREQUENCY_TERMS.fetch(frequency.to_s) {
-        fail "Don't know how to enumerate every: #{frequency}"
-      }
+    class << self
+      def parse(input)
+        if input.respond_to?(:parts)
+          frequency, interval = duration_to_frequency_parts(input)
+          {every: frequency.to_s.singularize.to_sym, interval: interval}
+        elsif input.is_a?(Numeric)
+          frequency, interval = numeric_to_frequency_parts(input)
+          {every: frequency, interval: interval}
+        else
+          {every: Frequency.assert(input)}
+        end
+      end
 
-      Montrose::Frequency.const_get(class_name).new(opts)
-    end
+      # Factory method for instantiating the appropriate Frequency
+      # subclass.
+      #
+      def from_options(opts)
+        frequency = opts.fetch(:every) { fail ConfigurationError, "Please specify the :every option" }
+        class_name = FREQUENCY_TERMS.fetch(frequency.to_s) {
+          fail "Don't know how to enumerate every: #{frequency}"
+        }
+
+        Montrose::Frequency.const_get(class_name).new(opts)
+      end
 
-    # @private
-    def self.assert(frequency)
-      FREQUENCY_TERMS.key?(frequency.to_s) || fail(ConfigurationError,
-        "Don't know how to enumerate every: #{frequency}")
+      def from_term(term)
+        FREQUENCY_TERMS.invert.map { |k, v| [k.downcase, v] }.to_h.fetch(term.downcase) do
+          fail "Don't know how to convert #{term} to a Montrose frequency"
+        end
+      end
 
-      frequency.to_sym
+      # @private
+      def assert(frequency)
+        FREQUENCY_TERMS.key?(frequency.to_s) || fail(ConfigurationError,
+          "Don't know how to enumerate every: #{frequency}")
+
+        frequency.to_sym
+      end
+
+      # @private
+      def numeric_to_frequency_parts(number)
+        parts = nil
+        %i[year month week day hour minute].each do |freq|
+          div, mod = number.divmod(1.send(freq))
+          parts = [freq, div]
+          return parts if mod.zero?
+        end
+        parts
+      end
+
+      # @private
+      def duration_to_frequency_parts(duration)
+        duration.parts.first
+      end
     end
 
     def initialize(opts = {})
@@ -63,15 +104,7 @@ module Montrose
     protected
 
     def interval_str
-      @interval != 1 ? "*/#{@interval}" : "*"
+      (@interval != 1) ? "*/#{@interval}" : "*"
     end
   end
 end
-
-require "montrose/frequency/daily"
-require "montrose/frequency/hourly"
-require "montrose/frequency/minutely"
-require "montrose/frequency/monthly"
-require "montrose/frequency/secondly"
-require "montrose/frequency/weekly"
-require "montrose/frequency/yearly"

data/lib/montrose/hour.rb

@@ -0,0 +1,22 @@
+module Montrose
+  class Hour
+    HOURS_IN_DAY = 1.upto(24).to_a.freeze
+
+    class << self
+      def parse(arg)
+        case arg
+        when String
+          parse(arg.split(","))
+        else
+          Array(arg).map { |h| assert(h.to_i) }.presence
+        end
+      end
+
+      def assert(hour)
+        raise ConfigurationError, "Out of range: #{HOURS_IN_DAY.inspect} does not include #{hour}" unless HOURS_IN_DAY.include?(hour)
+
+        hour
+      end
+    end
+  end
+end

data/lib/montrose/ical.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Montrose
+  class ICal
+    # DTSTART;TZID=US-Eastern:19970902T090000
+    # RRULE:FREQ=DAILY;INTERVAL=2
+    def self.parse(ical)
+      new(ical).parse
+    end
+
+    def initialize(ical)
+      @ical = ical
+    end
+
+    def parse
+      time_zone = extract_time_zone(@ical)
+
+      Time.use_zone(time_zone) do
+        Hash[*parse_properties(@ical)]
+      end
+    end
+
+    private
+
+    def extract_time_zone(ical_string)
+      _label, time_string = ical_string.split("\n").grep(/^DTSTART/).join.split(";")
+      time_zone_rule, _ = time_string.split(":")
+      _label, time_zone = (time_zone_rule || "").split("=")
+      time_zone
+    end
+
+    # First pass parsing to normalize arbitrary line breaks
+    def property_lines(ical_string)
+      ical_string.split("\n").each_with_object([]) do |line, lines|
+        case line
+        when /^(DTSTART|DTEND|EXDATE|RDATE|RRULE)/
+          lines << line
+        else
+          (lines.last || lines << "")
+          lines.last << line
+        end
+      end
+    end
+
+    def parse_properties(ical_string)
+      property_lines(ical_string).flat_map do |line|
+        (property, value) = line.split(":")
+        (property, tzid) = property.split(";")
+
+        case property
+        when "DTSTART"
+          parse_dtstart(tzid, value)
+        when "DTEND"
+          warn "DTEND not currently supported!"
+        when "EXDATE"
+          parse_exdate(value)
+        when "RDATE"
+          warn "RDATE not currently supported!"
+        when "RRULE"
+          parse_rrule(value)
+        end
+      end
+    end
+
+    def parse_dtstart(tzid, time)
+      return [] unless time.present?
+
+      @starts_at = parse_time([tzid, time].compact.join(":"))
+
+      [:starts, @starts_at]
+    end
+
+    def parse_timezone(time_string)
+      time_zone_rule, _ = time_string.split(":")
+      _label, time_zone = (time_zone_rule || "").split("=")
+      time_zone
+    end
+
+    def parse_time(time_string)
+      time_zone = parse_timezone(time_string)
+      Montrose::Utils.parse_time(time_string).in_time_zone(time_zone)
+    end
+
+    def parse_exdate(exdate)
+      return [] unless exdate.present?
+
+      @except = Montrose::Utils.as_date(exdate) # only currently supports dates
+
+      [:except, @except]
+    end
+
+    def parse_rrule(rrule)
+      rrule.gsub(/\s+/, "").split(";").flat_map do |rule|
+        prop, value = rule.split("=")
+        case prop
+        when "FREQ"
+          [:every, Montrose::Frequency.from_term(value)]
+        when "INTERVAL"
+          [:interval, value.to_i]
+        when "COUNT"
+          [:total, value.to_i]
+        when "UNTIL"
+          [:until, parse_time(value)]
+        when "BYMINUTE"
+          [:minute, Montrose::Minute.parse(value)]
+        when "BYHOUR"
+          [:hour, Montrose::Hour.parse(value)]
+        when "BYMONTH"
+          [:month, Montrose::Month.parse(value)]
+        when "BYDAY"
+          [:day, Montrose::Day.parse(value)]
+        when "BYMONTHDAY"
+          [:mday, Montrose::MonthDay.parse(value)]
+        when "BYYEARDAY"
+          [:yday, Montrose::YearDay.parse(value)]
+        when "BYWEEKNO"
+          [:week, Montrose::Week.parse(value)]
+        when "WKST"
+          [:week_start, value]
+        when "BYSETPOS"
+          warn "BYSETPOS not currently supported!"
+        else
+          raise "Unrecognized rrule '#{rule}'"
+        end
+      end
+    end
+  end
+end

data/lib/montrose/minute.rb

@@ -0,0 +1,22 @@
+module Montrose
+  class Minute
+    MINUTES_IN_HOUR = 0.upto(59).to_a.freeze
+
+    class << self
+      def parse(arg)
+        case arg
+        when String
+          parse(arg.split(","))
+        else
+          Array(arg).map { |m| assert(m.to_i) }.presence
+        end
+      end
+
+      def assert(minute)
+        raise ConfigurationError, "Out of range: #{MINUTES_IN_HOUR.inspect} does not include #{minute}" unless MINUTES_IN_HOUR.include?(minute)
+
+        minute
+      end
+    end
+  end
+end