Event Calendars in Rails

<h4>First, a little context</h4> The <a href="http://en.wikipedia.org/wiki/ICalendar">`RFC 2445` (iCalendar)</a> spec has become a pseudo standard for internet scheduling. Google Calendars, Microsoft Outlook, and Apples iCal software all support rendering iCalendar feeds. <a href="http://github.com/rubyredrick/ri_cal/tree/master">RiCal</a> is Rubys latest (and most complete) implementation for both creating and parsing the format. So, why am I suddenly so interested in calendars? I've been doing a lot of freelance work lately for an Ottawa based company named <a href="http://www.dejatechnologies.com">Deja Technologies</a>, and so happens, one of their clients needed a corporate calendaring system for their employees that could be integrated into the intranet site that I was building. <h4>Google Calendar Woes</h4> I've developed a bad habit of blindly choosing Google as my default solution provider. Google Maps is fantastic, Docs is amazing, why should their Calendar be any different? I had a seemingly simple idea: generate an iCalendar feed, and render it in in an embedded Google Calendar. It worked perfectly, almost. My software generated the iCalendar feed, Google Calendar displayed it correctly, and it embedded into the page easily. What was the deal breaker? Caching. At the time of posting, Google Calendar caches iCalendar feeds for anywhere between 3-6 hours. This is not manually refreshable. Such a limitation makes Google Calendars virtually useless as an embedded calendar solution. Google Calendar is still amazing, but it wasn't quite the solution I was hoping for. <h4>Won't Somebody Please, Render My Feed?</h4> Maybe I was looking in the wrong places, but their aren't embedded many iCalendar rendering services on the web (note to self)! I attempted to use <a href="http://instantcal.com/">InstantCal</a>, and everything worked fine, for awhile. Unfortunatly, they seem to have a bug in their feed parsing. It started doubling up reoccuring events after January 2010. <a href="http://phpicalendar.net/">PHP iCalendar</a> might have worked, but this was a Ruby project, and if I was going to start running my own calendar, I wanted a Ruby solution. <h4>If You Want Something Done Right..</h4> I decided that I had wasted enough time trying to find a solution. It would be much easier (and more fun) to just build one. I decided to use the <a href="http://github.com/rubyredrick/ri_cal/tree/master">ri_cal</a> gem to parse my feed, and give me the events. Once I knew the events, drawing the calendar would be a piece of cake. Install the require gems. <code> gem install ri_cal </code> <h4>Calendar & Calendar Event Models</h4> <code> class Calendar < ActiveRecord::Base require 'ri_cal' has_many :calendar_events attr_accessor :ics def to_ics(reload = false) if !@ics || reload icalendar = RiCal.Calendar do |c| self.calendar_events.each { |calendar_event| c.event do |e| e.summary = calendar_event.title.to_s e.description = calendar_event.description.to_s if calendar_event.all_day || calendar_event.start.to_date > calendar_event.end.to_date e.dtstart = calendar_event.start.to_date e.dtend = calendar_event.start.advance(:days => 1).to_date elsif calendar_event.all_day e.dtstart = calendar_event.start.to_date e.dtend = calendar_event.end.to_date else e.dtstart = calendar_event.start e.dtend = calendar_event.end end e.location = calendar_event.location.to_s if !calendar_event.frequency.to_s.empty? && CONFIG[:calendar]["frequency"].collect { |i| i[1] }.include?( calendar_event.frequency ) recurrence = [] recurrence << "FREQ=#{calendar_event.frequency}" if calendar_event.frequency recurrence << "INTERVAL=#{calendar_event.interval}" if calendar_event.interval recurrence << "UNTIL=#{ calendar_event.until.strftime('%Y%m%dT%H%M%SZ') }" if calendar_event.until e.rrule = recurrence.join(";") if recurrence.length > 0 end end } end @ics = icalendar end @ics end def bounded_events(start_date, end_date) events = self.to_ics.events.collect { |i| i.occurrences(:starting => start_date, :before => end_date).collect { |j| { :summary => j.summary, :description => j.description, :location => j.location, :start => j.dtstart, :end => j.dtend } } } events.reject { |i| i.empty? }.flatten end def bounded_events_by_date(start_date,end_date) events = self.bounded_events(start_date, end_date) rtn_hash = {} events.each { |e| rtn_hash[e[:start].strftime("%Y-%m-%d")] ||= [] rtn_hash[e[:start].strftime("%Y-%m-%d")] << e } rtn_hash.each_pair { |k,v| v.sort! { |a,b| a[:summary]<=>b[:summary] }.sort! { |a,b| a[:start]<=>b[:start] } } rtn_hash end end class CalendarEvent < ActiveRecord::Base require 'ri_cal' belongs_to :calendar validates_presence_of :title validates_presence_of :start validates_presence_of :end end </code> <h4>Database Migrations</h4> <code> class CreateCalendars < ActiveRecord::Migration def self.up create_table :calendars do |t| t.column :name, :string t.timestamps end end def self.down drop_table :calendars end end class CreateCalendarEvents < ActiveRecord::Migration def self.up create_table :calendar_events do |t| t.column :calendar_id, :integer t.column :start, :datetime t.column :end, :datetime t.column :frequency, :string t.column :interval, :integer t.column :until, :datetime t.column :description, :string t.column :location, :string t.column :all_day, :boolean t.timestamps end end def self.down drop_table :calendar_events end end </code> Stay tuned for part 2, where I'll go over how to turn all of this into a calendar. 1

