dcs-eventable 0.0.0 → 0.0.8

data/CHANGELOG.textile

@@ -0,0 +1,3 @@
+h2. 0.0.0 (27/04/2009)
+
+* started gem

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Mathijs Kwik
+Copyright (c) 2009 Dutch Coast Software
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.textile

@@ -0,0 +1,23 @@
+h1. Eventable
+
+Description goes here.
+
+h2. Getting started
+
+* ./script/generate eventable will generate a migration.
+* check/adjust this migration and migrate.
+* add acts_as_event (see rdoc) to your site's main event model.
+* general settings like authentication/permissions can be configured
+  by creating your own version of EventableController (see rdoc)
+* you can override model behaviour by subclassing the models
+* you can override controller actions by overriding methods from
+  Eventable::EventableController in ApplicationController (or a
+  mixin). define custom (before|after)_action_controller(_fail)? callbacks
+
+
+
+
+h2. Copyright
+
+Copyright (c) 2009 Dutch Coast Software. See LICENSE for details.
+

data/Rakefile

@@ -1,28 +1,50 @@
 require 'rubygems'
 require 'rake'
 
+def version
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    ""
+  end
+end
+
+# gem builder
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "eventable"
     gem.summary = %Q{TODO}
+    gem.description = %Q{TODO}
     gem.email = "info@dutchcoastsoftware.com"
     gem.homepage = "http://github.com/dcs/eventable"
     gem.authors = ["Mathijs Kwik"]
