Raymond Law: Tag ruby

Sanitize your output in Ruby on Rails

Raymond Law — Thu, 30 Oct 2008 14:37:00 -0400

We all know about the holy h() method that escapes your output when you do <=h blah %>. But how many of us can claim we remember to use it where it’s appropriate during development 100 of the time? Can you swear you’ve never missed one? Moreover, it’s such a mental distraction to think logic and h() at the same time. And when you take over a Rails project in the middle, how can you ensure the previous developers use h()?

Here’s the rescue.

safe_erb + footnotes

I don’t think I need to explain more. Just use it and you will find all those places where you should sanitize your output with h(), sanitize(), and untaint(), ...etc.

RailsRumble 2008

Raymond Law — Sun, 19 Oct 2008 19:40:00 -0400

We just finished the Lyricist application for RailsRumble 2008 with 3 other Intridea folks. Here are some observations:

Keep the idea small and achievable – There are only 48 hours, so you can’t build the next Google. And there’s pressure. Try to keep your idea small and make sure you can accomplish it. You have to deploy a finished product in order to have any chance of winning. So stop day dreaming about cool extra features because you won’t get that implemented.

Prior planning is the key – We barely had any because we had decided on the idea the day before the rumble began. When the competition started, people don’t know who’s doing what and it was kinda a mess. Fortunately we had a campfire room where all conversation happen, so we can kind of iron out the issues. However, better preparation and team cohesiveness would have helped a great deal in communication.

Deploy early – I’ve seen too many deployment problems came up before, so I took the initiative to make sure we could deploy as soon as the competition began. It helped tremendously because we never had to worry about if we could deploy before time expired. While you are fixing last minute bugs and the pressure, it would have been tough to set up a server and deploy flawlessly.

A lot of scaffolding – I took full advantage of Rails scaffolding. There’s just no time to reinvent the wheels when all the restful model and controller methods are already available with just one command. You use plugins and gems for the same reason, right? So, don’t be stupid.

Conflicts – The bigger your team, the more conflicts there would be when people check in and out. We were writing a new application, so people were editing the same files. Now, if you organize and assign work to people as in a regular project, conflicts don’t usually happen and even if they do occur, it is trivial to resolve. However, when you are rumbling, you will step on one another’s toes. I can guarantee you that.

Forget about writing tests – Look, I am in support of agile and test-driven development, with one exception. That is, you are not participating in RailsRumble. There’s just no time for it. If you are a good enough programmer, you can build a small application with no tests. If you can’t, I don’t want to work with you. Writing tests for a new application starting from scratch in just 48 hours is simple not feasible. No bargain!

No ticketing system like Unfuddle and Lighthouse – One team member had tried to use Unfuddle to create tickets to get ourselves more organized. While it was a sincere attempt, it simply didn’t work. There’s no time to accept a ticket, create a new ticket, ... We pretty much abandoned it soon after we started.

Nice to have a designer: – It is very nice if you have a designer on you team because it’s hard to wear two hats in 48 hours. Design work can draw your focus away from development.

Now that I’ve given you my insights for next year’s RailsRumble. As a token of appreciation, please vote for us!

UPDATE 2008/10/20

One more thought on RailsRumble the day after:

Numerous projects that I worked with before never deploy quickly, let alone in 48 hours. I think it’s refreshing and rewarding to have something built and deployed so quickly. It is true that we have to cut many features in order to deploy a first version, but lesser is better than never. I think many other projects can try to deploy early and often and just go through more iterations and get feedbacks from users and customers. The whole application doesn’t need to be finished. Even if you only have login and logout, you can still deploy. Add the next feature, deploy again. That way, you aren’t keeping the features to yourself. You can get feedback from users to see what improvements they are looking for and may even lead you to implement the real features that they truly want.

Capistrano Deployment Recipes

Raymond Law — Mon, 04 Aug 2008 17:30:00 -0400

Dealistic was first deployed to Slicehost when we were testing it on staging. However, I only got the 256 slice and low memory is a big problem for Ruby and Mongrel. We’ve moved to Amazon EC2 when we launched. It is running rock solid and we don’t run out of memory again, at least for now :P

As a result of all these, I wrote two Capistrano recipes for deployment, for both Slicehost and EC2. We also use GitHub for version control. I think these deployment recipes may be helpful to others. So here they are:

We wrote some custom Capistrano tasks to copy over configuration files, symlink plugins, start/stop BackgrounDRb, and a custom maintenance page. But these things are optional. It should be simple to add/remove things as you see fit.

Ruby Performance Benchmarking

Raymond Law — Wed, 09 Jul 2008 20:55:00 -0400

Courtesy of igvita.com

require 'benchmark'

n = 1000000
Benchmark.bm do |x|
  x.report('copy') { n.times do ; h = {}; h = h.merge({1 => 2}); end }

  x.report('no copy') { n.times do ; h = {}; h.merge!({1 => 2}); end }

  x.report('map(&:id)') do
    n.times do |i|
      h = {}
      h.map(&:object_id)
    end
  end

  x.report('map { |i| i.id }') do
    n.times do |i|
      h = {}
      h.map { |e| e.object_id }
    end
  end
end

In Rails script/console or Ruby 1.9:

>> load '/Users/rlaw/Desktop/bm.rb'
      user     system      total        real
copy  4.000000   0.020000   4.020000 (  4.081549)
no copy  2.780000   0.010000   2.790000 (  2.818923)
map(&:id) 10.880000   0.040000  10.920000 ( 11.094024)
map { |i| i.id }  2.060000   0.020000   2.080000 (  2.178544)
=> []

Deploying your Rails applications with Phusion Passenger

Raymond Law — Tue, 24 Jun 2008 10:00:00 -0400

There have been several methods to deploy an Ruby on Rails application. Until recently, the most popular is to run Apache and proxy balance to multiple Mongrel instances that are running simultaneously.

Passenger, developed by Phusion, is the new kid entering the Rails deployment market. We have been using the Apache PHP module for years and deploying a PHP applications is a snap. This has not been possible with Rails until Passenger. It is so easy too! You can still use Capistrano to automate deployment. I will show you how I get it to work on Ubuntu.

sudo gem install passenger
passenger-install-apache2-module

Update: Phusion just released Passenger 2.0 RC 1. You can download this version and do gem install passenger-1.9.0.gem instead. But I had an error compiling it on Mac OS X Leopard. hongli pointed me to use the version from GitHub that has the fix and it works like a charm. Thanks Phusion guys.

To get it from GitHub:

git clone git://github.com/FooBarWidget/passenger.git

I create a separate /etc/apache2/mods-available/passenger.load and it contains the following:

For 1.0.5:

LoadModule passenger_module /usr/local/lib/ruby/gems/1.8/gems/passenger-1.0.5/ext/apache2/mod_passenger.so
RailsSpawnServer /usr/local/lib/ruby/gems/1.8/gems/passenger-1.0.5/bin/passenger-spawn-server
RailsRuby /usr/local/bin/ruby

For the GitHub version (Of course the path will look different depending on where your git clone is):

LoadModule passenger_module /home/rlaw/downloads/passenger/ext/apache2/mod_passenger.so
PassengerRoot /home/rlaw/downloads/passenger
PassengerRuby /usr/local/bin/ruby

I then tell Apache to load the Passenger module:

a2enmod passenger

Now, I create a virtual host configuration for one of my Rails app in /etc/apache2/sites-available/dealistic:

<VirtualHost *:80>
  ServerAdmin webmaster@dealistic.com
  ServerName dealistic.com

  DocumentRoot /home/deploy/apps/dealistic/current/public

  <Directory /home/deploy/apps/dealistic/current/public>
    Options FollowSymLinks
    AllowOverride None
    Order allow,deny
    Allow from all
  </Directory>

  LogLevel warn
  ErrorLog /var/log/apache2/dealistic/error.log
  CustomLog /var/log/apache2/dealistic/access.log combined
</VirtualHost>

I then restart Apache:

sudo /etc/init.d/apache2 reload

When you need to restart your application because you have changed some code that Rails does not reload in production, just do:

touch /home/deploy/apps/dealistic/current/tmp/restart.txt

I have not tried their Ruby Enterprise Edition yet. They claim substantial memory and speed improvement at RailsConf 2008, so it will be interesting to see.

Badger Rails Plugin

Raymond Law — Mon, 23 Jun 2008 10:00:00 -0400

