montrose 0.11.0 → 0.13.0

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
@@ -238,7 +234,7 @@ module Montrose
                else
                  fail SerializationError,
                    "Object was supposed to be a #{self}, but was a #{obj.class}. -- #{obj.inspect}"
-               end
+        end
 
         JSON.dump(hash)
       end
@@ -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 = {})
@@ -308,7 +314,7 @@ module Montrose
     def to_hash
       default_options.to_hash
     end
-    alias to_h to_hash
+    alias_method :to_h, :to_hash
 
     # Returns json string of options used to create the recurrence
     #
@@ -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
@@ -346,20 +352,41 @@ module Montrose
     def include?(timestamp)
       return false if earlier?(timestamp) || later?(timestamp)
 
-      recurrence = finite? ? self : starts(timestamp)
+      recurrence = finite? ? self : fast_forward(timestamp)
 
       recurrence.events.lazy.each do |event|
         return true if event == timestamp
         return false if event > timestamp
-      end or false
+      end || false
     end
 
-    # Return true/false if recurrence will iterate infinitely
+    def fast_forward(timestamp)
+      return starts(timestamp) unless starts_at.present?
+
+      interval = default_options[:interval]
+      frequency = default_options[:every]
+      duration = interval.send(frequency)
+
+      # Calculate nearest earlier time ahead matching frequency * interval
+      jump = ((timestamp - starts_at) / duration).floor * duration
+
+      starts(starts_at + jump)
+    end
+
+    # Return true/false if recurrence will terminate
     #
-    # @return [Boolean] whether or not recurrence is infinite
+    # @return [Boolean] returns true if recurrence has an end
     #
     def finite?
-      ends_at || length
+      !infinite?
+    end
+
+    # Return true/false if recurrence will iterate infinitely
+    #
+    # @return [Boolean] returns true if recurrence has no end
+    #
+    def infinite?
+      !ends_at && !length
     end
 
     # Return true/false if given timestamp occurs before
@@ -391,7 +418,7 @@ module Montrose
         loop do
           stack.advance(clock.tick) do |time|
             yielder << time
-          end or break
+          end || break
         end
       end
     end

data/lib/montrose/rule/between.rb

@@ -22,7 +22,7 @@ module Montrose
       end
 
       def continue?(time)
-        @between.max > time
+        time < @between.max
       end
     end
   end

data/lib/montrose/rule/covering.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Montrose
+  module Rule
+    class Covering
+      include Montrose::Rule
+
+      def self.apply_options(opts)
+        opts[:covering].is_a?(Range) && opts[:covering]
+      end
+
+      # Initializes rule
+      #
+      # @param [Range] covering - timestamp range
+      #
+      def initialize(covering)
+        @covering = case covering.first
+        when Date
+          DateRange.new(covering)
+        else
+          covering
+        end
+      end
+
+      def include?(time)
+        @covering.include?(time)
+      end
+
+      def continue?(time)
+        time < @covering.last
+      end
+
+      class DateRange < SimpleDelegator
+        def include?(time)
+          __getobj__.include?(time.to_date)
+        end
+      end
+    end
+  end
+end

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/until.rb

@@ -8,7 +8,7 @@ module Montrose
       def self.apply_options(opts)
         return false unless opts[:until]
 
-        { until: opts[:until], exclude_end: opts.fetch(:exclude_end, false) }
+        {until: opts[:until], exclude_end: opts.fetch(:exclude_end, false)}
       end
 
       def initialize(opts)

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/between"
-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/schedule.rb

@@ -42,7 +42,7 @@ module Montrose
                 else
                   fail SerializationError,
                     "Object was supposed to be a #{self}, but was a #{obj.class}. -- #{obj.inspect}"
-                end
+        end
 
         JSON.dump(array)
       end
@@ -77,7 +77,7 @@ module Montrose
 
       self
     end
-    alias add <<
+    alias_method :add, :<<
 
     # Return true/false if given timestamp is included in any of the rules
     # found in the schedule
@@ -127,7 +127,7 @@ module Montrose
       enums = @rules.map { |r| r.merge(opts).events }
       Enumerator.new do |y|
         loop do
-          enum = active_enums(enums).min_by(&:peek) or break
+          (enum = active_enums(enums).min_by(&:peek)) || break
           y << enum.next
         end
       end
@@ -173,11 +173,9 @@ module Montrose
 
     def active_enums(enums)
       enums.select do |e|
