The Remarkable Labs Blog

The Rails 4 Way (beta) now available

Kevin Faustino — Tue, 07 May 2013 10:51:09 -0400

I'm excited to announce that I am a co-author of The Rails 4 Way. I'm joined with Obie Fernandez himself, and fellow co-authors Vitaly Kushner and Ari Lerner.

The original "The Rails Way" holds a special place in my heart as it was my ultimate reference when I started developing with Ruby on Rails. With each new edition of the book, it has become better and better, providing no fluff content and containing great advice from various Rails developers from around the world. What sets The Rails Way apart from other Rails books in the market, is that it covers topics and technologies that practitioners consider to be ideal. This means it covers things such Haml, RSpec, and FactoryGirl over Erb, TestUnit, and fixtures respectively. While this may not be everyone's preferred stack, the book still has something for everyone. The coverage of Active Record alone could be its own book and is a must read for any Rails developer.

Thanks to the cooperation of Addison-Wesley, you can purchase a DRM-free copy of The Rails 4 Way today on the great Leanpub service. For those who like physical books over digital copies, the published Addison-Wesley edition is expected to be released sometime late in the year.

Since the book is still in beta, its not 100% complete yet. Expect updates every couple of weeks, updating the second half of the book to Rails 4 and including many tips and gems that are relevant to Rails development today. Some things to look forward to is coverage of Sidekiq, Sorcery, Draper, Active Model Serializers, and more. We have also taken into consideration feedback from previous editions, and we are going to include a Haml, Sass, and CoffeeScript reference to make The Rails 4 Way an even better resource. You submit any suggestions or errors to our lighthouse issue tracking page.

Using Sidekiq to send emails asynchronously

Kevin Faustino — Tue, 22 Jan 2013 11:36:34 -0500

If your web application needs to send out emails, the best practice is to send them asynchronously in a background task. This usage is so common that Rails 4 added an asynchronous Action Mailer, but the feature will no longer be making the original 4.0 release. In spite of that, the asynchronous Action Mailer would have been a temporary solution for developers until they were ready to run their own dedicated queue.

A lot of Ruby developers are familiar with queues, such as DelayedJob and Resque. While these queues have been predominant the last couple of years, my tool of choice is Sidekiq, a Redis backed queue by Mike Perham. Sidekiq advertises that a single process can do the work of 20 Resque or DelayedJob processes. Another benefit of Sidekiq is the inclusion of extensions, which allows for testing and delayed mailers.

Getting Started

Add Sidekiq to your Rails project by including it to your Gemfile and run the bundle command:

# Gemfile
gem 'sidekiq'

To run Sidekiq, run the following:

$ bundle exec sidekiq

Sending Delayed Emails

Sidekiq supports sending emails asynchronously with Action Mailer out of the box. It does this by including three methods to the ActionMailer module.

`.delay`

The method that you will likely use the most is .delay. Calling .delay from an Action Mailer will result in the email being added to the DelayedMailer queue for processing.

Example:

SubscriptionMailer.delay.welcome(@user.id)

Note the absence of .deliver in the above code snippet, as that execution is performed by the DelayedMailer.

`.delay_for(interval)`

Sidekiq also supports the delayed delivery of emails by providing a specified interval to the .delay_for method.

Example:

UserMailer.delay_for(1.day).status_report(@user.id)

`.delay_until(timestamp)`

The last Action Mailer method added by Sidekiq is .delay_until. Sidekiq will wait until the provided time to send the email.

Example:

UserMailer.delay_until(3.days.from_now).status_report(@user.id)

How about Devise emails?

Devise has its own mailer for authentication emails. You can enable asynchronous emails for Devise by using the devise-async gem. Note that emails queued via devise-async are added the mailer queue by default.

To setup devise-async, add it to your Gemfile and run the bundle command:

# Gemfile
gem 'devise-async'

Add the :async option to the devise call in your authentication model:

class User < ActiveRecord::Base
  devise :database_authenticatable, :async, :confirmable #...
end

Finally, create an initializer to set Devise::Async.backend to use Sidekiq:

