Slim is a template language whose goal is to reduce the view syntax to the essential parts without becoming cryptic.
Slim is a fast, lightweight templating engine with support for Rails 3. It has been tested on Ruby 1.9.2 and Ruby/REE 1.8.7.
Slim's core syntax is guided by one thought: "What's the minimum required to make this work".
As more people have contributed to Slim, there have been optional syntax additions influenced from their use of Haml and Jade. The Slim team is open to these optional additions because we know beauty is in the eye of the beholder.
Slim uses Temple for parsing/compilation and is also integrated into Tilt, so it can be used together with Sinatra or plain Rack.
Within the Rails community, Erb and Haml are without doubt the two most popular templating engines. However, Erb's syntax is cumbersome and Haml's performance isn't exactly the best.
Slim was born to bring a minimalist syntax approach with speed. If people chose not to use Slim, it would not be because of speed.
Yes, Slim is speedy! Benchmarks are provided at the end of this README file. Alternatively, a benchmark rake task is provided so you could test it yourself (rake bench).
Install Slim as a gem:
gem install slim
Include Slim in your Gemfile:
gem 'slim', :require => 'slim/rails'
That's it! Now, just use the .slim extension and you're good to go.
If you want to use the Slim template directly, you can use the Tilt interface:
Tilt.new['template.slim'].render(scope)
Slim::Template.new(filename, optional_option_hash).render(scope)
Slim::Template.new(optional_option_hash) { source }.render(scope)
Syntax highlight support for Vim (very beta) and Emacs are included in the extra folder. There is also a Textmate bundle.
For Haml, there is a Haml2Slim converter. Please check out the issue tracker to see the status of the varies converters.
As a Rails developer, you might already be very familiar with Haml's syntax and you think it is fantastic - until you entered the magic kingdom of node.js and got introduced to Jade.
Slim's syntax has been influenced by both Haml and Jade.
Here's a quick example to demonstrate what a Slim template looks like:
! doctype html
html
head
title Slim Examples
meta name="keywords" content="template language"
body
h1 Markup examples
#content.example1
p Nest by indentation
= yield
- unless items.empty?
table
- for item in items do
tr
td = item.name
td = item.price
- else
p No items found
#footer
| Copyright © 2010 Andrew Stone
= render 'tracking_code'
script
| $(content).do_something();
The pipe tells Slim to just copy the line. It essentially escapes any processing.
The single quote tells Slim to copy the line (similar to |), but makes sure that a single trailing space is appended.
The dash denotes control code (similar to Haml). Examples of control code are loops and conditionals.
The equal sign tells Slim it's a Ruby call that produces output to add to the buffer (similar to Erb and Haml).
Same as the single equal sign, but does not go through the escape_html method.
This is a directive. Most common example:
! doctype html # renders <!doctype html>
Use the forward slash for ruby code comments - anything after it won't get displayed in the final render.
end is forbidden behind -. Blocks are defined only by indentation.
If you nest content (e.g. put it on the next line), start the line with a pipe (|) or a single quote (').
If you want to first indent 2 spaces, then 5 spaces, it's your choice. To nest markup you only need to indent by one space, the rest is gravy.
= javascript_include_tag \
"jquery", \
"application"`
If a delimiter makes the syntax more readable for you, you can use the characters {...}, (...), [...] to wrap the attributes.
body
h1(id="logo") = page_logo
h2[id="tagline" class="small tagline"] = page_tagline
Either start on the same line as the tag
body
h1 id="headline" Welcome to my site.
Or nest it. Note: Must use a pipe or a backtick to escape processing
body
h1 id="headline"
| Welcome to my site.
Can make the call on the same line
body
h1 id="headline" = page_headline
Or nest it.
body
h1 id="headline"
= page_headline
Similarly to Haml, you can specify the id and class
attributes in the following shortcut form
Note: the shortcut form does not evaluate ruby code
body
h1#headline
= page_headline
h2#tagline.small.tagline
= page_tagline
.content
= show_content
this is the same as
body
h1 id="headline"
= page_headline
h2 id="tagline" class="small tagline"
= page_tagline
div class="content"
= show_content
- Alternative 1: Use parentheses (), {}, []. The code in the parentheses will be evaluated.
- Alternative 2: If the code doesn't contain any spaces you can omit the parentheses.
- Alternative 3: Use standard ruby interpolation #{}
Attributes will always be html escaped.
body
table
- for user in users do
td id="user_#{user.id}" class=user.role
a href=user_action(user, :edit) Edit #{user.name}
a href={path_to_user user} = user.name
Use standard Ruby interpolation. The text will always be html escaped.
body
h1 Welcome #{current_user.name} to the show.
To escape the interpolation (i.e. render as is)
body
h1 Welcome \#{current_user.name} to the show.
Use a double equal sign
body
h1 id="headline"
== page_headline
Use a pipe (|) or single quote (') to start the escape.
Each following line that is indented greater than
the backtick is copied over.
body
p
|
This is a test of the text block.
The parsed result of the above:
<body><p>This is a test of the text block.</p></body>
The left margin is set at the indent of the backtick + one space. Any additional spaces will be copied over.
body
p
| This line is on the left margin.
This line will have one space in front of it.
This line will have two spaces in front of it.
And so on...
Use a forward slash for ruby code comments
body
p
/ This line won't get displayed.
Neither does this line.
The parsed result of the above:
<body><p></p></body>
There are two helpers you could use to validate your Slim syntax:
Slim::Validator.valid?(source) # -> true or false
Slim::Validator.validate!(source) # -> true or exception
# OS X 10.6 + Ruby 1.9.2, 1000 iterations
user system total real
(1) erb 0.420000 0.000000 0.420000 ( 0.429334)
(1) erubis 0.350000 0.000000 0.350000 ( 0.356078)
(1) fast erubis 0.350000 0.000000 0.350000 ( 0.355976)
(1) slim 3.300000 0.010000 3.310000 ( 3.340637)
(1) haml 2.950000 0.000000 2.950000 ( 2.970671)
(1) haml ugly 2.840000 0.010000 2.850000 ( 2.856405)
(2) erb 0.150000 0.000000 0.150000 ( 0.151098)
(2) erubis 0.130000 0.000000 0.130000 ( 0.130713)
(2) fast erubis 0.100000 0.000000 0.100000 ( 0.112199)
(2) slim 0.030000 0.000000 0.030000 ( 0.027752)
(2) haml 0.320000 0.000000 0.320000 ( 0.332581)
(2) haml ugly 0.280000 0.000000 0.280000 ( 0.305250)
(3) erb 0.010000 0.000000 0.010000 ( 0.014402)
(3) erubis 0.010000 0.000000 0.010000 ( 0.015365)
(3) fast erubis 0.010000 0.000000 0.010000 ( 0.012789)
(3) slim 0.010000 0.000000 0.010000 ( 0.015583)
(3) haml 0.120000 0.000000 0.120000 ( 0.120017)
(3) haml ugly 0.100000 0.010000 0.110000 ( 0.117665)
1. Uncached benchmark. Template is parsed every time.
Activate this benchmark with slow=1.
2. Cached benchmark. Template is parsed before the benchmark.
The ruby code generated by the template engine might be evaluated every time.
This benchmark uses the standard API of the template engine.
3. Compiled benchmark. Template is parsed before the benchmark and
generated ruby code is compiled into a method.
This is the fastest evaluation strategy because it benchmarks
pure execution speed of the generated ruby code.
This project is released under the MIT license.