Expression tags

<%= %> : This indicates that the tag encloses an expression. Such a tag starts with an opening tag delimiter followed by an equal to symbol and ends with an end tag delimiter. During the rendering of the template, this piece of code gets substituted with the result of the code. If the evaluated result is not a string, it gets converted to a string before it is rendered. For example:

require 'erb'
x = 500
template = ERB.new("The value of x is: <%= x %>")
puts template.result(binding)

The resulting text looks like this: The value of x is: 500^[1]

Execution tags

<% %> : Code enclosed in such tags is called as a scriptlet. The code in such a tag gets executed and its result gets replaced in place of the scriptlet. Such tags must have a matching <% end %> tag to denote the end of a functional block. For example:^[4]

<ul>
<% 4.times do %>

  <li>list item</li>

<% end %>
</ul>

In the above example, the text list item gets printed four times. The scriptlet produces no text on its own, it only makes the enclosed statement to run multiple times. The output of above code:

• list item
• list item
• list item
• list item

Comments tags

<%# %> : Contents of comment tags don't get rendered in the output. Such tags start with an open tag delimiter followed by a hash symbol and end with an end tag delimiter. Example of a comment tag is shown below:^[5]

<%# ruby code %>

This is the same as a comment in Ruby. All Ruby code after the # is ignored and generates nothing.

Other tags

Other things common in eRuby are simply common in Ruby, such as string substitution with #{string_name}, which is similar in languages such as Perl or PHP.

Newlines in eRuby can be suppressed by adding a hyphen at the beginning of the end tag delimiter. For example:

<%2.times do -%> 
    <%= @name %>
<% end -%>

In the output of the above code, the value of name gets printed twice in the same line.^[1][3]

erb

erb is an implementation of eRuby written purely in the Ruby programming language and included in the Ruby standard library.^[2]

A template can be generated by running a piece of code written using the ERB object. A simple example is as shown below:

require 'erb'
x = 400
simple_template = "Value of x is: is <%= x %>."
renderer = ERB.new(simple_template)
puts output = renderer.result(binding)

The result looks as follows: Value of x is: 400

The same could be achieved using the below code which does not make use of an ERB object:

x = 400
string = "The value of x is: #{x}"
puts string

Both of the above code snippets generate the same output. But what happens when we interchange lines 2 with line 3 in the first code snippet and line 1 with line 2 in the second code snippet? The first snippet changes to the code shown below:

require 'erb'
simple_template = "Value of x is: is <%= x %>."
x = 400
renderer = ERB.new(simple_template)
puts output = renderer.result(binding)

This still generates the same output. i.e., Value of x is: 400.

The second code snippet changes to the below code:

string = "The value of x is: #{x}"
x = 400
puts string

The above code will not get executed. This is because the 1st line does not know the value of x when it gets executed. Thus, the main reason of using an ERB object is to write templates ahead of time, by binding variables and methods which may not exist at the given time. The template gets processed only when result is called on the ERB object. In order to get access to instance methods and instance variable of an object, ERB makes use of a binding object. Access to variables and methods of an object is given by the private binding object which exists in each ruby class. It is easy to get access to methods and variables within the method of a class. But to access variables of a different class, that class will have to expose its binding object via a public method. The example is as shown below:^[2][4]

class ERBExample
  attr_accessor:variable1
  
  # using bind to access class variables
  def render()
    renderer.result(binding)
  end

  def initialize(variable1)
    @variable1 = variable1
  end

  # Expose private binding() method.
  def get_binding
    binding()
  end
end

example = ERBExample.new(variable1)
renderer = ERB.new(template)
puts output = renderer.result(example.get_binding)

As we can see in the above example, we are exposing the binding object of the class ERBExample. Furthermore, we have used the binding object to access the variables and methods of the class within one of its methods.

renderer = ERB.new(template, 3, '>')

erb sample1.erb.txt > my_view.html.erb

erb -r IPAddr sample1.txt.erb > my_view.html.erb

erb -S 4 sample1.erb.txt > my_view.html.erb

erubis

erubis is an implementation of eRuby implemented in Ruby and also in Java. According to its home page, it runs faster than eRuby and ERb and has several useful options, including alternate tags allowing for valid XML.

ember

ember is a pure Ruby implementation of eRuby for Linux. It allows debugging of eRuby templates, improves their composability, and provides powerful shorthand eRuby directives.