schedulable 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTg5Y2E4OWJkYzkwYTliN2UxZDE0NjRjMTNlMjViYWQ4MTA5NjIwNA==
+  data.tar.gz: !binary |-
+    YWNjZmE2NWE2ZjNjNmM4NjFhMmJiNDIyZTYxODcwNzQ4Yzc4NWFiMQ==
+SHA512:
+  metadata.gz: !binary |-
+    NTY0Y2UyZmQ2N2IzYjk3NjU2NWM3YzQ1NjRkNmExNGJlMDVkYTFlZDY0OWYw
+    NzNmMzcxYWYwZjUyZTkwYmI1ZTVmMDVlMzgyMTIzZGU4ZmVhODFiZTM3NmRk
+    YjEyM2YwNTIxNGIyZjQ0OWM3ODA3NzhkMjM1MWJlOTk1YTZiYWE=
+  data.tar.gz: !binary |-
+    ZWVjNzcxM2I5ZjA5NjgzMzNkYmJjZjZmYWQzZDJjN2M5YWVjMTgyMzAwYmM0
+    MWY1MWQ0MmY5M2JhMzM2NDVlNzljZjEwNmFhNzhjNmIzMGExMThhMTRlMjEz
+    ZWI5ZWJkMzBiYjlmNDRmMTM1NjdiNmZhMzUxMTJmMzYxODQ5MzQ=

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+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.md