# config/initializers/devise_async.rb
Devise::Async.backend = :sidekiq

Testing

Sidekiq comes with some great test/spec helpers to make testing against it easy.

In spec/spec_helper.rb, requiring sidekiq/testing forces Sidekiq to not push jobs to Redis, but an array named jobs for testing purposes.

# spec/spec_helper.rb
require 'sidekiq/testing'

To ensure emails are correctly enqueued in Sidekiq, you can test against the jobs size of the Sidekiq::Extensions::DelayedMailer:

expect { SubscriptionMailer.delay.welcome(user.id)}.to change(Sidekiq::Extensions::DelayedMailer.jobs, :size).by(1)

Creating Retina Images with CarrierWave

Kevin Faustino — Fri, 18 Jan 2013 11:11:05 -0500

In yesterday's post Retina Web Design, we covered multiple techniques to be "retina-ready" for the upcoming wave of double density screens. One of the techniques mentioned was to use retina.js, a JavaScript library that attempts to serve higher resolution images for visitors of your web application. To ensure even your uploaded image assets will work with retina.js, we can utilize CarrierWave to upload both standard and high resolution image versions.

One constraint we must conform to is naming our "retina" image versions to use the Apple @2x naming style. CarrierWave allows us to set a specific file name for each version of an uploaded file. To do this, we must override the #full_filename method defined in the CarrierWave::Uploader::Versions module.

Example

The key to using this technique is to not resize the original version of the image smaller than the "retina" version. In the example below, we do not process the original image and instead create a thumb and retina_thumb version. Also note that when creating a "retina" image, the dimensions must be double the size of the standard definition version.

class AvatarUploader < CarrierWave::Uploader::Base
  include CarrierWave::MiniMagick

  version :thumb do
    process resize_to_fill: [100, 100]
  end

  version :retina_thumb do
    process :resize_to_fill => [200, 200]

    def full_filename(for_file = model.avatar.file)
      super.tap do |file_name|
        file_name.gsub!('.', '@2x.').gsub!('retina_', '')
      end
    end
  end
end

Processing a png image to the AvatarUploader above, would result in three versions uploaded to your asset store:

The original file
A thumbnail named thumb.png with dimensions 100x100
A retina thumbnail named thumb@2x.png with dimensions 200x200

APIs

This technique is also useful for APIs designed specifically for iOS applications. If an API endpoint returns images, you can return both standard and high resolution version paths of the image and leave the decision of which version to use to the API consumer.

Retina Web Design

Kevin Faustino — Thu, 17 Jan 2013 15:26:02 -0500

Devices with retina displays are changing the way we design web applications. When Apple introduced the iPhone 4, we got a glimpse into how images on our sites look on retina enabled screens. Last year, the retina enabled iPad and Macbook Pro came to market, highlighting the fact that most web sites are not retina-ready.

One day retina displays will no longer be the exception, but the standard. However until that time, we need to take steps to ensure all the people visiting our web applications are getting the same polished experience.

What is retina?

Retina is a term used by Apple to describe their double density pixel screens. A device pixel is not the same as the pixels we define within our CSS declarations. A CSS pixel is an abstract unit used by web browsers to draw content. On non-retina displays a CSS pixel maps directly to a device pixel. On retina displays, this is quadrupled as one CSS pixel can equal 4 device pixels.

Image sizes on the web are also defined in CSS pixels. If a height/width is defined in either markup or CSS, the browsers will either stretch or squeeze the image when rendering the web page.

To demonstrate a non-retina image on a double density screen, let's take a look at the how the Remarkable Labs logo renders:

As you can see, the image becomes blurry as it is stretched to fit within a defined area of CSS pixels.

How to move forward?

There are a variety of strategies you can use to optimize your graphics to work with retina enabled devices. Let's take a look at some of the ones we use here at Remarkable Labs.

Use CSS3 and HTML5 over graphics

The days of using images for rounded corners, gradients, and text are long behind us. Using CSS3 properties, we are now able to create beautiful web pages natively within the browser with minimal graphics.

