Adventures In Coding

Now writing at The Remarkable Labs Blog

Mon, 29 Oct 2012 19:35:50 +0000

As some of you have noticed, Adventures in Coding has been missing in action for a while. This is because over the last couple of months, I have been starting a new Ruby on Rails consultancy based in Toronto, Ontario. The company is called Remarkable Labs.

This past week, I launched the company blog at http://blog.remarkablelabs.com. This is where I will continue sharing knowledge and tips about Ruby and various other technologies.

Adventures in Coding will remain online as a reference, but I will no longer be actively posting here. You can subscribe to the Remarkable Labs blog here.

Thanks, Kevin Faustino

A review of "The Rails View" by Bruce Williams and John Athayde

Tue, 05 Jun 2012 10:44:17 +0000

The Rails View: Create a Beautiful and Maintainable User Experience is a book published by the Pragmatic Bookshelf by Bruce Williams and John Athayde. It is the most comprehensive resource on the view layer in Ruby on Rails available, clocking in at 264 pages and 9 chapters.

The book explains each concept to the reader by building an application ArtFlow. Each chapter builds upon the content in the previous, and provides a good sense of the order in which things should be done while developing.

Despite the fact that I have been working with Rails for years, I found the book to be an excellent reference and filled with things I wasn't aware of. For example, having read multiple HTML5 books, I was surprised to discover <aside> tags are not to be used for layout sidebars. While some of the chapters were introductions to technologies such as Sass, the authors always provided enough tips and links to further explore each topic.

Who Should Read It?

Anybody working with Ruby and maintain views for web applications. While some of the chapters are Ruby on Rails specific, many of these concepts can be applied to any Ruby web framework such as Sinatra.
Rails developers looking for a great reference for building a maintainable view layer.
Experienced Rails developers looking to learn a couple new tips and tricks.

The Chapters

Here is a list of what is covered in The Rails View:

Creating an Application Layout
Improving Readability
Adding Cascading Style Sheets
Adding JavaScript
Building Maintainable Forms
Using Presenters
Handling Mobile Views
Working with Email
Optimizing Performance

Beautiful Markup

When reading the book, I was constantly reminded of a presentation I watched on the Envy Labs Blog named "Beautiful Markup"

Only after taking a look at the video again did I realaize that it was done by co-author of The Rails View, John Athayde.

While the presentation is from 2010, it is a great compliment to the book. Many of the topics are still relevent today and are expanded upon in the book.

Verdict

If you are developing Ruby on Rails applications for a living, you should pick up The Rails View. While some areas may be to introductory for some developers, there will always be enough new knowledge to be discovered that more than pays for the book.

Using elasticsearch with Heroku

Thu, 31 May 2012 18:18:30 +0000

In my previous post, I wrote about how to integrate elasticsearch in a Ruby on Rails application. The next step after you have everything up and running is to deploy your app to production. I will detail how to do this via Heroku, since other deployment strategies have been well documented.

Bonsai ElasticSearch

Heroku has a wide variety of addons including Bonsai ElasticSearch. Bonsai allows you to have an elasticsearch server without having to write a single line of configuration. Add the addon to your application via the command-line:

$ heroku addons:add bonsai:test

Configuring Tire to work with Bonsai

Nick Zadrozny wrote a gist detailing a technique he used to use Bonsai in production and a local elasticsearch server for development.

To begin, we are going to create an initializer that sets a constant BONSAI_INDEX_NAME that will be used by our indexed model. First we determine if an environment variable is set for BONSAI_INDEX_URL. The BONSAI_INDEX_URL is the address of your Bonasi elasticsearch server. If present, we configure Tire to use http://index.bonsai.io as the base url for our elasticsearch calls and set our index name to the unique bonasi id found in the address. Otherwise, we use the technique described in my previous post to ensure a unique index per environment.

# config/initializers/bonsai.rb

if ENV['BONSAI_INDEX_URL']
  Tire.configure do
    url "http://index.bonsai.io"
  end
  BONSAI_INDEX_NAME = ENV['BONSAI_INDEX_URL'][/[^\/]+$/]
else
  app_name = Rails.application.class.parent_name.underscore.dasherize
  BONSAI_INDEX_NAME = "#{app_name}-#{Rails.env}"
end

Next update the index_name set on your indexed model to use BONSAI_INDEX_NAME.

class Post
  ...
  index_name BONSAI_INDEX_NAME
end

At this point, your application is ready for deployment to Heroku.

Indexing

Once you deploy your Heroku application, you must create and populate the elasticsearch index. We do this by running the Heroku console and entering the following code:

Post.create_elasticsearch_index # Post is our example model
Tire.index BONSAI_INDEX_NAME do 
   import Post.all
   refresh
 end

Once your index is in place, test your application on production to see if you are receiving search results.

Final Note

The Bonasi addon is in public beta at the time of writing. This is just a word of warning if you have a mission critical application and you wanted to try elasticsearch out.

Full-Text Search in Rails using elasticsearch

Wed, 30 May 2012 20:06:26 +0000

Searching on websites is important from a content discovery and user usability perspective. It allows readers to control the way they look for content instead of navigating through menus. Given this blog was missing full-text search, I decided to implement it using elasticsearch. Here is a detailed step-by-step guide on how I did that using outside-in development.

elasticsearch

elasticsearch is a distributed open source search server based on Apache Lucene. It allows for real-time searching and the ability to scale easily through replicas. Getting started is easy as elasticsearch is schema less. You only have to pass it a typed JSON document and it will automatically be indexed for you. Types are automatically determined by the server. It also allows you to define your own mappings to set boost levels, analyzers, and types.

Blog Engine Background

The code examples are in the post are extracted from the Adventures in Coding blog engine source code. It is a Ruby on Rails 3.1 application with a MongoDB database. All testing is done via Cucumber and RSpec. Views and CSS are generated with Haml and Sass respectively.

Getting Started

The first step in getting started is running an elasticsearch server locally for development. I do all my development on a Mac, so I easily installed it via homebrew:

$ brew install elasticsearch

If you are running another platform, you can build elasticsearch from source.

Once installed, I launched the server running:

$ elasticsearch -f -D es.config=/usr/local/Cellar/elasticsearch/0.19.3/config/elasticsearch.yml

Tire

Knowing that I am going to need a elasticsearch client, I selected the most popular Ruby client Tire. It is actively maintained, has a large amount of users, and also integrates nicely with Rails and ActiveModel.

To add it to the project, I added it to my Gemfile, and ran bundle.

# Gemfile
gem 'tire'

Search Feature

Now that everything is setup, I defined my Cucumber "Search" feature and scenarios which will drive development.

# features/search.feature
Feature: Search
  As a User
  I want to search for content
  In order to find content easily over paginating

  Background:
   Given I am on the home page

  Scenario: Find posts by content
    Given the following posts:
      | title             |
      | Demon in a Bottle |
      | Extremis          |
    When I search for "Demon"
    Then I should be on the search page
    And I should see the post called "Demon in a Bottle" in the post list
    But I should not see the post called "Extremis" in the post list

  Scenario: No posts found
    When I search for "Armor Wars"
    Then I should be on the search page
    And I should see a message indicating no posts were found

When I ran cucumber, my search scenarios failed because I haven't defined two step definitions. Cucumber informs me of this with the following output:

You can implement step definitions for undefined steps with these snippets:

When /^I search for "([^"]*)"$/ do |arg1|
  pending # express the regexp above with the code you wish you had
end

Then /^I should see a message indicating no posts were found$/ do
  pending # express the regexp above with the code you wish you had
end

Wanting to keep all search related step definitions together to keep things organized, I created the file features/step_definitions/search_steps.rb:

# features/step_definitions/search_steps.rb
When /^I search for "([^"]*)"$/ do |query|
  fill_in 'query', with: query
  click_button 'Search'
end

Then /^I should see a message indicating no posts were found$/ do
  within('section.posts') do
    page.should have_content('No posts were found')
  end
end

Running cucumber again indicated that it couldn't find a query text field in the markup.

