andyw8-acts_as_event_owner 1.1.4

data/.gitignore

@@ -0,0 +1,8 @@
+.idea
+*.tmproj
+*.db
+*.swp
+.DS_Store
+*.gem
+*.rvmrc
+*.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in acts_as_event_owner.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,24 @@
+LICENSE
+
+The MIT License
+
+Copyright (c) 2010 Danny Burkes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.textile

@@ -0,0 +1,217 @@
+h1. ActsAsEventOwner
+
+ActsAsEventOwner is an ActiveRecord extension that adds calendar event management to any ActiveRecord model. Models that declare themselves as @acts_as_event_owner@ gain two @has_many@ associations- one for the event specifications, and one for the event occurrences.
+
+ActsAsEventOwner supports recurring events, with roughly the same recurrence rule capabilities as Apple's iCal application. Under the hood, ActsAsEventOwner uses "ri_cal":http://github.com/rubyredrick/ri_cal to provide recurring event support.
+
+h1. Installation
+
+h2. Rails 2.3.x
+
+ActsAsEventOwner is available both as a gem and as a plugin.
+
+h3. Installing as a Rails 2.3.x plugin
+
+To install as a plugin, just do
+
+<pre>
+  script/plugin install git://github.com/dburkes/acts_as_event_owner_.git
+</pre>
+
+You'll also need to install the @ri_cal@ gem by the method of your choice (bundler, system gems, etc).
+
+h3. Installing as a Rails 2.3.x gem
+
+To install as a gem, use your preferred method of gem installation, _e.g._ Bundler, @config.gem@, etc.
+
+h3. Rails 2.3.x post-installation steps
+
+After installation, generate a migration to add ActsAsEventOwner tables to your database:
+
+<pre>
+  script/generate acts_as_event_owner_migration
+  rake db:migrate
+</pre>
+
+If you want to use the acts_as_event_owner rake tasks, put the following in your Rakefile:
+
+<pre>
+  if Gem.searcher.find('acts_as_event_owner')
+    Dir["#{Gem.searcher.find('acts_as_event_owner').full_gem_path}/**/tasks/*.rake"].each { |ext| load ext }
+  end
+</pre>
+
+h2. Rails 3
+
+Just add it to your Gemfile, like so:
+
+<pre>
+  gem 'acts_as_event_owner'
+</pre>
+
+Then do:
+
+<pre>
+  bundle install
+</pre>
+
+h3. Rails 3 post-installation steps
+
+After installation, generate a migration to add ActsAsEventOwner tables to your database:
+
+<pre>
+  rails generate acts_as_event_owner:migration
+  rake db:migrate
+</pre>
+
+h1. Usage
+
+<pre>
+  class User < ActiveRecord::Base
+    acts_as_event_owner
+  end
+
+  @user = User.create :name => 'Alvin Seville'
+  @user.event_specifications.create :description => 'acquire cheese balls',
+    :start_at => Date.today.to_time,
+    :repeat => :daily,
+    :generate => false
+
+  @user.events # => []
+
+  @user.events.generate :from => Date.today.to_time, :to => Date.today.to_time + 1.week
+
+  # override the description on a per-generate basis
+  @user.events.generate :from => Date.today.to_time - 1.day, :to => Date.today.to_time + 1.week,
+    :attributes => { :description => 'acquire cheese balls, like, right away!' }
+
+  @user.events # => (8 ActsAsEventOwner::EventOccurrence objects)
+
+  @user.events.past # => (1 ActsAsEventOwner::EventOccurrence objects)
+  @user.events.upcoming #=> (7 ActsAsEventOwner::EventOccurrence objects)
+</pre>
+
+h2. Adding custom fields
+
+You can create your own migrations to add custom fields to the event objects- just make sure that you add the same fields to both the @event_specifications@ and @event_occurrences@ tables.
+
+When you create an @EventSpecification@, set the value of your custom fields, then, later, when you call @generate@, the values of those fields in the @EventSpecification@ will be copied over to any generated @EventOcurrence@ records.
+
+Just like you can do with the standard @:description@ attribute, you can override the default value of your custom fields with the @:attributes@ parameter when you call @generate@.
+
+h2. Recurrence rules
+
+ActsAsEventOwner supports recurrence rules roughly equivalent to those supported by Apple's iCal application. Examples are:
+
+h3. One-time event
+
+<pre>
+  EventSpecification.create :description => 'pick up laundry',
+    :start_at => Time.parse("4:00pm")
+</pre>
+
+h3. Every day at 08:00, 13:00, and 18:00
+
+<pre>
+  EventSpecification.create :description => 'walk the dog',
+    :start_at => Time.parse("8:00am"),
+    :repeat => :per_hour,
+    :target => [8,13,18]
+</pre>
+
+h3. Every day
+
+<pre>
+  EventSpecification.create :description => 'eat breakfast',
+    :start_at => Time.parse("7:30am"),
+    :repeat => :daily
+</pre>
+
+h3. Every three days
+
+<pre>
+  EventSpecification.create :description => 'call mom',
+    :start_at => Time.parse("10:30am"),
+    :repeat => :daily,
+    :frequency => 3
+</pre>
+
+h3. On Monday, Wednesday, and Friday of each week
+
+<pre>
+  EventSpecification.create :description => 'go to the gym',
+    :start_at => Time.parse("6:30am"),
+    :repeat => :weekly,
+    :on => [ :mo, :we, :fr ]
+</pre>
+
+h3. On Thursday, every other week
+
+<pre>
+  EventSpecification.create :description => 'clean the bathroom',
+    :start_at => Time.parse("8:00pm"),
+    :repeat => :weekly,
+    :frequency => 2, :on => [ :th ]
+</pre>
+
+h3. On the 10th and 25th of each month
+
+<pre>
+  EventSpecification.create :description => 'pick up paycheck',
+    :start_at => Time.parse("9:30am"),
+    :repeat => :monthly,
+    :on => [ 10, 25 ]
+</pre>
+
+h3. On the last Saturday of each month
+
+<pre>
+  EventSpecification.create :description => 'run a marathon',
+    :start_at => Time.parse("6:30am"),
+    :repeat => :monthly,
+    :on_the => :last,
+    :target => [ :sa ]
+</pre>
+
+h3. On the last weekday of each month
+
+<pre>
+  EventSpecification.create :description => 'wine tasting',
+    :start_at => Time.parse("6:30pm"),
+    :repeat => :monthly,
+    :on_the => :last,
+    :target => :wkday
+</pre>
+
+h3. Every April 15th
+
+<pre>
+  EventSpecification.create :description => 'pay taxes',
+    :start_at => Time.parse("4/15/2010 5:00pm"),
+    :repeat => :yearly
+</pre>
+
+h3. On the second Thursday in May, every other year, until Dec 31, 2012
+
+<pre>
+  EventSpecification.create :description => 'freak out',
+    :start_at => Time.zone.now,
+    :repeat => :yearly,
+    :frequency => 2,
+    :on => [ 5 ],
+    :on_the => :second,
+    :target => [ :th ],
+    :until => Time.parse("12/31/2012")
+</pre>
+
+h2. Using the Rake task
+
+A rake task is included to generate occurrences of recurring events.  For example, you might run this out of a cron job each day to generate any recurring events for the next 30 days, or whatever.
+
+<pre>
+  rake acts_as_event_owner:generate_events FROM=9/1/2010 TO=10/1/2010
+</pre>
+
+h1. Credits
+
+ActsAsEventOwner was developed for Josh Pigford and "Sabotage Media LLC":http://madebysabotage.com, for use in their excellent "Critterly":http://critterly.com product.  Big thanks to Josh and Sabotage for agreeing to make ActsAsEventOwner available by open source!

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rdoc/task'
+require 'rspec/core/rake_task'
+require 'bundler'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+Bundler::GemHelper.install_tasks

