Rack provides a minimal, modular and adaptable interface for developing web applications in Ruby.

By wrapping HTTP requests and response, Rack standardized the interface for a web server to interact with a web application.

Rack Middleware
Rails has been using Rack since version 2.3 and that gives Rails developers more power at their hands, such as enable Rack Middleware.

You might have heard about Rails Metal, which is similar to Middleware because it uses Rack interface to handle a request. The main difference is that Rails Metal acts as the endpoint of a request and returns a response while Middleware acts like a filter that can be used to intercept a request and alter the response.

Creating the Middleware
To demonstrate Rack Middleware we are going to intercept any request for HTML pages so that we can first tidy up them.

We are going to use tidy, Ruby interface to HTML Tidy Library Project. You will need to install HTML Tidy for your distribution first before having the tidy gem installed. We are using tidy-1.0-126.1 on OpenSUSE 11.2 while writing this post.

The Middleware we are going to create is just a Ruby class. Create a file named tidy_response.rb inside the lib folder.

require 'tidy'

class TidyResponse
  def initialize(app)
    @app = app
  end

  def call(env)
    status, headers, response = @app.call(env)

    Tidy.path = '/usr/lib/libtidy-0.99.so.0'
    if headers["Content-Type"].include? "text/html"
      xml = Tidy.open do |tidy|
        tidy.options.output_xml = true
        xml = tidy.clean(response.body)
      end
    end

    [status, headers, xml]
  end
end

Please note that you will need to replace the Tidy.path value according to your distribution.

Every Middleware classes have an initialize method that takes an application as an argument. As you notice we have created an instance variable called @app that will be a reference to Rails application.

def initialize(app)
  @app = app
end

All Rack applications have a call method that takes an environment hash variable as an argument and returns an array containing an HTTP status, a hash of headers and a response object

status, headers, response = @app.call(env)

In our example here, we first tidy up the response before return it to the client.

Configuring the Middleware
We have to add a line in the Rails::Initializer.run block so the application knows to treat our new class as Middleware

Rails::Initializer.run do |config|
  config.middleware.use "TidyResponse"
...

To test that our class is being use as a Middleware class we call rake middleware. Our TidyResponse should be list in the output

william@castafiore:/srv/www/htdocs/sandbox/testbed/rails> rake middleware
(in /srv/www/htdocs/sandbox/testbed/rails)
use Rack::Lock
use ActionController::Failsafe
use ActionController::Session::CookieStore, #

use ActionController::ParamsParser
use Rack::MethodOverride
use Rack::Head
use ActionController::StringCoercion
use TidyResponse
use ActiveRecord::ConnectionAdapters::ConnectionManagement
use ActiveRecord::QueryCache
run ActionController::Dispatcher.new

Testing the Middleware
To see whether the HTML is tidy up, we use untidy HTML in our view

so when you start the server without using the Middleware, this is what we get when viewing the source of the page

Now start the server the view the source of the page using your browser and you should see

The result is a much tidier HTML tags and smaller page size, also notice how HTML Tidy correcting the mismatched end tags

become

Now you have written a working Middleware class. So enjoy your trip with Rack Middleware and feel free to comment your thoughts and questions!

By using named_scope we can apply certain conditions when we do find without having to write it repeatedly.

For example, say I have a Book model that has the attribute published. To get a list of books already published, by just using the find I can write it like this

@books = Book.all(:conditions => ["published = ?", true])

By way as above, I will probably write it again and again if I want to use the @books on different controllers. We can avoid this by adding named_scope on Book model such as the following

class Book < ActiveRecord::Base
  named_scope :published_only, :conditions => ["published = ?", true]
end

so I can use it in the controller simply by invoke

@books = Book.published_only

of the code snippet above we can see that by using named_scope we have added a class method with the name published_only.

Unlike Book.find, the object that is returned by Book.published_only is not an Array object but rather more like the association that was built by the has_many declaration. For example, we can invoke Book.published_only.first or Book.published_only.count. In addition we can also implementing Enumerable on the object that is returned by the named_scope, for example Book.published_only.each(&block).

Named Scopes can also be called in sequence, for example we have one more named_scope

named_scope :hard_cover_only, :conditions => ["cover = ?", "hard"]

so that we can invoke

Book.published_only.hard_cover_only

Named Scopes are also available for has_many associations, eg

class Author > ActiveRecord::Base
  has_many :books
end

and

rowling = Author.find(221)

then rowling.published_only.hard_cover_only will return all books written by Rowling that have been published and has a hard cover.

You can also pass in variable by using a lambda

class Book < ActiveRecord::Base
  named_scope :language, lambda { |language|
    { :conditions => { :language => language } }
  }
