montrose 0.12.0 → 0.13.0

data/lib/montrose/options.rb

@@ -88,11 +88,13 @@ module Montrose
     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
@@ -113,6 +115,7 @@ module Montrose
         week: nil,
         month: nil,
         total: nil,
+        week_start: nil,
         exclude_end: nil
       }
 
@@ -149,7 +152,7 @@ module Montrose
       found = send(key)
       return found if found
       return args.first if args.length == 1
-      raise "Key #{key.inspect} not found" unless block
+      raise KeyError, "Key #{key.inspect} not found" unless block_given?
 
       yield
     end
@@ -177,37 +180,46 @@ 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)
@@ -219,7 +231,7 @@ module Montrose
     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)
@@ -260,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
@@ -312,18 +289,18 @@ 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
 
       raise ConfigurationError, "Did not recognize #{key} as a month or day"
@@ -336,13 +313,6 @@ module Montrose
       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)
@@ -369,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_arg(during.first), decompose_during_arg(during.last)]
+        [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_parts([during_parts.first, during_parts.last])
       when String
-        during.split(/[-—–]/).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

data/lib/montrose/recurrence.rb

@@ -2,10 +2,6 @@
 
 require "json"
 require "yaml"
-require "montrose/chainable"
-require "montrose/errors"
-require "montrose/stack"
-require "montrose/clock"
 
 module Montrose
   # Represents the rules for a set of recurring events. Can be instantiated
@@ -250,6 +246,16 @@ module Montrose
       rescue JSON::ParserError => e
         fail SerializationError, "Could not parse JSON: #{e}"
       end
+
+      alias_method :from_json, :load
+
+      def from_yaml(yaml)
+        new(YAML.safe_load(yaml))
+      end
+
+      def from_ical(ical)
+        new(Montrose::ICal.parse(ical))
+      end
     end
 
     def initialize(opts = {})
@@ -331,7 +337,7 @@ module Montrose
     # @return [String] YAML-formatted recurrence options
     #
     def to_yaml(*args)
-      YAML.dump(JSON.parse(to_json(*args)))
+      YAML.dump(as_json(*args))
     end
 
     def inspect

data/lib/montrose/rule/during.rb

@@ -21,22 +21,10 @@ module Montrose
         @during.any? { |range| range.include?(time) }
       end
 
-      class TimeOfDay
-        def initialize(hour, min, sec)
-          @hour = hour
-          @min = min
-          @sec = sec
-        end
-
-        def seconds_since_midnight
-          @seconds_since_midnight ||= (@hour * 60 * 60) + (@min * 60) + @sec
-        end
-      end
-
       class TimeOfDayRange
         def initialize(first, last, exclude_end: false)
-          @first = TimeOfDay.new(*first)
-          @last = TimeOfDay.new(*last)
+          @first = ::Montrose::TimeOfDay.new(first)
+          @last = ::Montrose::TimeOfDay.new(last)
           @exclude_end = exclude_end
         end
 
@@ -47,7 +35,11 @@ module Montrose
         private
 
         def range
-          @range ||= Range.new(@first.seconds_since_midnight, @last.seconds_since_midnight, @exclude_end)
+          @range ||= Range.new(
+            @first.seconds_since_midnight,
+            @last.seconds_since_midnight,
+            @exclude_end
+          )
         end
       end
     end

data/lib/montrose/rule/minute_of_hour.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Montrose
+  module Rule
+    class MinuteOfHour
+      include Montrose::Rule
+
+      def self.apply_options(opts)
+        opts[:minute]
+      end
+
+      # Initializes rule
+      #
+      # @param minutes [Array<Fixnum>] valid minutes of hour, e.g. [0, 20, 59]
+      #
+      def initialize(minutes)
+        @minutes = minutes
+      end
+
+      def include?(time)
+        @minutes.include?(time.min)
+      end
+    end
+  end
+end

data/lib/montrose/rule/nth_day_of_month.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "montrose/rule/nth_day_matcher"
-
 module Montrose
   module Rule
     class NthDayOfMonth

data/lib/montrose/rule/nth_day_of_year.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "montrose/rule/nth_day_matcher"
-
 module Montrose
   module Rule
     class NthDayOfYear

data/lib/montrose/rule/time_of_day.rb

@@ -24,7 +24,7 @@ module Montrose
       private
 
       def parts(time)
-        [time.hour, time.min, time.sec]
+        ::Montrose::TimeOfDay.to_parts(time)
       end
     end
   end

data/lib/montrose/rule.rb

@@ -3,6 +3,24 @@
 module Montrose
   # Defines the Rule duck type for recurrence rules
   module Rule
+    autoload :After, "montrose/rule/after"
+    autoload :Covering, "montrose/rule/covering"
+    autoload :DayOfMonth, "montrose/rule/day_of_month"
+    autoload :DayOfWeek, "montrose/rule/day_of_week"
+    autoload :DayOfYear, "montrose/rule/day_of_year"
+    autoload :During, "montrose/rule/during"
+    autoload :Except, "montrose/rule/except"
+    autoload :HourOfDay, "montrose/rule/hour_of_day"
+    autoload :MinuteOfHour, "montrose/rule/minute_of_hour"
+    autoload :MonthOfYear, "montrose/rule/month_of_year"
+    autoload :NthDayMatcher, "montrose/rule/nth_day_matcher"
+    autoload :NthDayOfMonth, "montrose/rule/nth_day_of_month"
+    autoload :NthDayOfYear, "montrose/rule/nth_day_of_year"
+    autoload :TimeOfDay, "montrose/rule/time_of_day"
+    autoload :Total, "montrose/rule/total"
+    autoload :Until, "montrose/rule/until"
+    autoload :WeekOfYear, "montrose/rule/week_of_year"
+
     def self.included(base)
       base.extend ClassMethods
     end
@@ -34,19 +52,3 @@ module Montrose
     end
   end
 end
-
-require "montrose/rule/after"
-require "montrose/rule/covering"
-require "montrose/rule/day_of_month"
-require "montrose/rule/day_of_week"
-require "montrose/rule/day_of_year"
-require "montrose/rule/during"
-require "montrose/rule/except"
-require "montrose/rule/hour_of_day"
-require "montrose/rule/month_of_year"
-require "montrose/rule/nth_day_of_month"
-require "montrose/rule/nth_day_of_year"
-require "montrose/rule/time_of_day"
-require "montrose/rule/total"
-require "montrose/rule/until"
-require "montrose/rule/week_of_year"

data/lib/montrose/stack.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "montrose/rule"
-
 module Montrose
   # Maintains stack of recurrences rules that apply to
   # an associated recurrence; manages advancing state
@@ -18,6 +16,7 @@ module Montrose
         Rule::Except,
         Rule::Total,
         Rule::TimeOfDay,
+        Rule::MinuteOfHour,
         Rule::HourOfDay,
         Rule::NthDayOfMonth,
         Rule::NthDayOfYear,

data/lib/montrose/time_of_day.rb

@@ -0,0 +1,48 @@
+module Montrose
+  class TimeOfDay
+    include Comparable
+
+    attr_reader :parts, :hour, :min, :sec
+
+    def self.parse(arg)
+      return new(arg) if arg.is_a?(Array)
+
+      from_time(::Montrose::Utils.as_time(arg))
+    end
+
+    def self.from_time(time)
+      new(to_parts(time))
+    end
+
+    def self.to_parts(time)
+      [time.hour, time.min, time.sec]
+    end
+
+    def initialize(parts)
+      @parts = parts
+      @hour, @min, @sec = *parts
+    end
+
+    def seconds_since_midnight
+      @seconds_since_midnight ||= (@hour * 60 * 60) + (@min * 60) + @sec
+    end
+
+    def to_a
+      @parts
+    end
+
+    # def inspect
+    #   "#<Montrose::TimeOfDay #{format_time(@hour)}:#{format_time(@min)}:#{format_time(@sec)}"
+    # end
+
+    def <=>(other)
+      to_a <=> other.to_a
+    end
+
+    private
+
+    def format_time(part)
+      format("%02d", part)
+    end
+  end
+end

data/lib/montrose/utils.rb

@@ -4,10 +4,6 @@ module Montrose
   module Utils
     module_function
 
-    MONTHS = ::Date::MONTHNAMES
-
-    DAYS = ::Date::DAYNAMES
-
     MAX_HOURS_IN_DAY = 24
     MAX_DAYS_IN_YEAR = 366
     MAX_WEEKS_IN_YEAR = 53
@@ -44,40 +40,6 @@ module Montrose
       ::Time.current
     end
 
-    def month_number(name)
-      case name
-      when Symbol, String
-        string = name.to_s
-        MONTHS.index(string.titleize) || month_number(to_index(string))
-      when 1..12
-        name
-      end
-    end
-
-    def month_number!(name)
-      month_numbers = MONTHS.map.with_index { |_n, i| i.to_s }.slice(1, 12)
-      month_number(name) || raise(ConfigurationError,
-        "Did not recognize month #{name}, must be one of #{(MONTHS + month_numbers).inspect}")
-    end
-
-    def day_number(name)
-      case name
-      when 0..6
-        name
-      when Symbol, String
-        string = name.to_s
-        DAYS.index(string.titleize) || day_number(to_index(string))
-      when Array
-        day_number name.first
-      end
-    end
-
-    def day_number!(name)
-      day_numbers = DAYS.map.with_index { |_n, i| i.to_s }
-      day_number(name) || raise(ConfigurationError,
-        "Did not recognize day #{name}, must be one of #{(DAYS + day_numbers).inspect}")
-    end
-
     def days_in_month(month, year = current_time.year)
       date = ::Date.new(year, month, 1)
       ((date >> 1) - date).to_i

data/lib/montrose/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Montrose
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 end

data/lib/montrose/week.rb

@@ -0,0 +1,20 @@
+module Montrose
+  class Week
+    class << self
+      NUMBERS = (-53.upto(-1).to_a + 1.upto(53).to_a)
+
+      def parse(arg)
+        return nil unless arg.present?
+
+        Array(arg).map { |value| assert(value.to_i) }
+      end
+
+      def assert(number)
+        test = number.abs
+        raise ConfigurationError, "Out of range: #{NUMBERS.inspect} does not include #{test}" unless NUMBERS.include?(number.abs)
+
+        number
+      end
+    end
+  end
+end

data/lib/montrose/year_day.rb

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

data/lib/montrose.rb

@@ -10,17 +10,29 @@ require "active_support/core_ext/numeric"
 require "active_support/core_ext/string"
 require "active_support/core_ext/time"
 
-require "montrose/utils"
-require "montrose/rule"
-require "montrose/clock"
-require "montrose/chainable"
-require "montrose/recurrence"
-require "montrose/frequency"
-require "montrose/schedule"
-require "montrose/stack"
 require "montrose/version"
+require "montrose/errors"
 
 module Montrose
+  autoload :Chainable, "montrose/chainable"
+  autoload :Clock, "montrose/clock"
+  autoload :Day, "montrose/day"
+  autoload :Frequency, "montrose/frequency"
+  autoload :Hour, "montrose/hour"
+  autoload :ICal, "montrose/ical"
+  autoload :Minute, "montrose/minute"
+  autoload :Month, "montrose/month"
+  autoload :MonthDay, "montrose/month_day"
+  autoload :Options, "montrose/options"
+  autoload :Recurrence, "montrose/recurrence"
+  autoload :Rule, "montrose/rule"
+  autoload :TimeOfDay, "montrose/time_of_day"
+  autoload :Schedule, "montrose/schedule"
+  autoload :Stack, "montrose/stack"
+  autoload :Utils, "montrose/utils"
+  autoload :Week, "montrose/week"
+  autoload :YearDay, "montrose/year_day"
+
   extend Chainable
 
   class << self

data/montrose.gemspec

@@ -20,9 +20,9 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.5.0"
+  spec.required_ruby_version = ">= 2.6.0"
 
-  spec.add_dependency "activesupport", ">= 5.2", "<= 7.0"
+  spec.add_dependency "activesupport", ">= 5.2", "< 7.1"
 
   spec.add_development_dependency "appraisal"
   spec.add_development_dependency "m"