module Lucky::BaseTags

Included Modules

Direct including types

Defined in:

lucky/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, :area, :article, :aside, :b, :bdi, :bdo, :blockquote, :body, :button, :caption, :cite, :code, :col, :colgroup, :data, :datalist, :del, :details, :dfn, :dialog, :div, :dd, :dl, :dt, :em, :embed, :fieldset, :figcaption, :figure, :footer, :form, :h1, :h2, :h3, :h4, :h5, :h6, :head, :header, :html, :i, :iframe, :ins, :kbd, :label, :legend, :li, :main, :map, :mark, :menuitem, :meter, :nav, :noscript, :object, :ol, :optgroup, :option, :output, :param, :picture, :pre, :progress, :q, :rp, :rt, :ruby, :s, :samp, :script, :section, :slot, :small, :span, :strong, :sub, :summary, :sup, :table, :tbody, :td, :template, :textarea, :tfoot, :th, :thead, :time, :title, :tr, :track, :u, :ul, :video, :wbr] of ::Symbol

Instance Method Summary

Macro Summary

Instance Method Detail

def a(content : Lucky::AllowedInTags | String) : Nil #

def a(content : Lucky::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 Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def a(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def a(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <abbr></abbr> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def abbr(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def abbr(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <address></address> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def address(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def address(options, **other_options) : Nil #

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 area(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <area></area> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
area("Sample", {"class" => "cls-1 red"}, [:required]) #=> <area class="cls-1 red" required>Sample</area>

def area(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def area(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def area(options, **other_options) : Nil #

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

def area(&) : Nil #

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

def article(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <article></article> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def article(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def article(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <aside></aside> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def aside(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def aside(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <b></b> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def b(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def b(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <bdi></bdi> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def bdi(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def bdi(options, **other_options) : Nil #

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 bdo(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <bdo></bdo> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
bdo("Sample", {"class" => "cls-1 red"}, [:required]) #=> <bdo class="cls-1 red" required>Sample</bdo>

def bdo(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def bdo(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def bdo(options, **other_options) : Nil #

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

def bdo(&) : Nil #

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

def blockquote(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <blockquote></blockquote> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
blockquote("Sample", {"class" => "cls-1 red"}, [:required]) #=> <blockquote class="cls-1 red" required>Sample</blockquote>

def blockquote(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def blockquote(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def blockquote(options, **other_options) : Nil #

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

def blockquote(&) : Nil #

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

def body(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <body></body> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def body(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def body(options, **other_options) : Nil #

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 <br> 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 <br> tag.


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

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

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

Generates a <button></button> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def button(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def button(options, **other_options) : Nil #

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 caption(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <caption></caption> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
caption("Sample", {"class" => "cls-1 red"}, [:required]) #=> <caption class="cls-1 red" required>Sample</caption>

def caption(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def caption(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def caption(options, **other_options) : Nil #

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

def caption(&) : Nil #

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

def cite(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <cite></cite> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
cite("Sample", {"class" => "cls-1 red"}, [:required]) #=> <cite class="cls-1 red" required>Sample</cite>

def cite(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def cite(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def cite(options, **other_options) : Nil #

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

def cite(&) : Nil #

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

def code(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <code></code> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def code(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def code(options, **other_options) : Nil #

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 col(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <col></col> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
col("Sample", {"class" => "cls-1 red"}, [:required]) #=> <col class="cls-1 red" required>Sample</col>

def col(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def col(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def col(options, **other_options) : Nil #

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

def col(&) : Nil #

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

def colgroup(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <colgroup></colgroup> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
colgroup("Sample", {"class" => "cls-1 red"}, [:required]) #=> <colgroup class="cls-1 red" required>Sample</colgroup>

def colgroup(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def colgroup(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def colgroup(options, **other_options) : Nil #

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

def colgroup(&) : Nil #

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

def data(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <data></data> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
data("Sample", {"class" => "cls-1 red"}, [:required]) #=> <data class="cls-1 red" required>Sample</data>

def data(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def data(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def data(options, **other_options) : Nil #

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

def data(&) : Nil #

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

def datalist(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <datalist></datalist> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
datalist("Sample", {"class" => "cls-1 red"}, [:required]) #=> <datalist class="cls-1 red" required>Sample</datalist>

def datalist(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def datalist(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def datalist(options, **other_options) : Nil #

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

def datalist(&) : Nil #

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

def dd(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <dd></dd> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dd(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dd(options, **other_options) : Nil #

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 del(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <del></del> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
del("Sample", {"class" => "cls-1 red"}, [:required]) #=> <del class="cls-1 red" required>Sample</del>

def del(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def del(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def del(options, **other_options) : Nil #

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

def del(&) : Nil #

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

def details(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <details></details> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def details(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def details(options, **other_options) : Nil #

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 dfn(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <dfn></dfn> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
dfn("Sample", {"class" => "cls-1 red"}, [:required]) #=> <dfn class="cls-1 red" required>Sample</dfn>

def dfn(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dfn(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dfn(options, **other_options) : Nil #

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

def dfn(&) : Nil #

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

def dialog(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <dialog></dialog> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dialog(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dialog(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <div></div> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def div(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def div(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <dl></dl> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dl(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dl(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <dt></dt> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dt(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dt(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <em></em> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def em(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def em(options, **other_options) : Nil #

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 embed(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <embed></embed> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
embed("Sample", {"class" => "cls-1 red"}, [:required]) #=> <embed class="cls-1 red" required>Sample</embed>

def embed(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def embed(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def embed(options, **other_options) : Nil #

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

def embed(&) : Nil #

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

def fieldset(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <fieldset></fieldset> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def fieldset(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def fieldset(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <figcaption></figcaption> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def figcaption(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def figcaption(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <figure></figure> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def figure(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def figure(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <footer></footer> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def footer(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def footer(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <form></form> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def form(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def form(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <h1></h1> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h1(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h1(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <h2></h2> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h2(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h2(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <h3></h3> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h3(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h3(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <h4></h4> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h4(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h4(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <h5></h5> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h5(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h5(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <h6></h6> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h6(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h6(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <head></head> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def head(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def head(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <header></header> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def header(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def header(options, **other_options) : Nil #

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 <hr> 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 <hr> tag.


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

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

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

Generates a <html></html> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def html(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def html(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <i></i> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def i(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def i(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <iframe></iframe> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def iframe(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def iframe(options, **other_options) : Nil #

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 <img> 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 <img> 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 <input> 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 <input> tag.


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

[View source]
def ins(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <ins></ins> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
ins("Sample", {"class" => "cls-1 red"}, [:required]) #=> <ins class="cls-1 red" required>Sample</ins>

def ins(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ins(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ins(options, **other_options) : Nil #

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

def ins(&) : Nil #

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

def kbd(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <kbd></kbd> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
kbd("Sample", {"class" => "cls-1 red"}, [:required]) #=> <kbd class="cls-1 red" required>Sample</kbd>

def kbd(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def kbd(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def kbd(options, **other_options) : Nil #

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

def kbd(&) : Nil #

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

def label(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <label></label> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def label(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def label(options, **other_options) : Nil #

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 legend(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <legend></legend> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
legend("Sample", {"class" => "cls-1 red"}, [:required]) #=> <legend class="cls-1 red" required>Sample</legend>

def legend(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def legend(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def legend(options, **other_options) : Nil #

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

def legend(&) : Nil #

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

def li(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <li></li> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def li(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def li(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <main></main> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def main(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def main(options, **other_options) : Nil #

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 map(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <map></map> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
map("Sample", {"class" => "cls-1 red"}, [:required]) #=> <map class="cls-1 red" required>Sample</map>

def map(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def map(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def map(options, **other_options) : Nil #

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

def map(&) : Nil #

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

def mark(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <mark></mark> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def mark(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def mark(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <menuitem></menuitem> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def menuitem(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def menuitem(options, **other_options) : Nil #

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 <meta> 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 <meta> tag.


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

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

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

Generates a <meter></meter> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def meter(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def meter(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <nav></nav> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def nav(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def nav(options, **other_options) : Nil #

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 noscript(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <noscript></noscript> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
noscript("Sample", {"class" => "cls-1 red"}, [:required]) #=> <noscript class="cls-1 red" required>Sample</noscript>

def noscript(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def noscript(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def noscript(options, **other_options) : Nil #

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

def noscript(&) : Nil #

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

def object(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <object></object> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
object("Sample", {"class" => "cls-1 red"}, [:required]) #=> <object class="cls-1 red" required>Sample</object>

def object(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def object(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def object(options, **other_options) : Nil #

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

def object(&) : Nil #

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

def ol(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <ol></ol> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ol(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ol(options, **other_options) : Nil #

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 optgroup(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <optgroup></optgroup> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
optgroup("Sample", {"class" => "cls-1 red"}, [:required]) #=> <optgroup class="cls-1 red" required>Sample</optgroup>

def optgroup(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def optgroup(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def optgroup(options, **other_options) : Nil #

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

def optgroup(&) : Nil #

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

def option(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <option></option> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def option(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def option(options, **other_options) : Nil #

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 output(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <output></output> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
output("Sample", {"class" => "cls-1 red"}, [:required]) #=> <output class="cls-1 red" required>Sample</output>

def output(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def output(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def output(options, **other_options) : Nil #

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

def output(&) : Nil #

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

def para(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <para></para> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def para(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def para(options, **other_options) : Nil #

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 param(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <param></param> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
param("Sample", {"class" => "cls-1 red"}, [:required]) #=> <param class="cls-1 red" required>Sample</param>

def param(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def param(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def param(options, **other_options) : Nil #

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

def param(&) : Nil #

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

def picture(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <picture></picture> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
picture("Sample", {"class" => "cls-1 red"}, [:required]) #=> <picture class="cls-1 red" required>Sample</picture>

def picture(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def picture(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def picture(options, **other_options) : Nil #

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

def picture(&) : Nil #

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

def pre(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <pre></pre> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def pre(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def pre(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <progress></progress> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def progress(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def progress(options, **other_options) : Nil #

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 q(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <q></q> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
q("Sample", {"class" => "cls-1 red"}, [:required]) #=> <q class="cls-1 red" required>Sample</q>

def q(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def q(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def q(options, **other_options) : Nil #

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

def q(&) : Nil #

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

def rp(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <rp></rp> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def rp(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def rp(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <rt></rt> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def rt(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def rt(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <ruby></ruby> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ruby(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ruby(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <s></s> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def s(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def s(options, **other_options) : Nil #

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 samp(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <samp></samp> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
samp("Sample", {"class" => "cls-1 red"}, [:required]) #=> <samp class="cls-1 red" required>Sample</samp>

def samp(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def samp(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def samp(options, **other_options) : Nil #

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

def samp(&) : Nil #

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

def script(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <script></script> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def script(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def script(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <section></section> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def section(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def section(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <select_tag></select_tag> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def select_tag(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def select_tag(options, **other_options) : Nil #

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 slot(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <slot></slot> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
slot("Sample", {"class" => "cls-1 red"}, [:required]) #=> <slot class="cls-1 red" required>Sample</slot>

def slot(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def slot(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def slot(options, **other_options) : Nil #

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

def slot(&) : Nil #

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

def small(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <small></small> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def small(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def small(options, **other_options) : Nil #

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 <source> 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 <source> tag.


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

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

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

Generates a <span></span> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def span(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def span(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <strong></strong> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def strong(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def strong(options, **other_options) : Nil #

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 <style></style> block for adding inline CSS

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

[View source]
def sub(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <sub></sub> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
sub("Sample", {"class" => "cls-1 red"}, [:required]) #=> <sub class="cls-1 red" required>Sample</sub>

def sub(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def sub(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def sub(options, **other_options) : Nil #

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

def sub(&) : Nil #

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

def summary(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <summary></summary> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def summary(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def summary(options, **other_options) : Nil #

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 sup(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <sup></sup> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
sup("Sample", {"class" => "cls-1 red"}, [:required]) #=> <sup class="cls-1 red" required>Sample</sup>

def sup(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def sup(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def sup(options, **other_options) : Nil #

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

def sup(&) : Nil #

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

def table(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <table></table> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def table(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def table(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <tbody></tbody> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tbody(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tbody(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <td></td> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def td(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def td(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <template></template> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def template(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def template(options, **other_options) : Nil #

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 | Lucky::AllowedInTags) : Nil #

Outputs content and escapes it.

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

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

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

Generates a <textarea></textarea> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def textarea(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def textarea(options, **other_options) : Nil #

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 tfoot(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <tfoot></tfoot> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
tfoot("Sample", {"class" => "cls-1 red"}, [:required]) #=> <tfoot class="cls-1 red" required>Sample</tfoot>

def tfoot(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tfoot(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tfoot(options, **other_options) : Nil #

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

def tfoot(&) : Nil #

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

def th(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <th></th> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def th(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def th(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <thead></thead> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def thead(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def thead(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <time></time> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def time(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def time(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <title></title> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def title(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def title(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <tr></tr> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tr(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tr(options, **other_options) : Nil #

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 track(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <track></track> tag.

  • The content argument is either a String, or any type that has included Lucky::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...
track("Sample", {"class" => "cls-1 red"}, [:required]) #=> <track class="cls-1 red" required>Sample</track>

def track(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def track(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def track(options, **other_options) : Nil #

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

def track(&) : Nil #

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

def u(content : Lucky::AllowedInTags | String) : Nil #

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

Generates a <u></u> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def u(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def u(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <ul></ul> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ul(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ul(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <video></video> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def video(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def video(options, **other_options) : Nil #

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 : Lucky::AllowedInTags | String) : Nil #

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

Generates a <wbr></wbr> tag.

  • The content argument is either a String, or any type that has included Lucky::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(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def wbr(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def wbr(options, **other_options) : Nil #

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]