@@ -0,0 +1,175 @@
+schedulable
+===========
+
+Handling recurring events in rails. 
+
+
+The schedulable plugin depends on the ice_cube scheduling-library:
+```
+gem 'ice_cube'
+```
+
+Install schedule migration and model
+```
+rails g schedulable:install
+```
+
+### Basic Usage
+
+Create your event model
+```
+rails g scaffold Event name:string
+```
+
+Configure your model to be schedulable:
+```
+# app/models/event.rb
+class Event < ActiveRecord::Base
+  acts_as_schedulable
+end
+```
+This will add an association named 'schedule' that holds the schedule information. 
+
+Now you're ready to setup form fields for the schedule association using the fields_for-form_helper. 
+
+### Attributes
+The schedule object respects the following attributes:
+<table>
+  <tr>
+    <th>Name</th><th>Type</th><th>Description</th>
+  </tr>
+  <tr>
+    <td>rule</td><td>String</td><td>One of 'singular', 'daily', 'weekly', 'monthly'</td>
+  </tr>
+  <tr>
+    <td>date</td><td>Date</td><td>The date-attribute is used for singular events and also as startdate of the schedule</td>
+  </tr>
+  <tr>
+    <td>time</td><td>Time</td><td>The time-attribute is used for singular events and also as starttime of the schedule</td>
+  </tr>
+  <tr>
+    <td>days</td><td>Array</td><td>An array of weekday-names, i.e. ['monday', 'wednesday']</td>
+  </tr>
+  <tr>
+    <td>day_of_week</td><td>Hash</td><td>A hash of weekday-names, containing arrays with indices, i.e. {:monday => [1, -1]} ('every first and last monday in month')</td>
+  </tr>
+  <tr>
+    <td>interval</td><td>Integer</td><td>Specifies the interval of the recurring rule, i.e. every two weeks</td>
+  </tr>
+  <tr>
+    <td>until</td><td>Date</td><td>Specifies the enddate of the schedule. Required for terminating events.</td>
+  </tr>
+  <tr>
+    <td>count</td><td>Integer</td><td>Specifies the total number of occurrences. Required for terminating events.</td>
+  </tr>
+</table>
+
+#### SimpleForm
+A custom input for simple_form is provided with the plugin
+```
+rails g schedulable:simple_form
+```
+
+```
+-# app/views/events/_form.html.haml
+.form-inputs
+  = f.input :name
+  = f.input :schedule, as: :schedule
+```
+
+#### Strong parameters
+```
+# app/controllers/event_controller.rb
+def event_params
+  params.require(:event).permit(:name, schedule_attributes: Schedulable::ScheduleSupport.param_names)
+end
+```
+
+### IceCube
+The schedulable plugin uses ice_cube for calculating occurrences. 
+You can access ice_cube-methods via the schedule association:
+```
+# prints all occurrences of the event until one year from now
+puts @event.schedule.occurrences(Time.now + 1.year)
+# export to ical
+puts @event.schedule.to_ical
+```
+See https://github.com/seejohnrun/ice_cube for more information.
+
+### Event occurrences
+We need to have the occurrences persisted because we want to query the database for all occurrences of all instances of an event model or need to add additional attributes and functionality, such as allowing users to attend to a specific occurrence of an event.
+The schedulable gem handles this for you. 
+Your occurrence model must include an attribute of type 'datetime' with name 'date' as well as a reference to your event model to setup up the association properly:  
+
+```
+rails g model EventOccurrence event_id:integer date:datetime
+```
+
+```
+# app/models/event_occurrence.rb
+class EventOccurrence < ActiveRecord::Base
+  belongs_to :event
+end
+```
+
+Then you can simply declare your occurrences with the acts_as_schedule-method like this:
+```
+# app/models/event.rb
+class Event < ActiveRecord::Base
+  acts_as_schedulable occurrences: :event_occurrences
+end
+```
+This will add a has_many-association with the name 'event_occurences' to your event-model. 
+Instances of remaining occurrences are built when the schedule is saved. 
+If the schedule has changed, the occurrences will be rebuilt if dates have also changed. Otherwise the time of the occurrence record will be adjusted to the new time.
+As in real life, previous occurrences will always stay untouched.
+
+#### Terminating and non-terminating events
+An event is terminating if an until- or count-attribute has been specified. 
+Since non-terminating events have infinite occurrences, we cannot build all occurrences at once ;-)
+So we need to limit the number of occurrences in the database. 
+By default this will be one year from now. 
+This can be configured via the 'build_max_count' and 'build_max_period'-options. 
+See notes on configuration. 
+
+#### Automate build of occurrences
+Since we cannot build all occurrences at once, we will need a task that adds occurrences as time goes by. 
+Schedulable comes with a rake-task that performs an update on all scheduled occurrences. 
+```
+rake schedulable:build_occurrences
+```
+You may add the task to crontab. 
+With the 'whenever' gem this can be easily achieved. 
+```
+gem 'whenever', :require => false
+```
+Create the 'whenever'-configuration file:
+```
+wheneverize .
+```
+Open up the file 'config/schedule.rb' and add the job:
+```
+set :environment, "development"
+set :output, {:error => "log/cron_error_log.log", :standard => "log/cron_log.log"}
+
+every 1.day do
+  rake "schedulable:build_occurrences"
+end
+```
+Write to the crontab:
+```
+whenever -w
+```
+
+### Configuration
+Generate the configuration file
+```
+rails g schedulable:config
+```
+Open 'config/initializers/schedulable.rb' and edit options as you need:
+```
+Schedulable.configure do |config|
+  config.max_build_count = 0
+  config.max_build_period = 1.year
+end
+```

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Schedulable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_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
+
+
+task default: :test

data/config/locales/schedulable.de.yml

@@ -0,0 +1,32 @@
+de: 
+  model:
+    schedule: 'Zeitplan'
+    
+  activerecord:
+    attributes:
+      schedule: 
+        name: Name
+        rule: Regel
+        time: Zeit
+        date: Datum
+        days: Wochentage
+        day_of_week: "Wochentage"
+        interval: Intervall
+        until: Wiederholen bis
+        count: Anzahl Wiederholungen
+        
+  schedulable: 
+    monthly_week_names:
+      1st: '1.'
+      2nd: '2.'
+      3rd: '3.'
+      4th: '4.'
+      last: 'Letzte'
+    rules: 
+      singular: Einmalig
+      monthly: Monatlich
+      weekly: Wöchentlich
+      daily: Täglich
+      
+      
+    

data/config/locales/schedulable.en.yml