(I also posted about this plugin in the Intridea blog )

Badger (hosted at GitHub) is a simple Rails plugin that creates badges. A site often allows its users to upload a profile image. A profile image is just that, an image resized to fit in a predefined space to show up in the user’s profile.

With Badger, you can have something prettier – a badge that shows the user-uploaded image on top of another image that identifies the user as a part of the community. We have company badges, security badges, so why not web badges to have your users show off his/her affection for your site?

Badger works by accepting cropping parameters of the overlay image in a hash (x1, y1, width, height), which is used to crop the overlay image. It then resizes the cropped image to the size specified by composite_width and composite_height in badger.yml. Finally, it places the resized image on top of the background image at location specified by composite_x and composite_y in badger.yml. The resulting image is saved back to either the filesystem or Amazon S3, using attachment_fu.

Badger requires the attachment_fu plugin, ImageMagick, and MiniMagick. Also, the JavaScript Image Cropper UI can be used to obtain the cropping parameters from the users.

For example:

+ =

Here I overlay RUBY on top of JAVA to produce I LOVE RUBY.

Back from RailsConf 2008

Raymond Law — Wed, 04 Jun 2008 11:31:00 -0400

Photos posted to my flickr.

Attending RailsConf 2008

Raymond Law — Fri, 23 May 2008 16:29:00 -0400

I will be attending the RailsConf from 5/29 to 6/1 in Portland with my colleagues from Intridea. It is going to be great to see the whole team there, and attend the different sessions. I am really excited to meet other Rails enthusiasts and talk about projects we are working on.

We will be helping with the Community Project Code-Drive on 5/29 from 10am to 5pm. Come check us out.

Josh Owens and Chris Selmer will also be presenting Building an app in 48 hours – A Rails Rumble Case Study to talk about their fast developments in their participation of the Rails Rumble event. Josh won first place with Tasty Planner in the event! Chris participated as a solo team on Your Pet Records. Come attend their session to see how they developed an app in just 48 short hours!

Tricky Git Submodule

Raymond Law — Tue, 29 Apr 2008 01:03:00 -0400

I recently spent a good amount of time figuring out why the acts_as_taggable_on plugin did not work for me. I used Git’s submodule to grab the code fom GitHub.

> git submodule add git://github.com/mbleigh/acts-as-taggable-on.git vendor/plugin/acts-as-taggable-on

It seems logical to name my plugin directory with dashes since that’s what the path suggests, right? Wrong! If you do that, it does not work because the plugin expects underscores. This is probably due to the way Rails finds and loads the plugins, I guess. Haven’t had time to really dig deep into that…

Use this instead:

> git submodule add git://github.com/mbleigh/acts-as-taggable-on.git vendor/plugin/acts_as_taggable_on

I initially didn’t pay attention to this because before Git, I just used:

> script/plugin install http://svn.intridea.com/svn/public/acts_as_taggable_on/

I did not have to explicitly tell where to put the plugin. script/plugin is a Rails thing while Git is not.

Hopefully anyone who gets tripped up by this in the future will find out this post.

Using Git Branches and Stash

Raymond Law — Sun, 27 Apr 2008 10:50:00 -0400

I recently started to learn and use Git for one of my projects. Git encourages easy and cheap branching, here’s what I do with Git branches and stash to switch between branches while working on different things.

Assume we want to develop yet another blog engine with Rails:

Create the application. No surprise here!

> rails -d mysql blog
> cd blog

Initialize the Git repository. This will create a .git/ directory in your project.

> git init
Initialized empty Git repository in .git/

Add everything in your project directory for the next commit to Git.

> git add .

Lets see what will be commited.