When I search for "Demon" # features/step_definitions/search_steps.rb:1
  cannot fill in, no text field, text area or password field with id, name, or label 'query' found (Capybara::ElementNotFound)

To solve this, I needed to create a new search controller, a form to submit the search query, and a search index view. Once implemented, Cucumber would be able to successfully interact with the search form and endpoints. Since I hadn't wired up the Post model to Tire yet, the scenarios were still failing.

Search Form

%section{ id: 'search' }
  = form_tag search_path, method: :get do
    = text_field_tag :query, params[:query], autocomplete: :off, placeholder: 'e.g. Ruby'
    = submit_tag('Search')

Controller

# app/controllers/search_controller.rb
class SearchController < ApplicationController
  def index
    @posts = []
  end
end

Route

# config/routes.rb:
get 'search', to: 'search#index'

Helper

# app/helpers/posts_helper.rb:
module PostsHelper
  def render_posts(posts)
    if posts.to_a.size > 0
      render(posts)
    else
      content_tag(:div, "No posts were found", class: 'message')
    end
  end
end

Search index view

%section.posts= render_posts(@posts)

Adding Tire to ActiveModel

To make my Post model searchable, I included two modules:

  include Tire::Model::Search
  include Tire::Model::Callbacks

Now when I save a document, it will automatically create/update the elasticsearch index.

Since I am running elasticsearch in both my test and development environments, I needed to create a unique elasticsearch index name per environment. This ensured when I ran my Cucumber features, that my development indexes were not wiped out. I accomplished this by setting index_name to "blog-engine-#{Rails.env}".

I also wanted control of what attributes are sent to Tire for indexing. If Tire finds a to_indexed_json method on your model, it will use that over to_json. I decided to index the model _id, title, content, and published_at date.

Finally instead of relying on a dynamic schema, I defined a mapping which is explicit in how posts are analyzed and scored.

Fields such as _id and published_at are indexed, but not analyzed.
Post title's are given a boost rating of 100 over the default 1.0.
Blog post text fields are analyzed with a snowball analyzer.

Here is the final app/models/post.rb code:

class Post
    ...
  include Tire::Model::Search
  include Tire::Model::Callbacks

  index_name "blog-engine-#{Rails.env}"

  mapping do
    indexes :_id, index: :not_analyzed
    indexes :title, analyzer: 'snowball', boost: 100
    indexes :content, analyzer: 'snowball'
    indexes :published_at, type: 'date', index: :not_analyzed
  end

  def to_indexed_json
    {
      _id: _id,
      title: title,
      content: content,
      published_at: published_at
    }.to_json
  end

    ...
end

Handling requests to elasticsearch from RSpec

To ensure no outside HTTP requests to elasticsearch are made when running specs, I added a dependency to webmock.

To install webmock add it to your Gemfile under the test group:

# Gemfile
group :test do
  gem 'webmock', require: nil
end

In my spec/spec_helper.rb file, I required the webmock library and stubbed out any request to the elasticsearch server (http://localhost:9200) in a before filter.

Here is an abbreviated version of my specs/spec_helper.rb:

ENV["RAILS_ENV"] ||= 'test'
require File.expand_path("../../config/environment", __FILE__)
require 'rspec/rails'
require 'webmock/rspec'
...
RSpec.configure do |config|
  config.before :each do
    stub_request(:post, /.*localhost:9200\/.*/).to_return(body: "{}")
    Mongoid.purge!
  end
end

If you are interested in finding out more about webmock, be sure to read the README on GitHub.

Handling search calls to elasticsearch

Finally, I need to implement a method that actually used elasticsearch to search for posts. I didn't want the method to live in my Post model, so I created a class PostRepository. I did this to keep view specific logic, such as pagination, away from my domain models.

PostRepository takes a hash of params from a controller. Using those params, it will extract the query and current page of results.

# app/models/post_repository.rb
class PostRepository
  POSTS_PER_PAGE = 5

  attr_accessor :params

  def initialize(params)
    self.params = params
  end

  def search
    query = params[:query]
    model.tire.search(load: true, page: params[:page], per_page: POSTS_PER_PAGE) do
      query { string query, default_operator: "AND" } if query.present?
      filter :range, published_at: { lte: Time.zone.now }
      sort { by :published_at, "desc" } if query.blank?
    end
  end

  protected

  def model
    Post
  end
end

Here is a breakdown of what is occurs in the search method:

I accessed the Tire search method from the Post.tire accessor.
Passing in option load: true to search queries the database for the models. If you store all your attributes in elasticsearch then this isn't needed.
query { string query, default_operator: "AND" } if query.present?: I query elasticsearch for the query string passed by the user. This string is analyzed using a AND operator.
filter :range, published_at: { lte: Time.zone.now }: I ensure that only published articles are returned in the results by filtering for dates less than or equal to the current time.
sort { by :published_at, "desc" } if query.blank?: If a user enters no query string, I return the results in descending order of their published date.

I also updated the search_controller to use the new search method:

# app/controllers/search_controller.rb
class SearchController < ApplicationController
  def index
    @posts = PostRepository.new(params).search
  end
end

Returning to Cucumber

Running the Cucumber search scenarios still resulted in failure. One of the main reasons is that I was not creating the Post index on each scenario run. To fix this, I added a Before hook to delete all existing indexes and recreate them based on my mappings.

# features/support/hooks.rb
Before do
  Post.tire.index.delete
  Post.create_elasticsearch_index
end

The features ran again, but still ended up in failure. Calls to elasticsearch were being done asynchronously, whereas my scenarios were being executed synchronously. The solution was to add a synchronization point in the code somewhere. The best place I thought was before any search execution. I updated the step definition /^I search for "([^"]*)"$/ to include an index refresh call Post.tire.index.refresh. This step definition would be executed after any data has been setup in a Given step.

# features/step_definitions/search_steps.rb
When /^I search for "([^"]*)"$/ do |query|
  Post.tire.index.refresh
  fill_in 'query', with: query
  click_button 'Search'
end
...

Running cucumber again resulted in success:

Feature: Search
  As a User
  I want to search for content
  In order to find content easily over paginating

  Background:
    Given I am on the home page 

  Scenario: Find posts by content 
    Given the following posts:   
      | title             |
      | Demon in a Bottle |
      | Extremis          |
    When I search for "Demon"    
    Then I should be on the search page 
    And I should see the post called "Demon in a Bottle" in the post list
    But I should not see the post called "Extremis" in the post list

  Scenario: No posts found  
    When I search for "Armor Wars" 
    Then I should be on the search page 
    And I should see a message indicating no posts were found

2 scenarios (2 passed)
10 steps (10 passed)
0m1.315s

After thoughts

I love developing outside-in as it allows you to know your progress every step of the development process. The process shown in this post was not your typical Cucumber example. Adding external services as a dependency to your integration test suite is something I always try to avoid. However, having the confidence that I will always know if my features are working outweighs that negative.

Also, be sure to read about using elasticsearch witin Heroku.

How to configure Cucumber and RSpec to work with Mongoid 3.0

Mon, 28 May 2012 21:07:11 +0000

With the upcoming release of Mongoid 3.0, I have decided to update a previous post about getting Mongoid to play nice with RSpec and Cucumber.

RSpec and Cucumber by default are setup to work with relational databases using ActiveRecord. To get them to work with Mongoid, we had previously run: Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop) in before hooks. The previous line will no longer work in Mongoid 3.0, as we now access databases via sessions. As of Mongoid version 2.0.2, the method Mongoid.purge! was added to easily drop all collections and indexes from your MongoDB database. This is what you should use moving forward.

RSpec

The following example spec_helper.rb file is the bare minimum you will need to get Mongoid running with RSpec:

# spec_helper.rb

ENV["RAILS_ENV"] ||= 'test'
require File.expand_path("../../config/environment", __FILE__)
require 'rspec/rails'

# Requires supporting ruby files with custom matchers and macros, etc,
# in spec/support/ and its subdirectories.
Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}

RSpec.configure do |config|
  config.mock_with :rspec

  config.before :each do
    Mongoid.purge!
  end
end

Cucumber

