Skip to content
General ruby templating with json, bson, xml, plist and msgpack support
Ruby HTML Other
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.


RABL (Ruby API Builder Language) is a Rails and Padrino ruby templating system for generating JSON and XML. When using the ActiveRecord 'to_json' method, I tend to quickly find myself wanting a more expressive and powerful system for generating APIs. This is especially frustrating when the json representation is complex or doesn't match the exact schema defined in the database itself.

I wanted a simple, and flexible system for generating APIs. In particular, I wanted to easily:

  • Create arbitrary nodes named based on combining data in an object
  • Pass arguments to methods and store the result as a child node
  • Partial templates and inheritance to reduce code duplication
  • Easily renaming attributes from their name in the model
  • Simple way to append attributes from a child into the parent
  • Include nodes only if a certain condition is met

Anyone who has tried the 'to_json' method used in ActiveRecord for generating a json response has felt the pain of this restrictive approach. RABL is a general templating system created to solve all of those problems.


Install RABL as a gem:

gem install rabl

or add to your Gemfile:

# Gemfile
gem 'rabl'

and run bundle install to install the dependency.

If you are using Rails 2.X, Rails 3 or Padrino, RABL works without configuration.

With Sinatra, or any other tilt-based framework, simply register:


and RABL will be initialized and ready for use.


Object Assignment

To declare the data object for use in the template:

 # app/views/users/show.json.rabl
 object @user

or specify an alias for the object:

object @user => :person
# => { "person" : { ... } }

or pass a collection of objects:

 collection @users
 # => [ { "user" : { ... } } ]

or even specify a root node label for the collection:

collection @users => :people
# => { "people" : [ { "person" : { ... } } ] }

and this will be used as the default data for the rendering.

There can also be odd cases where the root-level of the response doesn't map directly to any object:

object false
code(:some_count) { |m| @user.posts.count }
child(@user) { attribute :name }

In those cases, object can be assigned to 'false' and child nodes can be constructed independently.


Basic usage of the templater to define a few simple attributes for the response:

# app/views/users/show.json.rabl
attributes :id, :foo, :bar

or use with aliased attributes:

# Take the value of model attribute `foo` and name the node `bar`
attribute :foo => :bar
# => { bar : 5 }

or even multiple aliased attributes:

attributes :bar => :baz, :dog => :animal
# => # { baz : <bar value>, animal : <dog value> }

Child Nodes

Often a response requires including nested information from data associated with the parent model:

child :address do
  attributes :street, :city, :zip, :state

You can also add child nodes from an arbitrary data source:

child @posts => :foobar do
  attributes :id, :title

or use model associations with an alias:

# Renders all the 'posts' association
# from the model into a node called 'foobar'
child :posts => :foobar do
  attributes :id, :title

Gluing Attributes

You can also append child attributes back to the root node:

# Appends post_id and post_name to parent json object
glue @post do
  attributes :id => :post_id, :name => :post_name

Use glue to add additional attributes to the parent object.

Custom Nodes

This will generate a json response based on the result of the code block:

# app/views/users/show.json.rabl
code :full_name do |u|
  u.first_name + " " + u.last_name

or a custom node that exists only if a condition is true:

# m is the object being rendered, also supports :unless
code(:foo, :if => lambda { |m| m.has_foo? }) do |m|

You can use custom "code" nodes to create flexible representations of a value utilizing all the data from the model.


Often you need to access sub-objects in order to construct your own custom nodes for more complex associations. You can get access to the rabl representation of another object with:

code :location do
  { :city => @city, :address => partial("web/users/address", :object => @address) }

or an object associated to the parent model:

code :location do |m|
  { :city =>, :address => partial("web/users/address", :object => m.address) }

You can use this method to construct arbitrarily complex nodes for your APIs.


Another common issue of many template builders is unnecessary code redundancy. Typically many representations of an object across multiple endpoints share common attributes or nodes. The nodes for a 'post' object are probably the same or similar in most references throughout the various endpoints.

RABL has the ability to extend other "base" rabl templates and additional attributes:

# app/views/users/advanced.json.rabl
extends "users/base" # another RABL template in "app/views/users/base.json.rabl"

code :can_drink do |m|
  m.age > 21

You can also extend other rabl templates while constructing child nodes to reduce duplication:

# app/views/users/show.json.rabl
child @address do
  extends "address/item"

Using partials and inheritance can significantly reduce code duplication in your templates.

Deep Nesting

In APIs, you can often need to construct 2nd or 3rd level nodes. Let's suppose we have a 'quiz' model that has many 'questions' and then each question has many 'answers'. We can display this hierarchy in RABL quite easily:

# app/views/quizzes/show.json.rabl
object @quiz
attribute :title
child :questions do
  attribute :caption
  child :answers do
    # Use inheritance to reduce duplication
    extends "answers/item"

This will display the quiz object with nested questions and answers as you would expect with a quiz node, and embedded questions and answers. Note that RABL can be nested arbitrarily deep within child nodes to allow for these representations to be defined.


Check out the Issues tab for a full list:

  • No configuration options yet for how to create the json (root nodes) :(
  • Better Tilt template support (precompiling templates)
  • Benchmarks and performance optimizations

Authors and Contributors

Thanks to Miso for allowing me to create this for our applications and release this project!

More to come hopefully! Please fork and contribute, any help is appreciated!


There are a few excellent libraries that helped inspire RABL and they are listed below:

Thanks again for all of these great projects.


See the examples directory.


Copyright © 2011 Nathan Esquenazi. See MIT-LICENSE for details.

Something went wrong with that request. Please try again.