The Buckblog

ActiveSupport is the unsung hero of Rails. Much of what makes Rails code beautiful and powerful is implemented in ActiveSupport. It adds numerous methods to many of the core classes, which are used throughout Rails. If you don’t mind digging around, you can find all kinds of handy tricks to use in your own applications.

Consider this common idiom:

1
2
3
4
5
6
7

def create_book
  book = Book.new
  book.title = "Trafalgar: The Nelson Touch"
  book.author = "David Howarth"
  @db.add(book)
  book
end

You create an object, set some properties on it, and then return the object. ActiveSupport adds a new method (called returning) to Object, which can be used to beautify (and in some cases, simplify) that idiom:

1
2
3
4
5
6
7

def create_book
  returning Book.new do |book|
    book.title = "Trafalgar: The Nelson Touch"
    book.author = "David Howarth"
    @db.add(book)
  end
end

The latter is no shorter than the former, but it reads more elegantly. It feels more “Rubyish”. And there are times that it can save you a few lines of code, if that’s important. (Just scan the Rails source code for more examples.)

Object#returning has been in Rails for quite some time, being checked in on March 20, 2005 in revision 949. (It now lives in active_support/core_ext/object/misc.rb, and behaves slightly differently than the original did, but it is still as brief as ever.)

Looking at the comment for that method, you’ll see it described as “A Ruby-ized realization of the K combinator, courtesy of Mikael Brockman.”

In researching this article, I googled (pardon me, “searched Google”) for Mikael Brockman, to see just who this genius is. Unfortunately, though he seemed active enough in 2005, he appears to have fallen off the face of the Internet since then. At any rate: big props to Mr. Brockman for contributing this.

If you’re into functional programming at all, you probably know right away what the K combinator is. For the rest of us, this article is helpful (if a bit on the academic side, but that’s about par for the course for most reading about functional topics). Basically, the K combinator is a function of two arguments, that merely returns the first argument. The second argument is useful only for the side-effects it has on the first argument. The implementation of this in Ruby is beautifully succinct:

1
2
3
4

def returning(value)
  yield(value)
  value
end

It takes a value (the first argument), yields it to the associated block (the implicit second argument), and then returns the value. The block is used to operate on the first argument, and thus (by its side-effects) provides the actual work of this method.

It’s pretty handy!