Cucumber allows defining hooks in any file under the features/support directory. To setup Cucumber, create a file features/support/hooks.rb that will drop your MongoDB collections before each scenario:

# features/support/hooks.rb

Before do |scenario|
  Mongoid.purge!
end

Easily deploy to multiple environments on Heroku with heroku_san

Sat, 26 May 2012 00:59:28 +0000

Deploying to Heroku is one of the easiest things a Rails developer can experience. All you have to do is push your git repository to heroku master. As easy as this is, it is not ideal for applications with staging and production environments.

One of the most popular gems available to handle this issue is heroku_san

Install

Add the following to your project Gemfile:

group :development do
    gem 'heroku_san'
end

Once you run bundle install to add heroku_san to your application, you will need to generate a heroku configuration file.

Geneate config/heroku.yml via the heroku_san generator:

$ bundle exec rails generate heroku_san

config/heroku.yml

The power of heroku_san over the standard heroku deploy method is that it allows you to define all your environment variables and addons in one place. These settings can be shared with all environments or specific ones.

Here is a modified version of the adventuresincoding configuration file:

production:
  app: adventuresincoding
  stack: cedar
  config: &default_config
    BUNDLE_WITHOUT: "test:development"
  addons:
    - mongolab:starter
    - newrelic:standard

staging:
  app: adventuresincoding-staging
  stack: cedar
  config:
    <<: *default_config
    RAILS_ENV: 'staging'
  addons:
    - mongolab:starter

Setup

To setup your Heroku environments, run the following commands:

$ bundle exec rake all heroku:create
$ bundle exec rake all heroku:config    
$ bundle exec rake all heroku:addons

The above commands will create all your applications, configuration variables, and addons specified in your heroku.yml. When using the rake task all, commands are executed on each of your Heroku applications. If you want to only run commands on certain environments, use the name of the environment instead of all.

Deploying

heroku_san comes with a wide variety of rake tasks to manage your applications. One of those being heroku:deploy

For example, to deploy to staging, run:

$ bundle exec rake staging heroku:deploy

Benefits

Using heroku_san provides you the benefit of keeping all your deployment logic in one place. This allows you to easily keep track of the differences in configuration variables and addons between environments. It was also an essential piece of the puzzle when I migrated from the bamboo stack to cedar.

Managing your web applications with Foreman

Fri, 25 May 2012 18:21:42 +0000

Not all applications are created equal. While some applications can be as simple as a Ruby on Rails web app connecting to a database, others may have dependencies such as background workers. David Dollar realized his web applications were getting a lot more complicated to run, which resulted in him creating Foreman. Foreman is an excellent tool which allows you to encompass your entire application structure in a Procfile. A Procfile allows you to declare multiple processes that encompass your application and run them all with a single foreman start command.

Procfile

A Procfile is a list that contains a name to identify the process and the command used by the system to run it. Foreman will look for it by default in your project's root directory.

Here is an example Procfile of a Ruby on Rails application running Resque workers in the background:

web:    bundle exec thin start -p $PORT
worker: bundle exec rake resque:work QUEUE=*

Getting Started

Once your Procfile is in place, install the foreman gem:

$ gem install foreman

To start up your application from the command line, all you need to do is run foreman start. By default, this will run one instance of the each application type defined in your Procfile.

Concurrency

Foreman supports the ability to run more than 1 process of each type via the concurrency -c parameter. You must define the number of each process type to run.

For example, to increase the number of worker processes to two, execute:

$ foreman start -c web=1,worker=2

.env

Another great benefit to Foreman is the ability to define local ENV variables for development. By creating a .env file in the root directory of the project, Foreman will load all key/value pairs specified in the file into the default environment.

S3_KEY=abc
S3_SECRET=def

Be sure to include .env in your .gitignore file as well to ensure sensitive information is not stored in your repository.

Procfile.development

Sometimes you will want a different Procfile for development . For example, you may want to run redis on your local machine while developing your application to save system resources. A convention I use is that I suffix .development to my development Procfile.

# Procfile.development
web:    bundle exec thin start -p $PORT
redis:  redis-server /usr/local/etc/redis.conf
worker: bundle exec rake resque:work QUEUE=*

To run Foreman with a different Procfile, run foreman with the -f parameter:

$ foreman start -f Procfile.development

How to get ApacheBench(ab) to work on Mac OS X Lion

Wed, 16 May 2012 16:23:18 +0000

ApacheBench is a tool to do lightweight performance benchmarking on web applications. It is part of Apache which ships by default with Mac OS X. However, Mac OS X Lion comes with a version that has some issues.

Here is an example of benchmark running against a local Ruby on Rails application:

$ ab -n 100 -c5 http://127.0.0.1:3000/
This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 127.0.0.1 (be patient)...Send request failed!
Send request failed!
apr_socket_recv: Connection reset by peer (54)

A majority of the times when ab is run, you will receive an apr_socket_recv error on Lion.

Solution

To fix the issue with ApacheBench, we must replace the version on the system with one which is more recent.

Step 1: Download the latest version of apache

At the time of writing, the latest version of Apache availble is 2.4.2. You can find it and future versions at http://apache.mirrors.pair.com/httpd/.

$ curl -O http://apache.mirrors.pair.com/httpd/httpd-2.4.2.tar.gz

Step 2: Install missing dependencies

If you attempt to build Apache without installing pcre, you will get the following error: configure: error: pcre-config for libpcre not found. PCRE is required and available from http://pcre.org/.

Install pcre via Homebrew:

$ brew install pcre

Step 3: Build Apache

Once downloaded, extract and build the downloaded version of Apache:

$ tar xzvf httpd-2.4.2.tar.gz
$ cd httpd-2.4.2/
$ ./configure
$ make

Step 4: Replace ab

Replace the existing ApacheBench(ab) version on Mac OS X Lion with the newly built version:

$ sudo cp support/ab /usr/sbin

The future of Adventures in Coding

Tue, 08 May 2012 16:27:26 +0000

Over the course of the last year I had the feeling something was missing. There are a lot of factors that contribute to developer happiness such as their environment, work, and their team. One piece that I felt was missing from my day-to-day life was the joy I had when I shared something I've learned with the community. Moving forward, I plan on sharing as much as I can on adventuresincoding.com.

The Mission Statement

Before I sit down on the keyboard to write anything, I will reflect on this statement:

"Sharing experiences, opinions, & news for the ruby web developer"

If something doesn't fall within the mission statement, it will not make it on the blog.

What can you expect

Knowledge is sparse around the web for Ruby developers. I want to transform this site to be a hub for experienced and new Ruby developers alike.

Here is a list of what I'm planning:

Tutorials
Tips & Tricks
Opinions on code, team dynamics, and growing software craftsmanship in our communities
Focus on things I feel are of interest to myself and others. This includes Backbone.js, Rails, testing, and good code practices in general
Sharing news about our industry
Sharing experiments and implementation details of this blog engine
Updating older posts which have outdated information and code

Speed up your websites with Smusher

Fri, 18 Nov 2011 13:54:06 +0000

Images are a bulk of the load time for many sites. There are many techniques that can allow for less requests, such as creating CSS Sprites. While I believe these techniques are essential, clients will still have to download the images in the end.

Saving your images with Photoshop's "Save for Web & Devices" doesn't ensure that they are truly optimized. However, there are ways to get smaller images without quality loss.

"Lossless" images

Using optimization techniques, images can be optimized to smaller sizes without effecting their visual quality.

Yahoo! SmushIt and PunyPNG are two great services on the web that allow you to upload images and receive byte reduced versions.

Smusher

Using the above mentioned services requires manually selecting files and uploading them to the web. Thanks to Michael Grosser, we now have Smusher, a Ruby CLI for lossless reduction of your images.

Smusher will take an image or directory of images and process them through an image reduction service with just a single line in your terminal.

To install it, run the following:

$ gem install smusher

By default, smusher uses Yahoo! SmushIt, but also has to option to switch to the PunyPng service.

Usage

To process a directory of images, run the smusher command:

$ smusher public/images --service PunyPng

To demonstrate the savings, I ran smusher on a Ruby logo found on Wikipedia:

