# in config/routes.rb
  map.resources :first_resources do |first|
    first.resources :second_resources do |second|
      second.resources :third_resources
    end
  end

Here FirstResouce has_many SecondResources and SecondResource has_many ThirdResources. Now imagine how you would get the path to edit the third level resource. You’d have to write something like this:

edit_first_resource_second_resource_third_resource_path(@first_resource, \
    @second_resource, @third_resource)

Yes, that’s how bad it would look when the routes are written for the innermost resource in the routes.

When I found myself doing something similar a few days ago, I decided to look for a better way to do this, and it amazes me how I missed this simple (and universally used) approach to writing nested resource routes.

Let’s take the example of a school where each course would have many batches, and each batch would have many exams.

# app/models/course.rb
class Course < ActiveRecord::Base
  has_many :batches
end

# app/models/batch.rb
class Batch < ActiveRecord::Base
  belongs_to :course
  has_many :exams
end

# exam.rb
class Exam < ActiveRecord::Base
  belongs_to :batch
end

Writing the routes with two levels of nesting would give me something like this:

  # config/routes.rb
  map.resources :courses do |course|
    course.resources :batches do |batch|
      batch.resources :exams
    end
  end

The route to edit an exam object @exam (belonging to batch @batch which in turn belongs to course @course) would look like this:

edit_course_batch_exam_path(@course, @batch, @exam)

This is way too long and rather than make it easy to understand the path, it is going to make it even more confusing when somebody tries to understand the path. The url is going to be something like http://domain.com/courses/1/batches/1/exams/1/edit.