While I am not going to go into detail about CSS3, here are a couple of resources to look into if your interested:

Icon Fonts

I'm a big fan of using icon fonts wherever you can. They allow you to have "graphics" which are rendered as text. This means you can apply any CSS property you can use for text, such as font-size and color.

I highly recommend using Zurb's Foundation Icon Fonts 2:

You can even build your own with Fontello, an icon font generator that includes free icon fonts available on the web.

Media Query Targeting

Using media queries, we are able to target retina devices and minimum resolutions. When targeting with media queries, ensure you include all device-pixel-ratio browser specific properties. Also, setting min-device-pixel-ratio to 1.3 and min-resolution to 1.3dppx allows us to support new Android devices, such as the Google Nexus 7. The background-size property defines the width and height of image contained within the container.

.logo {
  background: url(path/to/image.png) no-repeat;
  @media (min--moz-device-pixel-ratio: 1.3),
          (-o-min-device-pixel-ratio: 2.6/2),
          (-webkit-min-device-pixel-ratio: 1.3),
          (min-device-pixel-ratio: 1.3),
          (min-resolution: 1.3dppx) {
      background-image: url(path/to/image@2x.png);
      background-size: 100px 100px;
  }
}

If you are using Sass for authoring your CSS, please use the great mixin shared in the 37Signals post Easy retina-ready images using SCSS.

SVG

SVG(Scalable Vector Graphics) support is now available on all major browsers, even Internet Explorer! The benefits of using vector graphics over images are:

Scalability: Scalable Vector Graphics do not have the limitation of regular images, as they can scale to any size without distortion.
Tiny Footprint: File sizes tend to be smaller and thus use less bandwidth.

To find out more about SVG, read the excellent article "Resolution Independence With SVG" on Smashing Magazine.

Using JavaScript with retina.js

With the JavaScript library retina.js, you can integrate retina graphics very easily just by including the library in your web pages. On the loading of a web page, retina.js will determine if the user is using a double density screen. If they are, retina.js will go through each image on the page and check the server to see if a high resolution version is available. The high resolution images are expected to follow the Apple naming standard <ImageName>@2x.<filename_extension>.

While this technique is very easy to implement, the main disadvantage is all retina enabled devices download both high resolution and standard images. In his post "Don't Use JavaScript for Retinafying", Thomas Fuchs advocates designing "retina-first" over using JavaScript libraries.

Designing "retina-first" does have disadvantages as well. Retina displays are not common place yet, thus by using higher resolution images only, we are serving larger assets to all our visitors. This can in turn slow down your sites as response payloads become much larger. My advice is look at your site metrics, and determine how many users are using "retina" displays to gauge which technique to pursue.

How to decrease coupling in your controllers & views with decent_exposure for better maintainability

Kevin Faustino — Fri, 11 Jan 2013 14:26:36 -0500

If you're a Rails developer, you're familiar with with the standard way of sharing data from the controller layer to the view layer. By convention, Rails copies all instance variables defined in the execution of a controller action to the view context. This standard usage will result in strong coupling between your controllers and views, as they are sharing state via instance variables.

To solve this problem, Stephen Caudill created the decent_exposure gem. Decent Exposure works by "exposing" methods over instance variables. This results in the ability to program views to an interface over a controller implementation.

Converting a standard controller to use decent_exposure

To demonstrate how to use decent_exposure, let's convert the follow controller:

class ComicsController < ApplicationController
  def index
    @comics = Comic.all
  end

  def show
    @comic = Comic.find(params[:id])
  end

  def new
    @comic = Comic.new
  end

  def edit
    @comic = Comic.find(params[:id])
  end

  def create
    @comic = Comic.new(params[:comic])

    if @comic.save
      redirect_to @comic, notice: 'Comic was successfully created.'
    else
      render action: "new"
    end
  end

  def update
    @comic = Comic.find(params[:id])

    if @comic.update_attributes(params[:comic])
      redirect_to @comic, notice: 'Comic was successfully updated.'
    else
      render action: "edit"
    end
  end

  def destroy
    @comic = Comic.find(params[:id])
    @comic.destroy

    redirect_to comics_url
  end