smushing Ruby-(programming-language)-logo-2008.png
27416 -> 23544                           = 85%

Smusher saved us 15% on just one image. Multiply that by every image on your site, and you will have made your users a little more happy with faster page downloads.

.puny_png_api_key

If you are a PunyPNG service subscriber, you can store your api key for future usage by smusher.

Add a file named .puny_png_api_key to your home directory with your PunyPNG api key as it's contents.

Use it

Smusher is a great tool that has been available for years and I feel is not really known to most web developers. Once you start using it, I truly believe it will be a part of your utility belt.

Getting Inherited Resources 1.2.1 and Mongoid to play nice

Sun, 20 Mar 2011 19:27:30 +0000

With the release of version 1.2.1 of Inherited Resources, compatibility with Mongoid was broken. To optimize the setting of a collection in a controller, Inherited Resources calls the scoped method at the end of the collection association chain over calling all. The change to use scoped results in a collection being lazily queried. The reason why Mongoid breaks is because it does not have a scoped method, thus using Inherited Resources in any Mongoid project causes collection controller actions to break.

Inherited Resources has rectified the issue in their master branch on GitHub by checking to see if the collection responds to scoped. If you cannot wait for the next release of Inherited Resources, add the following code to one of your Rails initializers to get it working with Mongoid again:

# app/config/initializers/inherited_resources.rb

module InheritedResources
  class Base

    def collection
      get_collection_ivar || begin
        c = end_of_association_chain
        set_collection_ivar(c.respond_to?(:scoped) ? c.scoped : c.all)
      end
    end

  end
end

Rails Templater - Agnostic at last

Mon, 31 Jan 2011 01:26:11 +0000

What Rails Templater used to be

Rails Templater was originally a Ruby on Rails 3 template inspired by Mike Gunderloy’s BigOldRailsTemplate project. It was a very opinionated template, as it only created Rails applications using Mongoid, RSpec, jQuery, Haml, and FactoryGirl. This resulted in a large amount of forks(34 to date) by fans of the project who wanted to generate applications their way.

What is Rails Templater today?

The initial intentions of the template framework were small. I wanted something to generate applications the way I wanted, without all the configuration changes required after the initial generation. For example, if I wanted to use Mongoid with RSpec instead of ActiveRecord, I would have to update the RSpec configuration to take care of dropping MongoDB collections. Rails Templater takes care of all these configuration details in post bundler strategies, which take into account all the recipes chosen by the user.

Rails Templater is no longer just a template, but a gem providing a simple interface for generating applications. Also, the project is now completely agnostic, thus allowing you to select what you want in your application. Some examples of choices are deciding which ORM, JavaScript framework, testing framework, and fixture replacement you want to use.

Usage

You can give Rails Templater a try right now with the following:

$ gem install rails_templater

Once installed, generate a new Ruby on Rails 3 application using templater

$ templater myapp

Rails Templater will ask you questions, such as which testing framework you would like to use. Once all questions are answered, a new Rails application will be generated just the way you like it.

Be sure to watch the screencast below to see an example of generating an app.

Contributing new recipes

If you would like to add more recipes to the project, fork it on GitHub and send me a pull request. The current road map is to add DataMapper support and more fixture replacements, such as Fabrication.

Writing modular HTTP client code with Faraday

Kevin Faustino — Thu, 23 Sep 2010 00:00:00 +0000

What is Faraday? A natural philosopher from the 1700s? An awesome Lost character? A ruby gem by technoweenie himself, Rick Olson? Since this blog is mostly development related, you may have concluded that this post is about the latter. Faraday is an HTTP client library inspired by Rack. Requests and Responses go through middleware which allow for abstraction and modular code.

Installation

gem install faraday

Be sure to also install the faraday-middleware by Wynn Netherland as it provides some great middleware to consume APIs.

gem install faraday-middleware

Using Faraday

To create a connection via Faraday, instantiate a new Faraday::Connection object with your desired options. The constructor of Faraday::Connection takes a block where you will define an adapter and your desired middleware.

An adapter represents the client library that Faraday will be utilizing to make your request. Faraday ships with the following:

NetHTTP (Faraday.default_adapter)
Patron
Typhoeus
Test (Allows stubbing of HTTP requests)

Example: Creating a connection

connection = Faraday::Connection.new(
  :url => 'http://api.twitter.com/1/statuses/public_timeline.json',
  :headers => { :accept =>  'application/json',
  :user_agent => 'Faraday Ruby Client'}) do |builder|
    builder.adapter Faraday.default_adapter
    builder.use Faraday::Response::MultiJson
    builder.use Faraday::Response::Mashify
end

The above example represents a Faraday connection to the Twitter API public timeline method. This connection uses two middlewares from the faraday-middleware gem. Faraday::Response::MultiJson sets the body of the response to a parsed JSON response using the multi_json gem. Afterwards, the Faraday::Response::Mashify middleware uses the hashie gem to allow dot notation on the response body instead of brackets.

By putting request/response operations in middleware, Faraday forces your code to follow the Single Responsibility Principle. For example, Faraday::Response::MultiJson is responsible for converting the JSON response into a ruby object using the best available JSON library and that alone.

Calling methods on the connection object will allow you to perform GET, HEAD, PUT, POST or DELETE operations.

Example: Faraday response with MultiJson and Mashify

response = connection.get
first_user = response.body.first.user
puts first_user.screen_name

Creating a Middleware

A common code practice when making client HTTP requests is to verify the response was successful. To abstract the response verification, move the code to Faraday response middleware. To create one, you must inherit from Response::Middleware and implement the methods self.register_on_complete and initialize. The interface is very similar to Rack. You can think of register_on_complete(env) as call(env) from Rack.

Example: Twitter Error Response Middleware

module Faraday
  class Response::TwitterErrors < Response::Middleware

    begin
      def self.register_on_complete(env)
        env[:response].on_complete do |finished_env|
          case finished_env[:status]
          when 400
              raise Twitter::RateLimitExceeded,
                "#{finished_env[:body]['error'] if finished_env[:body]}"
            when 401
              raise Twitter::UnauthorizedError,
                "#{finished_env[:body]['error'] if finished_env[:body]}"
            when 500
              raise Twitter::ServerError, 'api.twitter.com is currently down'
          end
        end
      end
    rescue LoadError, NameError => e
      self.load_error = e
    end

    def initialize(app)
      super
      @parser = nil
    end

  end
end

Note

Faraday does not have gem dependencies for many of the adapters and middlewares used within it’s codebase. Ensure you have all necessary gems installed on your system.

34 Ruby on Rails 3 resources to get you started

Kevin Faustino — Thu, 26 Aug 2010 00:00:00 +0000

With the ~~upcoming~~ final release of Ruby on Rails 3 ~~around the corner~~, get up to speed quickly with the following 34 resources:

Overviews

Rails 3.0 Release Notes - RailsGuides is an invaluable resource for all Ruby on Rails developers. The Rails 3 release notes provides a great overview the api changes and new features added to the framework.

RailsPlugins.org – Find out if your plugins work in Rails 3.

Having Ruby on Rails 3 My Way - A tutorial on how to setup Rails 3 with Mongoid, Haml, jQuery, and RSpec with Factory Girl.

The Rails Module (in Rails 3) - Nick Quaranto outlines some helpful methods in the Rails module.

Rails 3 I18n changes - A quick walkthrough the changes made to I18n.

Ruby on Rails 3 Screencast series - The official Ruby on Rails site screencast series by Gregg Pollack.

ActionController / Rack

Embracing REST with mind, body and soul - José Valim introduces RESTful responders within Rails 3 controllers.

Railscasts #224 Controllers in Rails 3 – Ryan shows us what’s new with Rails 3 controllers.

Render Options in Rails 3 - Yehuda goes through the rendering options available in Rails 3.

Adding Routes for tests / specs with Rails 3 - Jeff Dean outlines how to verify routes in our specs.

32 Rack Resources to Get You Started - A great collection of links to get you familiar with rack.

ActionMailer

New ActionMailer API in Rails 3.0 - Mikel Lindsaar demonstrates how to use the new ActionMailer.

