brakeman 5.2.2 → 7.1.1

data/bundle/ruby/3.1.0/gems/haml-6.4.0/REFERENCE.md

@@ -0,0 +1,1309 @@
+# Haml (HTML Abstraction Markup Language)
+
+Haml is a markup language that's used to cleanly and simply describe the HTML of
+any web document, without the use of inline code. Haml functions as a
+replacement for inline page templating systems such as PHP, ERB, and ASP.
+However, Haml avoids the need for explicitly coding HTML into the template,
+because it is actually an abstract description of the HTML, with some code to
+generate dynamic content.
+
+## Features
+
+* Whitespace active
+* Well-formatted markup
+* DRY
+* Follows CSS conventions
+* Integrates Ruby code
+* Implements Rails templates with the .haml extension
+
+## Using Haml
+
+Haml can be used in three ways:
+
+* as a command-line tool,
+* as a plugin for Ruby on Rails,
+* and as a standalone Ruby module.
+
+The first step for all of these is to install the Haml gem:
+
+    gem install haml
+
+To run Haml from the command line, just use
+
+    haml render input.haml > output.html
+
+Use `haml --help` for full documentation.
+
+To use Haml with Rails, add the following line to the Gemfile:
+
+    gem "haml"
+
+Once it's installed, all view files with the `".html.haml"` extension will be
+compiled using Haml.
+
+You can access instance variables in Haml templates the same way you do in ERB
+templates. Helper methods are also available in Haml templates. For example:
+
+    # file: app/controllers/movies_controller.rb
+
+    class MoviesController < ApplicationController
+      def index
+        @title = "Teen Wolf"
+      end
+    end
+
+    -# file: app/views/movies/index.html.haml
+
+    #content
+     .title
+       %h1= @title
+       = link_to 'Home', home_url
+
+may be compiled to:
+
+    <div id='content'>
+      <div class='title'>
+        <h1>Teen Wolf</h1>
+        <a href='/'>Home</a>
+      </div>
+    </div>
+
+### Ruby Module
+
+Haml can also be used completely separately from Rails and ActionView. To do
+this, install the gem with RubyGems:
+
+    gem install haml
+
+You can then use it by including the `haml` gem in Ruby code, and using
+{Haml::Template} like so:
+
+    engine = Haml::Template.new { "%p Haml code!" }
+    engine.render #=> "<p>Haml code!</p>\n"
+
+### Options
+
+Haml understands various configuration options that affect its performance and
+output.
+
+In Rails, options can be set by using `Haml::RailsTemplate.set_options` in an initializer:
+
+```ruby
+# config/initializers/haml.rb
+Haml::RailsTemplate.set_options(escape_html: false)
+```
+
+Outside Rails, you can set them by configuring them globally in `Haml::Template.options`:
+
+```ruby
+Haml::Template.options[:escape_html] = false
+```
+
+In sinatra specifically, you can set them in global config with:
+```ruby
+set :haml, { escape_html: false }
+```
+
+Finally, you can also set them by passing an options hash to `Haml::Engine.new` or `Haml::Template.new`.
+For the complete list of available options, please see [`Haml::Engine`](https://github.com/haml/haml/blob/main/lib/haml/engine.rb).
+
+## Plain Text
+
+A substantial portion of any HTML document is its content, which is plain old
+text. Any Haml line that's not interpreted as something else is taken to be
+plain text, and passed through unmodified. For example:
+
+    %gee
+      %whiz
+        Wow this is cool!
+
+is compiled to:
+
+    <gee>
+      <whiz>
+        Wow this is cool!
+      </whiz>
+    </gee>
+
+Note that HTML tags are passed through unmodified as well. If you have some HTML
+you don't want to convert to Haml, or you're converting a file line-by-line, you
+can just include it as-is. For example:
+
+    %p
+      <div id="blah">Blah!</div>
+
+is compiled to:
+
+    <p>
+      <div id="blah">Blah!</div>
+    </p>
+
+### Escaping: `\`
+
+The backslash character escapes the first character of a line, allowing use of
+otherwise interpreted characters as plain text. For example:
+
+    %title
+      = @title
+      \= @title
+
+is compiled to:
+
+    <title>
+      MyPage
+      = @title
+    </title>
+
+## HTML Elements
+
+### Element Name: `%`
+
+The percent character is placed at the beginning of a line. It's followed
+immediately by the name of an element, then optionally by modifiers (see below),
+a space, and text to be rendered inside the element. It creates an element in
+the form of `<element></element>`. For example:
+
+    %one
+      %two
+        %three Hey there
+
+is compiled to:
+
+    <one>
+      <two>
+        <three>Hey there</three>
+      </two>
+    </one>
+
+Any string is a valid element name; Haml will automatically generate opening and
+closing tags for any element.
+
+### Attributes: `{}` or `()` {#attributes}
+
+Braces represent a Ruby hash that is used for specifying the attributes of an
+element. It is literally evaluated as a Ruby hash, so logic will work in it and
+local variables may be used. Quote characters within the attribute will be
+replaced with appropriate escape sequences. The hash is placed after the tag is
+defined. For example:
+
+    %html{:xmlns => "http://www.w3.org/1999/xhtml", "xml:lang" => "en", :lang => "en"}
+
+is compiled to:
+
+    <html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en' lang='en'></html>
+
+Attribute hashes can also be stretched out over multiple lines to accommodate
+many attributes.
+
+    %script{
+      "type": text/javascript",
+      "src": javascripts/script_#{2 + 7}",
+      "data": {
+        "controller": "reporter",
+      },
+    }
+
+is compiled to:
+
+    <script src='javascripts/script_9' type='text/javascript' data-controller='reporter'></script>
+
+#### `:class` and `:id` Attributes {#class-and-id-attributes}
+
+The `:class` and `:id` attributes can also be specified as a Ruby array whose
+elements will be joined together. A `:class` array is joined with `" "` and an
+`:id` array is joined with `"_"`. For example:
+
+    %div{:id => [@item.type, @item.number], :class => [@item.type, @item.urgency]}
+
+is equivalent to:
+
+    %div{:id => "#{@item.type}_#{@item.number}", :class => "#{@item.type} #{@item.urgency}"}
+
+The array will first be flattened and any elements that do not test as true will
+be removed. The remaining elements will be converted to strings. For example:
+
+    %div{:class => [@item.type, @item == @sortcol && [:sort, @sortdir]] } Contents
+
+could render as any of:
+
+    <div class="numeric sort ascending">Contents</div>
+    <div class="numeric">Contents</div>
+    <div class="sort descending">Contents</div>
+    <div>Contents</div>
+
+depending on whether `@item.type` is `"numeric"` or `nil`, whether `@item == @sortcol`,
+and whether `@sortdir` is `"ascending"` or `"descending"`.
+
+If a single value is specified and it evaluates to false it is ignored;
+otherwise it gets converted to a string. For example:
+
+    .item{:class => @item.is_empty? && "empty"}
+
+could render as either of:
+
+    class="item"
+    class="item empty"
+
+#### HTML-style Attributes: `()`
+
+Haml also supports a terser, less Ruby-specific attribute syntax based on HTML's
+attributes. These are used with parentheses instead of braces, like so:
+
+    %html(xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en")
+
+Ruby variables can be used by omitting the quotes. Local variables or instance
+variables can be used. For example:
+
+    %a(title=@title href=href) Stuff
+
+This is the same as:
+
+    %a{:title => @title, :href => href} Stuff
+
+Because there are no commas separating attributes, though, more complicated
+expressions aren't allowed. For those you'll have to use the `{}` syntax. You
+can, however, use both syntaxes together:
+
+    %a(title=@title){:href => @link.href} Stuff
+
+You can also use `#{}` interpolation to insert complicated expressions in a
+HTML-style attribute:
+
+    %span(class="widget_#{@widget.number}")
+
+HTML-style attributes can be stretched across multiple lines just like
+hash-style attributes:
+
+    %script(type="text/javascript"
+            src="javascripts/script_#{2 + 7}")
+
+#### Ruby 1.9-style Hashes
+
+Haml also supports Ruby's new hash syntax:
+
+    %a{title: @title, href: href} Stuff
+
+#### Boolean Attributes
+
+Some attributes, such as "checked" for `input` tags or "selected" for `option`
+tags, are "boolean" in the sense that their values don't matter - it only
+matters whether or not they're present. In HTML (but not XHTML), these
+attributes can be written as
+
+    <input selected>
+
+To do this in Haml using hash-style attributes, just assign a Ruby `true` value
+to the attribute:
+
+    %input{:selected => true}
+
+In XHTML, the only valid value for these attributes is the name of the
+attribute. Thus this will render in XHTML as
+
+    <input selected='selected'>
+
+To set these attributes to false, simply assign them to a Ruby false value. In
+both XHTML and HTML,
+
+    %input{:selected => false}
+
+will just render as:
+
+    <input>
+
+HTML-style boolean attributes can be written just like HTML:
+
+    %input(selected)
+
+or using `true` and `false`:
+
+    %input(selected=true)
+
+This feature works only for attributes that are included in
+[`Haml::BOOLEAN_ATTRIBUTES`](https://github.com/haml/haml/blob/main/lib/haml/attribute_compiler.rb#L8),
+as well as `data-` and `aria-` attributes.
+
+    %input{'data-hidden' => false}
+    %input{'aria-hidden' => false}
+    %input{'xyz-hidden' => false}
+
+will render as:
+
+    <input>
+    <input>
+    <input xyz-hidden='false'>
+
+
+<!-- The title to the next section (Prefixed Attributes) has changed. This
+<a> tag is so old links to here still work. -->
+<a id="html5_custom_data_attributes" style="border:0;"></a>
+
+#### Data Attributes
+
+HTML5 allows for adding
+[custom non-visible data attributes](http://www.whatwg.org/specs/web-apps/current-work/multipage/elements.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
+to elements using attribute names beginning with `data-`. The
+[Accessible Rich Internet Applications](http://www.w3.org/WAI/intro/aria)
+specification makes use of attributes beginning with `aria-`.
+
+Haml can help generate collections of attributes that share a prefix like
+these. Any entry in an `data` or `aria` attribute hash that has a Hash as its
+value is expanded into a series of attributes, one for each key/value pair in
+the hash, with the attribute name formed by joining the “parent” key name to
+the key name with a hyphen. This works only for `data` or `aria`.
+
+For example:
+
+    %a{:href=>"/posts", :data => {:author_id => 123, :category => 7}} Posts By Author
+
+will render as:
+
+    <a data-author-id='123' data-category='7' href='/posts'>Posts By Author</a>
+
+This expansion of hashes is recursive – any value of the child hash that is
+itself a hash will create an attribute for each entry, with the attribute name
+prefixed with all ancestor keys. For example:
+
+    .book-info{:data => {:book => {:id => 123, :genre => 'programming'}, :category => 7}}
+
+will render as:
+
+    <div class='book-info' data-book-genre='programming' data-book-id='123' data-category='7'></div>
+
+### Class and ID: `.` and `#`
+
+The period and pound sign are borrowed from CSS. They are used as shortcuts to
+specify the `class` and `id` attributes of an element, respectively. Multiple
+class names can be specified in a similar way to CSS, by chaining the class
+names together with periods. They are placed immediately after the tag and
+before an attributes hash. For example:
+
+    %div#things
+      %span#rice Chicken Fried
+      %p.beans{ :food => 'true' } The magical fruit
+      %h1.class.otherclass#id La La La
+
+is compiled to:
+
+    <div id='things'>
+      <span id='rice'>Chicken Fried</span>
+      <p class='beans' food='true'>The magical fruit</p>
+      <h1 class='class otherclass' id='id'>La La La</h1>
+    </div>
+
+And,
+
+    %div#content
+      %div.articles
+        %div.article.title Doogie Howser Comes Out
+        %div.article.date 2006-11-05
+        %div.article.entry
+          Neil Patrick Harris would like to dispel any rumors that he is straight
+
+is compiled to:
+
+    <div id='content'>
+      <div class='articles'>
+        <div class='article title'>Doogie Howser Comes Out</div>
+        <div class='article date'>2006-11-05</div>
+        <div class='article entry'>
+          Neil Patrick Harris would like to dispel any rumors that he is straight
+        </div>
+      </div>
+    </div>
+
+These shortcuts can be combined with long-hand attributes; the two values will
+be merged together as though they were all placed in an array (see [the
+documentation on `:class` and `:id` attributes](#class-and-id-attributes)). For
+example:
+
+    %div#Article.article.entry{:id => @article.number, :class => @article.visibility}
+
+is equivalent to
+
+    %div{:id => ['Article', @article.number], :class => ['article', 'entry', @article.visibility]} Gabba Hey
+
+and could compile to:
+
+    <div class="article entry visible" id="Article_27">Gabba Hey</div>
+
+#### Implicit Div Elements
+
+Because divs are used so often, they're the default elements. If you only define
+a class and/or id using `.` or `#`, a div is automatically used. For example:
+
+    #collection
+      .item
+        .description What a cool item!
+
+is the same as:
+
+    %div#collection
+      %div.item
+        %div.description What a cool item!
+
+and is compiled to:
+
+    <div id='collection'>
+      <div class='item'>
+        <div class='description'>What a cool item!</div>
+      </div>
+    </div>
+
+#### Class Name Merging and Ordering
+
+Class names are ordered in the following way:
+
+1) Tag identifiers in order (aka, ".alert.me" => "alert me")
+2) Classes appearing in HTML-style attributes
+3) Classes appearing in Hash-style attributes
+
+For instance, this is a complicated and unintuitive test case illustrating the ordering
+
+    .foo.moo{:class => ['bar', 'alpha']}(class='baz')
+
+The resulting HTML would be as follows:
+
+    <div class='foo moo baz bar alpha'></div>
+
+*Versions of Haml prior to 5.0 would alphabetically sort class names.*
+
+### Empty (void) Tags: `/`
+
+The forward slash character, when placed at the end of a tag definition, causes
+Haml to treat it as being an empty (or void) element. Depending on the format,
+the tag will be rendered either without a closing tag (`:html4` or `:html5`), or
+as a self-closing tag (`:xhtml`).
+
+Taking the following as an example:
+
+    %br/
+    %meta{'http-equiv' => 'Content-Type', :content => 'text/html'}/
+
+When the format is `:html4` or `:html5` this is compiled to:
+
+    <br>
+    <meta content='text/html' http-equiv='Content-Type'>
+
+and when the format is `:xhtml` it is compiled to:
+
+    <br />
+    <meta content='text/html' http-equiv='Content-Type' />
+
+Some tags are automatically treated as being empty, as long as they have no
+content in the Haml source. `meta`, `img`, `link`, `br`, `hr`, `input`,
+`area`, `param`, `col` and `base` tags are treated as empty by default. This
+list can be customized by setting the {Haml::Options#autoclose `:autoclose`}
+option.
+
+### Whitespace Removal: `>` and `<`
+
+`>` and `<` give you more control over the whitespace near a tag. `>` will
+remove all whitespace surrounding a tag, while `<` will remove all whitespace
+immediately within a tag. You can think of them as alligators eating the
+whitespace: `>` faces out of the tag and eats the whitespace on the outside, and
+`<` faces into the tag and eats the whitespace on the inside. They're placed at
+the end of a tag definition, after class, id, and attribute declarations but
+before `/` or `=`. For example:
+
+    %blockquote<
+      %div
+        Foo!
+
+is compiled to:
+
+    <blockquote><div>
+      Foo!
+    </div></blockquote>
+
+And:
+
+    %img
+    %img>
+    %img
+
+is compiled to:
+
+    <img /><img /><img />
+
+And:
+
+    %p<= "Foo\nBar"
+
+is compiled to:
+
+    <p>Foo
+    Bar</p>
+
+And finally:
+
+    %img
+    %pre><
+      foo
+      bar
+    %img
+
+is compiled to:
+
+    <img /><pre>foo
+    bar</pre><img />
+
+### Object Reference: `[]`
+
+Square brackets follow a tag definition and contain a Ruby object that is used
+to set the class and id of that tag. The class is set to the object's class
+(transformed to use underlines rather than camel case) and the id is set to the
+object's class, followed by the value of its `#to_key` or `#id` method (in that
+order). This is most useful for elements that represent instances of Active
+Model models. Additionally, the second argument (if present) will be used as a
+prefix for both the id and class attributes. For example:
+
+    # file: app/controllers/users_controller.rb
+
+    def show
+      @user = FriendlyUser.find(15)
+    end
+
+    -# file: app/views/users/show.haml
+
+    %div[@user, :greeting]
+      %bar[290]/
+      Hello!
+
+is compiled to:
+
+    <div class='greeting_friendly_user' id='greeting_friendly_user_15'>
+      <bar class='fixnum' id='fixnum_581' />
+      Hello!
+    </div>
+
+If you require that the class be something other than the underscored object's
+class, you can implement the `haml_object_ref` method on the object.
+
+    # file: app/models/friendly_user.rb
+
+    class FriendlyUser < ActiveRecord::Base
+      def haml_object_ref
+        "a_friendly_user"
+      end
+    end
+
+    -# file: app/views/users/show.haml
+
+    %div[@user]
+      Hello!
+
+is compiled to:
+
+    <div class='a_friendly_user' id='a_friendly_user_15'>
+      Hello!
+    </div>
+
+The `:class` attribute may be used in conjunction with an object
+reference.  The compiled element will have the union of all classes.
+
+    - user = User.find(1)
+    %p[user]{:class => 'alpha bravo'}
+    <p id="user_1" class="alpha bravo user"></p>
+
+## Doctype: `!!!`
+
+When describing HTML documents with Haml, you can have a document type or XML
+prolog generated automatically by including the characters `!!!`. For example:
+
+    !!! XML
+    !!!
+    %html
+      %head
+        %title Myspace
+      %body
+        %h1 I am the international space station
+        %p Sign my guestbook
+
+is compiled to:
+
+    <?xml version='1.0' encoding='utf-8' ?>
+    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+    <html>
+      <head>
+        <title>Myspace</title>
+      </head>
+      <body>
+        <h1>I am the international space station</h1>
+        <p>Sign my guestbook</p>
+      </body>
+    </html>
+
+You can also specify the specific doctype after the `!!!` When the
+{Haml::Options#format `:format`} is set to `:xhtml`. The following doctypes are
+supported:
+
+`!!!`
+: XHTML 1.0 Transitional<br/>
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">`
+
+`!!! Strict`
+: XHTML 1.0 Strict<br/>
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">`
+
+`!!! Frameset`
+: XHTML 1.0 Frameset<br/>
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">`
+
+`!!! 5`
+: XHTML 5<br/>
+ `<!DOCTYPE html>`<br/>
+
+`!!! 1.1`
+: XHTML 1.1<br/>
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">`
+
+`!!! Basic`
+: XHTML Basic 1.1<br/>
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd"> `
+
+`!!! Mobile`
+: XHTML Mobile 1.2<br/>
+ `<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">`
+
+`!!! RDFa`
+: XHTML+RDFa 1.0<br/>
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">`
+
+When the {Haml::Options#format `:format`} option is set to `:html4`, the following
+doctypes are supported:
+
+`!!!`
+: HTML 4.01 Transitional<br/>
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">`
+
+`!!! Strict`
+: HTML 4.01 Strict<br/>
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">`
+
+`!!! Frameset`
+: HTML 4.01 Frameset<br/>
+ `<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">`
+
+When the {Haml::Options#format `:format`} option is set to `:html5`,
+`!!!` is always `<!DOCTYPE html>`.
+
+If you're not using the UTF-8 character set for your document, you can specify
+which encoding should appear in the XML prolog in a similar way. For example:
+
+    !!! XML iso-8859-1
+
+is compiled to:
+
+    <?xml version='1.0' encoding='iso-8859-1' ?>
+
+If the mime_type of the template being rendered is `text/xml` then a format of
+`:xhtml` will be used even if the global output format is set to `:html4` or
+`:html5`.
+
+## Comments
+
+Haml supports two sorts of comments: those that show up in the HTML output and
+those that don't.
+
+### HTML Comments: `/`
+
+The forward slash character, when placed at the beginning of a line, wraps all
+text after it in an HTML comment. For example:
+
+    %peanutbutterjelly
+      / This is the peanutbutterjelly element
+      I like sandwiches!
+
+is compiled to:
+
+    <peanutbutterjelly>
+      <!-- This is the peanutbutterjelly element -->
+      I like sandwiches!
+    </peanutbutterjelly>
+
+The forward slash can also wrap indented sections of code. For example:
+
+    /
+      %p This doesn't render...
+      %div
+        %h1 Because it's commented out!
+
+is compiled to:
+
+    <!--
+      <p>This doesn't render...</p>
+      <div>
+        <h1>Because it's commented out!</h1>
+      </div>
+    -->
+
+#### Conditional Comments: `/[]`
+
+You can also use [Internet Explorer conditional
+comments](http://www.quirksmode.org/css/condcom.html) by enclosing the condition
+in square brackets after the `/`. For example:
+
+    /[if IE]
+      %a{ :href => 'http://www.mozilla.com/en-US/firefox/' }
+        %h1 Get Firefox
+
+is compiled to:
+
+    <!--[if IE]>
+      <a href='http://www.mozilla.com/en-US/firefox/'>
+        <h1>Get Firefox</h1>
+      </a>
+    <![endif]-->
+
+To generate “downlevel-revealed” conditional comments, where the content is
+hidden from IE but not other browsers,  add a `!` before the brackets: `/![]`.
+Haml will produce valid HTML when generating this kind of conditional comment.
+
+For example:
+
+    /![if !IE]
+      You are not using Internet Explorer, or are using version 10+.
+
+is compiled to:
+
+    <!--[if !IE]><!-->
+      You are not using Internet Explorer, or are using version 10+.
+    <!--<![endif]-->
+
+### Haml Comments: `-#`
+
+The hyphen followed immediately by the pound sign signifies a silent comment.
+Any text following this isn't rendered in the resulting document at all.
+
+For example:
+
+    %p foo
+    -# This is a comment
+    %p bar
+
+is compiled to:
+
+    <p>foo</p>
+    <p>bar</p>
+
+You can also nest text beneath a silent comment. None of this text will be
+rendered. For example:
+
+    %p foo
+    -#
+      This won't be displayed
+        Nor will this
+                       Nor will this.
+    %p bar
+
+is compiled to:
+
+    <p>foo</p>
+    <p>bar</p>
+
+## Ruby Evaluation
+
+### Inserting Ruby: `=` {#inserting_ruby}
+
+The equals character is followed by Ruby code. This code is evaluated and the
+output is inserted into the document. For example:
+
+    %p
+      = ['hi', 'there', 'reader!'].join " "
+      = "yo"
+
+is compiled to:
+
+    <p>
+      hi there reader!
+      yo
+    </p>
+
+If the {Haml::Options#escape_html `:escape_html`} option is set, `=` will sanitize
+any HTML-sensitive characters generated by the script. For example:
+
+    = '<script>alert("I\'m evil!");</script>'
+
+would be compiled to
+
+    &lt;script&gt;alert(&quot;I'm evil!&quot;);&lt;/script&gt;
+
+`=` can also be used at the end of a tag to insert Ruby code within that tag.
+For example:
+
+    %p= "hello"
+
+would be compiled to:
+
+    <p>hello</p>
+
+A line of Ruby code can be stretched over multiple lines as long as each line
+but the last ends with a comma. For example:
+
+    = link_to_remote "Add to cart",
+        :url => { :action => "add", :id => product.id },
+        :update => { :success => "cart", :failure => "error" }
+
+Note that it's illegal to nest code within a tag that ends with `=`.
+
+### Running Ruby: `-`
+
+The hyphen character is also followed by Ruby code. This code is evaluated but
+*not* inserted into the document.
+
+**It is not recommended that you use this widely; almost all processing code and
+logic should be restricted to Controllers, Helpers, or partials.**
+
+For example:
+
+    - foo = "hello"
+    - foo << " there"
+    - foo << " you!"
+    %p= foo
+
+is compiled to:
+
+    <p>
+      hello there you!
+    </p>
+
+A line of Ruby code can be stretched over multiple lines as long as each line
+but the last ends with a comma. For example:
+
+    - links = {:home => "/",
+        :docs => "/docs",
+        :about => "/about"}
+
+#### Ruby Blocks
+
+Ruby blocks, like XHTML tags, don't need to be explicitly closed in Haml.
+Rather, they're automatically closed, based on indentation. A block begins
+whenever the indentation is increased after a Ruby evaluation command. It ends
+when the indentation decreases (as long as it's not an `else` clause or
+something similar). For example:
+
+    - (42...47).each do |i|
+      %p= i
+    %p See, I can count!
+
+is compiled to:
+
+    <p>42</p>
+    <p>43</p>
+    <p>44</p>
+    <p>45</p>
+    <p>46</p>
+    <p>See, I can count!</p>
+
+Another example:
+
+    %p
+      - case 2
+      - when 1
+        = "1!"
+      - when 2
+        = "2?"
+      - when 3
+        = "3."
+
+is compiled to:
+
+    <p>
+      2?
+    </p>
+
+### Whitespace Preservation: `~` {#tilde}
+
+`~` works just like `=`, except that it runs {Haml::Helpers.preserve}
+on its input. For example,
+
+    ~ "Foo\n<pre>Bar\nBaz</pre>"
+
+is the same as:
+
+    = find_and_preserve("Foo\n<pre>Bar\nBaz</pre>")
+
+and is compiled to:
+
+    Foo
+    <pre>Bar&#x000A;Baz</pre>
+
+See also [Whitespace Preservation](#whitespace_preservation).
+
+### Ruby Interpolation: `#{}`
+
+Ruby code can also be interpolated within plain text using `#{}`, similarly to
+Ruby string interpolation. For example,
+
+    %p This is #{h quality} cake!
+
+is the same as
+
+    %p= "This is #{h quality} cake!"
+
+and might compile to:
+
+    <p>This is scrumptious cake!</p>
+
+Backslashes can be used to escape `#{}` strings, but they don't act as escapes
+anywhere else in the string. For example:
+
+    %p
+      Look at \\#{h word} lack of backslash: \#{foo}
+      And yon presence thereof: \{foo}
+
+might compile to:
+
+    <p>
+      Look at \yon lack of backslash: #{foo}
+      And yon presence thereof: \{foo}
+    </p>
+
+Interpolation can also be used within [filters](#filters). For example:
+
+    :javascript
+      $(document).ready(function() {
+        alert(#{@message.to_json});
+      });
+
+might compile to:
+
+    <script type='text/javascript'>
+      //<![CDATA[
+        $(document).ready(function() {
+          alert("Hi there!");
+        });
+      //]]>
+    </script>
+
+#### Gotchas
+
+Haml uses an overly simplistic regular expression to identify string
+interpolation rather than a full-blown Ruby parser. This is fast and works for
+most code but you may have errors with code like the following:
+
+    %span #{'{'}
+
+This code will generate a syntax error, complaining about unbalanced braces.
+In cases like this, the recommended workaround is output the code as a Ruby
+string to force Haml to parse the code with Ruby.
+
+    %span= "#{'{'}"
+
+
+### Escaping HTML: `&=` {#escaping_html}
+
+An ampersand followed by one or two equals characters evaluates Ruby code just
+like the equals without the ampersand, but sanitizes any HTML-sensitive
+characters in the result of the code. For example:
+
+    &= "I like cheese & crackers"
+
+compiles to
+
+    I like cheese &amp; crackers
+
+If the {Haml::Options#escape_html `:escape_html`} option is set, `&=` behaves
+identically to `=`.
+
+`&` can also be used on its own so that `#{}` interpolation is escaped. For
+example,
+
+    & I like #{"cheese & crackers"}
+
+compiles to:
+
+    I like cheese &amp; crackers
+
+### Unescaping HTML: `!=` {#unescaping_html}
+
+An exclamation mark followed by one or two equals characters evaluates Ruby code
+just like the equals would, but never sanitizes the HTML.
+
+By default, the single equals doesn't sanitize HTML either. However, if the
+{Haml::Options#escape_html `:escape_html`} option is set, `=` will sanitize the
+HTML, but `!=` still won't. For example, if `:escape_html` is set:
+
+    = "I feel <strong>!"
+    != "I feel <strong>!"
+
+compiles to
+
+    I feel &lt;strong&gt;!
+    I feel <strong>!
+
+`!` can also be used on its own so that `#{}` interpolation is unescaped.
+For example,
+
+    ! I feel #{"<strong>"}!
+
+compiles to
+
+    I feel <strong>!
+
+## Filters {#filters}
+
+The colon character designates a filter. This allows you to pass an indented
+block of text as input to another filtering program and add the result to the
+output of Haml. The syntax is simply a colon followed by the name of the filter.
+For example:
+
+    %p
+      :markdown
+        # Greetings
+
+        Hello, *World*
+
+is compiled to:
+
+    <p>
+      <h1>Greetings</h1>
+
+      <p>Hello, <em>World</em></p>
+    </p>
+
+Filters can have Ruby code interpolated with `#{}`. For example:
+
+    - flavor = "raspberry"
+    #content
+      :textile
+        I *really* prefer _#{flavor}_ jam.
+
+is compiled to
+
+    <div id='content'>
+      <p>I <strong>really</strong> prefer <em>raspberry</em> jam.</p>
+    </div>
+
+The functionality of some filters such as Markdown can be provided by many
+different libraries. Usually you don't have to worry about this - you can just
+load the gem of your choice and Haml will automatically use it.
+
+However in some cases you may want to make Haml explicitly use a specific gem to
+be used by a filter. In these cases you can do this via Tilt, the library Haml
+uses to implement many of its filters:
+
+    Tilt.prefer Tilt::RedCarpetTemplate
+
+See the [Tilt documentation](https://github.com/rtomayko/tilt) for
+more info.
+
+Haml comes with the following filters defined:
+
+### `:cdata` {#cdata-filter}
+
+Surrounds the filtered text with CDATA tags.
+
+### `:coffee` {#coffee-filter}
+
+Compiles the filtered text to JavaScript in `<script>` tag using CoffeeScript.
+You can also reference this filter as `:coffeescript`. This filter is
+implemented using Tilt.
+
+### `:css` {#css-filter}
+
+Surrounds the filtered text with `<style>` and (optionally) CDATA tags. Useful
+for including inline CSS. Use the {Haml::Options#cdata `:cdata` option} to
+control when CDATA tags are added.
+
+### `:erb` {#erb-filter}
+
+Parses the filtered text with ERB, like an RHTML template. Not available if the
+{Haml::Options#suppress_eval `:suppress_eval`} option is set to true. Embedded
+Ruby code is evaluated in the same context as the Haml template. This filter is
+implemented using Tilt.
+
+### `:escaped` {#escaped-filter}
+
+Works the same as plain, but HTML-escapes the text
+before placing it in the document.
+
+### `:javascript` {#javascript-filter}
+
+Surrounds the filtered text with `<script>` and (optionally) CDATA tags.
+Useful for including inline Javascript. Use the {Haml::Options#cdata `:cdata`
+option} to control when CDATA tags are added.
+
+### `:less` {#less-filter}
+
+Parses the filtered text with [Less](http://lesscss.org/) to produce CSS output in `<style>` tag.
+This filter is implemented using Tilt.
+
+### `:markdown` {#markdown-filter}
+
+Parses the filtered text with
+[Markdown](http://daringfireball.net/projects/markdown). This filter is
+implemented using Tilt.
+
+### `:maruku` {#maruku-filter}
+
+Parses the filtered text with [Maruku](https://github.com/bhollis/maruku), which
+has some non-standard extensions to Markdown.
+
+As of Haml 4.0, this filter is defined in [Haml
+contrib](https://github.com/haml/haml-contrib) but is loaded automatically for
+historical reasons. In future versions of Haml it will likely not be loaded by
+default. This filter is implemented using Tilt.
+
+### `:plain` {#plain-filter}
+
+Does not parse the filtered text. This is useful for large blocks of text
+without HTML tags, when you don't want lines starting with `.` or `-` to be
+parsed.
+
+### `:preserve` {#preserve-filter}
+
+Inserts the filtered text into the template with whitespace preserved.
+`preserve`d blocks of text aren't indented, and newlines are replaced with the
+HTML escape code for newlines, to preserve nice-looking output. See also
+[Whitespace Preservation](#whitespace_preservation).
+
+### `:ruby` {#ruby-filter}
+
+Parses the filtered text with the normal Ruby interpreter.
+The Ruby code is evaluated in the same context as the Haml template.
+
+### `:sass` {#sass-filter}
+
+Parses the filtered text with [Sass](http://sass-lang.com/) to produce CSS
+output in `<style>` tag. This filter is implemented using Tilt.
+
+### `:scss` {#scss-filter}
+
+Parses the filtered text with Sass like the `:sass` filter, but uses the newer
+SCSS syntax to produce CSS output in `<style>` tag. This filter is implemented
+using Tilt.
+
+### `:textile` {#textile-filter}
+
+Parses the filtered text with [Textile](http://www.textism.com/tools/textile).
+Only works if [RedCloth](http://redcloth.org) is installed.
+
+As of Haml 4.0, this filter is defined in [Haml
+contrib](https://github.com/haml/haml-contrib) but is loaded automatically for
+historical reasons. In future versions of Haml it will likely not be loaded by
+default. This filter is implemented using Tilt.
+
+### Custom Filters
+
+You can also define your own filters.
+`Haml::Filters::YourCustomFilter#compile` should return
+[a Temple expression](https://github.com/judofyr/temple/blob/master/EXPRESSIONS.md).
+
+The simplest example of a filter might be something like:
+
+    class HelloFilter < Haml::Filters::Base
+      def compile(_node)
+        [:static, "hello world"]
+      end
+    end
+    
+    Haml::Filters.registered[:hello] ||= HelloFilter
+
+A more complex example:
+
+    class BetterFilter < Haml::Filters::Base
+      def compile(node)
+        temple = [:multi]
+        temple << [:static, "hello "]
+        temple << compile_text(node.value[:text])
+        temple << [:static, " world"]
+        temple
+      end
+    
+      private
+      def compile_text(text)
+        if ::Haml::Util.contains_interpolation?(text)
+          [:dynamic, ::Haml::Util.unescape_interpolation(text)]
+        else
+          [:static, text]
+        end
+      end
+    end
+
+    Haml::Filters.registered[:better] ||= BetterFilter
+
+See {Haml::Filters} for examples.
+
+## Multiline: `|` {#multiline}
+
+The pipe character designates a multiline string.
+It's placed at the end of a line (after some whitespace)
+and means that all following lines that end with `|`
+will be evaluated as though they were on the same line.
+**Note that even the last line in the multiline block
+should end with `|`.**
+For example:
+
+    %whoo
+      %hoo= h(                       |
+        "I think this might get " +  |
+        "pretty long so I should " + |
+        "probably make it " +        |
+        "multiline so it doesn't " + |
+        "look awful.")               |
+      %p This is short.
+
+is compiled to:
+
+    <whoo>
+      <hoo>I think this might get pretty long so I should probably make it multiline so it doesn't look awful.</hoo>
+      <p>This is short</p>
+    </whoo>
+
+Using multiline declarations in Haml is intentionally awkward.
+This is designed to discourage people from putting lots and lots of Ruby code
+in their Haml templates.
+If you find yourself using multiline declarations, stop and think:
+could I do this better with a helper?
+
+Note that there are a few cases where it's useful to allow
+something to flow over onto multiple lines in a non-awkward manner.
+One of these is HTML attributes.
+Some elements just have lots of attributes,
+so you can wrap attributes without using `|` (see [Attributes](#attributes)).
+
+In addition, sometimes you need to call Ruby methods or declare data structures
+that just need a lot of template information.
+So data structures and  functions that require lots of arguments
+can be wrapped over multiple lines,
+as long as each line but the last ends in a comma
+(see [Inserting Ruby](#inserting_ruby)).
+
+## Whitespace Preservation {#whitespace_preservation}
+
+Sometimes you don't want Haml to indent all your text.
+For example, tags like `pre` and `textarea` are whitespace-sensitive;
+indenting the text makes them render wrong.
+
+Haml deals with this by "preserving" newlines before they're put into the
+document -- converting them to the HTML whitespace escape code, `&#x000A;`. Then
+Haml won't try to re-format the indentation.
+
+Literal `textarea` and `pre` tags automatically preserve content given through
+`=`. Dynamically-generated `textarea`s and `pre`s can't be preserved
+automatically, and so should be passed through
+{Haml::Helpers.preserve} or the [`~` command](#tilde), which has the
+same effect.
+
+Blocks of literal text can be preserved using the [`:preserve` filter](#preserve-filter).
+
+## Turbo
+
+For people using Turbo-rails need to either:
+*  follow the naming convention with the html format (ie. ensure any `.haml` files end `.html.haml`), or
+*  add a monkey patch as follows:
+
+```rb
+# config/initializers/haml.rb
+require "haml/rails_template"
+
+module Haml
+  class RailsTemplate
+    def default_format
+      :html
+    end
+  end
+end
+```