The best solution in this case is to nest the resources to just one level so that batches a nested within courses (e.g. http://domain.com/courses/1/batches) and exams are nested only within batches (e.g. http://domain.com/batches/1/exams). Using a rails shortcut to define nested routes, we could write the routes like this:

  # in config/routes.rb
  map.resources :courses, :has_many => :batches
  map.resources :batches, :has_many => :exams

Now if you wanted to edit an exam resource, you could just write edit_batch_exam(@batch, @exam) without having to worry about specifying the course object in the route. If you needed the course object within the exams controller, all you need to do is write a before filter that loads the batch and course as shown here:

# app/controllers/exams_controller.rb
class ExamsController < ApplicationController
  before_filter :load_batch_and_course

  # RESTful actions

  private
  def load_batch_and_course
    @batch = Batch.find(params[:batch_id])
    @course = @batch.course
  end
end

Since we can get the course_id from the batch, there is no need for us to have the course_id in the route. This makes the routes much easier to understand.

Have you come across any situation where nesting more than one level is absolutely necessary? (I couldn't imagine any such situation off the top of my head.) How many levels of nested resources are okay with you? Do leave a comment and tell me what you think.

Day 1

Along with the rest of the team from Foradian, I took a bus to Bangalore the night before the conference and promptly got late and missed the kick off to the conference by Roy Singham.

Ola Bini presented a keynote on the present and future of programming languages. Despite the fact that we had to struggle to keep up with the references to languages we hadn’t heard of, Ola kept the talk very interesting.

Me and Aslam with Obie Fernandez at RubyConf India 2010

Ola’s talk was followed by a session by Obie Fernandez titled “Blood, Sweat and Rails 2010″. Obie was funny and controversial, and even got rebuked for “abusive language”. (Aw, c’mon organizers… you can’t invite someone to speak and then shout at them.) He spoke about agile and Hashrocket and shared a lot of anecdotes about his work in Hashrocket. There were plenty of funny pictures from Hashrocket offices and one or two from the movie 3 Idiots that got the crowd roaring with laughter.

In the afternoon, Matz joined in through video conference and spoke about Ruby. To hear the story of Ruby from the guy who created it was… well… awesome. He spoke about Ruby’s history and also the future of the language. Matz even mentioned that work on Ruby 2 will start in August after version 1.9.2 is completed.

I attended a couple of other talks on the day — Ruby on Rails versus Django – A newbie Web Developer’s Perspective by Shreyank Gupta and Mortal Kombat: Developer vs. Designer by Kapil Mohan and Arun J. Having two tracks meant that I had to sacrifice some very interesting talks in favor of others. Hopefully the videos will be uploaded soon and I’ll be able to catch the other talks.

Day 2

With Nick Sieger at RubyConf India 2010.

The first speaker on the second day was Nick Sieger from Engine Yard who spoke about the features of Rails 3. It was a great talk, and I am feeling more and more guilty about not having tried Rails 3 yet.

Pradeep Elankumaran then spoke about entrepreneurship in India and it was one of the most interactive sessions in RubyConf. He gave quite a few pointers on how to go about building web applications very quickly and about the tools they use at Intridea. I probably scribbled more on the notepad in this session than in all the other sessions combined.

In the afternoon, we attended a talk by Sarah Taraporewalla on the drawback of current view templating systems followed by another talk by Pradeep Elankumaran on Message Queuing in Ruby.

Brian Guthrie’s talk, “Advanced Ruby Idioms So Clean You Can Eat Off Of Them”, although a bit too advanced for newbies like us, was still very interesting. Brian kept the talk very lively with a lot of jokes — many of which the audience sadly missed. The sequence of slides at the end of the presentation with alternate slides in red and green backgrounds with “TEST” written in bold letters made a huge impact on the team on the importance of testing. If only I’d know this method would work so efficiently, I’d have done that long ago. :D

After Brian’s talk, we went to see Arvind’s presentation on Project Fedena which started a little late and therefore we had to run over to the other hall to catch Roy Singham’s closing note.

Ruby v/s Rails

Roy spoke about agile, software development, the ruby community and entrepreneurship. Towards the end of the talk, there was a disagreement between him and Obie Fernandez over the attitudes in the rails community. I have to agree with Obie that you cannot blame the entire Rails community for incidents like that presentation at the Golden Gate Ruby conference. In my opinion, Roy’s ranting against the rails community is only going to leave the community more polarized than before.

Women’s attendance at RubyConf

One thing that shocked me was when Roy Singham mentioned that the attendance of women at this RubyConf — 28 — was the highest ever at any RubyConf. I always knew this wasn’t a particularly women-friendly environment, but I didn’t know things were so bad that a 7% attendance would break all records for Ruby conferences.

Conclusion

Overall, it was a fantastic experience. To get an opportunity to actually speak to guys like Obie Fernandez, Satish Talim and Ola Bini is something I wouldn’t have believed possible a few months ago. I’m still mad at the organizers for interrupting Obie’s talk, but at least we have to be thankful that we got to hear all these people speak.

Did you attend RubyConf? If so, what did you think of the event? What’s your opinion on the whole ruby v/s rails controversy? What about the censoring of respected speakers? What did you like best about the event? Please do leave a comment.

We’ve been playing around with a very basic version of the app in development for some time now, but we decided to code it again from scratch sometime in February, and try to release it by the first of March. Things got delayed a little bit and we finally deployed it last weekend.

As of now, the application is very basic, and doesn’t even let users add books that aren’t on our database. We even left out commenting on others’ reviews until we could sort out the user interface, so the “social” part of this social networking site is still missing. However, we’re planning to roll out these features over the next few weeks, and we’ll start working on it again once we’ve returned from Bangalore after RubyConf ndia 2010.

Working on our own application has been great fun so far. But working on your own projects during spare time can be a difficult thing when you have a day job. It’s easy to put too much energy into your own project and then your projects at work will suffer. This is why we’ve been adding features very slowly and not work too many hours on this, so we don’t lose focus at the office.

Please do take a look at bukluv if you’re a book lover. We’d love the feedback. Let us know what you think we’re doing wrong with the application.

I’m off to catch a bus to Bangalore now. Feeling so excited about my first RubyConf. There are some great presentations scheduled, and of course, there’s the one about Project Fedena. Please do leave a comment here if you took a look at bukluv, and I’ll reply when I get back from Bangalore.

I’ve never had to use SEO friendly URLs in my projects so far and I assumed that generating these URLs is very complicated and some plugin might be at work. And like always, Rails proved me wrong and I’m amazed at how simple this is.

Suppose you had a RESTful resource called posts that had title and content fields. If you wanted the post page URLs to contain text from the title, you just have to add this to_param method to the Post model:

class Post
  # other stuff here

  def to_param
    "#{id}-#{title.gsub(/[^a-z0-9]+/i, '-')}"
  end
end

Now if you had a post whose title was “SEO friendly URLs”, and in your view you had <%= link_to @post.title, @post %> where @post is an instance of the Post model representing the “SEO friendly URLs” post. This will generate the following path: /posts/1-SEO-friendly-URLs.

As explained in Obie’s post, this will only work if you pass an instance of Post as the id parameter and the actual id itself. You don’t have to change anything in the controller to make this work.

This is just another one of those little tricks I discovered in rails that originally looked difficult but is actually incredibly easy to accomplish.

This is the first edition of RubyConf India and there were surprisingly few tickets — just 150. I was worried we wouldn’t manage to get tickets, but registering early in the morning helped. From the number of mentions it has been getting on twitter today, I guess it will be sold out before the end of the day.

Apart from keynote addresses by Chad Fowler and Ola Bini, there are quite a few big names speaking at the event. So I’m even more delighted that Fedena will also be presented there. I’ve been working on the Fedena developer community all week and we’ll hopefully have projectfedena.org ready by the time we leave for Bangalore.

I came across Thinking Sphinx plugin for full text search over MySQL and Postgres databases. It connects ActiveRecord to the Sphinx search engine and lets you perform searches over multiple columns and even multiple models easily.

Things went rather smoothly when I tried using the plugin and I managed to set it up and running within a few minutes. Here’s how I set up an example application and tested sphinx.

1. Download sphinx from here. If you’re on windows, you just have to extract the exe files to ruby/bin directory. On, Linux/Mac, you’ll have to compile the source. (See instructions here.)
2. Install the thinking_sphinx plugin like this:

   script/plugin install git://github.com/freelancing-god/thinking-sphinx.git

   You might run into trouble on Windows with the script/plugin install, so you can use this instead.

   ruby script/plugin install http://github.com/freelancing-god/thinking-sphinx.git/

3. For this example, let’s quickly set up a Post model through scaffolding.

   ruby script/generate scaffold Post title:string body:text

4. Now we’ll set up the indexes for the posts model like this:

     define_index do
       indexes title, body
     end

5. In the index method in PostsController, change Post.all to this:

   Post.search(params[:search])

6. Add a simple search form in articles/index.

   <% form_tag posts_path, :method => 'get' do %>
     <p>
       <%= text_field_tag :search, params[:search] %>
       <%= submit_tag "Search", :name => nil %>
     </p>
   <% end %>
   

7. Now we have to run a couple of rake commands to get sphinx to work. To get sphinx to process the data, run this rake task:

   rake thinking_sphinx:index

   To start the sphinx server:

   rake thinking_sphinx:start

8. Now if you search for something using the form, the page returns the posts matching your query.

It also allows you to search across multiple models that are related. For example, if a post has many comments, you could change define_index to search comments as well.

  define_index do
    indexes title, body
    indexes comments.body :as => :comments_body
  end

Sphinx also has support for delta indexing, which means that rather than index the entire table, it can index only those rows that have been added since the last index. You need to schedule the indexing according to your application’s requirement. There’s a nice little gem called whenever that will allow you to schedule the rake tasks in ruby.

What plugins have you used for full text search in rails? Have you tried Sphinx? Or ferret or solr? I’ve mostly heard people saying sphnx is better than solr or ferret. What do you think?

Update. I’ve put the source code for this example on github.

1. The file will have to be in CSV format, so you’ll have to open it with any spreadsheet application like Microsoft Excel (or Google Docs in my case) and save it as CSV. Put the file in your project folder.
2. FasterCSV is a ruby gem that lets you easily parse CSV files and is a faster alternative to ruby’s standard CSV library. Install it using the command:

   gem install fastercsv
   

3. Create a rake task that reads the CSV file using the fastercsv gem and saves the data in the database. Your code should look something like this:

   namespace :db do
   
     desc "load user data from csv"
     task :load_csv_data  => :environment do
       require 'fastercsv'
   
       FasterCSV.foreach("data.csv") do |row|
         User.create(
           :user_name => row[0],
           :email => row[1],
           :password => row[2]
         )
       end
     end
   end
   

   You can replace the User model here with whatever model you’re importing from the CSV file.

4. Save the task as a rake file in lib/tasks folder and name it import_csv_data.rake or something to that effect.
5. Go to the shell and run the task by:

   rake db:load_csv_data
   

When I came across this problem, my first reaction was to look for a ruby library that reads spreadsheets directly. But that’s a challenge for another day. For this particular project we can manually save the spreadsheets as CSV.

I did find a library called roo (http://roo.rubyforge.org/) that can access the contents of a spreadsheet directly and it might be worth looking into if you need to read an uploaded spreadsheet directly.

Have you had to do something similar in your projects? What other method would you suggest to accomplish this task?

I realized that setting up a Rails environment might seem a daunting task for a newbie. Here’s a list of steps to get Ruby on Rails working on a windows machine. I use NetBeans with MySQL because I found the least trouble to set up.

1. Go to www.ruby-lang.org and download the ruby one-click installer for Windows.
2. Install ruby using the one-click installer, and remember to select RubyGems when asked what components you want installed.
3. Download and install MySQL from http://dev.mysql.com/downloads/.
4. You will need java to run NetBeans, so download java from http://www.java.com/en/ and install.
5. Download the latest version (6.7 at the moment) of NetBeans from http://www.netbeans.org/. You might choose the complete NetBeans package or the Ruby only version. Either of them will do.
6. Install rails for your ruby installation by using this command in the command line:

   gem install rails

7. You will also need the ruby MySQL driver to be installed to be able to use MySQL databases. For this, install the mysql gem by this command:

   gem install mysql

8. When I started NetBeans and created a new rails project, NetBeans asked me to update ruby gems from 1.3.1 to 1.3.2. Unfortunately, the one click installer is available only for Ruby 1.8.6 and contains gem version 1.3.1, so you’ll have to update rubygems using the command line:

   gem update --system

That’s it… you can now use NetBeans as a rails development environment. I know that was a very long list of steps to get a rails IDE working, but it’s worth the trouble. Using ruby on rails as your development environment will make up for the effort required to set up the IDE.

What IDE do you use for rails development? When you were new to rails development, did you have trouble setting up a development environment? And in case you’re a newbie rails developer, is that how you got here?

Normally, you wouldn’t want to encrypt the source code of your ruby applications. The code resides on your server and there’s no way anyone else can access it. However, if you are going to allow others to host your code on their own servers, you might want to obfuscate your code so that nobody can see it.

I signed up for the free trial of Ruby Encoder and so far I’ve been impressed with how easy it is to set it up for use with the ruby on rails application I’m working on. It took me less than ten minutes to encrypt all the ruby files and run the project on the development machine.

Ruby Encoder works by encrypting the ruby source into bytecode and then decrypts this encrypted code using a loader (which is an compiled ruby module) and sends it to the interpreter. This way, all anyone will get to see in your .rb files will be a lot of gibberish and a call to the loader function.

I haven’t really had the time to check it out thoroughly and I don’t know how well it will work in production, but right now it looks like the best option (and probably the only option?) for what I am trying to accomplish.

I was discussing Ruby Encoder with a friend and one very valid argument that came up was about how far such software could help if someone really wanted to clone our application. If someone wanted to steal our code, they most likely would be capable of coding the application by themselves by looking at the views of the application. So is it really worth the trouble to use an application like Ruby Encoder just to make things a little bit more difficult for them?

What do you think of ruby source code encryption? Have you ever used Ruby Encoder or similar products for any of your projects? If so, how well has it worked for you? Do you think using such an application is a good idea?

What method would you employ if you had to ensure that your ruby code remained closed source?

I tried a few things, like restarting NetBeans, and opening another project to see if the problem was with my Ruby installation. (Other projects were running fine, so the problem wasn’t with Ruby.) I even tried running the project from another desktop, getting the same 500 error.

Finally, I did the one thing that I should have done first – checking the development log file. There I found that the problem was a tiny bit of buggy code in the application.rb file that was stopping the project from initializing properly. And because the application failed to initialize, I wasn’t getting those detailed error messages that I’m so familiar with.

Have you done something so stupid while developing an application? Forgetting to look at the first place where you could have spotted the problem and instead wasting an hour theorizing about what could be causing the problem?