Skip to content
Ruby Bindings for Handlebars.js
Ruby JavaScript
Find file
New pull request
Latest commit dd7b491 @hypomodern hypomodern Merge pull request #37 from cowboyd/handlebars-v3
Handlebars v3



Gem Version Build Status Dependency Status

This uses therubyracer to bind to the actual JavaScript implementation of Handlebars.js so that you can use it from ruby.


Simple stuff

require 'handlebars'
handlebars =
template = handlebars.compile("{{say}} {{what}}") => "Hey", :what => "Yuh!") #=> "Hey Yuh!"

functions as properties => "Hey ", :what => lambda {|this| ("yo" * 2) + "!"}) #=> "Hey yoyo!"

Block Helpers:

Just like JavaScript, you can write block helpers with an {{else}} section. To print out a section twice if a condition is met:

# V8 maps the first argument sent to a block to "this". All subsequent arguments are as
# described in the Handlebars documentation.
handlebars.register_helper(:twice) do |context, condition, block|
  if condition
template = handlebars.compile("{{#twice foo}}Hurray!{{else}}Boo!{{/twice}}") true) #=> Hurray!Hurray! false) #=> Boo!

Private variables:

Just like JavaScript, block helpers can inject private variables into their child templates. These can be accessed in a template using the @ prefix:

handlebars.register_helper(:list) do |this, context, block|
  "<ul>" + do |x, i|
    if block.keys.include? "data"
      data = handlebars.create_frame(
      data.index = i
    "<li>" + block.fn(x, data: data) + "</li>"
  end.join + "</ul>"
template = handlebars.compile("{{#list array}}{{@index}}. {{title}}{{/list}}") [{title: "Memento"}, {title: "Inception"}])
#=> "<ul><li>0. Memento</li><li>1. Inception</li></ul>"

Hash arguments:

When using hash arguments, beware of one gotcha - V8 defines the #hash method for every object. Therefore, to access the hash object of the options argument Handlebars sends to your block, you must use the [] method:

handlebars.register_helper :list do |this, context, options|
  attrs = options[:hash].map{|k,v| "#{k}=\"#{v}\""}.join(' ')
  "<ul #{attrs}>" +{|item| "<li>" + options.fn(item) + "</li>"}.join + "</ul>"
template = handlebars.compile(%({{#list nav id="nav-bar" class="top"}}<a href="{{url}}">{{title}}</a>{{/list}})){nav: [{url: '', title: 'Google'}]})
#=> <ul class="top" id="nav-bar"><li><a href="">Google</a></li></ul>

Safe Strings

By default, handlebars will escape strings that are returned by your block helpers. To mark a string as safe:

template = handlebars.compile("{{safe}}") => proc {"<pre>Totally Safe!<pre>")})


You can directly register partials

handlebars.register_partial("whoami", "I am {{who}}")
handlebars.compile("{{>whoami}}").call(:who => 'Legend') #=> I am Legend

Partials can also be dynamically looked up by defining a partial_missing behavior:

handlebars.partial_missing do |name|
  "unable to find >#{name}"
handlebars.compile("{{>missing}}").call #=> unable to find >missing

Missing partials can also be returned as a function:

count = 0
handlebars.partial_missing do |name|
  lambda do |this, context, options|
    count += 1
    "#{count} miss(es) when trying to look up a partial"
t = handlebars.compile("{{>missing}}") #=> 1 miss(es) when trying to look up a partial #=> 2 miss(es) when tyring to look up a partial


In general, you should not trust user-provided templates: a template can call any method (with no arguments) or access any property on any object in the Handlebars::Context.

If you'd like to render user-provided templates, you'd want to make sure you do so in a sanitized Context, e.g. no filesystem access, read-only or no database access, etc.


rspec spec/
Something went wrong with that request. Please try again.