montrose 0.1.0

data/lib/montrose/frequency/daily.rb

@@ -0,0 +1,9 @@
+module Montrose
+  class Frequency
+    class Daily < Frequency
+      def include?(time)
+        matches_interval? time.to_date - @starts.to_date
+      end
+    end
+  end
+end

data/lib/montrose/frequency/hourly.rb

@@ -0,0 +1,9 @@
+module Montrose
+  class Frequency
+    class Hourly < Frequency
+      def include?(time)
+        matches_interval?((time - @starts) / 1.hour)
+      end
+    end
+  end
+end

data/lib/montrose/frequency/minutely.rb

@@ -0,0 +1,9 @@
+module Montrose
+  class Frequency
+    class Minutely < Frequency
+      def include?(time)
+        matches_interval?((time - @starts) / 1.minute)
+      end
+    end
+  end
+end

data/lib/montrose/frequency/monthly.rb

@@ -0,0 +1,9 @@
+module Montrose
+  class Frequency
+    class Monthly < Frequency
+      def include?(time)
+        matches_interval?((time.month - @starts.month) + (time.year - @starts.year) * 12)
+      end
+    end
+  end
+end

data/lib/montrose/frequency/weekly.rb

@@ -0,0 +1,19 @@
+module Montrose
+  class Frequency
+    class Weekly < Frequency
+      def include?(time)
+        weeks_since_start(time) % @interval == 0
+      end
+
+      private
+
+      def weeks_since_start(time)
+        ((time.beginning_of_week - base_date) / 1.week).round
+      end
+
+      def base_date
+        @starts.beginning_of_week
+      end
+    end
+  end
+end

data/lib/montrose/frequency/yearly.rb

@@ -0,0 +1,9 @@
+module Montrose
+  class Frequency
+    class Yearly < Frequency
+      def include?(time)
+        matches_interval? time.year - @starts.year
+      end
+    end
+  end
+end

data/lib/montrose/options.rb

@@ -0,0 +1,293 @@
+module Montrose
+  class Options
+    @default_starts = nil
+    @default_until = nil
+    @default_every = nil
+
+    MAX_HOURS_IN_DAY = 24
+    MAX_DAYS_IN_YEAR = 366
+    MAX_WEEKS_IN_YEAR = 53
+    MAX_DAYS_IN_MONTH = 31
+
+    class << self
+      def new(options = {})
+        return options if options.is_a?(self)
+        super
+      end
+
+      def defined_options
+        @defined_options ||= []
+      end
+
+      def def_option(name)
+        defined_options << name.to_sym
+        attr_accessor name
+        protected :"#{name}="
+      end
+
+      attr_accessor :default_starts, :default_until, :default_every
+
+      # Return the default ending time.
+      #
+      # @example Recurrence.default_until #=> <Date>
+      #
+      def default_until
+        case @default_until
+        when String
+          Time.parse(@default_until)
+        when Proc
+          @default_until.call
+        else
+          @default_until
+        end
+      end
+
+      # Return the default starting time.
+      #
+      # @example Recurrence.default_starts #=> <Date>
+      #
+      def default_starts
+        case @default_starts
+        when String
+          Time.parse(@default_starts)
+        when Proc
+          @default_starts.call
+        when nil
+          Time.now
+        else
+          @default_starts
+        end
+      end
+    end
+
+    def_option :every
+    def_option :starts
+    def_option :until
+    def_option :hour
+    def_option :day
+    def_option :mday
+    def_option :yday
+    def_option :week
+    def_option :month
+    def_option :interval
+    def_option :total
+    def_option :between
+    def_option :at
+    def_option :on
+
+    def initialize(opts = {})
+      defaults = {
+        every: self.class.default_every,
+        starts: self.class.default_starts,
+        until: self.class.default_until,
+        interval: 1,
+        day: nil,
+        mday: nil,
+        yday: nil,
+        week: nil,
+        month: nil,
+        total: nil
+      }
+
+      options = defaults.merge(opts)
+      options.each { |(k, v)| self[k] ||= v unless v.nil? }
+    end
+
+    def to_hash
+      hash_pairs = self.class.defined_options.flat_map do |opt_name|
+        [opt_name, send(opt_name)]
+      end
+      Hash[*hash_pairs].reject { |_k, v| v.nil? }
+    end
+
+    def []=(option, val)
+      send(:"#{option}=", val)
+    end
+
+    def [](option)
+      send(:"#{option}")
+    end
+
+    def merge(other)
+      h1 = to_hash
+      h2 = other.to_hash
+
+      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
+      found = send(key)
+      return found if found
+      return args.first if args.length == 1
+      fail "Key #{key.inspect} not found" unless block_given?
+
+      yield
+    end
+
+    def key?(key)
+      respond_to?(key) && !send(key).nil?
+    end
+
+    def every=(arg)
+      parsed = parse_frequency(arg)
+
+      self[:interval] = parsed[:interval] if parsed[:interval]
+
+      @every = parsed.fetch(:every)
+    end
+
+    def starts=(time)
+      @starts = as_time(time) || self.class.default_starts
+    end
+
+    def until=(time)
+      @until = as_time(time) || self.class.default_until
+    end
+
+    def hour=(hours)
+      @hour = map_arg(hours) { |h| assert_hour(h) }
+    end
+
+    def day=(days)
+      @day = nested_map_arg(days) { |d| Montrose::Utils.day_number(d) }
+    end
+
+    def mday=(mdays)
+      @mday = map_mdays(mdays)
+    end
+
+    def yday=(ydays)
+      @yday = map_ydays(ydays)
+    end
+
+    def week=(weeks)
+      @week = map_arg(weeks) { |w| assert_week(w) }
+    end
+
+    def month=(months)
+      @month = map_arg(months) { |d| Montrose::Utils.month_number(d) }
+    end
+
+    def between=(range)
+      self[:starts] = range.first
+      self[:until] = range.last
+    end
+
+    def between
+      return nil unless self[:starts] && self[:until]
+
+      (self[:starts]..self[:until])
+    end
+
+    def at=(time)
+      times = map_arg(time) { |t| as_time(t) }
+      now = Time.now
+      first = times.map { |t| t < now ? t + 24.hours : t }.min
+      self[:starts] = first if first
+      @at = times
+    end
+
+    def on=(arg)
+      wday, mday = assert_wday_mday(arg)
+      self[:day] = wday
+      self[:mday] = mday if mday
+      @on = arg
+    end
+
+    private
+
+    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| Montrose::Utils.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..MAX_HOURS_IN_DAY, hour)
+    end
+
+    def assert_mday(mday)
+      assert_range_includes(1..MAX_DAYS_IN_MONTH, mday, :absolute)
+    end
+
+    def assert_yday(yday)
+      assert_range_includes(1..MAX_DAYS_IN_YEAR, yday, :absolute)
+    end
+
+    def assert_week(week)
+      assert_range_includes(1..MAX_WEEKS_IN_YEAR, week, :absolute)
+    end
+
+    def assert_wday_mday(arg)
+      case arg
+      when Hash
+        [map_days(arg.keys), map_mdays(*arg.values)]
+      else
+        map_days(arg)
+      end
+    end
+
+    def assert_range_includes(range, item, absolute = false)
+      test = absolute ? item.abs : item
+      fail ConfigurationError, "Out of range" unless range.include?(test)
+
+      item
+    end
+
+    def as_time(time)
+      return nil unless time
+
+      case
+      when time.is_a?(String)
+        Time.parse(time)
+      when time.respond_to?(:to_time)
+        time.to_time
+      else
+        Array(time).flat_map { |d| as_time(d) }
+      end
+    end
+
+    def parse_frequency(input)
+      if input.is_a?(Numeric)
+        frequency, interval = duration_to_frequency_parts(input)
+        { every: frequency, interval: interval }
+      else
+        { every: Frequency.assert(input) }
+      end
+    end
+
+    def duration_to_frequency_parts(duration)
+      parts = nil
+      [:year, :month, :week, :day, :hour, :minute].each do |freq|
+        div, mod = duration.divmod(1.send(freq))
+        parts = [freq, div]
+        return parts if mod.zero?
+      end
+      parts
+    end
+  end
+end

