dgp-schedule_attributes 0.4.0

data/lib/schedule_attributes/input.rb

@@ -0,0 +1,159 @@
+require 'schedule_attributes/time_helpers'
+
+module ScheduleAttributes
+  class Input
+
+    module RepeatingDates
+      def repeat?; true end
+
+      # Defaults to 1
+      # @return [Fixnum]
+      #
+      def interval
+        @params.fetch(:interval, 1).to_i
+      end
+
+      def interval_unit
+        @params[:interval_unit] if repeat?
+      end
+
+      def ordinal_unit
+        @params[:ordinal_unit].to_sym if @params[:ordinal_unit]
+      end
+
+      def ordinal_week
+        @params.fetch(:ordinal_week, 1).to_i
+      end
+
+      def ordinal_day
+        @params.fetch(:ordinal_day, 1).to_i
+      end
+
+      def yearly_start_month
+        return unless yearly_start_month?
+        @params[:yearly_start_month].to_i
+      end
+
+      def yearly_end_month
+        return unless yearly_end_month?
+        @params[:yearly_end_month].to_i
+      end
+
+      def yearly_start_month_day
+        return unless yearly_start_month_day?
+        @params[:yearly_start_month_day].to_i
+      end
+
+      def yearly_end_month_day
+        return unless yearly_end_month_day?
+        @params[:yearly_end_month_day].to_i
+      end
+
+      def yearly_start_month?
+        @params[:yearly_start_month].present?
+      end
+
+      def yearly_end_month?
+        @params[:yearly_end_month].present?
+      end
+
+      def yearly_start_month_day?
+        [ @params[:yearly_start_month].present?,
+          @params[:yearly_start_month_day].present?,
+          @params[:yearly_start_month_day].to_i > 1
+        ].all?
+      end
+
+      def yearly_end_month_day?
+        @params[:yearly_end_month].present? &&
+        @params[:yearly_end_month_day].present? &&
+        @params[:yearly_end_month_day].to_i < Time.days_in_month(@params[:yearly_end_month].to_i)
+      end
+
+      def weekdays
+        IceCube::TimeUtil::DAYS.keys.select { |day| @params[day].to_i == 1 }
+      end
+
+      private
+
+      def date_input
+        @params[:start_date] || @params[:date]
+      end
+    end
+
+    module SingleDates
+      def repeat?; false end
+
+      private
+
+      def date_input
+        @params[:dates] ? @params[:dates].first : @params[:date]
+      end
+    end
+
+    NEGATIVES = [false, "false", 0, "0", "f", "F", "no", "none"]
+
+    def initialize(params)
+      raise ArgumentError "expecting a Hash" unless params.is_a? Hash
+      @params = params.symbolize_keys.delete_if { |v| v.blank? }
+      date_methods = if NEGATIVES.none? { |v| params[:repeat] == v }
+                       RepeatingDates
+                     else
+                       SingleDates
+                     end
+      (class << self; self end).send :include, date_methods
+    end
+
+    attr_reader :params
+
+    def duration
+      return nil unless end_time
+      end_time - start_time
+    end
+
+    def start_time
+      time = @params[:start_time] unless @params[:all_day]
+      parse_date_time(date_input, time)
+    end
+
+    def end_time
+      return nil if @params[:all_day]
+      return nil unless @params[:end_time].present?
+      parse_date_time(end_time_date, @params[:end_time])
+    end
+
+    # if end_time < start_time, the schedule occurs over night
+    def end_time_date
+      return date_input unless @params[:start_time].present?
+      return nil if @params[:all_day]
+      return nil unless @params[:end_time].present?
+      parse_date_time(date_input, @params[:end_time]) <= start_time ? (Time.parse(date_input) + 1.day).strftime('%Y-%m-%d') : date_input
+    end
+
+    def start_date
+      parse_date_time(@params[:start_date]) if @params[:start_date]
+    end
+
+    def end_date
+      parse_date_time(@params[:end_date], @params[:start_time]) if @params[:end_date]
+    end
+
+    def ends?
+      @params[:end_date].present? && @params[:ends] != "never"
+    end
+
+    def dates
+      dates = (@params[:dates] || [@params[:date]]).compact
+      time = start_time.strftime('%H:%M') if @params[:start_time]
+      dates.map { |d| parse_date_time(d, time) }
+    end
+
+    private
+
+    def parse_date_time(date, time=nil)
+      date_time_parts = [date, time].compact
+      return if date_time_parts.empty?
+      TimeHelpers.parse_in_zone(date_time_parts.join(' '))
+    end
+  end
+end