@@ -0,0 +1,32 @@
+en:
+  model:
+    schedule: 'Schedule'
+    
+  activerecord:
+    attributes:
+      schedule:
+        name: Name
+        rule: Regel
+        time: Time
+        date: Date
+        rule: Rule
+        days: Weekdays
+        day_of_week: Weekdays
+        until: Repeat until
+        count: Repetition count
+        
+  schedulable: 
+    monthly_week_names:
+      1st: '1st'
+      2nd: '2nd'
+      3rd: '3rd'
+      4th: '4th'
+      last: 'Last'
+    rules: 
+      singular: Singular
+      monthly: Monthly
+      weekly: Weekly
+      daily: Daily
+      
+      
+    

data/lib/generators/schedulable/config_generator.rb

@@ -0,0 +1,15 @@
+module Schedulable
+  module Generators
+    class ConfigGenerator < ::Rails::Generators::Base
+      
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+      
+      def create_config
+        puts 'install schedulable config'
+        template 'config/schedulable.rb', "config/initializers/schedulable.rb"
+      end
+      
+    end
+  end
+end

data/lib/generators/schedulable/install_generator.rb

@@ -0,0 +1,27 @@
+module Schedulable
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      
+      # TODO: skip-migration
+      
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+      
+      def self.next_migration_number(path)
+        unless @prev_migration_nr
+          @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        else
+          @prev_migration_nr += 1
+        end
+        @prev_migration_nr.to_s
+      end
+      
+      def create_migrations
+        puts 'install schedulable'
+        migration_template 'migrations/create_schedules.rb', "db/migrate/create_schedules.rb"
+        template 'models/schedule.rb', "app/models/schedule.rb"
+      end
+      
+    end
+  end
+end

data/lib/generators/schedulable/locale_generator.rb

@@ -0,0 +1,16 @@
+module Schedulable
+  module Generators
+    class LocaleGenerator < ::Rails::Generators::Base
+      
+      argument :locale, :type => :string, :default => "en"  
+      
+      source_root File.expand_path('../../../../../config/locales', __FILE__)
+      
+      def create_locale
+        puts 'install locale'
+        template "schedulable.#{locale}.yml", "config/locales/schedulable.#{locale}.yml"
+      end
+      
+    end
+  end
+end

data/lib/generators/schedulable/occurrence_generator.rb

@@ -0,0 +1,27 @@
+require 'active_support/core_ext/module/introspection'
+require 'rails/generators/base'
+require 'rails/generators/generated_attribute'
+
+module Schedulable
+  module Generators
+    class OccurrenceGenerator < ::Rails::Generators::NamedBase
+      
+      argument :attributes, type: :array, default: [], banner: "field[:type][:index] field[:type][:index]"
+      
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+      
+      def self.next_migration_number(path)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+      
+      def create_migrations
+        puts 'create schedulable occurrence model'
+        migration_template 'migrations/create_occurrences.erb', "db/migrate/create_#{name.tableize}.rb", {name: self.name, attributes: self.attributes}
+        template 'models/occurrence.erb', "app/models/#{name.tableize.singularize}.rb", {name: self.name, attributes: self.attributes}
+      end
+      
+      
+    end
+  end
+end

data/lib/generators/schedulable/simple_form_generator.rb

@@ -0,0 +1,15 @@
+module Schedulable
+  module Generators
+    class SimpleFormGenerator < ::Rails::Generators::Base
+      
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+      
+      def create_config
+        puts 'install simple_form custom input'
+        template 'inputs/schedule_input.rb', "app/inputs/schedule_input.rb"
+      end
+      
+    end
+  end
+end

data/lib/generators/schedulable/templates/config/schedulable.rb

@@ -0,0 +1,4 @@
+Schedulable.configure do |config|
+  config.max_build_count = 0
+  config.max_build_period = 1.year
+end

data/lib/generators/schedulable/templates/inputs/schedule_input.rb