end

To begin, we need to use the expose macro style method provided by decent_exposure to define the methods we want to make available to our controller. The expose macro will also declare the method as a helper method for your views to access:

class ComicsController < ApplicationController
  respond_to :html

  expose(:comics)
  expose(:comic)

  def create
    comic.save
    respond_with(comic)
  end

  def update
    comic.save
    respond_with(comic)
  end

  def destroy
    comic.destroy
    respond_with(comic)
  end
end

At first glance, you will notice the removal of the index, show, new, and edit controller action definitions. This is a result of using another Rails convention. If a route is defined for the controller action, and a method is empty or not defined, Rails will by default render the standard template for the requested action. For example, if the index action was requested, Rails would render the view app/views/comics/index.html.erb by default. To clean up things further, we also take advantage of responders.

Also gone are the previously defined instance variables. The expose macro will initialize or query for resources based on some criteria. Here is a breakdown of how decent_exposure sets each resource in the above example:

The collection of comics used by the index action will be queried by default using Comic.scoped.
If no :id parameter is available in the controller params hash, decent_exposure returns Comic.new(params[:comic]).
If an :id parameter is present, decent_exposure will query for the resource by executing Comic.find(params[:id]. If a plural exposed resource is available, decent_exposure will scope the singular version to it. Thus, comic is set to Comic.scoped.find(params[:id]).

Next, all calls to previously defined instance variables must be changed to their method counterpart. For example, all calls to @comics, must now send a message to comics instead.

<!-- app/views/comics/index.html.erb -->
<h1>Listing comics</h1>

<table>
  <tr>
    <th>Title</th>
    <th>Volume</th>
    <th></th>
    <th></th>
    <th></th>
  </tr>

<% comics.each do |comic| %>
  <tr>
    <td><%= comic.title %></td>
    <td><%= comic.volume %></td>
    <td><%= link_to 'Show', comic %></td>
    <td><%= link_to 'Edit', edit_comic_path(comic) %></td>
    <td><%= link_to 'Destroy', comic, method: :delete, data: { confirm: 'Are you sure?' } %></td>
  </tr>
<% end %>
</table>

<br />

<%= link_to 'New Comic', new_comic_path %>

Nested Resources

Another benefit to using the decent_exposure gem is its ability to work with nested resources out of the box. As an example, say comics were nested under a publisher, decent_exposure will be able to instantiates/queries for resources based on Rails conventions:

expose(:publisher)
expose(:comics, ancestor: :publisher)
expose(:comic)

In the above code, the exposed publisher method will be set by Publisher.find(params[:publisher_id]). Next, a nested relationship is defined via the exposed comics method. The comic exposed method will then use the pluaral exposed method to ininitialize/query resources. In the above example, quering for a Comic resource would call Publisher.find(params[:publisher_id]).comics.find(params[:id]).

Scopes

In instances where you would like to use a scope with a exposed method, pass a block to the expose macro:

expose(:comics) { Comic.recent }

Non-Conventional

Your application will likely contain instances where you do not want to query by an id. In those cases, decent_exposure provides some options to make your life a little easier.

finder_parameter

Maybe you don't query all the time using an :id parameter. In these cases, you can define what you want decent_exposure to use via the :finder_parameter option:

expose(:issue, finder_parameter: :slug)

model

If the name of your exposed method does not match to an existing model, use the :model option:

expose(:issue, model: :comic_issue)

params

Sometimes if you are using a custom form, you will pass different parameters to your controller. To handle this situation, use the :params option:

expose(:comic, params: :comic_params)

Playing friendly with Strong Parameters

By default, decent_exposure does not support the Strong Parameters gem. With strong parameters being the standard for sanitizing your parameters moving forward in Rails 4, it is recommended you use the decent_exposure strategy available on the project's wiki

To enable support, create a file strong_parameters_strategy.rb in your lib directory with the following code:

# https://github.com/voxdolo/decent_exposure/wiki/Strategies:-Use-with-strong_parameters
class StrongParametersStrategy < DecentExposure::ActiveRecordWithEagerAttributesStrategy
  delegate :delete?, :to => :request

  def attributes
    (get? || delete?) ? super : controller.send(:"#{name.singularize}_params")
  end
end

Next, create an initializer to ensure the strategy will be available to decent_exposure:

# config/initializers/decent_exposure.rb
require 'strong_parameters_strategy'

Finally, in any exposed methods where you want to utilize strong parameters, set StrongParametersStrategy to the :strategy option:

expose(:comic, strategy: StrongParametersStrategy)

When saving/updating a resource, decent_exposure will now look for the associated resource_name_params method within your controller. In the above example, we would define a private controller method named comic_params:

def comic_params
  params.require(:comic).permit(:title, :volume)
end

Install

To use decent_exposure in your Rails project, add it to your Gemfile and run the bundle command:

gem 'decent_exposure'

MailCatcher: Making working with email in development mode a pleasure

Kevin Faustino — Wed, 09 Jan 2013 10:15:28 -0500

When developing web applications, working with email has always been a pain. By default in Ruby on Rails, all email messages sent in development via Action Mailer are delivered in test mode. This means if you send an email from your application, the output of that message would display in your development log. While this can show you if the output is correct, it does not indicate if the HTML of the email message is rendered correctly. A way around this would be to connect your development environment to an actual SMTP server. Even though this would allow you to view the email in your mail client of choice, it is a very bad idea, as you could potentially email real people.

Originally to solve this problem, the ruby gem letter_opener was our tool of choice. When an email was sent from the web application, letter_opener would open up the email in a new browser tab. However, in use cases where multiple emails were fired off, multiple browser tabs being opened at once was very obtrusive.

Enter MailCatcher

MailCatcher is a ruby gem that runs a local SMTP server on your machine. Any email message sent to this SMTP server will be captured and not sent out. Also, all messages will be viewable in a web interface available at http://localhost:1080.

MailCatcher utilizes WebSockets to display email messages immediately after they are sent without a refresh to the browser. If your browser does not support WebSockets, a simple refresh will update the email listing.

Another great feature of MailCatcher is the ability to view both the HTML and plain text versions of emails. This feature alone has saved us some time during testing of our email views.

MailCatcher also lists any attachments within the email for easy downloading.

Getting Started

To get up and running, install the mailcatcher gem:

$ gem install mailcatcher

Next, in your development configuration file config/development.rb, set the following Action Mailer settings:

config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = { address: 'localhost',
                                         port: 1025 }

Finally, start the mailcatcher daemon in your terminal:

$ mailcatcher
Starting MailCatcher
==> smtp://127.0.0.1:1025
==> http://127.0.0.1:1080
*** MailCatcher runs as a daemon by default. Go to the web interface to quit.

Quarterly Goals and Habits over Resolutions

Kevin Faustino — Mon, 07 Jan 2013 14:15:49 -0500

The beginning of the New Year is the time when businesses and individuals set resolutions for the year. While it's important to set high-level goals for the upcoming year, I tend to focus not on resolutions, but creation of habits and quarterly goals instead.

Setting a yearly goal/resolution is like developing a software product using the Waterfall model, it doesn't account for change. Things happen that can alter the course of our lives and businesses. By planning quarterly over yearly, it allows us to embrace change and shift our focus to goals that will have the most impact on our businesses and lives.

Achieve Yearly Objectives with Quarterly Goals

Planning quarterly all the time is nice, but sometimes there are high-level goals which your business does want to achieve. This can be something like reaching X amount of revenue in 2013. To plan for these types of goals, break them down into manageable parts.

For example, if a software product wanted to gain 1000 new customers in 2013, they could set a quarterly goal of 250 new customers instead. After the first quarter, based on the amount of new customers obtained, you can pivot the goal for the next quarter, or proceed with trying to obtain 250 more new customers.

How I Plan

I've developed a system using a combination of techniques found in The Accidental Creative, Getting Things Done, and Eat That Frog.

The Accidental Creative discusses the concept of "Checkpoints", which focuses on having weekly, monthly and quarterly reviews. Within each of these checkpoints, you evaluate:

Your areas of focus
Relationships
Energy (Are there projects that need to be pruned?)
Stimuli (What will help you with upcoming projects and grow?)
Hours (What will require the most of your time)

On top of these areas, I apply the "Law of Three" defined in Eat That Frog. In each following category, I define the three most important goals for the quarter:

Business/Career
Family/Relationship
Financial
Health
Professional Development
Social/Community

Once all quarterly goals have been set, I create projects for each goal in my GTD system. I recommend Things as it works perfectly with GTD and syncs over the internet. The next step is to set challenges/tasks for each goal/project. Set deadlines for each action step, as a goal without one has no urgency.

Habits

Some lifestyle goals such as losing X amount of weight/inches, and being more productive are fundamentally tied to developing habits. Charles Duhigg's book "The Power of Habit" goes into how certain habits are triggered via a habit loop. This loop consists of a trigger("cue"), a routine, and finally a reward.

Once you are aware of how habits are triggers and created, it makes it much easier to develop new ones. I cue habits everyday using the iPhone application Commit. At a specified time, Commit will send me a reminder("cue") asking if I've committed to a specified goal. By executing the commitment once I am reminded, it triggers a "routine", which ultimately allows me to reach my goal("reward").

Current Goals

Listed below is a sample of some goals/challenges I want to achieve in the next quarter.

Write 1000 words a day

One of my high-level goals is to become a better writer. The key to becoming better at anything is practice, practice, practice. Thus for the next quarter, and most likely the year, I want to write 1000 words a day. The writing can be done towards anything from this blog, a book, or a journal. I will be using the site 750words.com to keep track of my progress.

Complete the "Rails 4 Upgrading Guide" eBook

With the completion of the Rails 4 Countdown series, the next step is to expand on what I have wrote, and make an ebook which can be used as a reference for those developers upgrading from Rails 3. Over the next three months, I want to have this completed and sent to all the Remarkable Labs newsletter subscribers.

Launch a Web Application

Nathan Barry in his blog wrote about a Web App Challenge. Essentially to complete the challenge, you must build a web application within six months to have $5,000 in recurring revenue each month. Over the next quarter, I want to take the steps necessary to launch my own product to coincide with this challenge.

Get back to the gym and lose 18 pounds

While this goal is cliché, going to the gym in the morning was something that allowed my day to get off to a great start. I had more energy, felt better, and enjoyed setting fitness goals for myself. Over 8 months ago, I stopped going to the gym due to an injury and never got into the habit of going again. Hopefully, I can rectify that.

Feedback

I'd love to hear your thoughts on this system and any goals you have personally set. Feel free to email me or leave a comment.

Rails 4 Upgrading Guide [Rails 4 Countdown to 2013]

Kevin Faustino — Mon, 31 Dec 2012 09:27:27 -0500

This post is part of a series of 31 Rails 4 articles being released each day in December 2012.

As 2012 comes to a close, we can look forward to 2013 as Ruby on Rails 4.0 will be released sometime in the coming year. Over the month of December, we have covered what we feel are some of the biggest changes coming to Rails 4.

We at Remarkable Labs really hope you've enjoyed the series, and to finish it off, I wanted to announce that I will be writing an ebook, titled "The Rails 4 Upgrading Guide". While not yet complete, here is a list of some of the content to look forward to:

In-depth coverage of what's new to Rails 4
A step-by-step guide for upgrading your Rails 3 application
Tips and use cases on using Rails 4's new features
Upgrading checklist

The ebook will be available in PDF, ePub(iBooks, Nook), and Mobi(Kindle) formats. We are also making it absolutely free for all our mailing list subscribers. Be sure to sign up for the mailing list to receive your copy of "The Rails 4 Upgrading Guide" when it's finished.

Live Streaming [Rails 4 Countdown to 2013]

Kevin Faustino — Sun, 30 Dec 2012 16:38:35 -0500

This post is part of a series of 31 Rails 4 articles being released each day in December 2012.

One major feature being added to Rails 4 is the ability to stream data to the client. While the streaming of templates is currently available in Rails 3, thanks to Aaron Patterson's efforts, we can now stream other types of data such as JSON.

To enable live streaming in a controller, you must mixin the module ActionController::Live. This provides an I/O like interface to the response, allowing you to continuously write to the client until the stream is explicitly closed.

Here is an example of a live streaming controller from the Rails docs:

class MyController < ActionController::Base
  include ActionController::Live

  def stream
    response.headers['Content-Type'] = 'text/event-stream'
    100.times {
      response.stream.write "hello world\n"
      sleep 1
    }
    response.stream.close
  end
end

Requirements

All actions executed from ActionController::Live enabled controllers are run in a separate thread, thus controller action code must be thread safe.
A concurrent Ruby Web Server is required to take advantage of live streaming. Be sure to take a look at puma.
Headers must be written before anything is written to the client.
Streams must be closed.

Why is this important?

This feature alone allows Rails to do more than just serve HTTP web pages and JSON. It can now handle a variety of other use cases, that were not possible in the past. For example, using Server-sent events, the ability to create chat clients, push notifications, and real-time feeds are achievable from Rails itself.

A love affair with PostgreSQL [Rails 4 Countdown to 2013]

Kevin Faustino — Sat, 29 Dec 2012 16:04:05 -0500

This post is part of a series of 31 Rails 4 articles being released each day in December 2012.

Out of all the supported databases available in Active Record, PostgreSQL received the most amount of attention during the development of Rails 4. In today's countdown post, we are going to look at the various additions made to the PostgreSQL database adapter.

hstore support

Rails 4 comes with hstore support out of the box. hstore allows you to store a set of key/value pairs within a single PostgreSQL value. In other words, it allows you to have NoSQL schema-less data support in PostgreSQL.

To get started, first setup your database to use the hstore extension:

class AddHstoreExtension < ActiveRecord::Migration
  def up
    execute 'CREATE EXTENSION hstore'
  end

  def down
    execute 'DROP EXTENSION hstore'
  end
end

Next, add the hstore column type to a model:

 class AddPropertiesToComics < ActiveRecord::Migration
  def up
    add_column :comics, :properties, :hstore
  end

  def down
    remove_column :comics, :properties
  end
end

Using the store_accessor macro style method in Active Record models, we can add read/write accessors to key/value hstore properties:

class Comic < ActiveRecord::Base
  store_accessor :properties, :story_arc
end

comic = Comic.create
comic.properties # => nil
comic.story_arc = 'Throne of Atlantis'
comic.save
# => UPDATE "comics" SET "properties" = '"story_arc"=>"Throne of Atlantis"', "updated_at" = '2012-12-29 19:31:45.234882' WHERE "comics"."id" = 1

Using the store accessors, you can include the dynamic attributes in forms and also have the ability to add Active Model validations to them.

To query against hstore data in Active Record, use SQL string conditions with the where query method:

 Comic.where("properties -> 'story_arc' = 'Throne of Atlantis'")
#  SELECT "comics".* FROM "comics" WHERE (properties -> 'story_arc' = 'Throne of Atlantis')

Note: When an hstore attribute is returned from PostgreSQL, all key/values are going to be strings.

Indexes

If you are doing any queries on an hstore property, be sure to add the appropriate index. When adding an index, you will have to decide to use either GIN or GiST index types. The distinguishing factor between the two index types is that GIN index lookups are three times faster than GiST indexes, however they also take three times longer to build. Checkout the documentation, which goes into detail about the differences.

CREATE INDEX name ON table USING gin(column);
CREATE INDEX name ON table USING gist(column);

Example:

class AddIndexToComicsProperties < ActiveRecord::Migration
  def up
    execute 'CREATE INDEX comics_properties ON comics USING gin(properties)'
  end

  def down
    execute 'DROP INDEX comics_properties'
  end
end

Note: Indexes can only be used for queries with @>, ?, ?& and ?| operators. Thus the ActiveRecord example in the previous section using the -> operator would not use any indexes. (Thanks to Philip Hofstetter for pointing this out)

Upgrade Path

If this is something you would like to use in your Rails 3 applications today, you can use the activerecord-postgres-hstore gem.

hstore resources

Array support

Another native type being supported by Active Record for PostgreSQL databases is Array.

When creating a column in a migration, you must pass true to the array option to set the attribute as an Array.

Here is an example of creating a string array of tags:

class AddTagsToArticles < ActiveRecord::Migration
  def change
    change_table :articles do |t|
      t.string :tags, array: true
    end
  end
end

# ALTER TABLE "articles" ADD COLUMN "tags" character varying(255)[]

Next, add an item to the array attribute:

article.tags = ['rails']
article.save
# UPDATE "articles" SET "tags" = '{"rails"}', "updated_at" = '2012-12-29 20:12:49.825980' WHERE "articles"."id" = 1
article.reload
article.tags # => ["rails"]

If the pg_array_parser gem is included in the application Gemfile, Rails will use it when parsing PostgreSQL's array representation. The gem includes a native C extention and JRuby support.

Resources

uuid type

Universally unique identifier (UUID) column type support has been added to Rails 4.

To set a column as UUID, use add_column in your migration and set the data type to :uuid:

add_column :table_name, :unique_identifier, :uuid

When reading/writing to a UUID attribute, you will always be dealing with a string:

obj.unique_identifier = 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'

Network Address data types

PostgreSQL has data types exclusively for IPv4, IPv6, and MAC addresses. Data types inet and cidr are used for IPv4 or IPv6 host address. The difference between inet and cidr is that the former accepts values with nonzero bits to the right of the netmask. MAC addresses are represented with the macaddr data type.

When reading inet/cidr data types from the database, Active Record will convert the values to IPAddr objects. Reading and writing to macaddr attributes on the other hand uses strings.

To set a column as a network address, use add_column in your migration and set the data type to inet, cidr, or macaddr:

class AddNetworkAddresses < ActiveRecord::Migration
  def change
    add_column :table_name, :inet_address, :inet
    add_column :table_name, :cidr_address, :cidr
    add_column :table_name, :mac_address, :macaddr
  end
end

Example:

obj.inet_address = IPAddr.new('127.0.0.1')
obj.save
obj.reload
obj.inet_address # => <IPAddr: IPv4:127.0.0.1/255.255.255.255>

Other data types

The following datatypes can be created in PostgreSQL and be correctly converted to and from the database:

int4range
int8range
json

The Remarkable Labs Blog

The Rails 4 Way (beta) now available

Using Sidekiq to send emails asynchronously

Getting Started

Sending Delayed Emails

.delay

.delay_for(interval)

.delay_until(timestamp)

How about Devise emails?

Testing

Further Reading

Creating Retina Images with CarrierWave

Example

APIs

Retina Web Design

What is retina?

How to move forward?

Use CSS3 and HTML5 over graphics

Icon Fonts

Media Query Targeting

SVG

Using JavaScript with retina.js

How to decrease coupling in your controllers & views with decent_exposure for better maintainability

Converting a standard controller to use decent_exposure

Nested Resources

Scopes

Non-Conventional

finder_parameter

model

params

Playing friendly with Strong Parameters

Install

MailCatcher: Making working with email in development mode a pleasure

Enter MailCatcher

Getting Started

Further Reading

Quarterly Goals and Habits over Resolutions

Achieve Yearly Objectives with Quarterly Goals

How I Plan

Habits

Current Goals

Write 1000 words a day

Complete the "Rails 4 Upgrading Guide" eBook

Launch a Web Application

Get back to the gym and lose 18 pounds

Feedback

Rails 4 Upgrading Guide [Rails 4 Countdown to 2013]

Live Streaming [Rails 4 Countdown to 2013]

Requirements

Why is this important?

Further Reading

A love affair with PostgreSQL [Rails 4 Countdown to 2013]

hstore support

Indexes

Upgrade Path

hstore resources

Array support

Resources

uuid type

Network Address data types

Other data types

`.delay`

`.delay_for(interval)`

`.delay_until(timestamp)`