montrose 0.11.0 → 0.13.0

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) do
-        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
+
+      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
 
-    # @private
-    def self.assert(frequency)
-      FREQUENCY_TERMS.key?(frequency.to_s) or fail ConfigurationError,
-        "Don't know how to enumerate every: #{frequency}"
+      # @private
+      def assert(frequency)
+        FREQUENCY_TERMS.key?(frequency.to_s) || fail(ConfigurationError,
+          "Don't know how to enumerate every: #{frequency}")
 
-      frequency.to_sym
+        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 = {})
@@ -67,11 +108,3 @@ module Montrose
     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

data/lib/montrose/month.rb

@@ -0,0 +1,47 @@
+module Montrose
+  class Month
+    extend Montrose::Utils
+
+    NAMES = ::Date::MONTHNAMES # starts with nil to match 1-12 numbering
+    NUMBERS = NAMES.map.with_index { |_n, i| i.to_s }.slice(1, 12)
+
+    class << self
+      def parse(value)
+        case value
+        when String
+          parse(value.split(",").compact)
+        when Array
+          value.map { |m|
+            Montrose::Month.number!(m)
+          }.presence
+        else
+          parse(Array(value))
+        end
+      end
+
+      def names
+        NAMES
+      end
+
+      def numbers
+        NUMBERS
+      end
+
+      def number(name)
+        case name
+        when Symbol, String
+          string = name.to_s
+          NAMES.index(string.titleize) || number(to_index(string))
+        when 1..12
+          name
+        end
+      end
+
+      def number!(name)
+        numbers = NAMES.map.with_index { |_n, i| i.to_s }.slice(1, 12)
+        number(name) || raise(ConfigurationError,
+          "Did not recognize month #{name}, must be one of #{(NAMES + numbers).inspect}")
+      end
+    end
+  end
+end

data/lib/montrose/month_day.rb

@@ -0,0 +1,25 @@
+module Montrose
+  class MonthDay
+    class << self
+      MDAYS = (-31.upto(-1).to_a + 1.upto(31).to_a)
+
+      def parse(mdays)
+        return nil unless mdays.present?
+
+        case mdays
+        when String
+          parse(mdays.split(","))
+        else
+          Array(mdays).map { |d| assert(d.to_i) }
+        end
+      end
+
+      def assert(number)
+        test = number.abs
+        raise ConfigurationError, "Out of range: #{MDAYS.inspect} does not include #{test}" unless MDAYS.include?(number.abs)
+
+        number
+      end
+    end
+  end
+end

data/lib/montrose/options.rb

@@ -86,12 +86,15 @@ module Montrose
     def_option :starts
     def_option :until
     def_option :between
+    def_option :covering
     def_option :during
+    def_option :minute
     def_option :hour
     def_option :day
     def_option :mday
     def_option :yday
     def_option :week
+    def_option :week_start
     def_option :month
     def_option :interval
     def_option :total
@@ -112,6 +115,7 @@ module Montrose
         week: nil,
         month: nil,
         total: nil,
+        week_start: nil,
         exclude_end: nil
       }
 
@@ -120,12 +124,12 @@ module Montrose
     end
 
     def to_hash
-      hash_pairs = self.class.defined_options.flat_map do |opt_name|
+      hash_pairs = self.class.defined_options.flat_map { |opt_name|
         [opt_name, send(opt_name)]
-      end
+      }
       Hash[*hash_pairs].reject { |_k, v| v.nil? }
     end
-    alias to_h to_hash
+    alias_method :to_h, :to_hash
 
     def []=(option, val)
       send(:"#{option}=", val)
@@ -142,13 +146,13 @@ module Montrose
       self.class.new(h1.merge(h2))
     end
 
-    def fetch(key, *args, &_block)
-      fail ArgumentError, "wrong number of arguments (#{args.length} for 1..2)" if args.length > 1
+    def fetch(key, *args)
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 1..2)" if args.length > 1
 
       found = send(key)
       return found if found
       return args.first if args.length == 1
-      fail "Key #{key.inspect} not found" unless block_given?
+      raise KeyError, "Key #{key.inspect} not found" unless block_given?
 
       yield
     end
@@ -165,8 +169,8 @@ module Montrose
       @every = parsed.fetch(:every)
     end
 
-    alias frequency every
-    alias frequency= every=
+    alias_method :frequency, :every
+    alias_method :frequency=, :every=
 
     def starts=(time)
       @starts = normalize_time(as_time(time)) || default_starts
@@ -176,47 +180,58 @@ module Montrose
       @until = normalize_time(as_time(time)) || default_until
     end
 
+    def minute=(minutes)
+      @minute = Minute.parse(minutes)
+    end
+
     def hour=(hours)
       @hour = map_arg(hours) { |h| assert_hour(h) }
     end
 
-    def during=(during)
-      @during = case during
-                when Range
-                  [decompose_during_arg(during)]
-                else
-                  map_arg(during) { |d| decompose_during_arg(d) }
-                end
+    def during=(during_arg)
+      @during = decompose_during_arg(during_arg)
+        .each_with_object([]) { |(time_of_day_first, time_of_day_last), all|
+        if time_of_day_last < time_of_day_first
+          all.push(
+            [time_of_day_first.parts, end_of_day.parts],
+            [beginning_of_day.parts, time_of_day_last.parts]
+          )
+        else
+          all.push([time_of_day_first.parts, time_of_day_last.parts])
+        end
+      }.presence
     end
 
     def day=(days)
-      @day = nested_map_arg(days) { |d| day_number!(d) }
+      @day = Day.parse(days)
     end
 
     def mday=(mdays)