data/acts_as_event_owner.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acts_as_event_owner/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "andyw8-acts_as_event_owner"
+  gem.version       = ActsAsEventOwner::VERSION
+  gem.authors       = ["Danny Burkes", "Andy Waite"]
+  gem.email         = ["dburkes@netable.com", "github@andywaite.com"]
+  gem.description   = "Simple calendar events for any ActiveRecord model"
+  gem.summary       = "Simple calendar events for any ActiveRecord model"
+  gem.homepage      = "http://github.com/andyw8/acts_as_event_owner"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency 'ri_cal'
+end

data/generators/acts_as_event_owner_migration/USAGE

@@ -0,0 +1,6 @@
+Usage:
+
+  script/generate acts_as_event_owner_migration
+
+This will create a migration that will add the acts_as_event_owner tables to your database
+

data/generators/acts_as_event_owner_migration/acts_as_event_owner_migration_generator.rb

@@ -0,0 +1,7 @@
+class ActsAsEventOwnerMigrationGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.migration_template 'acts_as_event_owner_migration.rb', File.join('db', 'migrate'), :migration_file_name => "acts_as_event_owner_migration"
+    end
+  end
+end

data/generators/acts_as_event_owner_migration/templates/acts_as_event_owner_migration.rb

@@ -0,0 +1,38 @@
+class ActsAsEventOwnerMigration < ActiveRecord::Migration
+  def self.up
+    create_table :event_specifications do |t|
+      t.integer :owner_id
+      t.string :owner_type
+      t.string :description
+      t.datetime :start_at
+      t.datetime :end_at
+      t.string :repeat                         # daily, weekly, monthly, yearly
+      t.integer :frequency, :default => 1      # every 'n' days, weeks, months, or years
+      t.string :on                             # su, mo, tu, we, th, fr, sa, 1-31, jan-dec
+      t.string :on_the                         # first, second, third, fourth, last
+      t.string :target                         # su, mo, tu, we, th, fr, sa, day, wkday, wkend
+      t.datetime :until
+      t.timestamps
+    end
+
+    add_index :event_specifications, [:owner_id, :owner_type]
+
+    create_table :event_occurrences do |t|
+      t.integer :owner_id
+      t.string :owner_type
+      t.integer :event_specification_id
+      t.datetime :start_at
+      t.datetime :end_at
+      t.string :description
+      t.timestamps
+    end
+
+    add_index :event_occurrences, [:owner_id, :owner_type]
+    add_index :event_occurrences, :event_specification_id
+  end
+
+  def self.down
+    drop_table :event_specifications
+    drop_table :event_occurrences
+  end
+end

