hiccup 0.0.0 → 0.2.0

data/lib/hiccup/humanizable.rb

@@ -0,0 +1,68 @@
+require "hiccup/convenience"
+require "hiccup/core_ext/fixnum"
+
+
+module Hiccup
+  module Humanizable
+    include Convenience
+    
+    
+    
+    def humanize
+      case kind
+      when :never;      ""
+      when :weekly;     weekly_humanize
+      when :monthly;    monthly_humanize
+      when :annually;   yearly_humanize
+      else;             "Invalid"
+      end
+    end
+    
+    
+    
+  private
+    
+    
+    
+    def weekly_humanize
+      weekdays = pattern.map(&:humanize).to_sentence
+      if skip == 1 || pattern.length == 1
+        sentence("Every", ordinal, weekdays)
+      else
+        sentence(weekdays, "of every", ordinal, "week")
+      end
+    end
+    
+    def monthly_humanize
+      monthly_occurrences = pattern.map(&method(:monthly_occurrence_to_s)).to_sentence
+      sentence("The", monthly_occurrences, "of every", ordinal, "month")
+    end
+    
+    def yearly_humanize
+      sentence("Every", ordinal, "year on", self.start_date.strftime('%b %d'))
+    end
+    
+    
+    
+    def monthly_occurrence_to_s(monthly_occurrence)
+      if monthly_occurrence.is_a?(Array)
+        _skip, weekday = monthly_occurrence
+        ordinal = _skip.human_ordinalize
+        sentence(ordinal, weekday.humanize)
+      else
+        monthly_occurrence.ordinalize
+      end
+    end
+    
+    def ordinal
+      skip && skip.human_ordinalize(1 => nil, 2 => "other")
+    end
+    
+    def sentence(*array)
+      array.compact.join(" ")
+    end
+    
+    
+    
+  end
+end

data/lib/hiccup/schedule.rb

@@ -0,0 +1,42 @@
+require "hiccup"
+require "active_model/validations"
+
+
+module Hiccup
+  class Schedule
+    extend Hiccup
+    include ActiveModel::Validations
+    
+    
+    hiccup :enumerable,
+           :validatable,
+           :humanizable,
+           :serializable => [:ical]
+    
+    
+    def initialize(options={})
+      @kind       = options[:kind] || :never
+      @start_date = options[:start_date] || Date.today
+      @ends       = options.key?(:ends) ? options[:ends] : false
+      @end_date   = options[:end_date]
+      @skip       = options[:skip] || options[:interval] || 1
+      @pattern    = options[:pattern] || []
+    end
+    
+    
+    attr_accessor :kind, :start_date, :ends, :end_date, :skip, :pattern
+    
+    
+    def to_hash
+      {
+        :kind => kind,
+        :start_date => start_date,
+        :ends => ends,
+        :end_date => end_date,
+        :pattern => pattern
+      }
+    end
+    
+    
+  end
+end

data/lib/hiccup/serializable/ical.rb

@@ -0,0 +1,39 @@
+require "hiccup/serializers/ical"
+require "active_support/concern"
+
+
+module Hiccup
+  module Serializable
+    module Ical
+      extend ActiveSupport::Concern
+      
+      
+      def to_ical
+        ical_serializer.dump(self)
+      end
+      
+      
+      module ClassMethods
+        
+        def from_ical(ics)
+          ical_serializer.load(ics)
+        end
+        
+        def ical_serializer
+          @ical_serializer ||= Serializers::Ical.new(self)
+        end
+        
+      end
+      
+      
+    private
+      
+      
+      def ical_serializer
+        self.class.ical_serializer
+      end
+      
+      
+    end
+  end
+end

data/lib/hiccup/serializers/ical.rb

@@ -0,0 +1,189 @@
+require "ri_cal"
+
+
+module Hiccup
+  module Serializers
+    class Ical
+      
+      def initialize(klass)
+        @klass = klass
+      end
+      
+      
+      
+      def dump(obj)
+        @component = RiCal::Component::Event.new
+        @component.dtstart = obj.start_date.to_time
+        @obj = obj
+        
+        case obj.kind
+        when :weekly;   add_weekly_rule
+        when :monthly;  add_monthly_rule
+        when :annually; add_yearly_rule
+        end
+        
+        StringIO.new.tap {|io|
+          @component.export_properties_to(io)
+          @component.export_x_properties_to(io)
+        }.string
+      end
+      
+      
+      
+      def load(ics)
+        return unless ics # Required for now, for ActiveRecord
+        
+        component_ics = "BEGIN:VEVENT\n#{ics}\nEND:VEVENT"
+        component = RiCal.parse_string(component_ics).first
+        
+        @obj = @klass.new
+        @obj.start_date = component.dtstart_property.to_datetime
+        component.rrule_property.each do |rule|
+          case rule.freq
+          when "WEEKLY";    parse_weekly_rule(rule)
+          when "MONTHLY";   parse_monthly_rule(rule)
+          when "YEARLY";    parse_yearly_rule(rule)
+          end
+        end
+        
+        @obj
+      end
+      
+      
+      
+    private
+      
+      
+      
+      def add_weekly_rule
+        add_rule("WEEKLY", :byday => abbreviate_weekdays(@obj.pattern))
+      end
+      
+      
+      
+      def add_monthly_rule
+        byday = []
+        bymonthday = []
+        @obj.pattern.each do |occurrence|
+          if occurrence.is_a?(Array)
+            i, weekday = occurrence
+            byday << "#{i}#{abbreviate_weekday(weekday)}"
+          else
+            bymonthday << occurrence
+          end
+        end
+        
+        add_rule("MONTHLY", :bymonthday => bymonthday) if bymonthday.any?
+        add_rule("MONTHLY", :byday => byday) if byday.any?
+      end
+      
+      
+      
+      def add_yearly_rule
+        add_rule("YEARLY")
+      end
+      
+      
+      
+      def add_rule(freq, options={})
+        merge_default_options_for_new_rule!(freq, options)
+        parent = options.delete(:parent)
+        # puts "[add_rule] (#{parent.inspect}, #{options.inspect})"
+        rrule = RiCal::PropertyValue::RecurrenceRule.new(parent, options)
+        @component.rrule_property.push(rrule)
+      end
+      
+      def merge_default_options_for_new_rule!(freq, options)
+        options.merge!({
+          :freq => freq,
+          :interval => @obj.skip,
+          :until => @obj.ends? && @obj.end_date && @obj.end_date.to_time
+        })
+      end
+      
+      
+      
+      
+      
+      def parse_weekly_rule(rule)
+        @obj.kind = :weekly
+        @obj.pattern = backmap_weekdays(rule.by_list[:byday])
+        parse_rule(rule)
+      end
+      
+      
+      
+      def parse_monthly_rule(rule)
+        @obj.kind = :monthly
+        parse_monthly_bymonthyday(rule.by_list[:bymonthday])
+        parse_monthly_byday(rule.by_list[:byday])
+        parse_rule(rule)
+      end
+      
+      def parse_monthly_bymonthyday(bymonthday)
+        (bymonthday || []).each do |bymonthday|
+          @obj.pattern = @obj.pattern + [bymonthday.ordinal]
+        end
+      end
+      
+      def parse_monthly_byday(byday)
+        (byday || []).each do |byday|
+          @obj.pattern = @obj.pattern + [[byday.index, backmap_weekday(byday)]]
+        end
+      end
+      
+      
+      
+      def parse_yearly_rule(rule)
+        @obj.kind = :annually
+        parse_rule(rule)
+      end
+      
+      
+      
+      def parse_rule(rule)
+        @obj.skip = rule.interval
+        if rule.until
+          @obj.ends = true
+          @obj.end_date = rule.until.to_datetime
+        end
+      end
+      
+      
+      
+      
+      
+      def abbreviate_weekdays(weekdays)
+        weekdays.map(&method(:abbreviate_weekday)).compact
+      end
+      
+      def abbreviate_weekday(weekday)
+        WEEKDAY_MAP[weekday.to_s.downcase]
+      end
+      
+      def backmap_weekdays(byday)
+        byday ||= []
+        byday.map(&method(:backmap_weekday)).compact
+      end
+      
+      def backmap_weekday(byday)
+        Date::DAYNAMES[byday.wday]
+      end
+      
+      
+      
+      WEEKDAY_MAP = {
+        "sunday" => "SU",
+        "monday" => "MO",
+        "tuesday" => "TU",
+        "wednesday" => "WE",
+        "thursday" => "TH",
+        "friday" => "FR",
+        "saturday" => "SA"
+      }
+      
+      
+      
+    end
+  end
+end

data/lib/hiccup/validatable.rb

@@ -0,0 +1,110 @@
+require "hiccup/convenience"
+require "active_support/concern"
+
+
+module Hiccup
+  module Validatable
+    include Convenience
+    extend ActiveSupport::Concern
+    
+    
+    Kinds = [:never, :weekly, :monthly, :annually]
+    
+    
+    # !todo: use ActiveModel:Validation rather than a custom method
+    included do
+      validate                    :validate_recurrence
+    end
+    
+    
+  private
+    
+    
+    # !todo: use i18n to let clients of this library supply their own wording
+    def validate_recurrence
+      case kind
+      when :never;
+      when :weekly;     validate_weekly_recurrence
+      when :monthly;    validate_monthly_recurrence
+      when :annually;
+      else;             invalid_kind!
+      end
+      
+      errors.add(:start_date, "is a #{self.start_date.class} not a Date") unless self.start_date.is_a?(Date)
+      errors.add(:skip, "is not a positive integer") unless (skip.is_a? Fixnum) and (skip > 0)
+      if ends?
+        if self.end_date.is_a? Date
+          errors.add(:end_date, "cannot be before start") if (self.end_date < self.start_date)
+        else
+          errors.add(:end_date, "is a #{self.end_date.class} not a Date")
+        end
+      end
+    end
+    
+    
+    def validate_weekly_recurrence
+      if !pattern.is_a?(Array)
+        errors.add(:pattern, "is a #{pattern.class}. It should be an array")
+      elsif pattern.empty?
+        errors.add(:pattern, "is empty. It should contain a list of weekdays")
+      elsif (invalid_names = pattern - Date::DAYNAMES).any?
+        errors.add(:pattern, "should contain only weekdays. (#{invalid_names.to_sentence} are invalid)")
+      end
+    end
+    
+    
+    def validate_monthly_recurrence
+      if !pattern.is_a?(Array)
+        errors.add(:pattern, "is a #{pattern.class}. It should be an array")
+      elsif pattern.empty?
+        errors.add(:pattern, "is empty. It should contain a list of monthly occurrences")
+      elsif pattern.select(&method(:invalid_occurrence?)).any?
+        errors.add(:pattern, "contains invalid monthly occurrences")
+      end
+    end
+    
+    
+    def invalid_occurrence?(occurrence)
+      !valid_occurrence?(occurrence)
+    end
+    
+    def valid_occurrence?(occurrence)
+      if occurrence.is_a?(Array)
+        i, wd = occurrence
+        Date::DAYNAMES.member?(wd) && i.is_a?(Fixnum) && ((i == -1) || (1..6).include?(i))
+      else
+        i = occurrence
+        i.is_a?(Fixnum) && (1..31).include?(i)
+      end
+    end
+    
+    
+    def invalid_kind!
+      errors.add(:kind, "is not recognized. It must be one of #{Kinds.collect{|kind| "'#{kind}'"}.to_sentence(:two_words_connector => " or ", :last_word_connector => ", or ")}.")
+    end
+    
+    
+    # def valid_occurrence?(occurrence)
+    #   if occurrence.is_a?(Array)
+    #     ordinal, kind = occurrence
+    #     
+    #     errors.add(:kind, "is not a valid monthly occurrence kind") unless Date::DAYNAMES.member?(kind)
+    #     if ordinal.is_a?(Fixnum)
+    #       errors.add(:ordinal, "is not a valid integer") unless (ordinal==-1) or (1..6).include?(ordinal)        
+    #     else
+    #       errors.add(:ordinal, "is not an integer")
+    #     end
+    #   else
+    #     ordinal = occurrence
+    #     
+    #     if ordinal.is_a?(Fixnum)
+    #       errors.add(:ordinal, "is not an integer between 1 and 31") unless (1..31).include?(ordinal)
+    #     else
+    #       errors.add(:ordinal, "is not an integer")
+    #     end
+    #   end
+    # end
+    
+    
+  end
+end