data/lib/schedule_attributes/model.rb

@@ -0,0 +1,24 @@
+require 'schedule_attributes/core'
+
+module ScheduleAttributes::Model
+  extend ActiveSupport::Concern
+  include ScheduleAttributes::Core
+
+  module ClassMethods
+    attr_accessor :schedule_field
+  end
+
+  included do
+    @schedule_field ||= ScheduleAttributes::DEFAULT_ATTRIBUTE_KEY
+  end
+
+  private
+
+  def read_schedule_field
+    send(self.class.schedule_field)
+  end
+
+  def write_schedule_field(value)
+    send("#{self.class.schedule_field}=", value)
+  end
+end

data/lib/schedule_attributes/railtie.rb

@@ -0,0 +1,13 @@
+require 'schedule_attributes/active_record'
+
+module ScheduleAttributes
+  class Railtie < Rails::Railtie
+    initializer "active_record.initialize_schedule_attributes" do
+      ActiveSupport.on_load(:active_record) do
+        class ActiveRecord::Base
+          extend ScheduleAttributes::ActiveRecord::Sugar
+        end
+      end
+    end
+  end
+end

data/lib/schedule_attributes/rule_parser.rb

@@ -0,0 +1,25 @@
+require 'schedule_attributes/time_helpers'
+
+module ScheduleAttributes
+  module RuleParser
+    TimeHelpers = ScheduleAttributes::TimeHelpers
+
+    def self.[](interval)
+      parser_name = interval.to_s.capitalize
+      if parser_name.present? && RuleParser.const_defined?(parser_name)
+        RuleParser.const_get parser_name
+      end
+    end
+
+    def self.parse(options)
+      new(options).parse
+    end
+
+  end
+end
+
+require 'schedule_attributes/rule_parser/base'
+require 'schedule_attributes/rule_parser/day'
+require 'schedule_attributes/rule_parser/week'
+require 'schedule_attributes/rule_parser/month'
+require 'schedule_attributes/rule_parser/year'

data/lib/schedule_attributes/rule_parser/base.rb

@@ -0,0 +1,96 @@
+module ScheduleAttributes::RuleParser
+  class Base
+    # @param [Hash] options
+    #
+    def initialize(input)
+      @input = input
+      @rule ||= rule_factory.daily(input.interval)
+      @exceptions ||= []
+    end
+
+    attr_reader :input
+
+    def rule
+      parse_options
+      set_end_date
+      set_yearly_months
+
+      @rule
+    end
+
+    def exceptions
+      set_yearly_month_exceptions
+
+      @exceptions
+    end
+
+    private
+
+    def rule_factory
+      IceCube::Rule
+    end
+
+    def set_end_date
+      @rule.until(input.end_date) if input.ends?
+    end
+
+    def set_yearly_months
+      if (input.yearly_start_month? || input.yearly_end_month?) && (yearly_months.length < 12)
+        @rule.month_of_year(*yearly_months)
+      end
+    end
+
+    def set_yearly_month_exceptions
+      if input.yearly_start_month_day?
+        @exceptions << rule_factory.daily
+                      .month_of_year(start_month)
+                      .day_of_month(*1...start_day)
+      end
+
+      if input.yearly_end_month_day?
+        @exceptions << rule_factory.daily
+                       .month_of_year(end_month)
+                       .day_of_month(*(end_day+1)..31)
+      end
+    end
+
+    def yearly_months
+      y1 = Date.current.year
+      y2 = start_month > end_month ? y1+1 : y1
+      range = Date.new(y1,start_month,1)..Date.new(y2,end_month,1)
+      range.group_by(&:month).keys
+    end
+
+    def start_month
+      param_to_month(input.yearly_start_month, 1)
+    end
+
+    def end_month
+      param_to_month(input.yearly_end_month, 12)
+    end
+
+    def start_day
+      param_to_day(input.yearly_start_month_day, 1)
+    end
+
+    def end_day
+      param_to_day(input.yearly_end_month_day, 31)
+    end
+
+    def param_to_month(param, default)
+      param = param.to_i
+      (param % 12).tap do |m|
+        return param if param == 12
+        return default if m == 0
+      end
+    end
+
+    def param_to_day(param, default)
+      param = param.to_i
+      (param.to_i % 31).tap do |d|
+        return param if param == 31
+        return default if d == 0
+      end
+    end
+  end
+end