-        begin
-          e.peek
-        rescue StopIteration
-          false
-        end
+        e.peek
+      rescue StopIteration
+        false
       end
     end
   end

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
@@ -13,11 +11,12 @@ module Montrose
         Frequency,
         Rule::After,
         Rule::Until,
-        Rule::Between,
+        Rule::Covering,
         Rule::During,
         Rule::Except,
         Rule::Total,
         Rule::TimeOfDay,
+        Rule::MinuteOfHour,
         Rule::HourOfDay,
         Rule::NthDayOfMonth,
         Rule::NthDayOfYear,
@@ -44,7 +43,7 @@ module Montrose
       yes, no = @stack.partition { |rule| rule.include?(time) }
 
       if no.empty?
-        yes.all? { |rule| rule.advance!(time) } or return false
+        yes.all? { |rule| rule.advance!(time) } || (return false)
         puts time if ENV["DEBUG"]
         yield time if block_given?
         true

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
@@ -29,7 +25,7 @@ module Montrose
 
     # Recurrence at fractions of a second are not recognized
     def normalize_time(time)
-      time && time.change(usec: 0)
+      time&.change(usec: 0)
     end
 
     def as_date(time)
@@ -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) or fail 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) or fail 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
@@ -93,7 +55,7 @@ module Montrose
     # Returns string.to_i only if string fully matches an integer
     # otherwise ensures that return value won't match a valid index
     def to_index(string)
-      string =~ %r{^\d+} ? string.to_i : -1
+      /^\d+/.match?(string) ? string.to_i : -1
     end
   end
 end

data/lib/montrose/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Montrose
-  VERSION = "0.11.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

@@ -2,22 +2,37 @@
 
 require "active_support"
 require "active_support/core_ext/object"
-require "active_support/core_ext/numeric"
+
 require "active_support/core_ext/date"
-require "active_support/core_ext/time"
 require "active_support/core_ext/date_time"
+require "active_support/core_ext/integer"
+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
@@ -35,6 +50,23 @@ module Montrose
     def recurrence(options = {})
       branch(options)
     end
-    alias r recurrence
+    alias_method :r, :recurrence
+
+    # Create a new recurrence from given options
+    # An alias to {Montrose::Recurrence.new}
+    attr_reader :enable_deprecated_between_masking
+
+    def enable_deprecated_between_masking=(value)
+      warn "[DEPRECATION] Montrose.enable_deprecated_between_masking is deprecated and will be removed in a future version."
+      @enable_deprecated_between_masking = value
+    end
+
+    def enable_deprecated_between_masking?
+      result = !!enable_deprecated_between_masking
+      if result
+        warn "[DEPRECATION] Legacy Montrose.between masking behavior is deprecated. Please use Montrose.covering instead to retain this behavior."
+      end
+      result
+    end
   end
 end

data/montrose.gemspec

@@ -5,29 +5,29 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "montrose/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "montrose"
-  spec.version       = Montrose::VERSION
-  spec.authors       = ["Ross Kaffenberger"]
-  spec.email         = ["rosskaff@gmail.com"]
+  spec.name = "montrose"
+  spec.version = Montrose::VERSION
+  spec.authors = ["Ross Kaffenberger"]
+  spec.email = ["rosskaff@gmail.com"]
 
-  spec.summary       = "Recurring events in Ruby"
-  spec.description   = "A library for specifying, quering, and enumerating recurring events for calendars in Ruby."
-  spec.homepage      = "https://github.com/rossta/montrose"
-  spec.license       = "MIT"
+  spec.summary = "Recurring events in Ruby"
+  spec.description = "A library for specifying, quering, and enumerating recurring events for calendars in Ruby."
+  spec.homepage = "https://github.com/rossta/montrose"
+  spec.license = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.3.0"
+  spec.required_ruby_version = ">= 2.6.0"
 
-  spec.add_dependency "activesupport", ">= 4.1", "< 6.0"
+  spec.add_dependency "activesupport", ">= 5.2", "< 7.1"
 
-  spec.add_development_dependency "appraisal", "~> 2.2.0"
-  spec.add_development_dependency "m", "~> 1.5"
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "m"
   spec.add_development_dependency "minitest"
-  spec.add_development_dependency "rake", "~> 11.0"
-  spec.add_development_dependency "rubocop", "~> 0.64.0"
+  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "standard"
   spec.add_development_dependency "timecop"
 end