-      @mday = map_mdays(mdays)
+      @mday = MonthDay.parse(mdays)
     end
 
     def yday=(ydays)
-      @yday = map_ydays(ydays)
+      @yday = YearDay.parse(ydays)
     end
 
     def week=(weeks)
-      @week = map_arg(weeks) { |w| assert_week(w) }
+      @week = Week.parse(weeks)
     end
 
     def month=(months)
-      @month = map_arg(months) { |d| month_number!(d) }
+      @month = Month.parse(months)
     end
 
     def between=(range)
-      @between = range
+      if Montrose.enable_deprecated_between_masking?
+        @covering = range
+      end
       self[:starts] = range.first unless self[:starts]
       self[:until] = range.last unless self[:until]
     end
 
     def at=(time)
-      @at = map_arg(time) { |t| as_time_parts(t) }
+      @at = map_arg(time) { |t| time_of_day_parse(t).parts }
     end
 
     def on=(arg)
@@ -257,51 +272,16 @@ module Montrose
       self.class.default_until
     end
 
-    def nested_map_arg(arg, &block)
-      case arg
-      when Hash
-        arg.each_with_object({}) do |(k, v), hash|
-          hash[yield k] = [*v]
-        end
-      else
-        map_arg(arg, &block)
-      end
-    end
-
     def map_arg(arg, &block)
       return nil unless arg
 
       Array(arg).map(&block)
     end
 
-    def map_days(arg)
-      map_arg(arg) { |d| day_number!(d) }
-    end
-
-    def map_mdays(arg)
-      map_arg(arg) { |d| assert_mday(d) }
-    end
-
-    def map_ydays(arg)
-      map_arg(arg) { |d| assert_yday(d) }
-    end
-
     def assert_hour(hour)
       assert_range_includes(1..::Montrose::Utils::MAX_HOURS_IN_DAY, hour)
     end
 
-    def assert_mday(mday)
-      assert_range_includes(1..::Montrose::Utils::MAX_DAYS_IN_MONTH, mday, :absolute)
-    end
-
-    def assert_yday(yday)
-      assert_range_includes(1..::Montrose::Utils::MAX_DAYS_IN_YEAR, yday, :absolute)
-    end
-
-    def assert_week(week)
-      assert_range_includes(1..::Montrose::Utils::MAX_WEEKS_IN_YEAR, week, :absolute)
-    end
-
     def decompose_on_arg(arg)
       case arg
       when Hash
@@ -309,52 +289,45 @@ module Montrose
           key, val = month_or_day(k)
           result[key] = val
           result[:mday] ||= []
-          result[:mday] += map_mdays(v)
+          result[:mday] += Montrose::MonthDay.parse(v)
         end
       else
-        { day: map_days(arg) }
+        {day: Montrose::Day.parse(arg)}
       end
     end
 
     def month_or_day(key)
-      month = month_number(key)
+      month = Montrose::Month.number(key)
       return [:month, month] if month
 
-      day = day_number(key)
+      day = Montrose::Day.number(key)
       return [:day, day] if day
 
-      fail ConfigurationError, "Did not recognize #{key} as a month or day"
+      raise ConfigurationError, "Did not recognize #{key} as a month or day"
     end
 
     def assert_range_includes(range, item, absolute = false)
       test = absolute ? item.abs : item
-      fail ConfigurationError, "Out of range: #{range.inspect} does not include #{test}" unless range.include?(test)
+      raise ConfigurationError, "Out of range: #{range.inspect} does not include #{test}" unless range.include?(test)
 
       item
     end
 
-    def as_time_parts(arg)
-      return arg if arg.is_a?(Array)
-
-      time = as_time(arg)
-      [time.hour, time.min, time.sec]
-    end
-
     def parse_frequency(input)
       if input.respond_to?(:parts)
         frequency, interval = duration_to_frequency_parts(input)
-        { every: frequency.to_s.singularize.to_sym, interval: interval }
+        {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 }
+        {every: frequency, interval: interval}
       else
-        { every: Frequency.assert(input) }
+        {every: Frequency.assert(input)}
       end
     end
 
     def numeric_to_frequency_parts(number)
       parts = nil
-      [:year, :month, :week, :day, :hour, :minute].each do |freq|
+      %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?
@@ -366,15 +339,36 @@ module Montrose
       duration.parts.first
     end
 
-    def decompose_during_arg(during)
-      case during
+    def decompose_during_arg(during_arg)
+      case during_arg
+      when Range
+        [decompose_during_parts(during_arg)]
+      else
+        map_arg(during_arg) { |d| decompose_during_parts(d) } || []
+      end
+    end
+
+    def decompose_during_parts(during_parts)
+      case during_parts
       when Range
-        [decompose_during_arg(during.first), decompose_during_arg(during.last)]
+        decompose_during_parts([during_parts.first, during_parts.last])
       when String
-        during.split(%r{[-—–]}).map { |d| as_time_parts(d) }
+        decompose_during_parts(during_parts.split(/[-—–]/))
       else
-        as_time_parts(during)
+        during_parts.map { |parts| time_of_day_parse(parts) }
       end
     end
+
+    def time_of_day_parse(time_parts)
+      ::Montrose::TimeOfDay.parse(time_parts)
+    end
+
+    def end_of_day
+      @end_of_day ||= time_of_day_parse(Time.now.end_of_day)
+    end
+
+    def beginning_of_day
+      @beginning_of_day ||= time_of_day_parse(Time.now.beginning_of_day)
+    end
   end
 end