Rdoc - Info Slim

rdoc.
info
http://rdoc.info/github/stonean/slim
Slim
Slim is a template language whose goal is to reduce the view syntax to the essential parts without becoming cryptic. It started as an exercise to see how much could be removed from a standard html template (<, >, closing tags, etc...). As more people took an interest in Slim, the functionality grew and so did the flexibility of the syntax. A short list of the features... Short syntax without closing tags (Using indentation instead) Embedded engines like Markdown and Textile Configurable shortcut tags (# for div id and . for div class in the default configuration) Automatic HTML escaping and support for Rails' html_safe? HTML style mode with closing tags Logic less mode similar to Mustache, realized as plugin Translator/I18n, realized as plugin Highly configurable and extendable High performance (Comparable to ERB) Supported by all major frameworks (Rails, Sinatra, ...) Streaming support in Rails
Introduction
What is Slim?
Slim is a fast, lightweight templating engine with support for Rails 3. It has been heavily tested on all major ruby implementations. We use continous integration (travis-ci). 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 syntax additions influenced from their use of Haml and Jade. The Slim team is open to these 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. The architecture of Temple is very flexible and allows the extension of the parsing and compilation process without monkey-patching. This is used by the logic less plugin and the translator plugin which provides I18n.
Why use Slim?

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 syntax can be quite cryptic to the uninitiated. 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. Don't trust the numbers? That's as it should be. Therefore we provide a benchmark rake task so you could test it yourself (rake bench).
How to start?
Install Slim as a gem: gem install slim Include Slim in your Gemfile with gem ' slim' or require it with require ' slim' . That's it! Now, just use the .slim extension and you're good to go.
Syntax example
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" meta name=" author" content=author link rel=" icon" type=" image/png" href=file_path(" favicon.png" ) javascript: alert(' Slim supports embedded javascript!' ) body h1 Markup examples #content p This example shows you how a basic Slim file looks like. = yield - if items.any? table#items - for item in items do tr td.name = item.name td.price = item.price - else p No items found Please add some inventory. Thank you! div id=" footer" = render ' footer' | Copyright © #{year} #{author} Indentation matters, but the indentation depth can be chosen as you like. 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.
Line indicators
T ext |
The pipe tells Slim to just copy the line. It essentially escapes any processing. 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... You can also embed html in the text line - articles.each do |a| | <tr><td>#{a.name}</td><td>#{a.description}</td></tr>
T ext with trailing white space '

The single quote tells Slim to copy the line (similar to |), but makes sure that a single trailing white space is appended.
Inline html < (HT ML style)

You can write html tags directly in Slim which allows you to write your templates in a more html like style with closing tags or mix html and Slim style. <html> head title Example <body> - if articles.empty? - else table - articles.each do |a| <tr><td>#{a.name}</td><td>#{a.description}</td></tr> </body> </html>
Control code The dash denotes control code. Examples of control code are loops and conditionals. end is forbidden behind -. Blocks are defined only by indentation. If your ruby code needs to use multiple lines, append a backslash \ at the end of the lines. body - if articles.empty? | No inventory
Output =
The equal sign tells Slim it's a Ruby call that produces output to add to the buffer. If your ruby code needs to use multiple lines, append a backslash \ at the end of the lines, for example: = javascript_include_tag \ " jquery" , \ " application"
Output with trailing white space ='

Same as the single equal sign (=), except that it adds a trailing white space.
Output without HT ML escaping ==

Same as the single equal sign (=), but does not go through the escape_html method.
Output without HT ML escaping and trailing ws =='

Same as the double equal sign (==), except that it adds a trailing white space. Use the forward slash for code comments - anything after it won't get displayed in the final render. Use / for code comments and /! for html comments body p / This line won' t get displayed. Neither does this line. /! This will get displayed as html comments. The parsed result of the above:
<body><p></p></body> Use the forward slash immediately followed by an exclamation mark for html comments ( ). /[if IE] renders as 
Doctype tag
The doctype tag is a special tag which can be used to generate the complex doctypes in a very simple way. XML VERSION doctype xml <?xml version=" 1.0" encoding=" utf-8" ?> doctype xml ISO-8859-1 <?xml version=" 1.0" encoding=" iso-8859-1" ?> XHTML DOCTYPES
doctype html <!DOCTYPE html> doctype 5 <!DOCTYPE html> doctype 1.1 <!DOCTYPE html PUBLIC " -//W3C//DTD XHTML 1.1//EN" " http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd" > doctype strict <!DOCTYPE html PUBLIC " -//W3C//DTD XHTML 1.0 Strict//EN" " http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd" > doctype frameset <!DOCTYPE html PUBLIC " -//W3C//DTD XHTML 1.0 Frameset//EN" " http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd" > doctype mobile <!DOCTYPE html PUBLIC " -//WAPFORUM//DTD XHTML Mobile 1.2//EN" " http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd" > doctype basic <!DOCTYPE html PUBLIC " -//W3C//DTD XHTML Basic 1.1//EN" " http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd" > doctype transitional <!DOCTYPE html PUBLIC " -//W3C//DTD XHTML 1.0 Transitional//EN" " http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" > HTML 4 DOCTYPES doctype strict <!DOCTYPE html PUBLIC " -//W3C//DTD HTML 4.01//EN" " http://www.w3.org/TR/html4/strict.dtd" > doctype frameset <!DOCTYPE html PUBLIC " -//W3C//DTD HTML 4.01 Frameset//EN" " http://www.w3.org/TR/html4/frameset.dtd" > doctype transitional <!DOCTYPE html PUBLIC " -//W3C//DTD HTML 4.01 Transitional//EN" " http://www.w3.org/TR/html4/loose.dtd" > You can close tags explicitly by appending a trailing /. img src=" image.png" /
Note, that this is usually not necessary since the standard html tags (img, br, ...) are closed automatically. Sometimes you may want to be a little more compact and inline the tags. ul li.first: a href=" /a" A link li: a href=" /b" B link For readability, don't forget you can wrap the attributes. ul li.first: a[href=" /a" ] A link li: a[href=" /b" ] B link
T ext content
Either start on the same line as the tag body h1 id=" headline" Welcome to my site. Or nest it. You must use a pipe or a backtick to escape processing body h1 id=" headline" | Welcome to my site.
Dynamic content (= and ==)

Can make the call on the same line body h1 id=" headline" = page_headline Or nest it.
body h1 id=" headline" = page_headline
Attributes
You write attributes directly after the tag. For normal text attributes you must use double " or single quotes ' (Quoted attributes). a href=" http://slim-lang.com" title=' Slim Homepage' Goto the Slim homepage You can use text interpolation in the quoted attributes.
Attributes wrapper
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 If you wrap the attributes, you can spread them across multiple lines: h2[id=" tagline" class=" small tagline" ] = page_tagline
Quoted attributes
Example: a href=" http://slim-lang.com" title=' Slim Homepage' Goto the Slim homepage You can use text interpolation in the quoted attributes: a href=" http://#{url}" Goto the #{url} The attribute value will be escaped if the option :escape_quoted_attrs is set. Use == if you want to disable escaping in the attribute.
a href==" &"
Ruby attributes
Write the ruby code directly after the =. If the code contains spaces you have to wrap the code into parentheses (...), {...} or [...]. The code in the parentheses will be evaluated. 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 The attribute value will be escaped by default. Use == if you want to disable escaping in the attribute. a href==action_path(:start)
Boolean attributes
The attribute values true, false and nil are interpreted as booleans. If you use the attribut wrapper you can omit the attribute assigment input type=" text" disabled=" disabled" input type=" text" disabled=true input(type=" text" disabled) input type=" text" input type=" text" disabled=false input type=" text" disabled=nil
Attribute merging
You can configure attributes to be merged if multiple are given (See option :attr_delimiter). In the default configuration this is done for class attributes with the white space as delimiter. a.menu class=" highlight" href=" http://slim-lang.com/" Slim-lang.com
This renders as <a class=" menu highlight" href=" http://slim-lang.com/" >Slim-lang.com</a> You can also use an Array as attribute value and the array elements will be merged using the delimiter. a class=[" menu" ," highlight" ] a class=:menu,:highlight
Splat attributes *
The splat shortcut allows you turn a hash in to attribute/value pairs .card*{' data-url' =>place_path(place), ' data-id' =>place.id} = place.name renders as <div class=" card" data-id=" 1234" data-url=" /place/1234" >Slim' s house</div> You can also use methods or instance variables which return a hash as shown here: .card *method_which_returns_hash = place.name .card *@hash_instance_variable = place.name The hash attributes which support attribute merging (see Slim option :attr_delimiter) can be given as an Array .first *{:class => [:second, :third]} Text renders as div class=" first second third"
ID shortcut # and class shortcut .
Similarly to Haml, you can specify the id and class attributes in the following shortcut form 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
Attribute shortcuts
You can define custom shortcuts (Similar to # for id and . for class). In this example we add & to create a shortcut for the input elements with type attribute. Slim::Engine.set_default_options :shortcut => {' &' => ' input type' , ' #' => ' id' , ' .' => ' class' } We can use it in Slim code like this &text name=" user" &password name=" pw" &submit which renders to <input type=" text" name=" user" /> <input type=" password" name=" pw" /> <input type=" submit" />
In another example we add @ to create a shortcut for the role attribute. Slim::Engine.set_default_options :shortcut => {' @' => ' role' , ' #' => ' id' , ' .' => ' class' } We can use it in Slim code like this .person@admin = person.name which renders to <div class=" person" role=" admin" >Daniel</div>
Text interpolation
Use standard Ruby interpolation. The text will be html escaped by default. body h1 Welcome #{current_user.name} to the show. | Unescaped #{{content}} is also possible. To escape the interpolation (i.e. render as is) body h1 Welcome \#{current_user.name} to the show.
Embedded engines (Markdown, ...)

Thanks to Tilt, Slim has impressive support for embedding other template engines. Examples: coffee: square = (x) -> x * x markdown: #Header Hello from #{" Markdown!" } Second Line!
Supported engines: Filter ruby: Required gems none Type Shortcut Description Shortcut to embed ruby code Shortcut to embed javascript code and wrap in script tag Shortcut to embed css code and wrap in style tag Embed sass code and wrap in style tag Embedd scss code and wrap in style tag Embed less css code and wrap in style tag Embed stylus css code and wrap in style tag Compile coffee script code and wrap in script tag Compile markdown code and interpolate # {variables} in text Compile textile code and interpolate # {variables} in text Compile creole code and interpolate # {variables} in text
javascript:
none
Shortcut
css:
none
Shortcut
sass:
sass
Compile time Compile time Compile time Compile time Compile time
scss:
sass
less:
less
styl:
styl
coffee:
coffee-script
markdown:
redcarpet/rdiscount/kramdown
Compile time + Interpolation Compile time + Interpolation Compile time + Interpolation
textile:
redcloth
creole:
creole
wiki:, mediawiki:
wikicloth
Compile time + Interpolation Compile time + Interpolation Precompiled Precompiled
Compile wiki code and interpolate # {variables} in text Compile rdoc code and interpolate # {variables} in text Embed builder code Embed nokogiri builder code Embed erb code
rdoc:
rdoc
builder: nokogiri:
builder nokogiri
erb:
none
Precompiled
The embedded engines can be configured in Slim by setting the options directly on the Slim::EmbeddedEngine filter. Example: Slim::EmbeddedEngine.default_options[:markdown] = {:auto_ids => false}
Configuring Slim
Slim and the underlying Temple framework are highly configurable. The way how you configure Slim depends a bit on the compilation mechanism (Rails or Tilt). It is always possible to set default options per Slim::Engine class. This can be done in Rails' environment files. For instance, in config/environments/development.rb you probably want:
Default options
Slim::Engine.set_default_options :pretty => true, :sort_attrs => false Slim::Engine.set_default_options pretty: true, sort_attrs: false You can also access the option hash directly: Slim::Engine.default_options[:pretty] = true
Setting options at runtime

There are two ways to set options at runtime. For Tilt templates (Slim::Template) you can set
the options when you instatiate the template: Slim::Template.new(' template.slim' , optional_option_hash).render(scope) The other possibility is to set the options per thread which is interesting mostly for Rails: Slim::Engine.with_options(option_hash) do render :page, :layout => true end You have to be aware that the compiled engine code and the options are cached per template in Rails and you cannot change the option afterwards. Slim::Engine.with_options(:pretty => true) do render :page, :layout => true end Slim::Engine.with_options(:pretty => false) do render :page, :layout => true end
Available options
The following options are exposed by the Slim::Engine and can be set with Slim::Engine.set_default_options. There are a lot of them but the good thing is, that Slim checks the configuration keys and reports an error if you try to use an invalid configuration key. Type String Name :file Default nil
Integer
:tabsize
String
:encoding
"utf-8"
String
:default_tag
"div"
Hash
:shortcut
{'.' => 'class', '# ' => 'id'}
Symbol/String list
:enable_engines
nil (All enabled)
Symbol/String list
:disable_engines
nil (None disabled)
Boolean
:disable_capture
false (true in Rails)
Boolean
:disable_escape
false
Boolean
:escape_quoted_attrs
false
Boolean
:use_html_safe
false (true in Rails)
Symbol
:format
:xhtml
String
:attr_wrapper
'"'
Hash
:attr_delimiter
{'class' => ' '}
Boolean
:sort_attrs
true
Boolean
:pretty
false
String Boolean
:indent :streaming
'' false (true in Rails > 3.1)
Class
:generator
Temple::Generators::ArrayBuffer/RailsOutputBuffer
String
:buffer
'_buf' ('@output_buffer' in Rails)
There are more options which are supported by the Temple filters but which are not exposed and are not officially supported. You have to take a look at the Slim and Temple code for that.
Option priority and inheritance

For developers who know more about Slim and Temple architecture it is possible to override default options at different positions. Temple uses an inheritance mechanism to allow subclasses to override options of the superclass. The option priorities are as follows: 1. Slim::Template options passed at engine instatination 2. Slim::Template.default_options 3. Slim::Engine.thread_options, Slim::Engine.default_options 4. Parser/Filter/Generator thread_options, default_options (e.g Slim::Parser, Slim::Compiler)
It is also possible to set options for superclasses like Temple::Engine. But this will affect all temple template engines then. Slim::Engine < Temple::Engine Slim::Compiler < Temple::Filter
Plugins
Logic less mode
Logic less mode is inspired by Mustache. Logic less mode uses a dictionary object e.g. a recursive hash tree which contains the dynamic content.
Conditional
If the object is not false or empty?, the content will show - article h1 = title
Inverted conditional
If the object is false or empty?, the content will show -! article p Sorry, article not found
Iteration
If the object is an array, the section will iterate - articles tr: td = title
Wrapped dictionary - Resolution order

Example code:
- article h1 = title In wrapped dictionary acccess mode (the default, see the options), the dictionary object is accessed in the following order. 1. If article.respond_to?(:title), Slim will execute article.send(:title) 2. If article.respond_to?(:has_key?) and article.has_key?(:title), Slim will execute article[:title] 3. If article.instance_variable_defined?(@title), Slim will execute article.instance_variable_get @title If all the above fails, Slim will try to resolve the title reference in the same order against the parent object. In this example, the parent would be the dictionary object you are rendering the template against. As you might have guessed, the article reference goes through the same steps against the dictionary. Instance variables are not allowed in the view code, but Slim will find and use them. Essentially, you're just using dropping the @ prefix in your template. Parameterized method calls are not allowed.
Logic less in Rails

Install: $ gem install slim Require: gem ' slim' , :require => ' slim/logic_less' You might want to activate logic less mode only for a few actions, you should disable logic-less mode globally at first in the configuration Slim::Engine.set_default_options :logic_less => false and activate logic less mode per render call in your action
class Controller def action Slim::Engine.with_options(:logic_less => true) do render end end end
Logic less in Sinatra

Sinata has built-in support for Slim. All you have to do is require the logic less Slim plugin. This can be done in your config.ru: require ' slim/logic_less' You are then ready to rock! You might want to activate logic less mode only for a few actions, you should disable logic-less mode globally at first in the configuration Slim::Engine.set_default_options :logic_less => false and activate logic less mode per render call in your application get ' /page' slim :page, :logic_less => true end
Options
Type Boolean Name :logic_less Default true Purpose Enable logic less mode (Enabled if 'slim/logic_less' is required) Dictionary where variables are looked up Dictionary access mode (:string, :symbol, :wrapped)
String Symbol
:dictionary :dictionary_access
"self" :wrapped
T ranslator/I18n
The translator plugin provides automatic translation of the templates using Gettext, Fast-Gettext or Rails I18n. Static text in the template is replaced by the translated version. Example: h1 Welcome to Gettext translates the string from english to german where interpolations are replaced by %1, %2, ... " Welcome to %1!" -> " Willkommen auf %1!" and renders as <h1>Willkommen auf slim-lang.com!</h1> Enable the translator plugin with require ' slim/translator'
Options
Type Boolean Name :tr Default true Purpose Enable translator (Enabled if 'slim/translator' is required) When to translate: :static = at compile time, :dynamic = at runtime Translation function, could be '_' for gettext
Symbol
:tr_mode
:dynamic
String
:tr_fn
Depending on installed translation library
Framework support
T ilt
Slim uses Tilt to compile the generated code. If you want to use the Slim template directly, you can use the Tilt interface. Tilt.new[' template.slim' ].render(scope) Slim::Template.new(' template.slim' , optional_option_hash).render(scope) Slim::Template.new(optional_option_hash) { source }.render(scope) The optional option hash can have to options which were documented in the section above.
Sinatra
require ' sinatra' require ' slim' get(' /' ) { slim :index } __END__ @@ index doctype html html head title Sinatra With Slim body h1 Slim Is Fun!
Rails
Rails generators are provided by slim-rails. slim-rails is not necessary to use Slim in Rails though. Just install Slim and add it to your Gemfile with gem ' slim' . Then just use the .slim extension and you're good to go.
Streaming
HTTP streaming is enabled enabled by default if you use a Rails version which supports it.
Tools
Slim Command 'slimrb'
The gem 'slim' comes with the small tool 'slimrb' to test Slim from the command line.
$ slimrb --help Usage: slimrb [options] -s, --stdin Read input from standard input instead of an input file --trace Show a full traceback on error -c, --compile Compile only but do not run -r, --rails Generate rails compatible code (Implies --compile) -t, --translator Enable translator plugin -l, --logic-less Enable logic less plugin -p, --pretty Produce pretty html -o, --option [NAME=CODE] Set slim option -h, --help Show this message -v, --version Print version Start 'slimrb', type your code and press Ctrl-d to send EOF. Example usage:
$ slimrb markdown: First paragraph. Second paragraph. * one * two * three //Enter Ctrl-d <p>First paragraph </p> <p>Second paragraph </p> <ul> <li>one</li> <li>two</li> <li>three</li> </ul>
Syntax Highlighters
There are plugins for various text editors (including the most important ones - Vim, Emacs and Textmate): Vim Emacs Textmate / Sublime Text
Espresso text editor Coda
T emplate Converters (HAML, ERB, ...)

Haml2Slim converter HTML2Slim converter ERB2Slim converter
Testing
Benchmarks
The benchmarks demonstrate that Slim in production mode is nearly as fast as Erubis (which is the fastest template engine). So if you choose not to use Slim it is not due to its speed. Run the benchmarks with rake bench. You can add the option slow to run the slow parsing benchmark which needs more time. You can also increase the number of iterations. rake bench slow=1 iterations=1000
Linux + Ruby 1.9.3, 1000 iterations (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2) (2) (2) (2) (2) (3) (3) (3) (3) (3) user system total real erb 0.020000 0.000000 0.020000 ( 0.017383) erubis 0.020000 0.000000 0.020000 ( 0.015048) fast erubis 0.020000 0.000000 0.020000 ( 0.015372) <=== temple erb 0.030000 0.000000 0.030000 ( 0.026239) slim pretty 0.030000 0.000000 0.030000 ( 0.031463) slim ugly 0.020000 0.000000 0.020000 ( 0.018868) <=== haml pretty 0.130000 0.000000 0.130000 ( 0.122521) haml ugly 0.110000 0.000000 0.110000 ( 0.106640) erb 0.030000 0.000000 0.030000 ( 0.035520) erubis 0.020000 0.000000 0.020000 ( 0.023070) temple erb 0.040000 0.000000 0.040000 ( 0.036514) slim pretty 0.040000 0.000000 0.040000 ( 0.040086) slim ugly 0.030000 0.000000 0.030000 ( 0.028461) haml pretty 0.150000 0.000000 0.150000 ( 0.145618) haml ugly 0.130000 0.000000 0.130000 ( 0.129492) erb 0.140000 0.000000 0.140000 ( 0.134953) erubis 0.120000 0.000000 0.120000 ( 0.119723) fast erubis 0.100000 0.000000 0.100000 ( 0.097456) temple erb 0.040000 0.000000 0.040000 ( 0.035916) slim pretty 0.040000 0.000000 0.040000 ( 0.039626)
(3) (3) (3) (4) (4) (4) (4) (4) (4) (4) (4)
slim ugly 0.030000 0.000000 0.030000 ( 0.027827) haml pretty 0.310000 0.000000 0.310000 ( 0.306664) haml ugly 0.250000 0.000000 0.250000 ( 0.248742) erb 0.350000 0.000000 0.350000 ( 0.350719) erubis 0.310000 0.000000 0.310000 ( 0.304832) fast erubis 0.300000 0.000000 0.300000 ( 0.303070) temple erb 0.910000 0.000000 0.910000 ( 0.911745) slim pretty 3.410000 0.000000 3.410000 ( 3.413267) slim ugly 2.880000 0.000000 2.880000 ( 2.885265) haml pretty 2.280000 0.000000 2.280000 ( 2.292623) haml ugly 2.170000 0.000000 2.170000 ( 2.169292)
(1) 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. (2) Compiled Tilt benchmark. Template is compiled with Tilt, which gives a more accurate result of the performance in production mode in frameworks like Sinatra, Ramaze and Camping. (Rails still uses its own template compilation.) (3) 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. (4) Parsing benchmark. Template is parsed every time. This is not the recommended way to use the template engine and Slim is not optimized for it. Activate this benchmark with ' rake bench slow=1' . Temple ERB is the ERB implementation using the Temple framework. It shows the overhead added by the Temple framework compared to ERB.
T est suite and continous integration

Slim provides an extensive test-suite based on minitest. You can run the tests with 'rake test' and the rails integration tests with 'rake test:rails'. We are currently experimenting with human-readable literate tests which are written as markdown files: TESTS.md Travis-CI is used for continous integration testing: http://travis-ci.org/# !/stonean/slim Slim is working well on all major Ruby implementations: Ruby 1.8.7 Ruby 1.9.2
Ruby 1.9.3 Ruby EE JRuby Rubinius 2.0
Contributing
If you'd like to help improve Slim, clone the project with Git by running: $ git clone git://github.com/stonean/slim Work your magic and then submit a pull request. We love pull requests! Please remember to test against Ruby versions 1.9.2 and 1.8.7. If you find the documentation lacking (and you probably will), help us out The docs are located in the gh-pages branch: $ git checkout gh-pages If you don't have the time to work on Slim, but found something we should know about, please submit an issue.
License
Slim is released under the MIT license.
Authors
Andrew Stone Fred Wu Daniel Mendler
Discuss
Google Group IRC Channel # slim-lang on freenode.net
Related projects
Template compilation framework: Temple Framework support: Rails 3 generators (slim-rails) Syntax highlighting: Vim Emacs Textmate / Sublime Text Espresso text editor Coda Template Converters (HAML, ERB, ...): Haml2Slim converter HTML2Slim converter ERB2Slim converter Language ports/Similar languages: Coffee script plugin for Slim Clojure port of Slim Hamlet.rb (Similar template language) Plim (Python port of Slim) Skim (Slim for Javascript) Haml (Older engine which inspired Slim) Jade (Similar engine for javascript)

Rdoc - Info Slim

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Rdoc - Info Slim

Hochgeladen von

Copyright:

Verfügbare Formate

rdoc.

Why use Slim?

T ext with trailing white space '

Inline html < (HT ML style)

Output with trailing white space ='

Output without HT ML escaping ==

Output without HT ML escaping and trailing ws =='

Dynamic content (= and ==)

body h1 id=" headline" = page_headline

ID shortcut # and class shortcut .

Embedded engines (Markdown, ...)

Compile time + Interpolation Compile time + Interpolation Compile time + Interpolation

Compile time + Interpolation Compile time + Interpolation Precompiled Precompiled

Setting options at runtime

{'.' => 'class', '# ' => 'id'}

nil (All enabled)

nil (None disabled)

false (true in Rails)

false (true in Rails)

{'class' => ' '}

'' false (true in Rails > 3.1)

'_buf' ('@output_buffer' in Rails)

Option priority and inheritance

Wrapped dictionary - Resolution order

Logic less in Rails

Logic less in Sinatra

Depending on installed translation library

Espresso text editor Coda

T emplate Converters (HAML, ERB, ...)

T est suite and continous integration

Ruby 1.9.3 Ruby EE JRuby Rubinius 2.0

Das könnte Ihnen auch gefallen