Module | Haml::Helpers |
In: |
lib/haml/helpers.rb
lib/haml/helpers/xss_mods.rb lib/haml/helpers/action_view_extensions.rb |
This module contains various helpful methods to make it easier to do various tasks. {Haml::Helpers} is automatically included in the context that a Haml template is parsed in, so all these methods are at your disposal from within the template.
HTML_ESCAPE | = | { '&'=>'&', '<'=>'<', '>'=>'>', '"'=>'"', "'"=>''', } | Characters that need to be escaped to HTML entities from user input |
Captures the result of a block of Haml code, gets rid of the excess indentation, and returns it as a string. For example, after the following,
.foo - foo = capture_haml(13) do |a| %p= a
the local variable `foo` would be assigned to `"<p>13</p>\n"`.
@param args [Array] Arguments to pass into the block @yield [args] A block of Haml code that will be converted to a string @yieldparam args [Array] `args`
Escapes HTML entities in `text`, but without escaping an ampersand that is already part of an escaped entity.
@param text [String] The string to sanitize @return [String] The sanitized string
Uses \{preserve} to convert any newlines inside whitespace-sensitive tags into the HTML entities for endlines.
@param tags [Array<String>] Tags that should have newlines escaped
@overload find_and_preserve(input, tags = haml_buffer.options[:preserve])
Escapes newlines within a string. @param input [String] The string within which to escape newlines
@overload find_and_preserve(tags = haml_buffer.options[:preserve])
Escapes newlines within a block of Haml code. @yield The block within which to escape newlines
Outputs text directly to the Haml buffer, with the proper indentation.
@param text [to_s] The text to output
Creates an HTML tag with the given name and optionally text and attributes. Can take a block that will run between the opening and closing tags. If the block is a Haml block or outputs text using \{haml_concat}, the text will be properly indented.
`name` can be a string using the standard Haml class/id shorthand (e.g. "span#foo.bar", "foo"). Just like standard Haml tags, these class and id values will be merged with manually-specified attributes.
`flags` is a list of symbol flags like those that can be put at the end of a Haml tag (`:/`, `:<`, and `:>`). Currently, only `:/` and `:<` are supported.
`haml_tag` outputs directly to the buffer; its return value should not be used. If you need to get the results as a string, use \{capture_haml\}.
For example,
haml_tag :table do haml_tag :tr do haml_tag 'td.cell' do haml_tag :strong, "strong!" haml_concat "data" end haml_tag :td do haml_concat "more_data" end end end
outputs
<table> <tr> <td class='cell'> <strong> strong! </strong> data </td> <td> more_data </td> </tr> </table>
@param name [to_s] The name of the tag @param flags [Array<Symbol>] Haml end-of-tag flags
@overload haml_tag(name, *flags, attributes = {})
@yield The block of Haml code within the tag
@overload haml_tag(name, text, *flags, attributes = {})
@param text [#to_s] The text within the tag
Returns a hash containing default assignments for the `xmlns`, `lang`, and `xml:lang` attributes of the `html` HTML element. For example,
%html{html_attrs}
becomes
<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en-US' lang='en-US'>
@param lang [String] The value of `xml:lang` and `lang` @return [{to_s => String}] The attribute hash
Returns a copy of `text` with ampersands, angle brackets and quotes escaped into HTML entities.
Note that if ActionView is loaded and XSS protection is enabled (as is the default for Rails 3.0+, and optional for version 2.3.5+), this won‘t escape text declared as "safe".
@param text [String] The string to sanitize @return [String] The sanitized string
Note: this does *not* need to be called when using Haml helpers normally in Rails.
Initializes the current object as though it were in the same context as a normal ActionView instance using Haml. This is useful if you want to use the helpers in a context other than the normal setup with ActionView. For example:
context = Object.new class << context include Haml::Helpers end context.init_haml_helpers context.haml_tag :p, "Stuff"
Returns whether or not the current template is a Haml template.
This function, unlike other {Haml::Helpers} functions, also works in other `ActionView` templates, where it will always return false.
@return [Boolean] Whether or not the current template is a Haml template
Takes an `Enumerable` object and a block and iterates over the enum, yielding each element to a Haml block and putting the result into `<li>` elements. This creates a list of the results of the block. For example:
= list_of([['hello'], ['yall']]) do |i| = i[0]
Produces:
<li>hello</li> <li>yall</li>
And
= list_of({:title => 'All the stuff', :description => 'A book about all the stuff.'}) do |key, val| %h3= key.humanize %p= val
Produces:
<li> <h3>Title</h3> <p>All the stuff</p> </li> <li> <h3>Description</h3> <p>A book about all the stuff.</p> </li>
@param enum [Enumerable] The list of objects to iterate over @yield [item] A block which contains Haml code that goes within list items @yieldparam item An element of `enum`
Runs a block of code in a non-Haml context (i.e. \{is_haml?} will return false).
This is mainly useful for rendering sub-templates such as partials in a non-Haml language, particularly where helpers may behave differently when run from Haml.
Note that this is automatically applied to Rails partials.
@yield A block which won‘t register as Haml
Takes any string, finds all the newlines, and converts them to HTML entities so they‘ll render correctly in whitespace-sensitive tags without screwing up the indentation.
@overload perserve(input)
Escapes newlines within a string. @param input [String] The string within which to escape all newlines
@overload perserve
Escapes newlines within a block of Haml code. @yield The block within which to escape newlines
Surrounds a block of Haml code with strings, with no whitespace in between. For example:
= surround '(', ')' do %a{:href => "food"} chicken
Produces:
(<a href='food'>chicken</a>)
and
= surround '*' do %strong angry
Produces:
*<strong>angry</strong>*
@param front [String] The string to add before the Haml @param back [String] The string to add after the Haml @yield A block of Haml to surround
Decrements the number of tabs the buffer automatically adds to the lines of the template.
@param i [Fixnum] The number of tabs by which to decrease the indentation @see tab_up
Increments the number of tabs the buffer automatically adds to the lines of the template. For example:
%h1 foo - tab_up %p bar - tab_down %strong baz
Produces:
<h1>foo</h1> <p>bar</p> <strong>baz</strong>
@param i [Fixnum] The number of tabs by which to increase the indentation @see tab_down
Sets the number of tabs the buffer automatically adds to the lines of the template, but only for the duration of the block. For example:
%h1 foo - with_tabs(2) do %p bar %strong baz
Produces:
<h1>foo</h1> <p>bar</p> <strong>baz</strong>
@param i [Fixnum] The number of tabs to use @yield A block in which the indentation will be `i` spaces