@@ -0,0 +1,102 @@
+class ScheduleInput < SimpleForm::Inputs::Base
+  
+  
+  def input
+ 
+    input_html_options[:type] ||= input_type if html5?
+    
+    # options
+    input_options[:interval] = !input_options[:interval].nil? ? input_options[:interval] : true
+    input_options[:until] = !input_options[:until].nil? ? input_options[:until] : true
+    input_options[:count] = !input_options[:count].nil? ? input_options[:count] : true
+    
+    
+    @builder.simple_fields_for(:schedule, @builder.object.schedule || @builder.object.build_schedule) do |b|
+      
+      b.template.content_tag("div", {id: b.object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/,"_").sub(/_$/,"")}) do
+        
+        b.input(:rule, collection: ['singular', 'daily', 'weekly', 'monthly'], label_method: lambda { |i| i.capitalize }, label: false) << 
+        
+        template.content_tag("div", {data: {group: 'singular'}}) do
+          b.input :date
+        end <<
+        
+        template.content_tag("div", {data: {group: 'weekly'}}) do
+          b.input :days, collection: Time::DAYS_INTO_WEEK.invert.values, label_method: lambda { |v| v.capitalize }, as: :check_boxes
+        end <<
+        
+        template.content_tag("div", {data: {group: 'monthly'}}) do
+          b.simple_fields_for :day_of_week, OpenStruct.new(b.object.day_of_week || {}) do |db|
+            
+            template.content_tag("div", class: 'form-group') do
+              
+              db.label(:day_of_week, required: false) <<
+              
+              template.content_tag("table", style: 'min-width: 280px') do
+                template.content_tag("tr") do
+                  template.content_tag("td") <<
+                  ['1.', '2.', '3.', '4.', 'Last'].reduce(''.html_safe) { | x, item | 
+                    x << template.content_tag("td") do 
+                       db.label(item, required: false)
+                    end    
+                  }
+                end <<
+                Time::DAYS_INTO_WEEK.invert.values.reduce(''.html_safe) { | x, weekday | 
+                  x << template.content_tag("tr") do 
+                    template.content_tag("td") do
+                      db.label t(weekday.capitalize), required: false
+                    end << 
+                    db.collection_check_boxes(weekday.to_sym, [1, 2, 3, 4, -1], lambda { |i| i} , lambda { |i| "&nbsp;".html_safe}, item_wrapper_tag: :td, checked: db.object.send(weekday)) 
+                  end
+                }
+              end
+            end
+          end
+        end << 
+        
+        template.content_tag("div", {data: {group: 'singular,daily,weekly,monthly'}}) do
+          b.input :time
+        end << 
+        
+        (template.content_tag("div", {data: {group: 'daily,weekly,monthly'}}) do
+          b.input :interval
+        end if input_options[:interval]) <<
+        
+        (template.content_tag("div", {data: {group: 'daily,weekly,monthly'}}) do
+          b.input :until
+        end if input_options[:until]) <<
+        
+        (template.content_tag("div", {data: {group: 'daily,weekly,monthly'}}) do
+          b.input :count
+        end if input_options[:count])
+        
+        
+        
+      end <<
+      
+      template.javascript_tag(
+        "(function() {" << 
+        "  var container = $(\"*[id='#{b.object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/,"_").sub(/_$/,"")}']\");" << 
+        "  var select = container.find(\"select[name*='rule']\");" << 
+        "  function update() {" <<
+        "    var value = this.value;" << 
+        "    container.find(\"*[data-group]\").each(function() {" <<
+        "      var groups = $(this).data('group').split(',');" <<
+        "      if ($.inArray(value, groups) >= 0) {" <<
+        "        $(this).css('display', '');" << 
+        "      } else {" <<
+        "        $(this).css('display', 'none');" << 
+        "      }" <<
+        "    });" <<
+        "  }" << 
+        "  select.on('change', update);" <<
+        "  update.call(select[0]);" << 
+        "})()"
+      )
+      
+      
+    end
+    
+    
+  end
+end

data/lib/generators/schedulable/templates/migrations/create_occurrences.erb

@@ -0,0 +1,18 @@
+class Create<%= name.pluralize %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= name.tableize %> do |t|
+<% attributes.each do |attribute| %>
+      t.<%= attribute.type %> :<%= attribute.name %>
+<% end %>
+      t.references :schedulable, polymorphic: true
+      t.datetime :date
+
+      t.timestamps
+      
+    end
+  end
+
+  def self.down
+    drop_table :<%= name.tableize %>
+  end
+end