end

then Book.language('English') will return a list of English books.

To tell Rails what are gems that required, we simply add code like this in environment.rb

config.gem "will_paginate"
config.gem "hpricot"
config.gem "fastercsv"

Here are some ways to use gem in a Rails project.

Install the gem in the system

This way the most frequently used for those new to using Rails. Simply install the gem with the command: gem install whateveryouneed or rake gems:install and you are good to go. In this way requires us to ensure that gem is required have been installed on the server that is used for deployment later.

This method is quite practical when practiced by a small team or if you only as a developer, but would rather fuss if your team consists of many developers because they have to ensure that the required gem is already installed on their system.

Freeze gems

By using the command rake gems: unpack, all the gems that is required by your application will unpack into vendor/gems directory. Although this method will increase your application code size, but this will ease deployment later because gems do not have to be installed in the system.

Compared to the first method before, this method is more practical for a team that consists of many developers because each developer does not have to worry about whether the gem is needed is already installed on their system or not.

Bundler

This is the latest method. Bundler uses the management approach of the Merb and can be used not only on Rails course.

For Rails 2.3, Rails overriding Bundler own gem by inserting some handling code to config/boot.rb and create a new file config/preinitializer.rb. Then you move config.gem declarations to a file named Gemfile that is stored in the root directory of the application. We can categorize the required gem appropriate environment. Make sure to include Rails Itself and at least one source.

source :gemcutter
gem "rails", "~> 2.3.5"
gem "sqlite3-ruby", :require => "sqlite3"

# bundler requires these gems in all environments
# gem "nokogiri", "1.4.2"
# gem "geokit"

group :development do
  # bundler requires these gems in development
  # gem "rails-footnotes"
end

group :test do
  # bundler requires these gems while running tests
  # gem "rspec"
  # gem "faker"
end

You should find more information on their website.

Just as open source itself, in the Rails world there are always some options in doing something, of course choices we make will be influenced by our own needs. So how about you? methods such as what you use in handling the required gem in Rails?

For example, there is no user with login “wolfman” so user.email will raise NoMethodError

user = User.find_by_login("wolfman")
user.email

You can avoid NoMethodError using try

user = User.find_by_login("wolfman")
user.try(:email)

More documentation on try.

This post is a simple getting started guide, that will help you to:

1. Install the BrowserCMS
2. Create a new page
3. Add text content to the newly created page
4. Publish your page

Installation

Packaged as a gem, you can include BrowserCMS in any Rails (2.3 or later) project. Public assets, style sheets, images and JavaScript scripts is included in gem. In the installation process these assets will be copied to your project.

Let’s start install it by doing

$ sudo gem install browsercms

By the time I wrote this post, the latest version was 3.0.6. Now create a project using a specific BrowserCMS template (a Rails template is simply a Ruby script with some domain-specific extensions to facilitate application configuration.)

$ rails my_new_project_name -d mysql -m http://www.browsercms.org/templates/blank.rb

Unless you are not using password for your ‘root’ account to connect to the database, you will see this error message

Access denied for user 'root'@'localhost' (using password: NO)

you can reapply the template again at anytime after you change the database configuration in config/database.yml by running

$ rake rails:template LOCATION=http://www.browsercms.org/templates/blank.rb

from your project directory. Now run the server

$ script/server

and open your browser to http://localhost:3000/ and to log into the admin for the CMS go to http://localhost:3000/cms. In development mode the default username/password is cmsadmin/cmsadmin. You should now be logged in.

Create a new page

On the home page, you will see a menu labeled ‘Home’, you want to create new page ‘About Us’ with a menu link positioned below ‘Home’. Now log in into the CMS admin panel and do the following:

1. Click on ‘SITEMAP’. The Sitemap page shows you a tree structure with all the sections and pages in your site, but you can add/edit pages/sections, and also can reorganize your pages/sections using drag and drop.
2. Click on ‘My Site’
3. Click on ‘Add Page’
4. On the displayed form, there are several fields to fill out. Name and template are the important ones
5. Click ‘SAVE’ to create a new page

You will be taken to the newly created page, which will be blank.

Adding new text content to a page

What you want to do now is to add some text content the your ‘About Us’ page.

1. Turn on the Visual Editor
2. Click on the ‘Add Content’ icon below your page
3. Click on ‘Text’ on the ‘Select Content Type’ page
4. Fill out the ‘Name’ and ‘Content’ fields. You can enter ‘Tags’ to your content as well
5. Click ‘SAVE’

Publish your page

Your page is not published yet, to make it publicy available to the world click ‘PUBLISH’. To test your newly created page, simply log out from the admin panel and go to http://localhost:3000/about-us, you will see your text content you just added.