data/lib/schedule_attributes/rule_parser/day.rb

@@ -0,0 +1,13 @@
+module ScheduleAttributes::RuleParser
+  class Day < Base
+
+    private
+
+    # @return [IceCube::Rule]
+    #
+    def parse_options
+      @rule = rule_factory.daily(input.interval)
+    end
+
+  end
+end

data/lib/schedule_attributes/rule_parser/month.rb

@@ -0,0 +1,40 @@
+module ScheduleAttributes::RuleParser
+  # Parse an options hash to a monthly rule
+  #
+  # Assume a monthly rule starting on the :start_date if no :ordinal_day or
+  # :ordinal_week is given. If both of these options are present in the options
+  # hash, one can be selected with :ordinal_unit = ("day" or "week").
+  #
+  # Weekdays are applied for :ordinal_week only
+  #
+  class Month < Base
+
+    private
+
+    # @return [IceCube::Rule]
+    #
+    def parse_options
+      @rule = IceCube::Rule.monthly(input.interval)
+
+      case input.ordinal_unit
+      when :day
+        @rule.day_of_month(input.ordinal_day)
+      when :week
+        # schedule.add_recurrence_rule Rule.monthly.day_of_week(:tuesday => [1, -1])
+        # every month on the first and last tuesdays of the month
+        @rule.day_of_week(weekdays_by_week_of_month)
+      else
+        @rule
+      end
+    end
+
+    def weekdays_by_week_of_month
+      Hash[selected_weekdays.map { |wd| [wd, Array(input.ordinal_week)] }]
+    end
+
+    def selected_weekdays
+      input.weekdays.any? ? input.weekdays : ScheduleAttributes::DAY_NAMES
+    end
+
+  end
+end

data/lib/schedule_attributes/rule_parser/week.rb

@@ -0,0 +1,18 @@
+module ScheduleAttributes::RuleParser
+  # Parse an options hash to a weekly rule
+  # Weekdays used only if one or more are given, otherwise assume a weekly
+  # schedule starting the day of the :start_date
+  #
+  class Week < Base
+
+    private
+
+    # @return [IceCube::Rule]
+    #
+    def parse_options
+      @rule = IceCube::Rule.weekly(input.interval)
+      @rule.day(*input.weekdays) unless input.weekdays.empty?
+    end
+
+  end
+end

data/lib/schedule_attributes/rule_parser/year.rb

@@ -0,0 +1,21 @@
+module ScheduleAttributes::RuleParser
+  class Year < Base
+
+    private
+
+    # @return [IceCube::Rule]
+    #
+    def parse_options
+      @rule = rule_factory.yearly(input.interval).tap do |rule|
+        if input.start_date
+          rule.month_of_year(input.start_date.month)
+              .day_of_month(input.start_date.day)
+        end
+      end
+    end
+
+    def set_yearly_months; nil end
+
+    def set_yearly_month_exceptions; nil end
+  end
+end

data/lib/schedule_attributes/serializer.rb

@@ -0,0 +1,30 @@
+require 'ice_cube'
+
+module ScheduleAttributes
+  class Serializer
+
+    # Only load YAML serializations that are present, not empty strings
+    # An invalid value can raise an error that gets caught by ActiveRecord
+    # and results in the original string getting passed through. This allows
+    # it to be saved back unchanged if necessary.
+    #
+    def self.load(yaml)
+      IceCube::Schedule.from_yaml(yaml) if yaml.present?
+    end
+
+    # This should normally receive a Schedule object.
+    # In some unknown circumstance that I can't reproduce, it would save an
+    # already-dumped serialized YAML Schedule string into a YAML string
+    # wrapper, effectively double-bagging the YAML. I only assume it receives a
+    # String when loading a bad YAML value from the database, which then
+    # propagates and re-re-serializes itself into YAML on every save.
+    #
+    def self.dump(schedule)
+      case schedule
+      when IceCube::Schedule then schedule.to_yaml
+      when String            then schedule
+      end
+    end
+
+  end
+end