ERuby

eRuby

Other names	ERB
Repository	github.com/ruby/erb
Written in	Ruby
Type	Template engine
License	BSD 2-Clause License

Embedded Ruby (also shortened as ERB) is a templating system that embeds Ruby into a text document. It is often used to embed Ruby code in an HTML document, similar to ASP and JSP, and PHP and other server-side scripting languages. The templating system of eRuby combines Ruby code and plain text to provide flow control and variable substitution, thus making the combined code easier to maintain. ^[1]

The View module of Ruby on Rails is responsible for displaying the response or output on a browser. In its simplest form, a view can be a piece of HTML code which has some static content. For most applications, just having static content may not be enough. Many Ruby on Rails applications will require dynamic content created by the controller (action method) to be displayed in their view. This is made possible by using Embedded Ruby to generate templates which can contain dynamic content. Embedded Ruby allows ruby code to be embedded in a view document. This code gets replaced with proper value resulted from the execution of the code at run time. But, by having the ability to embed code in a view document, we risk bridging the clear separation present in the MVC frame. It is thus the responsibility of the developer to make sure that there is a clear separation of responsibility among the model, view and controller modules of his/her application. ^[2]

Usage

eRuby allows Ruby code to be embedded within a pair of <% and %> delimiters. These embedded code blocks are then evaluated in-place (they are replaced by the result of their evaluation). Apart from creating web pages, eRuby can also be used to create XML Documents, RSS feeds and other forms of structured text files. eRuby dynamically generates static files based on templates. These functionalities of eRuby can be found in the ERB Library.

Different types of tag markers used in ERB templates are:

1. Expression tags
2. Execution tags
3. Comment tags ^[3]

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=500template=ERB.new("The value of x is: <%= x %>")putstemplate.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.timesdo%><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.timesdo-%><%=@name%><%end-%>

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

Implementations

There are several implementations of eRuby, namely:

1. ERB
2. erubis
3. ember

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=400simple_template="Value of x is: is <%= x %>."renderer=ERB.new(simple_template)putsoutput=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=400string="The value of x is: #{x}"putsstring

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=400renderer=ERB.new(simple_template)putsoutput=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=400putsstring

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]}

classERBExampleattr_accessor:variable1# using bind to access class variablesdefrender()renderer.result(binding)enddefinitialize(variable1)@variable1=variable1end# Expose private binding() method.defget_bindingbinding()endendexample=ERBExample.new(variable1)renderer=ERB.new(template)putsoutput=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.

new() method of ERB

The new method of the ERB object takes two more parameters. The second parameter specifies a safety level. By giving a number in the second parameter (max value = 4) one can make the template run in a different thread. The value of the number determines the safety level. At the maximum isolation level, unless the binding object is marked as trusted, ERB cannot use it. The third parameter specify optional modifiers. These can be used to control adding of newlines to the output. For example, to make sure that ERB does not output newlines after tag ends, we can create the ERB object as shown below ^{[3] [4]}

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

To only provide the third parameter and ignore the second parameter, use 0 as the input for second parameter.

ERB has many other methods exposed which can be used to render a template. For full list of APIs exposed by the ERB object, refer to the ERB documentation given in the reference section.

Running ERB from Command-line

As it has been already explained in the previous sections, the erb is used to generate templates. This is often used to generate web pages or other text files. Usually needs erb to push the output to his or her desired file. To achieve this, we can use the redirection ability provided in the command-line and redirect the output to a file rather than making it print on the standard output. ^[3]

erbsample1.erb.txt>my_view.html.erb 

In the above example, output gets redirected to my_view.html.erb file.

Linking of third party libraries is achievable by making use of the -r option and providing the name of the library. To remember this functionality, one can remember the Ruby key word require , which does the same functionality as the -r option. The below example uses the IPAddr library.

erb-rIPAddrsample1.txt.erb>my_view.html.erb 

As we have mentioned about the safety levels in the previous section, one can specify the safety level as a command line argument using the -S option ^[3]

erb-S4sample1.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.

Different implementation tags comparison

The below table compares the tags available in each of the above implementations ^{[4] [6] [7]}

Implementations	Simple expression tag <%=%>	Simple execution tag <%%>	Simple comment tag <%#%>	Ability to configure tag pattern	Short hand notation for tags	<%~%>	<%+%>	<%<>	<%|>
erb	Yes	Yes	Yes	No	Yes, <%xy%> can be written as %xy.	No	No	No	No
erubis	Yes	Yes	Yes	Yes, can change tag pattern to anything. ex - [% %] etc.	Yes, as one can change tag patterns.	No	No	No	No
ember	Yes	Yes	Yes	No	Yes, <%xy%> can be written as %xy.	The content of the tag is evaluated as an eRuby template.	The content of the tag is evaluated as Ruby code and is expected to be a path pointing to a Ruby template file which is read, evaluated, and rendered.	Same as <%+%> but file contents are simply rendered into the output.	Treats the enclosed code as a block of Ruby code and (if necessary) appends a do keyword to the body of the tag.

See also

• Free and open-source software portal

• mod_ruby
• Phusion Passenger (mod_rails)
• Haml
• RDoc
• Markaby

References

1. Brown, Gregory (2009). Ruby Best Practices . O'Reilly. pp.  279–281. ISBN   978-0596523008.
2. S., Ruby; D., Thomas; Hansson D, Heinemeier (2011). Agile Web Development with Rails. The Pragmatic Programmers. p. 35. ISBN   978-1-934356-54-8.
3. Ellis, Stuart (1 July 2016). "An Introduction to ERB Templating" . Retrieved 12 September 2016.
4. "ERB". 23 February 2015. Retrieved 12 September 2016.
5. "ERB – Ruby Templating". 2016. Retrieved 12 September 2016.
6. "ember(1)". 29 June 2011. Retrieved 12 September 2016.
7. "Erubis". 2011. Archived from the original on 27 March 2017. Retrieved 12 September 2016.

External links

• ERB Library
• "Ruby and the web", a chapter from "The Pragmatic Programmer's Guide"
• "web-mode.el", emacs major mode for editing eRuby templates
• ERB – Ruby Templating
• erb documentation
• Ruby standard library
• erubis documentation Archived 2017-03-27 at the Wayback Machine
• ember documentation