data/lib/acts_as_event_owner.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'active_support/time_with_zone'
+require 'active_record'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'acts_as_event_owner/ri_cal_fix'
+require 'acts_as_event_owner/core'
+require 'acts_as_event_owner/event_specification'
+require 'acts_as_event_owner/event_occurrence'
+require 'acts_as_event_owner/exception'
+require 'acts_as_event_owner/railtie'
+require 'acts_as_event_owner/version'
+
+$LOAD_PATH.shift
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.send :include, ActsAsEventOwner::Core
+end

data/lib/acts_as_event_owner/core.rb

@@ -0,0 +1,46 @@
+module ActsAsEventOwner
+  module Core
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      def acts_as_event_owner options = {}
+        include InstanceMethods
+
+        class_eval do
+          has_many :event_specifications, :class_name => ActsAsEventOwner::EventSpecification.name, :as => :owner, :dependent => :destroy
+          has_many :events, :class_name => ActsAsEventOwner::EventOccurrence.name, :as => :owner, :readonly => true do
+            def generate(options={})
+              proxy_association.owner.event_specifications.find(:all, :conditions => "until IS NULL OR until >= '#{Time.zone.now.to_s(:db)}'").each {|spec| spec.generate_events(options)}
+              self.reload
+            end
+
+            def <<(obj)
+              raise ActsAsEventOwner::Exception.new("Do not add events directly- add event specifications, then call events.generate")
+            end
+
+            def build(attributes={})
+              raise ActsAsEventOwner::Exception.new("Do not build events directly- build event specifications, then call events.generate")
+            end
+
+            def create(attributes={})
+              raise ActsAsEventOwner::Exception.new("Do not create events directly- build event specifications, then call events.generate")
+            end
+
+            def upcoming
+              find(:all, :conditions => ["start_at >= ?", Time.zone.now])
+            end
+
+            def past
+              find(:all, :conditions => ["start_at < ?", Time.zone.now])
+            end
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+    end
+  end
+end

data/lib/acts_as_event_owner/event_occurrence.rb