> git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#    new file: README
#    new file: Rakefile
#    new file: app/controllers/application.rb
#    new file: app/helpers/application_helper.rb
#    new file: config/boot.rb
#    new file: config/database.yml
#    new file: config/environment.rb
#    new file: config/environments/development.rb
#    new file: config/environments/production.rb
#    new file: config/environments/test.rb
#    new file: config/initializers/inflections.rb
#    new file: config/initializers/mime_types.rb
#    new file: config/routes.rb
#    new file: doc/README_FOR_APP
#    new file: log/development.log
#    new file: log/production.log
#    new file: log/server.log
#    new file: log/test.log
#    new file: public/.htaccess
#    new file: public/404.html
#    new file: public/422.html
#    new file: public/500.html
#    new file: public/dispatch.cgi
#    new file: public/dispatch.fcgi
#    new file: public/dispatch.rb
#    new file: public/favicon.ico
#    new file: public/images/rails.png
#    new file: public/index.html
#    new file: public/javascripts/application.js
#    new file: public/javascripts/controls.js
#    new file: public/javascripts/dragdrop.js
#    new file: public/javascripts/effects.js
#    new file: public/javascripts/prototype.js
#    new file: public/robots.txt
#    new file: script/about
#    new file: script/console
#    new file: script/destroy
#    new file: script/generate
#    new file: script/performance/benchmarker
#    new file: script/performance/profiler
#    new file: script/performance/request
#    new file: script/plugin
#    new file: script/process/inspector
#    new file: script/process/reaper
#    new file: script/process/spawner
#    new file: script/runner
#    new file: script/server
#    new file: test/test_helper.rb
#

Lets do our first commit.

> git commit -m 'Initial commit'
Created initial commit aa5e7a0: Initial commit
 43 files changed, 8362 insertions(+), 0 deletions(-)
 create mode 100644 README
 create mode 100644 Rakefile
 create mode 100644 app/controllers/application.rb
 create mode 100644 app/helpers/application_helper.rb
 create mode 100644 config/boot.rb
 create mode 100644 config/database.yml
 create mode 100644 config/environment.rb
 create mode 100644 config/environments/development.rb
 create mode 100644 config/environments/production.rb
 create mode 100644 config/environments/test.rb
 create mode 100644 config/initializers/inflections.rb
 create mode 100644 config/initializers/mime_types.rb
 create mode 100644 config/routes.rb
 create mode 100644 doc/README_FOR_APP
 create mode 100644 log/development.log
 create mode 100644 log/production.log
 create mode 100644 log/server.log
 create mode 100644 log/test.log
 create mode 100644 public/.htaccess
 create mode 100644 public/404.html
 create mode 100644 public/422.html
 create mode 100644 public/500.html
 create mode 100755 public/dispatch.cgi
 create mode 100755 public/dispatch.fcgi
 create mode 100755 public/dispatch.rb
 create mode 100644 public/favicon.ico
 create mode 100644 public/images/rails.png
 create mode 100644 public/index.html
 create mode 100644 public/javascripts/application.js
 create mode 100644 public/javascripts/controls.js
 create mode 100644 public/javascripts/dragdrop.js
 create mode 100644 public/javascripts/effects.js
 create mode 100644 public/javascripts/prototype.js
 create mode 100644 public/robots.txt
 create mode 100755 script/about
 create mode 100755 script/console
 create mode 100755 script/destroy
 create mode 100755 script/generate
 create mode 100755 script/performance/benchmarker
 create mode 100755 script/performance/profiler
 create mode 100755 script/performance/request
 create mode 100755 script/plugin
 create mode 100755 script/process/inspector
 create mode 100755 script/process/reaper
 create mode 100755 script/process/spawner
 create mode 100755 script/runner
 create mode 100755 script/server
 create mode 100644 test/test_helper.rb

Our project is in the Git repository now. Lets see what branches it currently has.

> git branch
* master

It only has one branch called master, which is the default branch created by Gik, a.k.a. Subversion’s trunk.

Our blog is going to have posts and comments. So we probably should create the Post and Comment resources. Before we do that, lets do some forward thinking. While working on the blog, we likely will be working with posts and comments at the same time. It will be confusing and unnessarily consume our brain cells if we were to remember which files and changes are for fixing a bug in posts or comments. It may be a good idea to create separate branches for working on posts and comments. So lets do that first.

> git branch posts
> git branch comments

Use gitk to show a visual picture of where we are.

> git branch
  comments
* master
  posts

So we have three branches: master, posts, and comments. We are currently working in the master branch. Great!

Lets switch to the posts branch.

> git checkout posts
Switched to branch "posts"
> git branch
  comments
  master
* posts

We are now ready to generate our resources

> script/generate resource post title:string body:text published:boolean

And add and commit these new files to our Git repository.