data/lib/generators/schedulable/templates/migrations/create_schedules.rb

@@ -0,0 +1,25 @@
+class CreateSchedules < ActiveRecord::Migration
+  def self.up
+    create_table :schedules do |t|
+      t.references :schedulable, polymorphic: true
+      
+      t.date :date
+      t.time :time
+      
+      t.string :rule
+      t.string :interval
+      
+      t.text :days
+      t.text :day_of_week
+      
+      t.date :until
+      t.integer :count
+      
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :schedules
+  end
+end

data/lib/generators/schedulable/templates/models/occurrence.erb

@@ -0,0 +1,6 @@
+class <%= name %> < ActiveRecord::Base
+  belongs_to :schedulable, polymorphic: true
+  default_scope :order => 'date ASC'
+  scope :remaining, lambda{where(["date >= ?",Time.now])}
+  scope :previous, lambda{where(["date < ?",Time.now])}
+end

data/lib/generators/schedulable/templates/models/schedule.rb

@@ -0,0 +1,13 @@
+class Schedule < ActiveRecord::Base
+  
+  include Schedulable::ScheduleSupport
+  
+  serialize :days
+  serialize :day_of_week, Hash
+  
+  belongs_to :schedulable, polymorphic: true
+  
+  after_initialize :init_schedule
+  after_save :init_schedule
+  
+end

data/lib/schedulable.rb

@@ -0,0 +1,20 @@
+require 'schedulable/railtie.rb' if defined? ::Rails::Railtie
+require 'schedulable/acts_as_schedulable.rb'
+require 'schedulable/schedule_support.rb'
+require 'i18n'
+
+module Schedulable
+  
+  class Config
+    attr_accessor :max_build_count, :max_build_period
+  end
+
+  def self.config
+    @@config ||= Config.new
+  end
+
+  def self.configure
+    yield self.config
+  end
+
+end

data/lib/schedulable/acts_as_schedulable.rb

