Adventures In Coding

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 gem 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_oncomplete(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 – 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 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

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 everytime 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 mongoid 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 2 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:

A screencast demonstrating how to use the binged gem to display bing search results.

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, you 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.

An introduction to gem dependency management in Ruby on Rails 3 using 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.