A Whole New ActionMailer - Mikel Lindsaar’s Rails Dispatch post giving a tour of the ActionMailer features.

ActiveRecord/ActiveModel

ActiveModel: Make Any Ruby Object Feel Like ActiveRecord – Yehuda writes about the modularity of ActiveModel.

Railscasts #219 Active Model - See how to include certain ActiveModel modules to tableless models.

ActiveRelation: ActiveRecord Gets a Facelift - Carl Lerche introduces the new ActiveRecord finder api.

Active Record Query Interface - Pratik gives an overview of the changes made to the ActiveRecord query interface since Rails 2.

Bundler

Gembundler.com -The official project site for Bundler that includes extensive documentation.

Library Management Gets an Update in Rails 3 - Andre Arko gives an overview about bundler for the Rails Dispatch blog.

Railscasts #201 Bundler - A Railscasts by Ryan Bates demonstrating how to use bundler with Rails 3.

AdventuresInCoding.com screencast on Bundler – Our very first screencast from last February.

Railties

Rails 3 Internals: Railtie & Creating Plugins - Ilya Grigorik goes over Railties in Rails 3.

rails-templater - A template project which generates a greenfield Rails 3 application.

Making generators for Rails 3 with Thor – A tutorial showing you how to use the new generators and how to bundle them in a gem.

Routes

The Lowdown on Routes in Rails 3 - Rizwan Reza gives us a great summary of all the different ways to create routes in Rails 3.

Rails Routing from the Outside In - RailsGuide documentation about the new router.

Plugins

Plugin Authors: Toward a Better Future - Yehuda goes through the changes for making plugins in Rails 3.

Customizing Rails Apps with Plugins - José Valim gives an overview of using responders, simple form, devise, and mail form plugins.

Devise 1.1 is out and ready to rock with Rails 3 - Outlines some new feature in Devise 1.1 including being able to authenticate a given url in the router!

Books

Beginning Rails 3 – Cloves Carneiro Jr and Rida Al Barazi bring us a great beginner Rails 3 book with examples viewable in gists.

The Rails 3 Way - The ultimate Ruby on Rails reference by Obie Fernandez.

Rails 3 In Action - Ryan Bigg and Yehuda Katz deliver a great Rails book which teaches readers Rails by doing BDD with Cucumber and RSpec.

Rails 3 Upgrade Handbook - Jeremy McAnally’s book gives you 120 pages of information about upgrading your Rails 2 application to version 3.

Ruby on Rails Tutorial: Learn Rails by Example – Michael Hartl’s ebook that teaches Rails step by step.

Update: Rails 3.0.0 was released on August 29th, 2010. To get more details, be sure to read the official announcement.

Prototypal Inheritance in JavaScript Explained

Kevin Faustino — Tue, 27 Jul 2010 00:00:00 +0000

One of the more advanced topics in JavaScript is how to implement inheritance in your code. The reason why inheritance causes so much confusion is because there are so many ways to implement it in JavaScript.

For those who are unfamiliar with inheritance, it allows us to extend a previously existing entity and supplement it by adding methods/properties to create an entirely new entity. It is an amazing way to reuse code!

Here is Wikipedia’s definition:

"In object-oriented programming(OOP), Inheritance is a way to compartmentalize and reuse code by creating collections of attributes and behaviors called objects which can be based on previously created objects"

There are a variety of JavaScript frameworks that provide a means to perform classical inheritance. Some of these include Prototype, MooTools, and ClassJS. This is a great option for a team where most of the developers come from other object-oriented languages. Even though the above implementations are viable solutions, Douglas Crockford suggests the ideal solution is to use the prototypal inheritance, which has objects inheriting from other objects

Implementation

In JavaScript everything is an object, there is no concept of a class like other object-oriented programming languages. With prototypal inheritance, we implement inheritance by creating objects which will act as prototypes for other objects.

My favourite implementation comes from Stoyan Stefanov’s book Object-Oriented JavaScript: Create scalable, reusable high-quality JavaScript applications, and libraries. Here is my slightly modified version of a function which abstracts the creation of a child object:

function object(parent, supplements){
  /*  Create a variable that will store our child object. */
  var child;

  /*  Create an empty function F which will act as an intermediary between
      the parent and the child. F will have no properties of its own.   */
  function F() {};

  /*  Assign the parent constructor to the prototype of F.
      This will allow the child to copy all the parentâs properties without
      having to set itâs prototype to the parent instance. */
  F.prototype = parent;

  /*  Create a new child object from F. We get a copy of all the parentâs properties.
      Functions/objects are copied by reference. */
  child = new F();

  /*  Define a property uber which points to the parent object. Simulates super
      from other languages. */
  child.uber = parent;

  /*  Add any functions/properties desired for the child object. */
  for(var i in supplements){
    child[i] = supplements[i]
  }

  return child;
};

Example

Here is a basic example displaying how the properties are copied and overridden in a parent/child relationship.

var parent = {
  firstName: "William",
  lastName: "Adama",
  fullName: function() {
    return this.firstName + " " + this.lastName;
  }
};

var child = object(parent, {
  firstName: "Lee"
});

child.fullName(); // "Lee Adama"
parent.fullName(); // "William Adama"

We can implement another version of fullName() that indicates William is Lee’s father without removing the parent function.

child.fullName = function(){
  return this.uber.fullName() + "'s child " + this.firstName;
};

child.fullName(); // "William Adama's child Lee"
parent.fullName(); // "William Adama"

We can even remove our child’s fullName() function and still have access to out parent’s function because it exists in the child’s prototype chain.

delete child.fullName
child.fullName(); // "Lee Adama"

Benefits

The benefit of using prototypal inheritance is that we are working with the strengths of JavaScript and not trying to imitate features of another language.

Not only does it provide an easy way to do inheritance, but there is a performance boost as well. When a function is defined in an object, they are created by reference, resulting in all child objects pointing to the same function and not creating their own copies. This can also lead to some issues if you are unaware of this. If you do not want to share any objects or functions in your child object, make sure to supplement them. Any functions/objects you create in your child object will take precedence over the parent’s version.

Out in the Wild

In the latest ECMAScript 5 standard, prototypal inheritance became a first class citizen as a new native method Object.create(proto [, propertiesObject ]) was added. It allows you to create a new object with the specified prototype object and properties. You can also use it today in YUI 3 via the Y.Object(…) function from YUI core.

How to configure Cucumber and RSpec to work with Mongoid

Kevin Faustino — Thu, 22 Jul 2010 00:00:00 +0000

Update: This post is outdated. An updated version is available which explains how to use RSpec and Cucumber with Mongoid 3.0.

RSpec and Cucumber by default are setup to work with relational databases using ActiveRecord. This has been fine for the most part until so many NoSQL databases have come onto the scene. Let’s focus on getting Cucumber and RSpec working with MongoDB using Mongoid.

First you will need to setup your Rails 3 application to use Mongoid, Cucumber, RSpec, and Factory Girl. Once you have a project skeleton, you will need to setup RSpec to drop all the MongoDB collections of the project before each spec is run to ensure a clean test harness.

The best command to drop your MongoDB collections comes from Mongoid creator Durran Jordan in Mongoid’s code base:

Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)

RSpec

Here is a sample RSpec configuration which will empty your MongoDB db and also use Factory Girl to create your models. Note that config.user_transactional_fixtures is commented out.

# spec_helper.rb

ENV["RAILS_ENV"] ||= 'test'
require File.expand_path("../../config/environment", __FILE__)
require 'rspec/rails'
require 'remarkable/active_model'
require 'remarkable/mongoid'
require 'factory_girl'

# Requires supporting files with custom matchers and macros, etc,
# in ./support/ and its subdirectories.
Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

RSpec.configure do |config|
  config.mock_with :rspec

  # If you're not using ActiveRecord, or you'd prefer not to run each of your
  # examples within a transaction, comment the following line or assign false
  # instead of true.
  # config.use_transactional_fixtures = true

    config.before :each do
      Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
    end

end

Cucumber

Cucumber allows defining hooks in any file under the features/support directory. To begin setting up Cucumber, first create a file features/support/hooks.rb that will drop your MongoDB collections before each scenario.

