module Motion::HTML::BaseTags

Included Modules

Direct including types

Defined in:

motion/html/tags/base_tags.cr

Constant Summary

EMPTY_HTML_ATTRS = {} of String => String
EMPTY_TAGS = [:img, :br, :hr, :input, :meta, :source] of ::Symbol
RENAMED_TAGS = {para: "p", select_tag: "select"}
TAGS = [:a, :abbr, :address, :article, :aside, :b, :bdi, :body, :button, :code, :details, :dialog, :div, :dd, :dl, :dt, :em, :fieldset, :figcaption, :figure, :footer, :form, :h1, :h2, :h3, :h4, :h5, :h6, :head, :header, :html, :i, :iframe, :label, :li, :main, :mark, :menuitem, :meter, :nav, :ol, :option, :pre, :progress, :rp, :rt, :ruby, :s, :script, :section, :small, :span, :strong, :summary, :table, :tbody, :td, :template, :textarea, :th, :thead, :time, :title, :tr, :u, :ul, :video, :wbr] of ::Symbol

Instance Method Summary

Macro Summary

Instance Method Detail

def a(content : String | Motion::HTML::AllowedInTags) : Nil #

def a(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a <a></a> tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
a("Sample", {"class" => "cls-1 red"}, [:required]) #=> <a class="cls-1 red" required>Sample</a>

def a(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def a(&) : Nil #

def a(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def abbr(content : String | Motion::HTML::AllowedInTags) : Nil #

def abbr(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;abbr&gt;&lt;/abbr&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
abbr("Sample", {"class" => "cls-1 red"}, [:required]) #=> <abbr class="cls-1 red" required>Sample</abbr>

def abbr(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def abbr(&) : Nil #

def abbr(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def address(content : String | Motion::HTML::AllowedInTags) : Nil #

def address(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;address&gt;&lt;/address&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
address("Sample", {"class" => "cls-1 red"}, [:required]) #=> <address class="cls-1 red" required>Sample</address>

def address(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def address(&) : Nil #

def address(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def article(content : String | Motion::HTML::AllowedInTags) : Nil #

def article(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;article&gt;&lt;/article&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
article("Sample", {"class" => "cls-1 red"}, [:required]) #=> <article class="cls-1 red" required>Sample</article>

def article(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def article(&) : Nil #

def article(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def aside(content : String | Motion::HTML::AllowedInTags) : Nil #

def aside(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;aside&gt;&lt;/aside&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
aside("Sample", {"class" => "cls-1 red"}, [:required]) #=> <aside class="cls-1 red" required>Sample</aside>

def aside(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def aside(&) : Nil #

def aside(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def b(content : String | Motion::HTML::AllowedInTags) : Nil #

def b(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;b&gt;&lt;/b&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
b("Sample", {"class" => "cls-1 red"}, [:required]) #=> <b class="cls-1 red" required>Sample</b>

def b(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def b(&) : Nil #

def b(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def bdi(content : String | Motion::HTML::AllowedInTags) : Nil #

def bdi(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;bdi&gt;&lt;/bdi&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
bdi("Sample", {"class" => "cls-1 red"}, [:required]) #=> <bdi class="cls-1 red" required>Sample</bdi>

def bdi(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def bdi(&) : Nil #

def bdi(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def body(content : String | Motion::HTML::AllowedInTags) : Nil #

def body(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;body&gt;&lt;/body&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
body("Sample", {"class" => "cls-1 red"}, [:required]) #=> <body class="cls-1 red" required>Sample</body>

def body(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def body(&) : Nil #

def body(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def br(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;br&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
br([:required], {"class" => "cls-1"}) #=> <br class="cls-1" required>

[View source]
def br : Nil #

Generates a &lt;br&gt; tag.


[View source]
def br(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def button(content : String | Motion::HTML::AllowedInTags) : Nil #

def button(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;button&gt;&lt;/button&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
button("Sample", {"class" => "cls-1 red"}, [:required]) #=> <button class="cls-1 red" required>Sample</button>

def button(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def button(&) : Nil #

def button(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def code(content : String | Motion::HTML::AllowedInTags) : Nil #

def code(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;code&gt;&lt;/code&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
code("Sample", {"class" => "cls-1 red"}, [:required]) #=> <code class="cls-1 red" required>Sample</code>

def code(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def code(&) : Nil #

def code(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dd(content : String | Motion::HTML::AllowedInTags) : Nil #

def dd(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;dd&gt;&lt;/dd&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
dd("Sample", {"class" => "cls-1 red"}, [:required]) #=> <dd class="cls-1 red" required>Sample</dd>

def dd(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dd(&) : Nil #

def dd(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def details(content : String | Motion::HTML::AllowedInTags) : Nil #

def details(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;details&gt;&lt;/details&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
details("Sample", {"class" => "cls-1 red"}, [:required]) #=> <details class="cls-1 red" required>Sample</details>

def details(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def details(&) : Nil #

def details(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dialog(content : String | Motion::HTML::AllowedInTags) : Nil #

def dialog(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;dialog&gt;&lt;/dialog&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
dialog("Sample", {"class" => "cls-1 red"}, [:required]) #=> <dialog class="cls-1 red" required>Sample</dialog>

def dialog(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dialog(&) : Nil #

def dialog(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def div(content : String | Motion::HTML::AllowedInTags) : Nil #

def div(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;div&gt;&lt;/div&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
div("Sample", {"class" => "cls-1 red"}, [:required]) #=> <div class="cls-1 red" required>Sample</div>

def div(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def div(&) : Nil #

def div(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dl(content : String | Motion::HTML::AllowedInTags) : Nil #

def dl(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;dl&gt;&lt;/dl&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
dl("Sample", {"class" => "cls-1 red"}, [:required]) #=> <dl class="cls-1 red" required>Sample</dl>

def dl(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dl(&) : Nil #

def dl(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dt(content : String | Motion::HTML::AllowedInTags) : Nil #

def dt(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;dt&gt;&lt;/dt&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
dt("Sample", {"class" => "cls-1 red"}, [:required]) #=> <dt class="cls-1 red" required>Sample</dt>

def dt(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dt(&) : Nil #

def dt(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def em(content : String | Motion::HTML::AllowedInTags) : Nil #

def em(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;em&gt;&lt;/em&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
em("Sample", {"class" => "cls-1 red"}, [:required]) #=> <em class="cls-1 red" required>Sample</em>

def em(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def em(&) : Nil #

def em(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def fieldset(content : String | Motion::HTML::AllowedInTags) : Nil #

def fieldset(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;fieldset&gt;&lt;/fieldset&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
fieldset("Sample", {"class" => "cls-1 red"}, [:required]) #=> <fieldset class="cls-1 red" required>Sample</fieldset>

def fieldset(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def fieldset(&) : Nil #

def fieldset(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def figcaption(content : String | Motion::HTML::AllowedInTags) : Nil #

def figcaption(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;figcaption&gt;&lt;/figcaption&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
figcaption("Sample", {"class" => "cls-1 red"}, [:required]) #=> <figcaption class="cls-1 red" required>Sample</figcaption>

def figcaption(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def figcaption(&) : Nil #

def figcaption(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def figure(content : String | Motion::HTML::AllowedInTags) : Nil #

def figure(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;figure&gt;&lt;/figure&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
figure("Sample", {"class" => "cls-1 red"}, [:required]) #=> <figure class="cls-1 red" required>Sample</figure>

def figure(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def figure(&) : Nil #

def figure(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def footer(content : String | Motion::HTML::AllowedInTags) : Nil #

def footer(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;footer&gt;&lt;/footer&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
footer("Sample", {"class" => "cls-1 red"}, [:required]) #=> <footer class="cls-1 red" required>Sample</footer>

def footer(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def footer(&) : Nil #

def footer(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def form(content : String | Motion::HTML::AllowedInTags) : Nil #

def form(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;form&gt;&lt;/form&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
form("Sample", {"class" => "cls-1 red"}, [:required]) #=> <form class="cls-1 red" required>Sample</form>

def form(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def form(&) : Nil #

def form(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h1(content : String | Motion::HTML::AllowedInTags) : Nil #

def h1(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h1&gt;&lt;/h1&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h1("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h1 class="cls-1 red" required>Sample</h1>

def h1(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h1(&) : Nil #

def h1(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h2(content : String | Motion::HTML::AllowedInTags) : Nil #

def h2(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h2&gt;&lt;/h2&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h2("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h2 class="cls-1 red" required>Sample</h2>

def h2(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h2(&) : Nil #

def h2(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h3(content : String | Motion::HTML::AllowedInTags) : Nil #

def h3(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h3&gt;&lt;/h3&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h3("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h3 class="cls-1 red" required>Sample</h3>

def h3(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h3(&) : Nil #

def h3(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h4(content : String | Motion::HTML::AllowedInTags) : Nil #

def h4(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h4&gt;&lt;/h4&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h4("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h4 class="cls-1 red" required>Sample</h4>

def h4(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h4(&) : Nil #

def h4(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h5(content : String | Motion::HTML::AllowedInTags) : Nil #

def h5(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h5&gt;&lt;/h5&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h5("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h5 class="cls-1 red" required>Sample</h5>

def h5(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h5(&) : Nil #

def h5(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h6(content : String | Motion::HTML::AllowedInTags) : Nil #

def h6(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h6&gt;&lt;/h6&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h6("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h6 class="cls-1 red" required>Sample</h6>

def h6(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h6(&) : Nil #

def h6(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def head(content : String | Motion::HTML::AllowedInTags) : Nil #

def head(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;head&gt;&lt;/head&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
head("Sample", {"class" => "cls-1 red"}, [:required]) #=> <head class="cls-1 red" required>Sample</head>

def head(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def head(&) : Nil #

def head(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def header(content : String | Motion::HTML::AllowedInTags) : Nil #

def header(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;header&gt;&lt;/header&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
header("Sample", {"class" => "cls-1 red"}, [:required]) #=> <header class="cls-1 red" required>Sample</header>

def header(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def header(&) : Nil #

def header(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def hr(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;hr&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
hr([:required], {"class" => "cls-1"}) #=> <hr class="cls-1" required>

[View source]
def hr : Nil #

Generates a &lt;hr&gt; tag.


[View source]
def hr(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def html(content : String | Motion::HTML::AllowedInTags) : Nil #

def html(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;html&gt;&lt;/html&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
html("Sample", {"class" => "cls-1 red"}, [:required]) #=> <html class="cls-1 red" required>Sample</html>

def html(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def html(&) : Nil #

def html(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def i(content : String | Motion::HTML::AllowedInTags) : Nil #

def i(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;i&gt;&lt;/i&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
i("Sample", {"class" => "cls-1 red"}, [:required]) #=> <i class="cls-1 red" required>Sample</i>

def i(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def i(&) : Nil #

def i(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def iframe(content : String | Motion::HTML::AllowedInTags) : Nil #

def iframe(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;iframe&gt;&lt;/iframe&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
iframe("Sample", {"class" => "cls-1 red"}, [:required]) #=> <iframe class="cls-1 red" required>Sample</iframe>

def iframe(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def iframe(&) : Nil #

def iframe(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def img(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;img&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
img([:required], {"class" => "cls-1"}) #=> <img class="cls-1" required>

[View source]
def img : Nil #

Generates a &lt;img&gt; tag.


[View source]
def img(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def input(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;input&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
input([:required], {"class" => "cls-1"}) #=> <input class="cls-1" required>

[View source]
def input : Nil #

Generates a &lt;input&gt; tag.


[View source]
def input(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def label(content : String | Motion::HTML::AllowedInTags) : Nil #

def label(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;label&gt;&lt;/label&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
label("Sample", {"class" => "cls-1 red"}, [:required]) #=> <label class="cls-1 red" required>Sample</label>

def label(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def label(&) : Nil #

def label(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def li(content : String | Motion::HTML::AllowedInTags) : Nil #

def li(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;li&gt;&lt;/li&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
li("Sample", {"class" => "cls-1 red"}, [:required]) #=> <li class="cls-1 red" required>Sample</li>

def li(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def li(&) : Nil #

def li(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def main(content : String | Motion::HTML::AllowedInTags) : Nil #

def main(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;main&gt;&lt;/main&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
main("Sample", {"class" => "cls-1 red"}, [:required]) #=> <main class="cls-1 red" required>Sample</main>

def main(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def main(&) : Nil #

def main(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def mark(content : String | Motion::HTML::AllowedInTags) : Nil #

def mark(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;mark&gt;&lt;/mark&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
mark("Sample", {"class" => "cls-1 red"}, [:required]) #=> <mark class="cls-1 red" required>Sample</mark>

def mark(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def mark(&) : Nil #

def mark(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def menuitem(content : String | Motion::HTML::AllowedInTags) : Nil #

def menuitem(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;menuitem&gt;&lt;/menuitem&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
menuitem("Sample", {"class" => "cls-1 red"}, [:required]) #=> <menuitem class="cls-1 red" required>Sample</menuitem>

def menuitem(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def menuitem(&) : Nil #

def menuitem(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def meta(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;meta&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
meta([:required], {"class" => "cls-1"}) #=> <meta class="cls-1" required>

[View source]
def meta : Nil #

Generates a &lt;meta&gt; tag.


[View source]
def meta(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def meter(content : String | Motion::HTML::AllowedInTags) : Nil #

def meter(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;meter&gt;&lt;/meter&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
meter("Sample", {"class" => "cls-1 red"}, [:required]) #=> <meter class="cls-1 red" required>Sample</meter>

def meter(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def meter(&) : Nil #

def meter(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def nav(content : String | Motion::HTML::AllowedInTags) : Nil #

def nav(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;nav&gt;&lt;/nav&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
nav("Sample", {"class" => "cls-1 red"}, [:required]) #=> <nav class="cls-1 red" required>Sample</nav>

def nav(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def nav(&) : Nil #

def nav(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ol(content : String | Motion::HTML::AllowedInTags) : Nil #

def ol(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;ol&gt;&lt;/ol&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
ol("Sample", {"class" => "cls-1 red"}, [:required]) #=> <ol class="cls-1 red" required>Sample</ol>

def ol(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ol(&) : Nil #

def ol(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def option(content : String | Motion::HTML::AllowedInTags) : Nil #

def option(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;option&gt;&lt;/option&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
option("Sample", {"class" => "cls-1 red"}, [:required]) #=> <option class="cls-1 red" required>Sample</option>

def option(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def option(&) : Nil #

def option(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def para(content : String | Motion::HTML::AllowedInTags) : Nil #

def para(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;para&gt;&lt;/para&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
para("Sample", {"class" => "cls-1 red"}, [:required]) #=> <para class="cls-1 red" required>Sample</para>

def para(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def para(&) : Nil #

def para(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def pre(content : String | Motion::HTML::AllowedInTags) : Nil #

def pre(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;pre&gt;&lt;/pre&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
pre("Sample", {"class" => "cls-1 red"}, [:required]) #=> <pre class="cls-1 red" required>Sample</pre>

def pre(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def pre(&) : Nil #

def pre(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def progress(content : String | Motion::HTML::AllowedInTags) : Nil #

def progress(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;progress&gt;&lt;/progress&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
progress("Sample", {"class" => "cls-1 red"}, [:required]) #=> <progress class="cls-1 red" required>Sample</progress>

def progress(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def progress(&) : Nil #

def progress(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def rp(content : String | Motion::HTML::AllowedInTags) : Nil #

def rp(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;rp&gt;&lt;/rp&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
rp("Sample", {"class" => "cls-1 red"}, [:required]) #=> <rp class="cls-1 red" required>Sample</rp>

def rp(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def rp(&) : Nil #

def rp(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def rt(content : String | Motion::HTML::AllowedInTags) : Nil #

def rt(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;rt&gt;&lt;/rt&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
rt("Sample", {"class" => "cls-1 red"}, [:required]) #=> <rt class="cls-1 red" required>Sample</rt>

def rt(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def rt(&) : Nil #

def rt(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ruby(content : String | Motion::HTML::AllowedInTags) : Nil #

def ruby(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;ruby&gt;&lt;/ruby&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
ruby("Sample", {"class" => "cls-1 red"}, [:required]) #=> <ruby class="cls-1 red" required>Sample</ruby>

def ruby(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ruby(&) : Nil #

def ruby(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def s(content : String | Motion::HTML::AllowedInTags) : Nil #

def s(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;s&gt;&lt;/s&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
s("Sample", {"class" => "cls-1 red"}, [:required]) #=> <s class="cls-1 red" required>Sample</s>

def s(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def s(&) : Nil #

def s(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def script(content : String | Motion::HTML::AllowedInTags) : Nil #

def script(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;script&gt;&lt;/script&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
script("Sample", {"class" => "cls-1 red"}, [:required]) #=> <script class="cls-1 red" required>Sample</script>

def script(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def script(&) : Nil #

def script(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def section(content : String | Motion::HTML::AllowedInTags) : Nil #

def section(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;section&gt;&lt;/section&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
section("Sample", {"class" => "cls-1 red"}, [:required]) #=> <section class="cls-1 red" required>Sample</section>

def section(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def section(&) : Nil #

def section(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def select_tag(content : String | Motion::HTML::AllowedInTags) : Nil #

def select_tag(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;select_tag&gt;&lt;/select_tag&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
select_tag("Sample", {"class" => "cls-1 red"}, [:required]) #=> <select_tag class="cls-1 red" required>Sample</select_tag>

def select_tag(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def select_tag(&) : Nil #

def select_tag(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def small(content : String | Motion::HTML::AllowedInTags) : Nil #

def small(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;small&gt;&lt;/small&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
small("Sample", {"class" => "cls-1 red"}, [:required]) #=> <small class="cls-1 red" required>Sample</small>

def small(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def small(&) : Nil #

def small(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def source(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;source&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
source([:required], {"class" => "cls-1"}) #=> <source class="cls-1" required>

[View source]
def source : Nil #

Generates a &lt;source&gt; tag.


[View source]
def source(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def span(content : String | Motion::HTML::AllowedInTags) : Nil #

def span(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;span&gt;&lt;/span&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
span("Sample", {"class" => "cls-1 red"}, [:required]) #=> <span class="cls-1 red" required>Sample</span>

def span(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def span(&) : Nil #

def span(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def strong(content : String | Motion::HTML::AllowedInTags) : Nil #

def strong(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;strong&gt;&lt;/strong&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
strong("Sample", {"class" => "cls-1 red"}, [:required]) #=> <strong class="cls-1 red" required>Sample</strong>

def strong(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def strong(&) : Nil #

def strong(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def style(styles : String) : Nil #

Generates a &lt;style&gt;&lt;/style&gt; block for adding inline CSS

style("a { color: red; }") # => <style>a { color: red; }</style>

[View source]
def summary(content : String | Motion::HTML::AllowedInTags) : Nil #

def summary(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;summary&gt;&lt;/summary&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
summary("Sample", {"class" => "cls-1 red"}, [:required]) #=> <summary class="cls-1 red" required>Sample</summary>

def summary(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def summary(&) : Nil #

def summary(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def table(content : String | Motion::HTML::AllowedInTags) : Nil #

def table(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;table&gt;&lt;/table&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
table("Sample", {"class" => "cls-1 red"}, [:required]) #=> <table class="cls-1 red" required>Sample</table>

def table(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def table(&) : Nil #

def table(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def tbody(content : String | Motion::HTML::AllowedInTags) : Nil #

def tbody(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;tbody&gt;&lt;/tbody&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
tbody("Sample", {"class" => "cls-1 red"}, [:required]) #=> <tbody class="cls-1 red" required>Sample</tbody>

def tbody(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def tbody(&) : Nil #

def tbody(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def td(content : String | Motion::HTML::AllowedInTags) : Nil #

def td(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;td&gt;&lt;/td&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
td("Sample", {"class" => "cls-1 red"}, [:required]) #=> <td class="cls-1 red" required>Sample</td>

def td(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def td(&) : Nil #

def td(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def template(content : String | Motion::HTML::AllowedInTags) : Nil #

def template(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;template&gt;&lt;/template&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
template("Sample", {"class" => "cls-1 red"}, [:required]) #=> <template class="cls-1 red" required>Sample</template>

def template(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def template(&) : Nil #

def template(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def text(content : String | Motion::HTML::AllowedInTags) : Nil #

Outputs content and escapes it.

text("Hello") # => Hello
text("<div>") # => &lt;div&gt;

[View source]
def textarea(content : String | Motion::HTML::AllowedInTags) : Nil #

def textarea(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;textarea&gt;&lt;/textarea&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
textarea("Sample", {"class" => "cls-1 red"}, [:required]) #=> <textarea class="cls-1 red" required>Sample</textarea>

def textarea(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def textarea(&) : Nil #

def textarea(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def th(content : String | Motion::HTML::AllowedInTags) : Nil #

def th(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;th&gt;&lt;/th&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
th("Sample", {"class" => "cls-1 red"}, [:required]) #=> <th class="cls-1 red" required>Sample</th>

def th(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def th(&) : Nil #

def th(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def thead(content : String | Motion::HTML::AllowedInTags) : Nil #

def thead(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;thead&gt;&lt;/thead&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
thead("Sample", {"class" => "cls-1 red"}, [:required]) #=> <thead class="cls-1 red" required>Sample</thead>

def thead(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def thead(&) : Nil #

def thead(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def time(content : String | Motion::HTML::AllowedInTags) : Nil #

def time(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;time&gt;&lt;/time&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
time("Sample", {"class" => "cls-1 red"}, [:required]) #=> <time class="cls-1 red" required>Sample</time>

def time(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def time(&) : Nil #

def time(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def title(content : String | Motion::HTML::AllowedInTags) : Nil #

def title(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;title&gt;&lt;/title&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
title("Sample", {"class" => "cls-1 red"}, [:required]) #=> <title class="cls-1 red" required>Sample</title>

def title(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def title(&) : Nil #

def title(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def tr(content : String | Motion::HTML::AllowedInTags) : Nil #

def tr(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;tr&gt;&lt;/tr&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
tr("Sample", {"class" => "cls-1 red"}, [:required]) #=> <tr class="cls-1 red" required>Sample</tr>

def tr(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def tr(&) : Nil #

def tr(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def u(content : String | Motion::HTML::AllowedInTags) : Nil #

def u(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;u&gt;&lt;/u&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
u("Sample", {"class" => "cls-1 red"}, [:required]) #=> <u class="cls-1 red" required>Sample</u>

def u(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def u(&) : Nil #

def u(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ul(content : String | Motion::HTML::AllowedInTags) : Nil #

def ul(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;ul&gt;&lt;/ul&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
ul("Sample", {"class" => "cls-1 red"}, [:required]) #=> <ul class="cls-1 red" required>Sample</ul>

def ul(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ul(&) : Nil #

def ul(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def video(content : String | Motion::HTML::AllowedInTags) : Nil #

def video(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;video&gt;&lt;/video&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
video("Sample", {"class" => "cls-1 red"}, [:required]) #=> <video class="cls-1 red" required>Sample</video>

def video(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def video(&) : Nil #

def video(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def wbr(content : String | Motion::HTML::AllowedInTags) : Nil #

def wbr(content : Motion::HTML::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;wbr&gt;&lt;/wbr&gt; tag.

  • The content argument is either a String, or any type that has included Motion::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
wbr("Sample", {"class" => "cls-1 red"}, [:required]) #=> <wbr class="cls-1 red" required>Sample</wbr>

def wbr(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def wbr(&) : Nil #

def wbr(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

Macro Detail

macro generate_tag_methods(method_name, tag) #

[View source]