> git add .
> git commit -m 'Created Post resource'
Created commit 1ec37dc: Created Post resource
 8 files changed, 50 insertions(+), 0 deletions(-)
 create mode 100644 app/controllers/posts_controller.rb
 create mode 100644 app/helpers/posts_helper.rb
 create mode 100644 app/models/post.rb
 create mode 100644 db/migrate/001_create_posts.rb
 create mode 100644 test/fixtures/posts.yml
 create mode 100644 test/functional/posts_controller_test.rb
 create mode 100644 test/unit/post_test.rb

If we switch back to our master branch, we find that the Post resource we just created is gone! Don’t worry. They are in the posts branch but not in the master branch. Gitk shows this.

Lets switch to the comments branch and create the Comment resource.

> git checkout comments
Switched to branch "comments"
> script/generate resource comment name:string blog:string body:text
> git add .
> git commit -m 'Created Comment resource'
Created commit 7f110d3: Created Comment resource
 8 files changed, 50 insertions(+), 0 deletions(-)
 create mode 100644 app/controllers/comments_controller.rb
 create mode 100644 app/helpers/comments_helper.rb
 create mode 100644 app/models/comment.rb
 create mode 100644 db/migrate/001_create_comments.rb
 create mode 100644 test/fixtures/comments.yml
 create mode 100644 test/functional/comments_controller_test.rb
 create mode 100644 test/unit/comment_test.rb

Now we created a Post resource in the posts branch and a Comment resource in the comments branch. We want to merge them back together to the master branch.

> git checkout master
Switched to branch "master"
> git merge posts
Updating c680d0c..1ec37dc
Fast forward
 app/controllers/posts_controller.rb      |    2 ++
 app/helpers/posts_helper.rb              |    2 ++
 app/models/post.rb                       |    2 ++
 config/routes.rb                         |    2 ++
 db/migrate/001_create_posts.rb           |   15 +++++++++++++++
 test/fixtures/posts.yml                  |   11 +++++++++++
 test/functional/posts_controller_test.rb |    8 ++++++++
 test/unit/post_test.rb                   |    8 ++++++++
 8 files changed, 50 insertions(+), 0 deletions(-)
 create mode 100644 app/controllers/posts_controller.rb
 create mode 100644 app/helpers/posts_helper.rb
 create mode 100644 app/models/post.rb
 create mode 100644 db/migrate/001_create_posts.rb
 create mode 100644 test/fixtures/posts.yml
 create mode 100644 test/functional/posts_controller_test.rb
 create mode 100644 test/unit/post_test.rb
> git merge comments
Auto-merged config/routes.rb
CONFLICT (content): Merge conflict in config/routes.rb
Automatic merge failed; fix conflicts and then commit the result.

Oops! There seems to be a config in config/routes.rb. Lets see what is in that file.

ActionController::Routing::Routes.draw do |map|
<<<<<<< HEAD:config/routes.rb
  map.resources :posts
=======
  map.resources :comments
>>>>>>> comments:config/routes.rb

  # The priority is based upon order of creation: first created -> highest priority.

  # Sample of regular route:
  #   map.connect 'products/:id', :controller => 'catalog', :action => 'view'
  # Keep in mind you can assign values other than :controller and :action

  # Sample of named route:
  #   map.purchase 'products/:id/purchase', :controller => 'catalog', :action => 'purchase'
  # This route can be invoked with purchase_url(:id => product.id)

  # Sample resource route (maps HTTP verbs to controller actions automatically):
  #   map.resources :products

  # Sample resource route with options:
  #   map.resources :products, :member => { :short => :get, :toggle => :post }, :collection => { :sold => :get }

  # Sample resource route with sub-resources:
  #   map.resources :products, :has_many => [ :comments, :sales ], :has_one => :seller

  # Sample resource route within a namespace:
  #   map.namespace :admin do |admin|
  #     # Directs /admin/products/* to Admin::ProductsController (app/controllers/admin/products_controller.rb)
  #     admin.resources :products
  #   end

  # You can have the root of your site routed with map.root -- just remember to delete public/index.html.
  # map.root :controller => "welcome"

  # See how all your routes lay out with "rake routes"

  # Install the default routes as the lowest priority.
  map.connect ':controller/:action/:id'
  map.connect ':controller/:action/:id.:format'
end