@@ -0,0 +1,175 @@
+module Schedulable
+  
+  module ActsAsSchedulable
+
+    extend ActiveSupport::Concern
+   
+    included do
+    end
+   
+    module ClassMethods
+      
+      def acts_as_schedulable(options = {})
+        
+        name = options[:name] || :schedule
+        attribute = :date
+        
+        has_one name, as: :schedulable, dependent: :destroy
+        accepts_nested_attributes_for name
+        
+        if options[:occurrences]
+          
+          # setup association
+          if options[:occurrences].is_a?(String) || options[:occurrences].is_a?(Symbol)
+            occurrences_association = options[:occurrences].to_sym
+            options[:occurrences] = {}
+          else
+            occurrences_association = options[:occurrences][:name]
+            options[:occurrences].delete(:name)
+          end
+          options[:occurrences][:class_name] = occurrences_association.to_s.classify
+          options[:occurrences][:as]||= :schedulable
+          options[:occurrences][:dependent]||:destroy
+          options[:occurrences][:autosave]||= true
+          
+          has_many occurrences_association, options[:occurrences]
+          
+          # remaining
+          remaining_occurrences_options = options[:occurrences].clone
+          remaining_occurrences_association = ("remaining_" << occurrences_association.to_s).to_sym
+          has_many remaining_occurrences_association, -> { where "date >= ?", Time.now}, remaining_occurrences_options
+          
+          # previous
+          previous_occurrences_options = options[:occurrences].clone
+          previous_occurrences_association = ("previous_" << occurrences_association.to_s).to_sym
+          has_many previous_occurrences_association, -> { where "date < ?", Time.now}, previous_occurrences_options
+          
+          ActsAsSchedulable.add_occurrences_association(self, occurrences_association)
+          
+          after_save "build_#{occurrences_association}"
+ 
+          self.class.instance_eval do
+            define_method("build_#{occurrences_association}") do 
+              # build occurrences for all events
+              # TODO: only invalid events
+              schedulables = self.all
+              puts "build occurrences for #{schedulables.length} #{self.name.tableize}" 
+              schedulables.each do |schedulable| 
+                schedulable.send("build_#{occurrences_association}")
+              end
+            end
+          end
+        
+          define_method "build_#{occurrences_association}" do 
+            
+            # build occurrences for events
+            
+            schedule = self.send(name)
+            
+            now = Time.now
+            occurrence_attribute = :date
+            
+            schedulable = schedule.schedulable
+            terminating = schedule.until.present? || schedule.count.present? && schedule.count > 0
+
+            max_build_period = Schedulable.config.max_build_period || 1.year
+            max_date = now + max_build_period
+            max_date = terminating ? [max_date, schedule.last.to_time].min : max_date
+            
+            max_build_count = Schedulable.config.max_build_count || 0
+            max_build_count = terminating ? [max_build_count, schedule.remaining_occurrences.count].min : max_build_count
+
+            # get occurrences
+            if max_build_count > 0
+              # get next occurrences for max_build_count
+              occurrences = schedule.next_occurrences(max_build_count)
+            end
+            
+            if !occurrences || occurrences.last && occurrences.last.to_time > max_date 
+              # get next occurrences for max_date
+              all_occurrences = schedule.occurrences(max_date)
+              occurrences = []
+              # filter future dates
+              all_occurrences.each do |occurrence_date|
+                if occurrence_date.to_time > now
+                  occurrences << occurrence_date
+                end
+              end
+            end
+            
+            
+            puts 'build occurrences'
+
+            # build occurrences
+            assocs = schedulable.class.reflect_on_all_associations(:has_many)
+            assocs.each do |assoc|
+              puts assoc.name
+            end
+            
+            occurrences_records = schedulable.send(occurrences_association)
+            
+            # clean up unused remaining occurrences 
+            record_count = 0
+            occurrences_records.each do |occurrence_record|
+              if occurrence_record.date > now
+                # destroy occurrence if it's not used anymore
+                if !schedule.occurs_on?(occurrence_record.date) || occurrence_record.date > max_date || record_count > max_build_count
+                  if occurrences_records.destroy(occurrence_record)
+                    puts 'an error occurred while destroying an unused occurrence record'
+                  end
+                end
+                record_count = record_count + 1
+              end
+            end
+            
+            # build occurrences
+            occurrences.each do |occurrence|
+              
+              # filter existing occurrence records
+              existing = occurrences_records.select { |record|
+                record.date.to_date == occurrence.to_date
+              }
+              if existing.length > 0
+                # a record for this date already exists, adjust time
+                existing.each { |record|
+                  #record.date = occurrence.to_datetime
+                  if !occurrences_records.update(record, date: occurrence.to_datetime)
+                    puts 'an error occurred while saving an existing occurrence record'
+                  end
+                }
+              else
+                # create new record
+                if !occurrences_records.create(date: occurrence.to_datetime)
+                  puts 'an error occurred while creating an occurrence record'
+                end
+              end
+            end
+            
+          end
+          
+        end
+        
+      end
+  
+    end
+    
+    def self.occurrences_associations_for(clazz)
+      @@schedulable_occurrences||= []
+      @@schedulable_occurrences.select { |item|
+        item[:class] == clazz
+      }.map { |item|
+        item[:name]
+      }
+    end
+    
+    private
+    
+    def self.add_occurrences_association(clazz, name)
+      @@schedulable_occurrences||= []
+      @@schedulable_occurrences << {class: clazz, name: name}
+    end
+    
+      
+  end
+end  
+ActiveRecord::Base.send :include, Schedulable::ActsAsSchedulable

data/lib/schedulable/railtie.rb

@@ -0,0 +1,26 @@
+require 'rails'
+module Schedulable
+  class Railtie < ::Rails::Railtie
+    
+    railtie_name :schedulable
+    
+    # application configuration initializer
+    config.schedulable = ActiveSupport::OrderedOptions.new # enable namespaced configuration in Rails environments
+  
+    initializer "schedulable.configure" do |app|
+      Schedulable.configure do |config|
+        
+        # copy parameters from application configuration
+        config.max_build_count = app.config.schedulable[:max_build_count]
+        config.max_build_period = app.config.schedulable[:max_build_period]
+      end
+    end
+    
+    
+    # rake tasks
+    rake_tasks do
+      load "tasks/schedulable_tasks.rake"
+    end
+    
+  end
+end