# features/support/hooks.rb

Before do |scenario|
    Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
end

I also find that using Factory Girl for my Cucumber scenarios makes my life a lot easier. Below is an example features/support/env.rb file which will import all your factories. It will also provide some already defined step definitions by the guys at thoughtbot. Be sure to read about them in their post gimme three steps.

# env.rb

ENV["RAILS_ENV"] ||= "test"
require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')

require 'cucumber/formatter/unicode'
require 'cucumber/rails/rspec'
require 'cucumber/rails/world'
require 'cucumber/web/tableish'

require 'capybara/rails'
require 'capybara/cucumber'
require 'capybara/session'
require 'cucumber/rails/capybara_javascript_emulation'

Capybara.default_selector = :css

ActionController::Base.allow_rescue = false

require 'factory_girl'
require 'factory_girl/step_definitions'
Dir[File.expand_path(File.join(File.dirname(__FILE__),'..','..',
  'spec','factories','*.rb'))].each {|f| require f}

All the step definitions from factory_girl/step_definitions work except for "create record & set one attribute":

Given an author exists with an email of "author@example.com"

The reason for this is because in the Factory girl code, there is a check that determines if the given model responds to :columns. To get around this, add the following code to a new file features/step_definitions/mongoid_steps.rb:

# features/step_definitions/mongoid_steps.rb

Given /^an? (.+) exists with an? (.+) of "([^"]*)"$/ do |model, field, value|
  factory_name = model.gsub(' ', '_')
  Factory factory_name, field => value
end

The last thing to do is stub out the rake task for db:test:prepare. The Cucumber rake tasks are still dependent on the ActiveRecord test workflow and will attempt to load the db schema into the test db. Create the file lib/tasks/mongo.rake to get around this:-

Update: As of version 2.0.0.beta.14 of mongoid, a stubbed rake task for db:test:clone is included.

# lib/tasks/mongo.rake

namespace :db do
  namespace :test do
    task :prepare do
      # Stub out for MongoDB
    end
  end
end

Finally, if you don’t want to do this every time you setup an application, I’ve updated rails-templater to do the above steps automatically.

Jumpstart your Ruby on Rails 3 applications with rails-templater

Kevin Faustino — Mon, 19 Jul 2010 06:00:00 +0000

Update: Rails Templater is now a gem and agnostic.

In Having Ruby on Rails my way, I outlined how to manually setup your Ruby on Rails 3 application to use custom generators for Mongoid, Haml, jQuery, RSpec, and factory_girl.

To simplify things further, I have started a template project called rails-templater. It is inspired by Mike Gunderloy’s BigOldRailsTemplate project which provides templates for Rails 2.3.x projects. To get started, clone the rails-templater repository to your hard drive:

% git clone http://github.com/kfaustino/rails-templater.git

When you are ready to create a new Rails 3 application, run:

% rails new app_name -JOT -m \
 /path/to/rails-tempater/templater.rb

Optionally you can also use Compass as your stylesheet framework and Cucumber for integration testing.

I will be continuously making updates to the project by adding new recipes and template options.

Be sure to check out the project GitHub page.

Photo credit: Railroad in Crestwood by dystopos

Having Ruby on Rails 3 my way

Kevin Faustino — Mon, 19 Jul 2010 00:00:00 +0000

At RailsConf 2009, David Heinemeier Hansson during his keynote mentioned that one of the central themes behind the Ruby on Rails and Merb merge was to "Have it your way". Given the fact that Rails 3 is almost at a release candidate, I wanted to share my ideal Ruby on Rails setup.

My ideal application stack consists of Mongoid as my ODM, Haml as my template engine, jQuery as my JavaScript framework, RSpec as my testing framework, and factory_girl as my fixture replacement.

I will outline how to setup each of these individually for your Ruby on Rails 3 application.

To begin, generate a new Rails 3 application with the following command:

% rails new app_name -TOJ

The flags passed into the rails command will remove certain elements from the generation of our application.

T – represents Test::Unit
O – represents ActiveRecord
J – represents Prototype

Replacing ActiveRecord with Mongoid

Mongoid is an Object Document Mapper for MongoDB. It has a beautiful chaining criteria dsl for queries and is optimized for extremely large datasets.

To add mongoid to your project, add the following to your Gemfile:

gem 'mongoid', '>= 2.0.0.beta14'
gem 'bson_ext', '1.0.4'

Mongoid provides a generator to setup your project to create documents for model generation and setup a sample database connection configuration. To run this generator, first execute bundle install to ensure all missing dependencies are installed. Finally, run the mongoid:config generator:

% rails g mongoid:config

Replacing ERB with Haml

Haml was one of the primary reasons why I feel in love with working on Ruby on Rails applications. It just makes working with markup a pleasure.

Adding Haml to your project requires only 1 lines in your Gemfile:

gem 'rails3-generators'
gem 'haml'

The gem rails3-generators provides a variety of generators for Ruby on Rails 3 applications including factory_girl which we will be using later.

In config/application.rb, add the following to your application configuration:

config.generators do |g|
  g.template_engine :haml
end

Replacing Prototype with jQuery

Using jQuery simplifies dealing with the DOM and provides all the tools necessary to do unobtrusive JavaScript in your web application. According to Hampton Catlin's 2010 ruby survey, 78.8% of all ruby users prefer it over Prototype.

Run the following two commands in the root of your project directory:

curl -L http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js > \
public/javascripts/jquery.js

curl -L http://github.com/rails/jquery-ujs/raw/master/src/rails.js > \
public/javascripts/rails.js

Once you setup a layout file, include the two javascript files and your set.

Replacing Test::Unit with RSpec

With the latest beta release of RSpec 2, all generators and rake tasks are now exposed through a Railtie.

To replace Test::Unit as your default test framework, include the rspec-rails gem in both the :development and :test group in your Gemfile:

group :development, :test do
  gem 'rspec-rails', '>= 2.0.0.beta.19'
end

The next step is to install rspec into the application. The rspec:install generator will create a spec directory and some skeleton files. Run the following in your project root:

% bundle install
% rails g rspec:install

Even though you are including RSpec as a development environment dependency, it is not completely loaded. It is only completely loaded when you invoke rails generate or rake. Read more details about this change at David Chelimsky's post rspec-rails-2 generators and rake tasks – part II.

Replacing Fixtures with Factory Girl

The rails3-generators gem we included earlier also provides some factory_girl generators. This allows for the creation of a factory when we use the model generator from Rails.

Add a dependency to the factory_girl_rails to the test environment in your Gemfile:

gem 'factory_girl_rails', :group => :test

You will also need to manually configure your generators to use factory_girl in config/application.rb. Your generators configuration should now look like the following:

config.generators do |g|
  g.template_engine :haml
  g.fixture_replacement :factory_girl, :dir => "spec/factories"
end

Update: If you absolutely love this stack, be sure to check out rails-templater.

10 TextMate bundles/plugins to boost your Ruby on Rails development productivity

Kevin Faustino — Mon, 31 May 2010 00:00:00 +0000

TextMate is a widely used GUI text editor that many in the Ruby on Rails community use. The editor benefits from a large and active community of users whom develop bundles and plugins that extend TextMate’s functionality to work with a wide variety of languages and libraries.

Here are ten of my favourite bundles and plugins available to TextMate that will save you time and effort while working with Ruby on Rails:

1 - PeepOpen: One of the best features of TextMate is fuzzy search(Command-T) which allows you to find files in your project with just a few characters of the filename. The issue with fuzzy search is that it becomes hard to pinpoint a file when there are many files with the same name in your project. Working in Ruby on Rails, you will face an endless amount repeated filenames in your views such as index.html.erb. Geoffrey Grosenbach from PeepCode, has developed an application PeepOpen that replaces the default fuzzy search with a beautiful fuzzy search that also allows you to pinpoint directories within your search. For a mere $9.00, it is a must own add-on to TextMate.