data/lib/montrose/recurrence.rb

@@ -0,0 +1,67 @@
+require "json"
+require "montrose/chainable"
+require "montrose/errors"
+require "montrose/stack"
+require "montrose/clock"
+
+module Montrose
+  class Recurrence
+    include Chainable
+    include Enumerable
+
+    attr_reader :default_options
+
+    class << self
+      def new(options = {})
+        return options if options.is_a?(self)
+        super
+      end
+
+      def dump(obj)
+        return nil if obj.nil?
+        unless obj.is_a?(self)
+          fail SerializationError,
+            "Object was supposed to be a #{self}, but was a #{obj.class}. -- #{obj.inspect}"
+        end
+
+        JSON.dump(obj.to_hash)
+      end
+
+      def load(json)
+        new JSON.load(json)
+      end
+    end
+
+    def initialize(opts = {})
+      @default_options = Montrose::Options.new(opts)
+    end
+
+    def events
+      event_enum
+    end
+
+    def each(&block)
+      events.each(&block)
+    end
+
+    def to_hash
+      default_options.to_hash
+    end
+
+    private
+
+    def event_enum
+      opts = @default_options
+      stack = Stack.new(opts)
+      clock = Clock.new(opts)
+
+      Enumerator.new do |yielder|
+        loop do
+          stack.advance(clock.tick) do |time|
+            yielder << time
+          end or break
+        end
+      end
+    end
+  end
+end

data/lib/montrose/rule.rb

@@ -0,0 +1,47 @@
+module Montrose
+  # Defines the Rule duck type for recurrence rules
+  module Rule
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def include?(_time)
+      fail "Class must implement #{__method__}"
+    end
+
+    def advance!(_time)
+      true
+    end
+
+    def continue?
+      true
+    end
+
+    module ClassMethods
+      def apply_option(_opts)
+        nil
+      end
+
+      def apply_options?(opts)
+        apply_options(opts)
+      end
+
+      def from_options(opts)
+        new(apply_options(opts)) if apply_options?(opts)
+      end
+    end
+  end
+end
+
+require "montrose/rule/after"
+require "montrose/rule/before"
+require "montrose/rule/day_of_month"
+require "montrose/rule/day_of_week"
+require "montrose/rule/day_of_year"
+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/week_of_year"