data/lib/schedulable/schedule_support.rb

@@ -0,0 +1,69 @@
+module Schedulable
+  
+  module ScheduleSupport
+    
+    def to_icecube
+      return @schedule
+    end
+    
+    def to_s
+      return @schedule.to_s
+    end
+    
+    def method_missing(meth, *args, &block)
+      if @schedule
+        @schedule.send(meth, *args, &block)
+      end
+    end
+    
+    def self.param_names
+      [:id, :date, :time, :rule, :until, :count, :interval, days: [], day_of_week: [monday: [], tuesday: [], wednesday: [], thursday: [], friday: [], saturday: [], sunday: []]]
+    end
+  
+    private
+    
+    def init_schedule()
+      
+      self.rule||= "singular"
+      self.interval||= 1
+      
+      date = self.date ? self.date.to_time : Time.now
+      if self.time
+        date = date.change({hour: self.time.hour, min: self.time.min})
+      end
+      
+      @schedule = IceCube::Schedule.new(date)
+      
+      if self.rule && self.rule != 'singular'
+        
+        self.interval = self.interval.present? ? self.interval.to_i : 1
+        
+        rule = IceCube::Rule.send("#{self.rule}", self.interval)
+        
+        if self.until
+          rule.until(self.until)
+        end
+        
+        if self.count && self.count.to_i > 0
+          rule.count(self.count.to_i)
+        end
+      
+        if self.days
+          days = self.days.reject(&:empty?)
+          if self.rule == 'weekly'
+            days.each do |day|
+              rule.day(day.to_sym)
+            end
+          elsif self.rule == 'monthly'
+            days = {}
+            day_of_week.each do |weekday, value|
+              days[weekday.to_sym] = value.reject(&:empty?).map { |x| x.to_i }
+            end
+            rule.day_of_week(days)
+          end
+        end
+        @schedule.add_recurrence_rule(rule)
+      end
+    end
+  end
+end

data/lib/schedulable/version.rb

@@ -0,0 +1,3 @@
+module Schedulable
+  VERSION = "0.0.2"
+end

data/lib/tasks/schedulable_tasks.rake

@@ -0,0 +1,13 @@
+require 'rake'
+desc 'builds occurrences for schedulable models'
+namespace :schedulable do
+  task :build_occurrences => :environment do
+    Schedule.all(group: :schedulable_type).each do |schedule|
+      clazz = schedule.schedulable.class
+      occurrences_associations = Schedulable::ActsAsSchedulable.occurrences_associations_for(clazz)
+      occurrences_associations.each do |association|
+        clazz.send("build_" + association.to_s)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: schedulable
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Rafael Nowrotek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.3
+- !ruby/object:Gem::Dependency
+  name: ice_cube
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Handling recurring events in rails.
+email:
+- mail@benignware.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- config/locales/schedulable.de.yml
+- config/locales/schedulable.en.yml
+- lib/generators/schedulable/config_generator.rb
+- lib/generators/schedulable/install_generator.rb
+- lib/generators/schedulable/locale_generator.rb
+- lib/generators/schedulable/occurrence_generator.rb
+- lib/generators/schedulable/simple_form_generator.rb
+- lib/generators/schedulable/templates/config/schedulable.rb
+- lib/generators/schedulable/templates/inputs/schedule_input.rb
+- lib/generators/schedulable/templates/migrations/create_occurrences.erb
+- lib/generators/schedulable/templates/migrations/create_schedules.rb
+- lib/generators/schedulable/templates/models/occurrence.erb
+- lib/generators/schedulable/templates/models/schedule.rb
+- lib/schedulable/acts_as_schedulable.rb
+- lib/schedulable/railtie.rb
+- lib/schedulable/schedule_support.rb
+- lib/schedulable/version.rb
+- lib/schedulable.rb
+- lib/tasks/schedulable_tasks.rake
+- MIT-LICENSE
+- Rakefile
+- README.md
+homepage: http://github.com/benignware
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Handling recurring events in rails.
+test_files: []