2 - Ruby on Rails: Ruby on Rails development just got better with the recent changes made by Carlos Brando to Dr. Nic’s bundle. Not only does it include all the snippets and Rails integrations we are all used to, but now we also get a pseudo-intellisense for attributes for each ActiveRecord model in your project. One of my favourite additions to the bundle is the ability to easily create RVM .rvmrc files for your project. The best resource for this bundle is PeepCode’s TextMate for Rails 2 screencast, be sure to check it out.

3 - AckMate: If you need to find some text fast, AckMate is your answer. By default, you have the power of regular expressions to pinpoint even the most complex pattern of text. AckMate also allows the filtering of files by specifying file extensions and pattern matching if a filename contains certain text.

4 - JavaScript Tools: JavaScript is ingrained in web development regardless of the server technology being utilized. Using the JavaScript Tools bundle you get all of the following:

JavaScript Lint to check all your source code for common JavaScript mistakes
A JavaScript beautifier to uniform line breaks and indentation
Packing and minimizer tools to compress your JavaScript documents for production

5 - JavaScript jQuery: jQuery is the most popular JavaScript library available today. This bundle by jQuery team member Karl Swedberg and Jonathan Chaffer provides a huge amount of snippets to save you some keystrokes when working with jQuery.

6 - Git: The Git bundle provides access to common Git commands without leaving your editor. Do things like viewing your uncommitted changes, find out who made that bad code change, and commit your changes to the repository.

7 & 8 - rSpec/Cucumber: Outside-in Rails development has never been easier with Behaviour Driven Development (BDD) tools rSpec and Cucumber. These bundles allow for the running of specs and features from within TextMate and provide an HTML output of the results.

9 - Code Beautifier: TextMate does a good job of formatting your code but there is room for improvement. Using the Option-Command-B keyboard combination, the Code Beautifier bundle will clean up any white space and fix indentation in your ruby code. This is one of my most used bundles when I work with TextMate.

10 - Compass + Blueprint: Compass is the amazing Sass framework which cuts down development time by providing mixins and a means for doing unobtrusive CSS. This Compass bundle focuses on snippets for the popular Blueprint CSS framework.

Give these bundles/plugins a try and be sure to let me know of any you think belong on this list.

How to setup Git to use Diffmerge

Kevin Faustino — Sat, 03 Apr 2010 00:00:00 +0000

Merge conflicts, they are bound to happen sooner or later when you are working in parallel with a team of developers. When Git cannot automatically merge changes, a merge fails and the conflicted file becomes littered with <<<<<<<, =======, and >>>>>>> markers. To ease the pain of having to performing merges, Git allows using one of many supported merge tools or you can configure Git to use the tool of your choice instead.

In this post, I am going to show you how to do the latter in Mac OS X using my preferred merge tool, Diffmerge. Diffmerge is a free graphical file comparison tool by SourceGear available in Mac OS X, Linux, and Windows. It is ideal to perform 3-way merges as it supports 3-way file comparison. During a conflict, you are presented with the version of the branch you are working on, the common file ancestor, and the branch you are merging in.

Visual Mergetool Configuration

Running the following commands in your terminal will set Diffmerge as your default visual mergetool:

git config --global merge.tool diffmerge

git config --global mergetool.diffmerge.cmd "diffmerge --merge
--result=\$MERGED \$LOCAL \$BASE \$REMOTE"

git config --global mergetool.diffmerge.trustExitCode true

As of the 3.3 release of Diffmerge, exiting a visual merge will return the correct status to Git. Prior to this release, Diffmerge would always return 0, indicating that the merge was resolved even on aborted merges. When you attempt to close Diffmerge, you will be prompted to choose if the merge is to be aborted or is resolved.

To start a 3-way merge with your visual mergetool, run:

git mergetool

This will perform a visual merge for each file in conflict. You may also provide an optional file parameter, to perform a merge on a specific file.

Don’t store backups

By default, Git will store a backup of the original file with conflict markers after a successful merge. These files will have a .orig extension added to the original filename. When I configure Git, I ensure that these files are not saved. To globally disable backups of the original merge file, run the following:

git config --global mergetool.keepBackup false

Visual Difftool Configuration

You may also setup Diffmerge to be your visual Difftool by running the following commands in your terminal:

git config --global diff.tool diffmerge
git config --global difftool.diffmerge.cmd "diffmerge \$LOCAL \$REMOTE"

This will allow you to compare two different versions of files visually. For example:

git difftool master~1 foo.rb

Binged In Action

Kevin Faustino — Sun, 21 Mar 2010 00:00:00 +0000

In our last post, we introduced Binged, a simple api wrapper for the Bing API. To demonstrate how to utilize this gem in your Ruby on Rails projects, view the screencast below:

Outsource your site-wide search with Binged

Kevin Faustino — Mon, 15 Mar 2010 00:00:00 +0000

Why use Bing for your site?

The Bing API does not cost you a single penny to use. It’s completely free! Bing’s biggest competitor, Google Site Search on the other hand can cost you from $100 annually to a price point only known by calling a google sales representative. Looking at the their small business plan, it will cost $250 annually for 1,001 – 5000 indexed pages. If your site has a lot of pages, it will start feeling very limited. Using the Bing API, you have access to the same results as the Bing search engine and not a small subset. The one limitation to the API is that you can only request the first 1000 results of a query. If your site displays 20 results per page, that is a total of 50 pages of search results.

Bing also provides unlimited bandwidth for queries as long as you make less than 7 queries per second per IP address. In a single day, you can query 518,400 times per server. That is a magnitude of search queries that will satisfy even large web applications. Compare this with the $750 annual google plan that only allows 500,000 queries per year!

Finally, the another great benefit of using the Bing API is that you can style the results to match the look and feel of your site.

The Rules

Based on the Bing Web Services API Terms of Use, the following rules must be followed in order to use Bing:

It is to only be used for display in your Website or application.
You must display some form of attribution to Bing compliant with the Microsoft branding rules.
Do not filter any results you request.
If you interleave with other sources, you must clearly differentiate those sources.
Be sure to read the full Terms of Use to know exactly what you are entitled to.

Bing in Ruby via Binged

Binged is a ruby gem I wrote that wraps the Bing API. It allows ruby developers to work with bing using all the common ruby syntax and idioms they know. Binged also has a chainable query syntax to allow easy query construction based on a large set of available filters.

Installation

[sudo] gem install binged

Get Your Bing API key

To use binged, you will require a Bing API key. Create one at http://www.bing.com/developers/createapp.aspx.

Usage

Instantiate a Client

binged = Binged::Client.new(:api_key => 'binged')

The client is used to search via different sources and holds a reference to your api key to simplify calls to the API.

Ruby on Rails configuration

Binged allows for configuration to be done once using a configure block. To use binged in your Ruby on Rails project, configure it globally in an initializer like this:

# config/initializers/binged.rb
Binged.configure do |config|
  config.api_key = 'api_key'
end

Globally configuring Binged removes the need to provide the client with any credentials or options in your code as they would have already been set. For example, defining a client would be as follows:

binged = Binged::Client.new

Web Search Example

The following example demonstrates how to search within a specific site for a keyword and provide a maximum of 30 results:

Binged::Client.new.web('ruby').from_site('adventuresincoding.com').per_page(30).each do |result|
  puts result.title
  puts result.description
  puts result.url
end

Conclusion

For simple site-wide search, Bing is the optimal solution for most web applications. It is free and the usage limits are so lax, they can almost be thought of as unlimited. Be sure to check out the Binged documentation to get a grasp of all the conditions you can specify in your queries. If you find a bug or have a great feature idea, create an issue over at GitHub.

Update

View the Binged screencast on how to integrate Binged with your Ruby on Rails application.

Creative Commons: http://www.flickr.com/photos/chrisjohnbeckett/ / CC BY-NC-ND 2.0

How to clean up your ActiveRecord migrations

Kevin Faustino — Thu, 18 Feb 2010 00:00:00 +0000

Migrations in Ruby on Rails allow you to alter your database using a convenient and easy DSL. When I started using Rails, migrations were a breath of fresh air. Database schema were finally easy. No longer did I have to pass SQL scripts to developers to run against their development DB or make a huge script to run at deployment. Migrations took care of this. However the problem with migrations is that after a while, a huge amount of migration files build up in your project. Below are detailed steps on how to clean up your migrations to make managing them easier.