2009-08-21T18:48:26Z

Calendar feed tutorial in Ruby on Rails 16 iCalendar, ri_cal, ruby on rails

Build your own calendar with reoccurring events using ri_cal

2009-08-21T18:56:50Z

Running a Rails application under Windows server is a far from the ideal deployment environment, but in some instances it must be done. In my case, a Windows 2003 box is the only server available to my employer. It was deployed before I arrived in my current position, and despite my best efforts and arguments to management, still remains. The server is currently running 3 Rails applications that I've developed, each application with 4 mongrel instances running as services. Apache is used in the front end, and as far as I was aware, everything worked smoothly. One day I arrived at work very early, 6am to be exact, and for some reason, received a 503 proxy error when checking one of the applications! Every application gave the same 503 Proxy error. Mongrel seemed to be going to sleep after several hours of inactivity. Google did not have any answers, either. <h4>The Fix</h4> Luckily the solution to this problem is simple enough, I would just set up a Windows "Scheduled Task" (cron job to all you Linux folk) to hit my mongrel instances every half hour. I haven't had the problem since. There is even an added benefit - the applications seem to respond even more quickly, probably due to my constant prodding at Mongrel. The implementation is very hack-ish. My original thought was just to use Windows Telnet to make the requests, but that turned out to be much harder than I thought. The Windows version of Telnet does not seem to like being handled by a batch file. After 20 minutes, I gave up on Windows Telnet. Oh, it was easy enough to manually request the page from the server using Telnet, but for the life of me I could not get the batch file to do it. I'm too used to the Linux shell I suppose Next, I tried PuTTY. Again, it was very easy to get it to work under the actual PuTTY client. But, getting Plink (PuTTY's command-line only version) to accomplish the same feat through a batch file was like pulling teeth. For everyone not keeping score: <table> <tr> <th>Windows</th><td> 2</td> foreach($sites as $site) { $file = fopen( $site,"r"); if (!$file) { // Error opening site } else { // Site opened } fclose($file); } </tr> <tr> <th>Me</th><td> 0</td> </tr> </table> At this point, frustration and desperation kicked in. I turned to the quickest solution I could think of: Ruby! <h4>mongrel_keepalive.bat</h4> <code> @echo off ruby < mongrel_keepalive.rb </code> <h4>mongrel_keepalive.rb</h4> <code> require 'net/http' sites = [ "http://127.0.0.1:5000/", "http://127.0.0.1:5001/", "http://127.0.0.1:5002/", "http://127.0.0.1:5003/", "http://127.0.0.1:5100/", "http://127.0.0.1:5101/", "http://127.0.0.1:5102/", "http://127.0.0.1:5103/", "http://127.0.0.1:5200/", "http://127.0.0.1:5201/", "http://127.0.0.1:5202/", "http://127.0.0.1:5203/" ] sites.each { |i| Net::HTTP.get( URI.parse( i ) ) } </code> -Butch 1

2009-07-04T20:46:44Z

15 ruby on rails, ruby, rails, mongrel, windows, apache, proxy error

Windows, Mongrel, and an Apache proxy error!

Mongrel Falls Asleep

2009-07-05T18:24:17Z

Today we're going to solve the problem of implementing searching and sorting in an index view. By providing your users with an easy method of sorting and searching though their views you are increasing their happiness and productivity, and by implementing searching and sorting in an easy to understand and maintainable manner you are ensuring your own sanity. All of the utilities required to accomplish searching and sorting your data is already provided to you in your SQL database. The real trick is to get queries to the database that are both injection safe and are generated in a manner that is easy for you or your eventual replacements to understand. It's very tempting to rush ahead and implement some fancy AJAX features right away, but I urge you to stop and think about first implementing legacy support, and than dealing with more advanced features. It's always necessary to ensure graceful degradation in all the applications that you write. <h4>Fat Models, Skinny Controllers</h4> Implementing business logic in your controllers is one of the most tempting and messy practices that you can fall into the habit of. Just `getting it working` and than `cleaning it up later` is not a good way to write code, and I urge everyone to always design twice, and code once. Our user will have to pass to the Controller how they would like the data searched and sorted, the controller will ask the appropriate Model to carry out the work, and the view will display the result. The real trick is to figure out how the Model should implement and return the different scopes that the data can be ordered in, and how should we indicate to the view how that data should be displayed. <h4>Project Setup</h4> A project can have many programmers, but only one manager. The following models will be assumed throughout the all of the examples. <code> class Person < ActiveRecord::Base end class ProjectProgrammer < ActiveRecord::Base belongs_to :project belongs_to :person end class Project < ActiveRecord::Base belongs_to :manager, :foreign_key => :manager_id, :class_name => "Person" has_many :project_programmers has_many :programmers, :through => :project_programmers, :source => :person, :class_name => "Person" end </code> <h4>Named Scopes</h4> Named scopes allow for some pretty amazing things, and will be the underpinning of our sorting and searching. There are many places on the Internet that <a href='http://ryandaigle.com/articles/2008/3/24/what-s-new-in-edge-rails-has-finder-functionality'>better explain exactly what named scopes do</a>. I am going to explain how to used named scopes to quickly and cleanly sort and search your data. <code> class Project < ActiveRecord::Base #.. Scopes = { :manager_asc => { :order => "manager.`last_name` ASC, manager.`first_name` ASC", :joins => "LEFT JOIN people AS manager ON manager.`id` = projects.`manager_id`" } }, :manager_desc => { :order => "manager.`last_name` DESC, manager.`first_name` DESC", :joins => "LEFT JOIN people AS manager ON manager.`id` = projects.`manager_id`" } } } named_scope :by_scope, lambda { |scope| return {} unless Project::Scopes[scope.to_sym]; Project::Scopes[scope.to_sym] } #.. end </code> Load up the console: <code> >> Project.by_scope('manager_asc') >> Project.by_scope('manager_desc') </code> This is a basic example, but you get the idea. You can define any number of pre-canned views in your Model, and call them from your views automatically by passing the appropriate scope. Injection safe, easy to understand! I'll leave it up to you as to how you want to implement searching, but from the above example I'm sure I've already given you a few ideas. Small disclaimer: The above code hasn't actually been tested, and was done from memory, so you may or may not have syntax errors. The essence of the method is there, however. -Butch 1

2009-06-02T20:58:48Z

10 ruby on rails, ruby, rails, named scopes, custom ordering, tutorial

Custom Ordering Using Named Scopes

2009-07-04T21:39:12Z

I ran into an interesting problem today, all of my RJS calls refused to execute! Of course, In the end, it was entirely my fault. I had completed the AJAX DOM manipulation code, tested it for any mistakes, and had forgotten about it while I attended to other parts of the application. When deploying for some internal testing, I noticed that the DOM wasn't updating. Very strange, especially since there were no errors reported. <ol> <li>Firebug reported that my request had completed.</li> <li>A `puts "test"` verfied that code was executed before, and after the offending RJS file.</li> <li>Everything was OK with the response. <code> try { alert("the response seems to be evaled fine!"); } catch (e) { alert('RJS error:\n\n' + e.toString()); alert('alert(\"the response seems to be evaled fine!\");'); throw e } </code> </li> </ol> I was stumped, and thus began the arduous process of determining what I had done. After some code tracing, I stumbled upon this block in prototype.js: <code> respondToReadyState: function(readyState) { var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this); if (state == 'Complete') { try { this._complete = true; (this.options['on' + response.status] || this.options['on' + (this.success() ? 'Success' : 'Failure')] || Prototype.emptyFunction)(response, response.headerJSON); } catch (e) { this.dispatchException(e); } var contentType = response.getHeader('Content-type'); if (this.options.evalJS == 'force' || (this.options.evalJS && this.isSameOrigin() && contentType && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i))) { this.evalResponse(); } } </code> The console reported code executing before, and after this.evalResponse, but not inbetween! What had I done to break things? It all came down to my response headers. The data for this project was migrated from a legacy MS Access program, so all data was in the Western ISO-8859-1 character set. Instead of fixing the data, I lazily forced all headers to "text/html; charset=ISO-8859-1". This had the side effect of also forcing my RJS response headers to "text/html; charset=ISO-8859-1", while prototype is expecting "text/javascript;". -Butch 1

2009-05-28T18:17:06Z

8 ruby on rails, ruby, rails, ajax, response, tutorial

check your response headers

Rails AJAX Response Refuses to Execute

2009-07-04T21:38:48Z

Today I've decided to take my best shot at explaining the Ruby on Rails multi-model form. This is an important skill for any Rails enthusiast to have a good grasp on, and is one that personally took me a while to get. The technique I'll be using is described very well in the <a href='http://www.railscasts.com'>Railscasts</a> <a href='http://railscasts.com/episodes/75-complex-forms-part-3'>complex forms</a> episode, and is another excellent resource for learning this technique. Why is this an extremely important technique? <ol> <li>It allows for easy and understandable multi-form validations.</li> <li>It gives us skinny controllers and fat models.</li> </ol> <h4>Project Setup</h4> Define a Train model, which will be comprised of many Cars. Our join model will be TrainCar. To do this from the terminal, type: <code> >> ruby ./script/generate scaffold Train >> ruby ./script/generate model Car >> ruby ./script/generate model TrainCar </code> This example is good because any Train can be comprised of any number of cars at any given time. Also notice the `position` column on the train_cars table. This will let us order the cars in our train. <code> class Train < ActiveRecord::Base has_many :train_cars has_many :cars, :through => :train_cars, :order => "train_cars.`position` ASC" end </code> <code> class Car < ActiveRecord::Base has_many :train_cars has_many :trains, :through => :train_cars, :order => "train_cars.`position` ASC" end </code> <code> class TrainCar < ActiveRecord::Base belongs_to :train belongs_to :car end </code> In the migrations: <code> create_table :trains do |t| t.column :name, :string t.timestamps end </code> <code> create_table :cars do |t| t.column :name, :string t.timestamps end </code> <code> create_table :train_cars do |t| t.column :car_id, :integer t.column :train_id, :integer t.column :position, :integer t.timestamps end </code> Migrate your database: <code> >> rake db:migrate </code> <h4>Define Attribute Accessors</h4> Your previous attempts at multi-model forms may have included attempting to build your multi-model associations from the passed hash within the controller. We're going to DRY up that method a significant amount by off loading all of the model association building to where they originally belonged: the model. Open up your train model, and add the following code: <code> class Train < ActiveRecord::Base has_many :train_cars has_many :cars, :through => :train_cars, :order => "train_cars.`position` ASC" after_update :save_train_cars def new_train_car_attributes=(train_car_attributes) train_car_attributes.each_pair do |object_id,attributes| train_cars.build(attributes) end end def existing_train_car_attributes=(train_car_attributes) train_cars.reject(&:new_record?).each do |train_car| attributes = train_car_attributes[train_car.id.to_s] if attributes train_car.attributes = attributes else train_cars.delete(train_car) end end end def save_train_cars train_cars.each do |train_car| train_car.save(false) end end end </code> This does exactly what you might think. Now, your train model can handle the attributes passed from our controller hash params[:train][:new_train_car_attributes] and params[:train][:existing_train_car_attributes]. Additionally, after the update completes, those changes are saved to the database through the `save_train_cars` method. <h4>Define our Helper Method</h4> The helper method we're going to define here is going to be used to get data into those `new_train_car_attributes` and `existing_train_car_attributes` methods that we just defined in the Train model. Open up app/helpers/trains_helper.rb <code> module TrainsHelper def fields_for_train_car(train_car, &block) if train_car.new_record? train_car_id = ((train_car.object_id > 0)? train_car.object_id * -1 : train_car.object_id) fields_for("train[new_train_car_attributes][#{train_car_id}]", train_car, &block) else fields_for("train[existing_train_car_attributes][]", train_car, &block) end end end </code> If you pass the `fields_for_train_car` helper a TrainCar object, and it will determine whether it is a new or existing TrainCar (saved in the database or not), and put all of its attributes in the appropriate hash (`new_train_car_attributes` or `existing_train_car_attributes`) to be processed by the Train model. <h4>The Train Controller</h4> Open the controller that was automatically generated by the scaffold at app/controllers/trains_controller.rb. We're going to leave this file virtually unchanged, accept for the addition of a single line to the `update` method. <code> def update @train = Train.find(params[:id]) params[:train][:existing_train_car_attributes] ||= {} respond_to do |format| if @train.update_attributes(params[:train]) flash[:notice] = 'Train was successfully updated.' format.html { redirect_to(@train) } format.xml { head :ok } else format.html { render :action => "edit" } format.xml { render :xml => @train.errors, :status => :unprocessable_entity } end end end </code> Adding params[:train][:existing_train_car_attributes] ||= {} means that if there is no container `existing_train_car_attributes` in the `train` hash, create an empty one. This is needed to trigger the `existing_train_car_attributes` method within the Train model if all cars have been removed from the train. Since the hash contains no elements, it would otherwise not fire, and not remove all of the cars from the train as was intended. <h4>The Edit View</h4> The final piece of our puzzle will be the actual view that we'll be using to editing the multi-model form. We will be using an AJAX approach for adding and removing elements, so don't forget to include Prototype/Scriptaculous to your layout file. <ol> <li>In edit.html.erb and new.html.erb add: <code> <% form_for(@train) do |f| %> ... <%= render :partial => 'form', :locals => { :f => f, :train => @train} %> ... <% end %> </code> This will take care of both the 'new' and 'edit' views with our _form.html.erb partial. </li> <li>Create the file app/views/trains/_form.html.erb, add: <code> <% content_tag("ul") do %> <%= content_tag("dl", f.label(:name) ) %> <%= content_tag("dd", f.text_field(:name) ) %> <% end %> <% content_tag("fieldset") do %> <% content_tag("legend") do %> Cars <%= select_tag("car_id", options_for_select( Car.find(:all).collect { |i| [i.name,i.id] } ), { :id => "car_id" } ) %> <%= link_to_function("add", remote_function( :url => { :controller => :trains, :action => :add_train_car, :train_id => train.id }, :with => "'car_id='+$(\"car_id\").options[ $(\"car_id\").options.selectedIndex ].value" ) ) %> <% end %> <% content_tag("div", { :id => "train_cars" }) do %> <% @train.train_cars.each { |train_car| %> <%= render :partial => 'train_car', :locals => { :train_car => train_car } %> <% } %> <% end %> <% end %> </code> This is the actual partial. All of our train cars will go into the DIV#train_cars container. The select_tag contains all possible trains for us to add. The add button summons our add_train_car.rjs file to plunk the trains down into our DIV#train_cars container. Comprende? </li> <li>Create the file app/views/trains/add_train_car.rjs, add: <code> train_car = TrainCar.new(:train_id => params[:train_id], :car_id => params[:car_id]) if train_car.valid? page.insert_html :bottom, :train_cars,:partial => 'train_car', :locals => {:train_car => train_car} end </code> The add_train_car RJS file will link up the train and the car, and place it at the bottom of DIV#train_cars. Please note that nothing has been saved to the database yet. </li> <li>Create the file app/views/trains/_train_car.html.erb, add: <code> <% content_tag("div", :id => "train_car_#{train_car.object_id}") do %> <% fields_for_train_car(train_car) do |f| %> <%= f.hidden_field(:car_id) %> <%= f.text_field(:position) %> <%= train_car.car.name %> <%= link_to_function("remove", "$('train_car_#{train_car.object_id}').remove()") %> <% end %> <% end %> </code> Once the `add` button has been pressed, this partial will be rendered into the DIV#train_cars container. Also note that the `remove` button will remove this train car, but changes will only be saved once the `update` button has been pressed. </li> </ol> That's a lot of code! Hopefully it all makes sense to you. It's all been tested to work in the Rails 2.3.2 environment with Ruby 1.9.1. -Butch 1

2009-05-25T23:30:06Z

7 ruby on rails, ruby, rails, multi model form, form, tutorial

lets build some trains to go with our rails!

Rails Multi-Model Forms Tutorial

2009-07-04T21:39:51Z

Refactoring a project in Rails can be a handful, especially when the original database does not conform to Rails standards. Lately, I've found it much quicker to simply redesign the data model, and migrate the data from the old database. I've had to tackle this problem a couple of times now, and feel like I've refined the process a great deal. I don't know if this is the correct way of doing things, I'm just saying, it works for me. <h4>Step #1 - Map the legacy database</h4> <ol> <li>Create a new file under config/initializers called legacy.rb</li> <li>Create a new module, we'll call it "Legacy" <code> module Legacy end </code> </li> <li>Map your original database as best you can to rails models. <code> module Legacy     class ActiveRecordLegacy < ActiveRecord::Base         self.establish_connection(             :adapter => 'mysql',             :host => 'localhost',             :username => 'username',             :password => 'password',             :database => 'legacy_database'         )     end     class LegacyTable < ActiveRecordLegacy         set_table_name :legacy_table         set_primary_key :LegacyTableID     end end </code> </li> </ol> <h4>Step #2 - Create your migration script</h4> <ol> <li>Create a new file model under app/models called migrate.rb <code> class Migrate end </code> </li> <li>Fill in your migration steps! <code> class Migrate     def self.run         Migrate.migrate_legacy_table()     end     def self.migrate_legacy_table         Legacy::LegacyTable.find(:all).each { |record|              # Do some nifty migrations here         }     end end </code> </li> <li>Load up the rails console: ruby ./script/console <code> >> Migrate.run </code> </li> </ol> Again, I don't know if this is the "correct" method, it's just how I do things. -Butch 1

2009-05-01T20:32:11Z

Migrating from a Legacy Datasource

2009-05-01T20:32:17Z

I love Ruby! I've always loved Ruby, but today's discovery just reaffirms the validity of my devotion. I may need to watch my words in the future. My girlfriend (like all girlfriends) doesn't like competition, and I wouldn't want any harm to come to my beloved Ruby. This handy little trick was picked up from Josh Susser over at <a href='http://blog.hasmanythrough.com/'>has_many :through</a>. His post <a href='http://blog.hasmanythrough.com/2006/8/19/magic-join-model-creation'>Magic join model creation</a> goes over a lot of the details, but needed a little updating for Ruby 1.9.1 and Rails 2.0. We've all run across the situation: two tables, many to many association, but one model can have many 'types' of another. To better explain what I'm getting at take this example: <code>People <-n --- n-> Book</code> A person has many books, a book has many people. Simple enough, right? Well, sort of. I'm sure those people associated with a book can have any number of affiliations that we may want to capture in our data model. <code>Author <-n --- n-> Book</code> <code>Editor <-n --- n-> Book</code> <code>Reviewer <-n --- n-> Book</code> All of these associations (author, editor, reviewer) are people, and all are associated with our book in some way or another, but creating the individual tables (book_authors, book_editors, book_reviewers) isn't my ideal solution to this problem, and there's a better way. Instead of creating all of those join tables, lets just make one: "book_people". <code> create_table :book_people do |t|     t.column :person_id, :integer     t.column :book_id, :integer     t.column :person_type, :string     t.timestamps end </code> In model "People". <code> class Person < ActiveRecord::Base     has_many :book_people, :dependent => :destroy     has_many :books, :through => :book_people end </code> In model "Book" <code> class Book < ActiveRecord::Base     has_many :book_people, :dependent => :destroy     has_many :people, :through => :book_people, :uniq => true     has_many :authors, :through => :book_people, :source => :author, :conditions => ["`book_people`.contact_type = ?","Author"] do         def <<(author)             BookPeople.send(:with_scope, :create => { :contact_type => "Author" } ) { self.concat author }         end     end     has_many :editors, :through => :book_people, :source => :editor, :conditions => ["`book_people`.contact_type = ?","Editor"] do         def <<(editor)             BookPeople.send(:with_scope, :create => { :contact_type => "Editor" } ) { self.concat editor }         end     end end </code> And finally, in model "BookPeople" <code> class BookPeople < ActiveRecord::Base     belongs_to :person     belongs_to :book     belongs_to :author, :class_name => "Person", :foreign_key => :person_id     belongs_to :editor, :class_name => "Person", :foreign_key => :person_id end </code> Amazing! Three tables, infinite association types! This model is superior to the many association tables model in a number of ways: <ol> <li>If you simply want to find out all books a person is associated with, regardless of granularity, person.books works nicely! One table, one query.</li> <li>The Person model can be extended. Associations such as person.authored_books, person.edited_books etc. are easy to add.</li> <li>Clean database - I always try to get away with as few tables as possible.</li> </ol> Now, I just hope this code works properly. -Butch 1

2009-04-21T18:24:23Z

fancy dancy many-to-many model associations!

Has_Many :Through - Setting a type on the join table

2009-04-21T18:24:23Z

Well, my blog as officially gone live, and it's kind of fitting that my first post has to do with deploying Ruby on Rails websites. Ever received this error while deploying a Phusion Passenger site? <center><img src="/system/images/passenger_error_message.jpg" title="Phusion Passenger Error - no such file to load" alt="Phusion Passenger Error - no such file to load" /></center> I did! The file existed, so I hope my bewilderment is forgivable. After 20 minutes of poking around, it finally occurred to me: check who owns the folder! My Capitrano deploy makes whatever user account that deployed the release the owner of that release. Passenger does not like this if that owner doesn't happen to be Apache. The lesson for today? Make sure that www-data, apache, or whatever user Apache is installed under owns all of the folders! -Butch 1

2009-04-16T00:36:35Z

1 ruby on rails, ruby, rails, passenger

Don't forget to chown!

Passenger with a Capistrano Deployment

2009-07-04T21:40:19Z