@@ -0,0 +1,7 @@
+module ActsAsEventOwner
+  class EventOccurrence < ::ActiveRecord::Base
+    unloadable
+    belongs_to :owner, :polymorphic => true
+    belongs_to :event_specification, :class_name => "::ActsAsEventOwner::EventSpecification"
+  end
+end

data/lib/acts_as_event_owner/event_specification.rb

@@ -0,0 +1,186 @@
+require 'ri_cal'
+
+module ActsAsEventOwner
+  class EventSpecification < ::ActiveRecord::Base
+    unloadable
+    belongs_to :owner, :polymorphic => true
+    has_many :event_occurrences, :dependent => :destroy, :class_name => "::ActsAsEventOwner::EventOccurrence"
+
+    serialize :repeat
+    serialize :on
+    serialize :on_the
+    serialize :target
+
+    ON_THE = { :first => '1', :second => '2', :third => '3', :fourth => '4', :last => '-1' }
+    BYDAYS = { :day => 'SU,MO,TU,WE,TH,FR,SA', :wkday => 'MO,TU,WE,TH,FR', :wkend => 'SU,SA'}
+
+    before_validation :set_defaults
+    validates_presence_of :description
+    validates_inclusion_of :repeat, :in => [:by_hour,:daily,:weekly,:monthly,:yearly], :allow_nil => true
+    validates_inclusion_of :on_the, :in => ON_THE.keys, :allow_nil => true
+    validates_numericality_of :frequency, :allow_nil => true
+    validates_presence_of :start_at
+    validate :validate_recurrence_rules
+    after_validation :set_defaults_after_validation
+
+    attr_accessor :generate
+    after_create :auto_generate_events
+
+    def validate_recurrence_rules
+      case self.repeat
+        when :by_hour
+          errors.add(:target, "must be an array") if !self.target.present? || !self.target.is_a?(Array)
+          [:on, :on_the].each {|v| errors.add(v, :present) if self.send(v)}
+
+        when :daily
+          [:on, :on_the, :target].each {|v| errors.add(v, :present) if self.send(v)}
+
+        when :weekly
+          errors.add(:on, "must be an array") if self.on.present? && !self.on.is_a?(Array)
+          [:on_the, :target].each {|v| errors.add(v, :present) if self.send(v)}
+
+        when :monthly
+          if self.on_the
+            errors.add(:target, "must be an array, :day, :wkday, or :wkend") if self.target.nil? || !(self.target.is_a?(Array) || BYDAYS.keys.include?(self.target))
+            errors.add(:on, :present) if self.on.present?
+          elsif self.on
+            errors.add(:on, "must be an array") if !self.on.is_a?(Array)
+            [:on_the, :target].each {|v| errors.add(v, :present) if self.send(v)}
+          end
+
+        when :yearly
+          if self.on_the
+            errors.add(:on, "must be an array") if !self.on.present? || !self.on.is_a?(Array)
+            errors.add(:target, "must be an array, :day, :wkday, or :wkend") if self.target.nil? || !(self.target.is_a?(Array) || BYDAYS.keys.include?(self.target))
+          elsif self.on
+            errors.add(:on, "must be an array") if !self.on.present? || !self.on.is_a?(Array)
+          end
+      end
+    end
+
+    def to_rrule
+      return nil if !self.valid? || self.repeat.nil?
+
+      components = []
+      repeat = self.repeat
+      frequency = self.frequency
+
+      case self.repeat
+        when :by_hour
+          repeat = "DAILY"
+          components << "BYHOUR=#{self.target.join(',')}"
+          frequency = nil
+
+        when :daily
+
+        when :weekly
+          components << "BYDAY=#{self.on.join(',').upcase}" if self.on
+
+        when :monthly
+          if self.on_the
+            components << "BYSETPOS=#{ON_THE[self.on_the]}"
+            components << "BYDAY=#{byday}"
+          end
+          components << "BYMONTHDAY=#{self.on.join(',').upcase}" if self.on
+
+        when :yearly
+          components << "BYMONTH=#{self.on.join(',').upcase}" if self.on
+          components << "BYSETPOS=#{ON_THE[self.on_the]};BYDAY=#{byday}" if self.on_the
+      end
+
+      components.unshift "INTERVAL=#{frequency}" if frequency
+      components.unshift "FREQ=#{repeat.to_s.upcase}"
+      components << "UNTIL=#{self.until.strftime("%Y%m%dT%H%M%S")}" if self.until
+      components.join(';')
+    end
+
+    def generate_events options={}
+      raise ActsAsEventOwner::Exception.new("Invalid Event Specification") if !valid?
+
+      opts = options.clone
+      opts[:from] ||= self.start_at
+      opts[:to] ||= (opts[:from] + 30.days) if opts[:from]
+      opts[:from] -= 1.second
+      opts[:to] -= 1.second
+      opts[:from] = opts[:to] = nil if opts[:count]
+      attribute_overrides = opts[:attributes] || {}
+
+      # puts "generate #{self.attributes.inspect} from #{opts[:from]} to #{opts[:to]} with #{attribute_overrides.inspect}"
+
+      start_at = self.start_at
+      end_at = self.end_at
+      cal = RiCal.Calendar do |cal|
+        cal.event do |event|
+          event.description self.description
+          event.dtstart(start_at.in_time_zone) if start_at
+          event.dtend(end_at.in_time_zone) if end_at
+          event.rrule = self.to_rrule if self.to_rrule
+        end
+      end
+      event = cal.events.first
+      # puts "event is #{event.inspect}"
+      occurrences = event.occurrences(:starting => opts[:from], :before => opts[:to], :count => opts[:count])
+      # puts "got #{occurrences.length} occurrences"
+      occurrences.collect do |occurrence|
+        @@OCCURRENCE_COLUMNS ||= (EventOccurrence.columns.collect(&:name) - EXCLUDED_COLUMNS)
+        @@SPECIFICATION_COLUMNS ||= (EventSpecification.columns.collect(&:name) - EXCLUDED_COLUMNS)
+        additional_columns = (@@SPECIFICATION_COLUMNS).inject({}) do |additional, column|
+          additional[column] = self.attributes[column] if @@OCCURRENCE_COLUMNS.include?(column)
+          additional
+        end
+        
+        # puts "*********** #{occurrence.start_time} : #{occurrence.start_time.zone}"
+        # puts "*********** #{Time.zone.at(occurrence.start_time.to_i)}"
+        
+        hash = {
+          :owner_id => self.owner_id, :owner_type => self.owner_type, :event_specification_id => self.id,
+          :description => occurrence.description, :start_at => occurrence.start_time.utc,
+          :end_at => occurrence.finish_time.utc}.stringify_keys.merge(additional_columns).merge(attribute_overrides.stringify_keys)
+          
+        EventOccurrence.find_or_create_by_owner_id_and_owner_type_and_event_specification_id_and_start_at_and_end_at(hash)
+      end
+    end
+
+    def self.generate_events options={}
+      self.all(:conditions => "until IS NULL OR until >= '#{Time.zone.now.to_s(:db)}'").each {|spec|
+        spec.generate_events(options)
+      }
+    end
+    
+    def repeat
+      self.attributes["repeat"].try(:to_sym)
+    end
+
+    protected
+
+    def set_defaults
+      self.start_at ||= Time.zone.now
+      self.end_at ||= self.start_at + 1.hour
+      self.generate = { :from => self.start_at, :to => self.start_at + 30.days } if self.generate.nil?
+    end
+
+    def set_defaults_after_validation
+      if self.errors.empty? && self.repeat == :by_hour
+        current_start_hour = self.start_at.hour
+        closest_repeat_hour = self.target.detect {|h| h > current_start_hour}
+        if closest_repeat_hour
+          self.start_at = Time.local(self.start_at.year, self.start_at.month, self.start_at.day, closest_repeat_hour)
+        else
+          tomorrow = self.start_at + 24.hours
+          self.start_at = Time.local(tomorrow.year, tomorrow.month, tomorrow.day, self.target.first)
+        end
+      end
+    end
+
+    def byday
+      self.target.is_a?(Array) ? self.target.join(',').upcase : BYDAYS[self.target]
+    end
+
+    def auto_generate_events
+      self.generate_events(self.generate) if self.generate
+      self.generate = nil
+    end
+
+    EXCLUDED_COLUMNS = [ "id", "owner_id", "owner_type", "description", "start_at", "end_at", "repeat", "frequency", "on", "on_the", "target", "until", "created_at", "updated_at" ]
+  end
+end