Step 1: Ensure you include `db/schema.rb` in your SCM

The file db/schema.rb is the current definition of your database. It is versioned and updated after a migration is run. This file is essential in creating your database once all your older migrations are gone. Remember that db/schema.rb is db agnostic, so any implementation specific db statements in your migrations will not exist in the schema.

Step 2: Migrate to the latest version

Notify your team to checkout the latest version of your project and migrate. This will ensure that future migrations will continue to run smoothly on their current development database.

Step 3: Seed your database with db/seeds.rb

Go through each of your migrations and ensure that no data is being inserted in any of them. Migrations are only supposed to be used to manipulate the structure of your database, not populate it. Rails provides a file db/seeds.rb where you can run ruby code and model creation statements to set all the data required by your application to start.

Below is an example of a db/seeds.rb file setting up the users of a system:

User.create [{ :name => 'admin' }, { :name => 'foo' }, { :name => 'bar' }]

You can populate your database with seed data anytime by running rake db:seed. Seeding was added in Ruby on Rails 2.3.4.

Step 4: Keep only latest migrations

Go to db/migrate folder and delete all but your latest migration or move the older migrations to a folder such as db/archieved_migrations. You will want to keep the last migration as a reference if you need to migrate down.

Step 5: Setting up a fresh environment

Even though all your migrations are gone except for one, a developer can setup a fresh environment with a development database containing all required data by running one rake task: rake db:setup. This task will create the database, load the entire schema from db/schema.rb, and then populate the database based on db/seeds.rb.

Creative Commons: http://www.flickr.com/photos/kaiton/ / CC BY-SA 2.0

Riding Ruby on Rails 3: Bundler

Kevin Faustino — Tue, 09 Feb 2010 00:00:00 +0000

This week a gift was given to us by the rails core team with the release of the Ruby on Rails 3 beta. To prepare both newcomers and experienced Rails developers, AdventuresInCoding is going to be releasing screencasts and posts about Ruby on Rails 3. Our first screencast is about gem dependency management with Bundler.

Taking the helm of ruby with Ruby Version Manager

Kevin Faustino — Mon, 08 Feb 2010 00:00:00 +0000

Ruby Version Manager) the name says it all. The sole purpose of this gem is to mange which version of ruby your system is currently utilizing. The days of creating symbolic links to different installations of ruby are over. With a single command, RVM will change the version of ruby and its gems for your entire user profile.

Developers using Mac OS X can start using ruby the moment they boot up their machine for the first time. In fact, the latest version of Mac OS X Snow Leopard ships with ruby 1.8.7 MRI patch level 77. The problem with system versions such as the one bundled with Mac OS X is that they stagnate, causing developers to miss out on the latest patches applied to ruby. For example. my current default version of ruby is 1.8.7 MRI patch level 248.

Besides the benefits of patches, why would a developer with a default version of ruby care about managing it? According to a recent report by New Relic, 63.5% of all deployments use ruby 1.8.6 MRI. This indicates that a large portion of the ruby community does not want to make the jump to higher version numbers. RVM provides you the tools to test, benchmark and switch your ruby versions with minimal effort. Before RVM, you would have had to compile which version of ruby you wanted, manage the symlink to it and update the PATH environment variable. If you wanted another version installed, you would have to link it to another name such as ruby19.

Installing RVM

Before installing RVM, make sure you have the latest Xcode developer tools installed as you will experience compilation issues with certain gems if you do not. Mongrel for example will not compile its native extensions without the latest Xcode developer tools.

To get started, you must first install the gem:

sudo gem install rvm

Once installed, initialize the RVM installation and follow all prompts:

rvm-install

Finally, install any version of ruby you would like to use, in this case the latest version of 1.8.7 MRI:

rvm install 1.8.7

Switching Between Ruby Versions

To switch between versions of ruby, pass the use action to RVM:

rvm use 1.9.1 
rvm use 1.9.1-p378

RVM allows you to set a default version via the –default flag to easily switch to the version of ruby you use most:

rvm 1.8.7 --default 
rvm default

If you ever feel the need to use the original system version of ruby, RVM allows switching via the system action:

rvm system

Installing Gems

All gems are installed in their own gem directory for each version of ruby. You would install gems with RVM the same way you do now, except you do not prefix sudo to the gem command. RVM runs under your user profile. By running sudo, you are telling the system to run as the root user which does not have your RVM setup.

Example, install the rails gem:

gem install rails

RVM also allows installation of gems on multiple versions of ruby:

rvm 1.8.7,1.9.1 gem install rails

RVM Configuration

To set common flags when compiling ruby gems, RVM allows settings to be placed in a .rvmrc file.

Here are the contents of my ~/.rvmrc file:

rvm_archflags="-arch x86_64"

MySQL Gem

Some gems require flags such as the MySQL gem. To install the MySQL gem make sure you have set rvm_archflags in your .rvmrc file.

gem install mysql -- --with-mysql-config=/usr/local/mysql/bin/mysql_config

The Benefits

Besides the benefit of being able to experiment with any ruby interpreter and version, RVM has a few killer features as well. For example, RVM allows the execution of ruby programs and rake tasks across all of your ruby versions, which ensures backwards compatibility and future proofing of your ruby gems, applications, etc.

To run a ruby program against all installed ruby interpreters, use the ruby action:

rvm ruby hello_world.rb

As with most actions, the ruby action can be restricted to a few versions:

rvm ruby 1.8.7,jruby hello_word.rb

The feature I use most often is the ability to run your rake tasks across all interpreters. This is done via the rake action.

rvm rake spec

Running the above command runs all of your specs across the installed interpreters. Since running your specs is a common task, RVM provides a shortcut:

rvm specs

Finally, with minimal effort, RVM can help you learn how fast your code will run under each ruby version through the benchmark action.

rvm benchmark hello_world.rb

Ruby Version Manager is an amazing project by Wayne E. Seguin. It is an essential tool for gem authors and any ruby developer who has to maintain applications across multiple versions of ruby. I have been using RVM for over 6 months and it has made managing ruby a pleasure.

Adventures In Coding

Now writing at The Remarkable Labs Blog

A review of "The Rails View" by Bruce Williams and John Athayde

Who Should Read It?

The Chapters

Beautiful Markup

Verdict

Using elasticsearch with Heroku

Bonsai ElasticSearch

Configuring Tire to work with Bonsai

Indexing

Final Note

Full-Text Search in Rails using elasticsearch

elasticsearch

Blog Engine Background

Getting Started

Tire

Search Feature

Search Form

Controller

Route

Helper

Search index view

Adding Tire to ActiveModel

Handling requests to elasticsearch from RSpec

Handling search calls to elasticsearch

Returning to Cucumber

After thoughts

How to configure Cucumber and RSpec to work with Mongoid 3.0

RSpec

Cucumber

Easily deploy to multiple environments on Heroku with heroku_san

Install

config/heroku.yml

Setup

Deploying

Benefits

Managing your web applications with Foreman

Procfile

Getting Started

Concurrency

.env

Procfile.development

Further Reading

How to get ApacheBench(ab) to work on Mac OS X Lion

Solution

Step 1: Download the latest version of apache

Step 2: Install missing dependencies

Step 3: Build Apache

Step 4: Replace ab

The future of Adventures in Coding

The Mission Statement

What can you expect

Speed up your websites with Smusher

"Lossless" images

Smusher

Usage

.puny_png_api_key

Use it

Getting Inherited Resources 1.2.1 and Mongoid to play nice

Rails Templater - Agnostic at last

What Rails Templater used to be

What is Rails Templater today?

Usage

Contributing new recipes

Writing modular HTTP client code with Faraday

Installation

Using Faraday

Creating a Middleware

Note

34 Ruby on Rails 3 resources to get you started

Overviews

ActionController / Rack

ActionMailer

ActiveRecord/ActiveModel

Bundler

Railties

Routes

Plugins

Books

Step 1: Ensure you include `db/schema.rb` in your SCM