Ah, when we generated the resources, they edited the same line on the file. That’s an easy fix. Just get rid of the conflict markers. Merge again.

> git add .
> git commit -m 'Merged from comment branch.  Resolved config/routes.rb'
Created commit cfb3b0e: Merged from comment branch.  Resolved config/routes.rb
 8 files changed, 49 insertions(+), 0 deletions(-)
 create mode 100644 app/controllers/comments_controller.rb
 create mode 100644 app/helpers/comments_helper.rb
 create mode 100644 app/models/comment.rb
 create mode 100644 db/migrate/001_create_comments.rb
 create mode 100644 test/fixtures/comments.yml
 create mode 100644 test/functional/comments_controller_test.rb
 create mode 100644 test/unit/comment_test.rb

Now we have both Post and Comment resources in our master branch. At this point, we can delete the posts and comments branches.

> git branch -d posts
Deleted branch posts.
> git branch -d comments
error: The branch 'comments' is not an ancestor of your current HEAD.
If you are sure you want to delete it, run 'git branch -D comments'.

Since we manually merge and fix the conflict, Git is complaining that it is unsafe to delete the comments branch since we could lose some unmerged changes. But we know we already have them in the master branch.

> git branch -D comments
Deleted branch comments.

Lets establish some ActiveRecord relationships. Before we do that, lets create another branch called relationships.

> git branch relationships
> git checkout relationships
Switched to branch "relationships"

Add the one-to-many relationship to post.rb.

class Post < ActiveRecord::Base
  has_many :comments
end

At this point, lets assume our customer notifies us there is an urgent bug in the master branch. We want to make them happy, so we will temporarily suspend our work in the relationships branch and fix the bug in the master branch, before we come back to finish our work in the relationships branch.

We use a stash to do that.

> git stash save
Saved working directory and index state "WIP on relationships: cfb3b0e... Merged from comment branch.  Resolved config/routes.rb"
HEAD is now at cfb3b0e... Merged from comment branch.  Resolved config/routes.rb

The git-stash man page says:

Use git-stash when you want to record the current state of the working directory and the index, but want to go back to a clean working directory. The command saves your local modifications away and reverts the working directory to match the HEAD commit.

A few more stash commands.

> git stash list
stash@{0}: WIP on relationships: cfb3b0e... Merged from comment branch. Resolved config/routes.rb
> git stash show
 app/models/post.rb |    1 +
 1 files changed, 1 insertions(+), 0 deletions(-)
> git stash show -p
diff --git a/app/models/post.rb b/app/models/post.rb
index 791dcb5..6ad2382 100644
--- a/app/models/post.rb
+++ b/app/models/post.rb
@@ -1,2 +1,3 @@
 class Post < ActiveRecord::Base
+  has_many :comments
 end

Our changes are now saved to the stash, as evidenced by running git status.

> git status
# On branch relationships
nothing to commit (working directory clean)

Lets fix the urgent bug in the master branch.

> git checkout master
Switched to branch "master"

It turns out the bug is really trivial.

> rm public/index.html
> git commit -a -m 'Fixed urgent bug'
Created commit 9a6dcf7: Fixed urgent bug
 1 files changed, 0 insertions(+), 277 deletions(-)
 delete mode 100644 public/index.html

We can resume our work in the relationships branch now. We need to retrieve the work we have done so far in the branch from the stash.

> git checkout relationships
Switched to branch "relationships"
> git stash apply
# On branch relationships
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#
#    modified:   app/models/post.rb
#
no changes added to commit (use "git add" and/or "git commit -a")

Lets finish our relationship modeling by modifying comment.rb

class Comment < ActiveRecord::Base
  belongs_to :post
end

We are ready to commit our changes now.

> git commit -a -m 'Added post-comment relationship'
Created commit f71752b: Added post-comment relationship
 2 files changed, 2 insertions(+), 0 deletions(-)

A quick peek at gitk.

We can merge the relationships branch to the master branch now.

> git checkout master
Switched to branch "master"
> git merge relationships
Merge made by recursive.
 app/models/comment.rb |    1 +
 app/models/post.rb    |    1 +
 2 files changed, 2 insertions(+), 0 deletions(-)
> git branch -d relationships
Deleted branch relationships.

We can now clear our stash because we already have the changes.

> git stash clear

Final picture.

Yay!