-
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+    gem.add_development_dependency('redgreen')
+    gem.files = FileList["[A-Z]*", "{app,config,generators,lib,shoulda_macros,rails}/**/*"]
+    gem.rdoc_options << '--main' << 'README.textile' << '--title' << "Eventable #{version}"
+    gem.extra_rdoc_files = ["*.textile", "LICENSE", "app/**/*.rb"]
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
+
+
+# rdoc generation
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Eventable #{version}"
+  rdoc.rdoc_files.include('*.textile')
+  rdoc.rdoc_files.include('LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('app/**/*.rb')
+  rdoc.main = "README.textile"
 end
 
+
+# rcov test coverage
 begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |test|
@@ -37,20 +59,48 @@ rescue LoadError
 end
 
 
-task :default => :test
+# testing with a full empty rails app
+require 'rake/testtask'
+namespace :test do
+  Rake::TestTask.new(:all => ['generator:cleanup',
+                              'generator:generate']) do |task|
+    task.libs << 'lib'
+    task.libs << "test"
+    task.pattern = 'test/**/*_test.rb'
+    task.verbose = false
+  end
+end
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION.yml')
-    config = YAML.load(File.read('VERSION.yml'))
-    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
-  else
-    version = ""
+
+generators = %w(eventable)
+
+namespace :generator do
+  desc "Cleans up the test app before running the generator"
+  task :cleanup do
+    generators.each do |generator|
+      FileList["generators/#{generator}/templates/**/*.*"].each do |each|
+        file = "test/rails_root/#{each.gsub("generators/#{generator}/templates/",'')}"
+        File.delete(file) if File.exists?(file)
+      end
+    end
+
+    FileList["test/rails_root/db/migrate/*_setup_eventable_#{version.gsub('.', '_')}.rb"].each do |each|
+      FileUtils.rm_rf(each)
+    end
+
+    FileUtils.rm_rf("test/rails_root/vendor/plugins/eventable")
+    FileUtils.mkdir_p("test/rails_root/vendor/plugins")
+    eventable_root = File.expand_path(File.dirname(__FILE__))
+    system("ln -fns #{eventable_root} test/rails_root/vendor/plugins/eventable")
   end
 
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "eventable #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  desc "Run the generator on the tests"
+  task :generate do
+    generators.each do |generator|
+      system "cd test/rails_root && ./script/generate #{generator} && rake db:migrate db:test:prepare"
+    end
+  end
 end
 
+desc "Run the test suite"
+task :default => 'test:all'

data/TODO.textile

@@ -0,0 +1,5 @@
+h2. To-do
+
+* use delocalize plugin/gem instead of manual setter-intervention
+
+

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 0
-:patch: 0
+:patch: 8

data/app/controllers/eventable/categories_controller.rb

@@ -0,0 +1,58 @@
+class Eventable::CategoriesController < Eventable::EventableController
+
+  before_filter :get_categories, :only => [:index]
+  before_filter :get_category, :only => [:show, :edit, :update, :destroy]
+  before_filter :new_category, :only => [:new, :create]
+
+  def create
+    if @category.update_attributes(params[:eventable_category])
+      try_after_callback do
+        flash[:notice] = 'Category was successfully created.'
+        redirect_to(eventable_category_path(@category))
+      end
+    else
+      try_after_callback :fail do
+        render :action => "new"
+      end
+    end
+  end
+
+  def update
+    if @category.update_attributes(params[:eventable_category])
+      try_after_callback do
+        flash[:notice] = 'Category was successfully updated.'
+        redirect_to(eventable_category_path(@category))
+      end
+    else
+      try_after_callback :fail do
+        render :action => "edit"
+      end
+    end
+  end
+
+  def destroy
+    @category.destroy
+    try_after_callback do
+      redirect_to(eventable_categories_path)
+    end
+  end
+
+  private
+
+  def model
+    Eventable::Category
+  end
+
+  def get_categories
+    @categories = model.all
+  end
+
+  def get_category
+    @category = model.find(params[:id])
+  end
+
+  def new_category
+    @category = model.new
+  end
+
+end

data/app/controllers/eventable/categorylists_controller.rb

@@ -0,0 +1,29 @@
+class Eventable::CategorylistsController < Eventable::EventableController
+
+  before_filter :get_event
+  before_filter :get_categorylist
+
+  def update
+    if @categorylist.update_attributes(params[:eventable_categorylist])
+      try_after_callback do
+        flash[:notice] = 'Categories were successfully updated.'
+        redirect_to(eventable_event_categorylist_path(@event))
+      end
+    else
+      try_after_callback :fail do
+        render :action => "edit"
+      end
+    end
+  end
+
+  private
+
+  def get_event
+    @event = event_model.find(params[:event_id])
+  end
+
+  def get_categorylist
+    @categorylist = @event.categorylist
+  end
+
+end

data/app/controllers/eventable/eventable_controller.rb

@@ -0,0 +1,45 @@
+class Eventable::EventableController < ApplicationController
+
+  before_filter :try_before_callback
+
+  # make default actions that do nothing but just execute the callback
+  %w(index show new create edit update destroy).each do |action|
+    define_method action do
+      try_after_callback
+    end
+  end
+
+  private
+
+  # auto detected from the model that uses acts_as_event
+  def event_model
+    Eventable.model
+  end
+
+  # events themselves should be handled by the application
+  # override to true to use the (debugging) eventscontroller from this
+  # gem
+  def enable_events_controller
+    false
+  end
+
+  def try_before_callback
+    m = "before_#{action_name}_#{controller_name}"
+    send(m) if respond_to?(m)
+  end
+
+
+  # influence eventable controller actions below here
+  # the naming scheme is (before|after)_action / after_action_fail
+
+  def try_after_callback(failing = false)
+    m = "after_#{action_name}_#{controller_name}"
+    m << "_fail" if failing
+    if respond_to? m
+      send(m)
+    else
+      yield if block_given?
+    end
+  end
+
+end

data/app/controllers/eventable/events_controller.rb

@@ -0,0 +1,54 @@
+class Eventable::EventsController < Eventable::EventableController
+
+  before_filter :service_not_available, :unless => :enable_events_controller
+
+  before_filter :get_events, :only => [:index]
+  before_filter :get_event, :only => [:show, :edit, :update, :destroy]
+  before_filter :new_event, :only => [:new, :create]
+
+  def create
+    if @event.update_attributes(params[:eventable_event])
+      flash[:notice] = 'Event was successfully created.'
+      redirect_to(eventable_event_path(@event))
+    else
+      render :action => "new"
+    end
+  end
+
+  def update
+    if @event.update_attributes(params[:eventable_event])
+      flash[:notice] = 'Event was successfully updated.'
+      redirect_to(eventable_event_path(@event))
+    else
+      render :action => "edit"
+    end
+  end
+
+  def destroy
+    @event.destroy
+    redirect_to(eventable_events_path)
+  end
+
+  private
+
+  def model
+    event_model
+  end
+
+  def get_events
+    @events = model.all
+  end
+
+  def get_event
+    @event = model.find(params[:id])
+  end
+
+  def new_event
+    @event = model.new
+  end
+
+  def service_not_available
+    raise "the events controller from the eventable gem should not be used except for debugging"
+  end
+
+end

data/app/controllers/eventable/opening_periodlists_controller.rb

@@ -0,0 +1,40 @@
+class Eventable::OpeningPeriodlistsController < Eventable::EventableController
+
+  before_filter :get_event
+  before_filter :get_opening_periodlist
+
+  def show
+    @new_opening_period = @event.opening_periods.build
+    try_after_callback
+  end
+
+  def edit
+    # you can add a blank/new item like this:
+    # @opening_periodlist.add_blank
+    try_after_callback
+  end
+
+  def update
+    if @opening_periodlist.update_attributes(params[:eventable_opening_periodlist])
+      try_after_callback do
+        flash[:notice] = 'Opening periods were successfully updated.'
+        redirect_to(eventable_event_opening_periodlist_path(@event))
+      end
+    else
+      try_after_callback :fail do
+        render :action => "edit"
+      end
+    end
+  end
+
+  private
+
+  def get_event
+    @event = event_model.find(params[:event_id])
+  end
+
+  def get_opening_periodlist
+    @opening_periodlist = @event.opening_periodlist
+  end
+
+end

data/app/controllers/eventable/opening_periods_controller.rb

@@ -0,0 +1,78 @@
+class Eventable::OpeningPeriodsController < Eventable::EventableController
+
+  before_filter :get_event
+
+  before_filter :get_opening_periods, :only => [:index]
+  before_filter :get_opening_period, :only => [:show, :edit, :update, :destroy]
+  before_filter :new_opening_period, :only => [:new, :create]
+
+  def create
+    if @opening_period.update_attributes(params[:eventable_opening_period])
+      try_after_callback do
+        flash[:notice] = 'Opening Period was successfully added.'
+        redirect_to (if params[:list]
+                       eventable_event_opening_periodlist_path @event
+                     else
+                       eventable_event_opening_period_path @event, @opening_period
+                     end)
+      end
+    else
+      try_after_callback :fail do
+        render :action => "new"
+      end
+    end
+  end
+
+  def update
+    if @opening_period.update_attributes(params[:eventable_opening_period])
+      try_after_callback do
+        flash[:notice] = 'Opening period was successfully updated.'
+        redirect_to (if params[:list]
+                       eventable_event_opening_periodlist_path @event
+                     else
+                       eventable_event_opening_period_path @event, @opening_period
+                     end)
+      end
+    else
+      try_after_callback :fail do
+        render :action => "edit"
+      end
+    end
+  end
+
+  def destroy
+    @opening_period.destroy
+    try_after_callback do
+      redirect_to (if params[:list]
+                     eventable_event_opening_periodlist_path @event
+                   else
+                     eventable_event_opening_periods_path @event
+                   end)
+    end
+  end
+
+  private
+
+  def model
+    @event ? @event.opening_periods : Eventable::OpeningPeriod
+  end
+
+  def get_opening_periods
+    @opening_periods = model.all
+  end
+
+  def get_opening_period
+    @opening_period = model.find(params[:id])
+    @event ||= @opening_period.event  #fix @event in case we aren't
+                                      #below /events
+  end
+
+  def new_opening_period
+    @opening_period = @event ? model.build : model.new
+  end
+
+  def get_event
+    @event = event_model.find(params[:event_id]) if params[:event_id]
+  end
+
+end