Hopefully this post will help you to getting started with BrowserCMS. Besides the concept that you need to understand, there are still many hidden power of BrowserCMS to be found and you can start from its Reference Documentation.

If you need help in developing a CMS solution in Ruby on Rails, please dont hesitate to contact us at info[at]kiranatama[dot]com!

We used I18n for all our static contents, it’s a piece of cake. And all the client needs to do is to update that ymls files. For dynamic contents, we use Globalize2.

Here comes the fun part. Because you are most likely be working on an existing application, the bulk of the work is not making a nice back-end for multi-language objects, but it’s making sure the Rails application works correctly after we implement multi-language. It’s especially true when the application doesn’t have a complete test suite :)

Some things worth noting:

1. All occurrences of find_by_name will no longer work correctly. So grep that and modify accordingly
2. Basically all queries that use ‘name’ field, either on the select clause or condition clause, will also no longer work correctly
3. All routes that need locale path should also be added /locale/ to it
4. Javascript methods within a .js file that calls a Rails action and needs ‘locale’. Simply make a global Javascript variable for the locale and use that when necessary within the .js file
5. Javascript method that uses hard-coded words. Eg. “this.value = ‘Beware’”. Either we refactor it completely since it’s most likely we can do it another cleaner way, or we have to pull out that Javascript method from .js file to rhtml

If you need a partner in developing your next Multi-language Rails application, we may be able to offer a good help! Contact us at info[at]kiranatama[dot]com

As with all other gems, the best way to understand a gem, besides asking shifu Google, is to dig into the gem code itself and find sample apps, example usage, test units, etc

It’s pretty straightforward, and yet I feel like wanting to share some interesting things:

1. If your PayPal timezone is different from your server’s timezone, you have to take note. Otherwise PayPal might refuse user payment because the start subscription time is in the past!
   Assuming you are saving times in UTC in your database, the following code would work well as the start subscription date passed to PayPal:
   TZInfo::Timezone.get(PAYPAL_TIMEZONE).utc_to_local(subscription.starts_on)
2. You want to keep a history of user activities (valid payments, invalid payments, cancellation, etc). In this case you’ll have to set a notification URL in your PayPal setting. Make sure the URL is accessible by Paypal, and check the example in ActiveMerchant:

   /lib/active_merchant/billing/integrations/paypal/notification.rb

The necessary tweak is that we have to handle the case where a subscribing customer’s credit card on file has expired or becomes invalid – in which case we have to terminate the customer’s subscription on our database.

Btw if you need to develop a recurring billing paypal feature on your Rails app, we may be a good partner. Contact us info[at]kiranatama[dot]com

For example:

class User < ActiveRecord::Base
  has_many :items
end

class Item < ActiveRecord::Base
  belongs_to :user
end

If we have 2 users, and several items we have controller like this:

def index
  @users = User.find(:all)
end

and in the view we have something like this:

<% @users.each do |user| %>
    <%= user.items.collect(&:name) %>
<% end %>

If we watch the queries on the log, we should see something like this :

SELECT * FROM "users"
SELECT * FROM "items" WHERE ("items".user_id = 1)
SELECT * FROM "items" WHERE ("items".user_id = 2)

if we have 1000 items, that means we are doing 1000+1 queries!
Off course we can fix it like this (eager loading):

def index
  @users = User.find(:all, :include => :items)
end

And now we only have two queries.

Detecting it in our application is another matter. If we have huge project, detecting it can be hard work and time wasting. I found a cool plugin/gem that help detecting n+1 queries problem, called Bullet. You can install it as a gem:

sudo gem install flyerhzm-bullet --source http://gems.github.com

or as a plugin

script/plugin install git://github.com/flyerhzm/bullet.git

or you can build the gem right from the source from:

git clone git://github.com/flyerhzm/bullet.git
cd bullet
gem build bullet.gemspec
sudo gem install bullet --local

If you are using it as a gem, don’t forget to include this in your environment.rb:

config.gem 'flyerhzm-bullet', :lib => 'bullet', :source => 'http://gems.github.com'

include this in development.rb, and remember not to use bullet on production:

config.after_initialize do
  Bullet.enable = true  
  Bullet::Association.alert = true
  Bullet::Association.bullet_logger = true
  Bullet::Association.rails_logger = false
end

You want to make two profiles in your Firefox, one for regular browsing, and one without caching enabled since sometimes it is not working in regular profile. So disable caching on your browser if you want to see pop-up box if we are doing n+1 queries. Also Bullet detect eager loading that is not used. I attached a screenshot so you can see it in action: