hiccup 0.0.0 → 0.2.0

data/Rakefile

@@ -1 +1,9 @@
-require 'bundler/gem_tasks'
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end

data/hiccup.gemspec

@@ -10,9 +10,15 @@ Gem::Specification.new do |s|
   s.homepage    = "http://boblail.github.com/hiccup/"
   s.summary     = %q{Recurrence features a-la-cart}
   s.description = %q{Recurrence features a-la-cart}
-
+  
   s.rubyforge_project = "hiccup"
-
+  
+  s.add_dependency "activesupport"
+  
+  s.add_development_dependency "ri_cal"
+  s.add_development_dependency "rails"
+  s.add_development_dependency "turn"
+  
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }

data/lib/hiccup.rb

@@ -1,5 +1,73 @@
 require "hiccup/version"
 
+
+# =======================================================
+# Hiccup
+# =======================================================
+#
+# This module contains mixins that can apply, serialize,
+# validate, and humanize an object that models a recurrence
+# pattern and which exposes the following properties:
+#
+# * kind - One of :never, :weekly, :monthly, :annually            # <== change to :none and :yearly
+# * start_date - The date when the recurrence pattern
+#   should start
+# * ends - true or false indicating whether the recurrence
+#   ever ends
+# * end_date - The date when the recurrence pattern ends
+# * skip - The number of instances to skip                        # <== change this to :interval
+# * pattern - An array of recurrence rules
+#
+#   Examples:
+#    
+#    Every other Monday
+#    :kind => :weekly, :pattern => ["Monday"]
+#
+#    Every year on June 21 (starting in 1999)
+#    :kind => :yearly, :start_date => Date.new(1999, 6, 21)
+#
+#    The second and fourth Sundays of the month
+#    :kind => :monthly, :pattern => [[2, "Sunday"], [4, "Sunday"]]
+#
+#
 module Hiccup
-  # Your code goes here...
+  
+  
+  def hiccup(*modules)
+    options = modules.extract_options!
+    add_hiccup_modules(modules)
+    add_hiccup_serialization_formats(options[:serializable])
+  end
+  
+  
+private
+  
+  
+  def add_hiccup_modules(modules)
+    (modules||[]).each {|name| add_hiccup_module(name)}
+  end
+  
+  def add_hiccup_module(symbol)
+    include_hiccup_module "hiccup/#{symbol}"
+  end
+  
+  
+  def add_hiccup_serialization_formats(formats)
+    (formats||[]).each {|format| add_hiccup_serialization_format(format)}
+  end
+  
+  def add_hiccup_serialization_format(format)
+    include_hiccup_module "hiccup/serializable/#{format}"
+  end
+  
+  
+  def include_hiccup_module(module_path)
+    require module_path
+    include module_path.classify.constantize
+  end
+  
+  
 end
+
+
+ActiveRecord::Base.extend(Hiccup) if defined?(ActiveRecord::Base)

data/lib/hiccup/convenience.rb

@@ -0,0 +1,28 @@
+module Hiccup
+  module Convenience
+    
+    
+    def never?
+      kind == :never
+    end
+    
+    def weekly?
+      kind == :weekly
+    end
+    
+    def monthly?
+      kind == :monthly
+    end
+    
+    def annually?
+      kind == :annually
+    end
+    
+    
+    def ends?
+      (ends == true) || %w{true 1 t}.member?(ends)
+    end
+    
+    
+  end
+end

data/lib/hiccup/core_ext/date.rb

@@ -0,0 +1,29 @@
+module Hiccup
+  module CoreExtensions
+    module Date
+      
+      
+      def get_months_since(earlier_date)
+        ((self.year - earlier_date.year) * 12) + (self.month - earlier_date.month).to_int
+      end
+      
+      def get_years_since(earlier_date)
+        (self.year - earlier_date.year)
+      end
+      
+      
+      def get_months_until(later_date)
+        later_date.months_since(self)
+      end
+      
+      def get_years_until(later_date)
+        later_date.years_since(self)
+      end
+      
+      
+    end
+  end
+end
+
+Date.send     :include, Hiccup::CoreExtensions::Date
+DateTime.send :include, Hiccup::CoreExtensions::Date

data/lib/hiccup/core_ext/duration.rb

@@ -0,0 +1,25 @@
+require "active_support/all"
+
+
+module Hiccup
+  module CoreExt
+    module DurationExtensions
+      
+      def from(*args)
+        since(*args)
+      end
+      
+      def after(*args)
+        since(*args)
+      end
+      
+      def before(*args)
+        ago(*args)
+      end
+      
+    end
+  end
+end
+
+
+ActiveSupport::Duration.send(:include, Hiccup::CoreExt::DurationExtensions)

data/lib/hiccup/core_ext/fixnum.rb

@@ -0,0 +1,37 @@
+class Fixnum
+  
+  # todo: complete
+  def human_ordinalize(map={})
+    map.key?(self) ? map[self] : (begin
+      if self < -1
+        "#{(-self).human_ordinalize} to last"
+      else
+        case self
+        when -1;  "last"
+        when 1;   "first"
+        when 2;   "second"
+        when 3;   "third"
+        when 4;   "fourth"
+        when 5;   "fifth"
+        when 6;   "sixth"
+        when 7;   "seventh"
+        when 8;   "eighth"
+        when 9;   "ninth"
+        when 10;  "tenth"
+        when 11;  "eleventh"
+        when 12;  "twelfth"
+        when 13;  "thirteenth"
+        when 14;  "fourteenth"
+        when 15;  "fifteenth"
+        when 16;  "sixteenth"
+        when 17;  "seventeeth"
+        when 18;  "eighteenth"
+        when 19;  "nineteenth"
+        when 20;  "twentieth"
+        else;     self.ordinalize
+        end
+      end
+    end)
+  end
+  
+end

data/lib/hiccup/enumerable.rb

@@ -0,0 +1,230 @@
+require "hiccup/convenience"
+require "hiccup/core_ext/date"
+require "hiccup/core_ext/duration"
+
+
+module Hiccup
+  module Enumerable
+    include Convenience
+    
+    
+    
+    def occurrences_during_month(year, month)
+      date1 = Date.new(year, month, 1)
+      date2 = date1.at_end_of_month
+      occurrences_between(date1, date2)
+    end
+    
+    
+    
+    def occurrences_between(earlier_date, later_date)
+      [].tap do |occurrences|
+        if (!ends? || earlier_date <= end_date) && (later_date >= start_date)
+          earlier_date = start_date if (earlier_date < start_date)
+          later_date = end_date if ends? && (later_date > end_date)
+          occurrence = first_occurrence_on_or_after(earlier_date)
+          while occurrence && (occurrence <= later_date)
+            occurrences << occurrence
+            occurrence = next_occurrence_after(occurrence)
+          end
+        end
+      end
+    end
+    
+    
+    
+    def first_occurrence_on_or_after(date)
+      date = date.to_date unless date.is_a?(Date) || !date.respond_to?(:to_date)
+      date = self.start_date if (date < self.start_date)
+      
+      result = nil
+      case kind
+      when :never
+        result = date if date == self.start_date # (date > self.start_date) ? nil : self.start_date
+      
+      when :weekly
+        wday = date.wday
+        pattern.each do |weekday|
+          wd = Date::DAYNAMES.index(weekday)
+          wd = wd + 7 if wd < wday
+          days_in_the_future = wd - wday
+          temp = days_in_the_future.days.after(date)
+          
+          remainder = ((temp - start_date) / 7).to_i % skip
+          temp = (skip - remainder).weeks.after(temp) if (remainder > 0)
+          
+          result = temp if !result || (temp < result)
+        end
+      
+      when :monthly
+        pattern.each do |occurrence|
+          temp = nil
+          (0...30).each do |i| # If an occurrence doesn't occur this month, try up to 30 months in the future
+            temp = monthly_occurrence_to_date(occurrence, i.months.after(date))
+            break if temp && (temp >= date)
+          end
+          next unless temp
+          
+          remainder = months_between(temp, start_date) % skip
+          temp = monthly_occurrence_to_date(occurrence, (skip - remainder).months.after(temp)) if (remainder > 0)        
+          
+          result = temp if !result || (temp < result)
+        end
+      
+      when :annually
+        result, try_to_use_2_29 = if((start_date.month == 2) && (start_date.day == 29))
+          [Date.new(date.year, 2, 28), true]
+        else
+          [Date.new(date.year, start_date.month, start_date.day), false]
+        end
+        result = 1.year.after(result) if (result < date)
+        
+        remainder = years_between(result, start_date) % skip
+        result = (skip - remainder).years.after(result) if (remainder > 0)
+        
+        if try_to_use_2_29
+          begin
+            date = Date.new(result.year, 2, 29)
+          rescue
+          end
+        end
+      end
+      
+      result = nil if (self.ends? && result && result > self.end_date)
+      result
+    end
+    
+    
+    
+    def next_occurrence_after(date)
+      first_occurrence_on_or_after(1.day.after(date))
+    end
+    
+    
+    
+    def first_occurrence_on_or_before(date)
+      date = date.to_date unless date.is_a?(Date) || !date.respond_to?(:to_date)
+      date = self.end_date if (self.ends? && date > self.end_date)
+      
+      result = nil
+      case kind
+      when :never
+        result = date # (date > self.start_date) ? nil : self.start_date
+      
+      when :weekly
+        wday = date.wday
+        pattern.each do |weekday|
+          wd = Date::DAYNAMES.index(weekday)
+          wd = wd - 7 if wd > wday
+          days_in_the_past = wday - wd
+          temp = days_in_the_past.days.before(date)
+          
+          remainder = ((temp - start_date) / 7).to_i % skip
+          temp = remainder.weeks.before(temp) if (remainder > 0)
+          
+          result = temp if !result || (temp > result)
+        end
+      
+      when :monthly
+        pattern.each do |occurrence|
+          temp = nil
+          (0...30).each do |i| # If an occurrence doesn't occur this month, try up to 30 months in the past
+            temp = monthly_occurrence_to_date(occurrence, i.months.before(date))
+            break if temp && (temp <= date)
+          end
+          next unless temp
+          
+          remainder = months_between(temp, start_date) % skip
+          temp = monthly_occurrence_to_date(occurrence, remainder.months.before(temp)) if (remainder > 0)        
+          
+          result = temp if !result || (temp > result)
+        end
+      
+      when :annually
+        result, try_to_use_2_29 = if((start_date.month == 2) && (start_date.day == 29))
+          [Date.new(date.year, 2, 28), true]
+        else
+          [Date.new(date.year, start_date.month, start_date.day), false]
+        end
+        result = 1.year.before(result) if (result < date)
+
+        remainder = years_between(result, start_date) % skip
+        result = remainder.years.before(result) if (remainder > 0)
+        if try_to_use_2_29
+          begin
+            date = Date.new(result.year, 2, 29)
+          rescue
+          end
+        end
+      end
+      
+      result = nil if (result && result < self.start_date)
+      result
+    end
+    
+    
+    
+    def first_occurrence_before(date)
+      first_occurrence_on_or_before(1.day.before(date))
+    end
+    
+    
+    
+    def occurs_on(date)
+      date = date.to_date
+      first_occurrence_on_or_after(date).eql?(date)
+    end
+    alias :contains? :occurs_on
+    
+    
+    
+    def monthly_occurrence_to_date(occurrence, date)
+      year, month = date.year, date.month
+      
+      day = begin
+        if occurrence.is_a?(Array)
+          ordinal, weekday = occurrence
+          wday_of_first_of_month = Date.new(year, month, 1).wday
+          wday = Date::DAYNAMES.index(weekday)
+          day = wday
+          day = day + 7 if (wday < wday_of_first_of_month)
+          day = day - wday_of_first_of_month
+          day = day + (ordinal * 7) - 6
+        else
+          occurrence
+        end
+      end
+      
+      last_day_of_month = Date.new(year, month, -1).day
+      (day > last_day_of_month) ? nil : Date.new(year, month, day)
+    end
+    
+    
+    
+  private
+    
+    
+    
+    def months_between(date1, date2)
+      later_date, earlier_date = sort_dates(date1, date2)
+      later_date.get_months_since(earlier_date)
+    end
+    
+    def weeks_between(date1, date2)
+      later_date, earlier_date = sort_dates(date1, date2)
+      later_date.get_weeks_since(earlier_date)
+    end
+    
+    def years_between(date1, date2)
+      later_date, earlier_date = sort_dates(date1, date2)
+      later_date.get_years_since(earlier_date)
+    end
+    
+    def sort_dates(date1, date2)
+      (date1 > date2) ? [date1, date2] : [date2, date1]
+    end
+    
+    
+    
+  end
+end