jets 1.4.11 → 1.5.0

data/vendor/rails/actionview/test/template/resolver_cache_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ResolverCacheTest < ActiveSupport::TestCase
+  def test_inspect_shields_cache_internals
+    assert_match %r(#<ActionView::Resolver:0x[0-9a-f]+ @cache=#<ActionView::Resolver::Cache:0x[0-9a-f]+ keys=0 queries=0>>), ActionView::Resolver.new.inspect
+  end
+end

data/vendor/rails/actionview/test/template/resolver_patterns_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ResolverPatternsTest < ActiveSupport::TestCase
+  def setup
+    path = File.expand_path("../fixtures", __dir__)
+    pattern = ":prefix/{:formats/,}:action{.:formats,}{+:variants,}{.:handlers,}"
+    @resolver = ActionView::FileSystemResolver.new(path, pattern)
+  end
+
+  def test_should_return_empty_list_for_unknown_path
+    templates = @resolver.find_all("unknown", "custom_pattern", false, locale: [], formats: [:html], variants: [], handlers: [:erb])
+    assert_equal [], templates, "expected an empty list of templates"
+  end
+
+  def test_should_return_template_for_declared_path
+    templates = @resolver.find_all("path", "custom_pattern", false, locale: [], formats: [:html], variants: [], handlers: [:erb])
+    assert_equal 1, templates.size, "expected one template"
+    assert_equal "Hello custom patterns!", templates.first.source
+    assert_equal "custom_pattern/path",    templates.first.virtual_path
+    assert_equal [:html],                  templates.first.formats
+  end
+
+  def test_should_return_all_templates_when_ambiguous_pattern
+    templates = @resolver.find_all("another", "custom_pattern", false, locale: [], formats: [:html], variants: [], handlers: [:erb])
+    assert_equal 2, templates.size, "expected two templates"
+    assert_equal "Another template!",      templates[0].source
+    assert_equal "custom_pattern/another", templates[0].virtual_path
+    assert_equal "Hello custom patterns!", templates[1].source
+    assert_equal "custom_pattern/another", templates[1].virtual_path
+  end
+
+  def test_should_return_all_variants_for_any
+    templates = @resolver.find_all("hello_world", "test", false, locale: [], formats: [:html, :text], variants: :any, handlers: [:erb])
+    assert_equal 3, templates.size, "expected three templates"
+    assert_equal "Hello phone!",       templates[0].source
+    assert_equal "test/hello_world",   templates[0].virtual_path
+    assert_equal "Hello texty phone!", templates[1].source
+    assert_equal "test/hello_world",   templates[1].virtual_path
+    assert_equal "Hello world!",       templates[2].source
+    assert_equal "test/hello_world",   templates[2].virtual_path
+  end
+end

data/vendor/rails/actionview/test/template/sanitize_helper_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+# The exhaustive tests are in the rails-html-sanitizer gem.
+# This tests that the helpers hook up correctly to the sanitizer classes.
+class SanitizeHelperTest < ActionView::TestCase
+  tests ActionView::Helpers::SanitizeHelper
+
+  def test_strip_links
+    assert_equal "Dont touch me", strip_links("Dont touch me")
+    assert_equal "on my mind\nall day long", strip_links("<a href='almost'>on my mind</a>\n<A href='almost'>all day long</A>")
+    assert_equal "Magic", strip_links("<a href='http://www.rubyonrails.com/'>Mag<a href='http://www.ruby-lang.org/'>ic")
+    assert_equal "My mind\nall <b>day</b> long", strip_links("<a href='almost'>My mind</a>\n<A href='almost'>all <b>day</b> long</A>")
+    assert_equal "&lt;malformed &amp; link", strip_links('<<a href="https://example.org">malformed & link</a>')
+  end
+
+  def test_sanitize_form
+    assert_equal "", sanitize("<form action=\"/foo/bar\" method=\"post\"><input></form>")
+  end
+
+  def test_should_sanitize_illegal_style_properties
+    raw      = %(display:block; position:absolute; left:0; top:0; width:100%; height:100%; z-index:1; background-color:black; background-image:url(http://www.ragingplatypus.com/i/cam-full.jpg); background-x:center; background-y:center; background-repeat:repeat;)
+    expected = %r(\Adisplay:\s?block;\s?width:\s?100%;\s?height:\s?100%;\s?background-color:\s?black;\s?background-x:\s?center;\s?background-y:\s?center;\z)
+    assert_match expected, sanitize_css(raw)
+  end
+
+  def test_strip_tags
+    assert_equal("Dont touch me", strip_tags("Dont touch me"))
+    assert_equal("This is a test.", strip_tags("<p>This <u>is<u> a <a href='test.html'><strong>test</strong></a>.</p>"))
+    assert_equal "This has a  here.", strip_tags("This has a <!-- comment --> here.")
+    assert_equal("Jekyll &amp; Hyde", strip_tags("Jekyll & Hyde"))
+    assert_equal "", strip_tags("<script>")
+  end
+
+  def test_strip_tags_will_not_encode_special_characters
+    assert_equal "test\r\n\r\ntest", strip_tags("test\r\n\r\ntest")
+  end
+
+  def test_sanitize_is_marked_safe
+    assert_predicate sanitize("<html><script></script></html>"), :html_safe?
+  end
+end

data/vendor/rails/actionview/test/template/streaming_render_test.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class TestController < ActionController::Base
+end
+
+class SetupFiberedBase < ActiveSupport::TestCase
+  def setup
+    view_paths = ActionController::Base.view_paths
+    @assigns = { secret: "in the sauce", name: nil }
+    @view = ActionView::Base.new(view_paths, @assigns)
+    @controller_view = TestController.new.view_context
+  end
+
+  def render_body(options)
+    @view.view_renderer.render_body(@view, options)
+  end
+
+  def buffered_render(options)
+    body = render_body(options)
+    string = "".dup
+    body.each do |piece|
+      string << piece
+    end
+    string
+  end
+end
+
+class FiberedTest < SetupFiberedBase
+  def test_streaming_works
+    content = []
+    body = render_body(template: "test/hello_world", layout: "layouts/yield")
+
+    body.each do |piece|
+      content << piece
+    end
+
+    assert_equal "<title>",      content[0]
+    assert_equal "",             content[1]
+    assert_equal "</title>\n",   content[2]
+    assert_equal "Hello world!", content[3]
+    assert_equal "\n",           content[4]
+  end
+
+  def test_render_file
+    assert_equal "Hello world!", buffered_render(file: "test/hello_world")
+  end
+
+  def test_render_file_with_locals
+    locals = { secret: "in the sauce" }
+    assert_equal "The secret is in the sauce\n", buffered_render(file: "test/render_file_with_locals", locals: locals)
+  end
+
+  def test_render_partial
+    assert_equal "only partial", buffered_render(partial: "test/partial_only")
+  end
+
+  def test_render_inline
+    assert_equal "Hello, World!", buffered_render(inline: "Hello, World!")
+  end
+
+  def test_render_without_layout
+    assert_equal "Hello world!", buffered_render(template: "test/hello_world")
+  end
+
+  def test_render_with_layout
+    assert_equal %(<title></title>\nHello world!\n),
+      buffered_render(template: "test/hello_world", layout: "layouts/yield")
+  end
+
+  def test_render_with_layout_which_has_render_inline
+    assert_equal %(welcome\nHello world!\n),
+      buffered_render(template: "test/hello_world", layout: "layouts/yield_with_render_inline_inside")
+  end
+
+  def test_render_with_layout_which_renders_another_partial
+    assert_equal %(partial html\nHello world!\n),
+      buffered_render(template: "test/hello_world", layout: "layouts/yield_with_render_partial_inside")
+  end
+
+  def test_render_with_nested_layout
+    assert_equal %(<title>title</title>\n\n<div id="column">column</div>\n<div id="content">content</div>\n),
+      buffered_render(template: "test/nested_layout", layout: "layouts/yield")
+  end
+
+  def test_render_with_file_in_layout
+    assert_equal %(\n<title>title</title>\n\n),
+      buffered_render(template: "test/layout_render_file")
+  end
+
+  def test_render_with_handler_without_streaming_support
+    assert_match "<p>This is grand!</p>", buffered_render(template: "test/hello")
+  end
+
+  def test_render_with_streaming_multiple_yields_provide_and_content_for
+    assert_equal "Yes, \nthis works\n like a charm.",
+      buffered_render(template: "test/streaming", layout: "layouts/streaming")
+  end
+
+  def test_render_with_streaming_with_fake_yields_and_streaming_buster
+    assert_equal "This won't look\n good.",
+      buffered_render(template: "test/streaming_buster", layout: "layouts/streaming")
+  end
+
+  def test_render_with_nested_streaming_multiple_yields_provide_and_content_for
+    assert_equal "?Yes, \n\nthis works\n\n? like a charm.",
+      buffered_render(template: "test/nested_streaming", layout: "layouts/streaming")
+  end
+
+  def test_render_with_streaming_and_capture
+    assert_equal "Yes, \n this works\n like a charm.",
+      buffered_render(template: "test/streaming", layout: "layouts/streaming_with_capture")
+  end
+end
+
+class FiberedWithLocaleTest < SetupFiberedBase
+  def setup
+    @old_locale = I18n.locale
+    I18n.locale = "da"
+    super
+  end
+
+  def teardown
+    I18n.locale = @old_locale
+  end
+
+  def test_render_with_streaming_and_locale
+    assert_equal "layout.locale: da\nview.locale: da\n\n",
+      buffered_render(template: "test/streaming_with_locale", layout: "layouts/streaming_with_locale")
+  end
+end

data/vendor/rails/actionview/test/template/tag_helper_test.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class TagHelperTest < ActionView::TestCase
+  include RenderERBUtils
+
+  tests ActionView::Helpers::TagHelper
+
+  def test_tag
+    assert_equal "<br />", tag("br")
+    assert_equal "<br clear=\"left\" />", tag(:br, clear: "left")
+    assert_equal "<br>", tag("br", nil, true)
+  end
+
+  def test_tag_builder
+    assert_equal "<span></span>", tag.span
+    assert_equal "<span class=\"bookmark\"></span>", tag.span(class: "bookmark")
+  end
+
+  def test_tag_builder_void_tag
+    assert_equal "<br>", tag.br
+    assert_equal "<br class=\"some_class\">", tag.br(class: "some_class")
+  end
+
+  def test_tag_builder_void_tag_with_forced_content
+    assert_equal "<br>some content</br>", tag.br("some content")
+  end
+
+  def test_tag_builder_is_singleton
+    assert_equal tag, tag
+  end
+
+  def test_tag_options
+    str = tag("p", "class" => "show", :class => "elsewhere")
+    assert_match(/class="show"/, str)
+    assert_match(/class="elsewhere"/, str)
+  end
+
+  def test_tag_options_rejects_nil_option
+    assert_equal "<p />", tag("p", ignored: nil)
+  end
+
+  def test_tag_builder_options_rejects_nil_option
+    assert_equal "<p></p>", tag.p(ignored: nil)
+  end
+
+  def test_tag_options_accepts_false_option
+    assert_equal "<p value=\"false\" />", tag("p", value: false)
+  end
+
+  def test_tag_builder_options_accepts_false_option
+    assert_equal "<p value=\"false\"></p>", tag.p(value: false)
+  end
+
+  def test_tag_options_accepts_blank_option
+    assert_equal "<p included=\"\" />", tag("p", included: "")
+  end
+
+  def test_tag_builder_options_accepts_blank_option
+    assert_equal "<p included=\"\"></p>", tag.p(included: "")
+  end
+
+  def test_tag_options_accepts_symbol_option_when_not_escaping
+    assert_equal "<p value=\"symbol\" />", tag("p", { value: :symbol }, false, false)
+  end
+
+  def test_tag_options_accepts_integer_option_when_not_escaping
+    assert_equal "<p value=\"42\" />", tag("p", { value: 42 }, false, false)
+  end
+
+  def test_tag_options_converts_boolean_option
+    assert_dom_equal '<p disabled="disabled" itemscope="itemscope" multiple="multiple" readonly="readonly" allowfullscreen="allowfullscreen" seamless="seamless" typemustmatch="typemustmatch" sortable="sortable" default="default" inert="inert" truespeed="truespeed" />',
+      tag("p", disabled: true, itemscope: true, multiple: true, readonly: true, allowfullscreen: true, seamless: true, typemustmatch: true, sortable: true, default: true, inert: true, truespeed: true)
+  end
+
+  def test_tag_builder_options_converts_boolean_option
+    assert_dom_equal '<p disabled="disabled" itemscope="itemscope" multiple="multiple" readonly="readonly" allowfullscreen="allowfullscreen" seamless="seamless" typemustmatch="typemustmatch" sortable="sortable" default="default" inert="inert" truespeed="truespeed" />',
+      tag.p(disabled: true, itemscope: true, multiple: true, readonly: true, allowfullscreen: true, seamless: true, typemustmatch: true, sortable: true, default: true, inert: true, truespeed: true)
+  end
+
+  def test_content_tag
+    assert_equal "<a href=\"create\">Create</a>", content_tag("a", "Create", "href" => "create")
+    assert_predicate content_tag("a", "Create", "href" => "create"), :html_safe?
+    assert_equal content_tag("a", "Create", "href" => "create"),
+                 content_tag("a", "Create", href: "create")
+    assert_equal "<p>&lt;script&gt;evil_js&lt;/script&gt;</p>",
+                 content_tag(:p, "<script>evil_js</script>")
+    assert_equal "<p><script>evil_js</script></p>",
+                 content_tag(:p, "<script>evil_js</script>", nil, false)
+  end
+
+  def test_tag_builder_with_content
+    assert_equal "<div id=\"post_1\">Content</div>", tag.div("Content", id: "post_1")
+    assert_predicate tag.div("Content", id: "post_1"), :html_safe?
+    assert_equal tag.div("Content", id: "post_1"),
+                 tag.div("Content", "id": "post_1")
+    assert_equal "<p>&lt;script&gt;evil_js&lt;/script&gt;</p>",
+                 tag.p("<script>evil_js</script>")
+    assert_equal "<p><script>evil_js</script></p>",
+                 tag.p("<script>evil_js</script>", escape_attributes: false)
+  end
+
+  def test_tag_builder_nested
+    assert_equal "<div>content</div>",
+                 tag.div { "content" }
+    assert_equal "<div id=\"header\"><span>hello</span></div>",
+                 tag.div(id: "header") { |tag| tag.span "hello" }
+    assert_equal "<div id=\"header\"><div class=\"world\"><span>hello</span></div></div>",
+                 tag.div(id: "header") { |tag| tag.div(class: "world") { tag.span "hello" } }
+  end
+
+  def test_content_tag_with_block_in_erb
+    buffer = render_erb("<%= content_tag(:div) do %>Hello world!<% end %>")
+    assert_dom_equal "<div>Hello world!</div>", buffer
+  end
+
+  def test_tag_builder_with_block_in_erb
+    buffer = render_erb("<%= tag.div do %>Hello world!<% end %>")
+    assert_dom_equal "<div>Hello world!</div>", buffer
+  end
+
+  def test_content_tag_with_block_in_erb_containing_non_displayed_erb
+    buffer = render_erb("<%= content_tag(:p) do %><% 1 %><% end %>")
+    assert_dom_equal "<p></p>", buffer
+  end
+
+  def test_tag_builder_with_block_in_erb_containing_non_displayed_erb
+    buffer = render_erb("<%= tag.p do %><% 1 %><% end %>")
+    assert_dom_equal "<p></p>", buffer
+  end
+
+  def test_content_tag_with_block_and_options_in_erb
+    buffer = render_erb("<%= content_tag(:div, :class => 'green') do %>Hello world!<% end %>")
+    assert_dom_equal %(<div class="green">Hello world!</div>), buffer
+  end
+
+  def test_tag_builder_with_block_and_options_in_erb
+    buffer = render_erb("<%= tag.div(class: 'green') do %>Hello world!<% end %>")
+    assert_dom_equal %(<div class="green">Hello world!</div>), buffer
+  end
+
+  def test_content_tag_with_block_and_options_out_of_erb
+    assert_dom_equal %(<div class="green">Hello world!</div>), content_tag(:div, class: "green") { "Hello world!" }
+  end
+
+  def test_tag_builder_with_block_and_options_out_of_erb
+    assert_dom_equal %(<div class="green">Hello world!</div>), tag.div(class: "green") { "Hello world!" }
+  end
+
+  def test_content_tag_with_block_and_options_outside_out_of_erb
+    assert_equal content_tag("a", "Create", href: "create"),
+                 content_tag("a", "href" => "create") { "Create" }
+  end
+
+  def test_tag_builder_with_block_and_options_outside_out_of_erb
+    assert_equal tag.a("Create", href: "create"),
+                 tag.a("href": "create") { "Create" }
+  end
+
+  def test_content_tag_with_block_and_non_string_outside_out_of_erb
+    assert_equal content_tag("p"),
+                 content_tag("p") { 3.times { "do_something" } }
+  end
+
+  def test_tag_builder_with_block_and_non_string_outside_out_of_erb
+    assert_equal tag.p,
+                 tag.p { 3.times { "do_something" } }
+  end
+
+  def test_content_tag_nested_in_content_tag_out_of_erb
+    assert_equal content_tag("p", content_tag("b", "Hello")),
+                 content_tag("p") { content_tag("b", "Hello") },
+                 output_buffer
+    assert_equal tag.p(tag.b("Hello")),
+                 tag.p { tag.b("Hello") },
+                 output_buffer
+  end
+
+  def test_content_tag_nested_in_content_tag_in_erb
+    assert_equal "<p>\n  <b>Hello</b>\n</p>", view.render("test/content_tag_nested_in_content_tag")
+    assert_equal "<p>\n  <b>Hello</b>\n</p>", view.render("test/builder_tag_nested_in_content_tag")
+  end
+
+  def test_content_tag_with_escaped_array_class
+    str = content_tag("p", "limelight", class: ["song", "play>"])
+    assert_equal "<p class=\"song play&gt;\">limelight</p>", str
+
+    str = content_tag("p", "limelight", class: ["song", "play"])
+    assert_equal "<p class=\"song play\">limelight</p>", str
+
+    str = content_tag("p", "limelight", class: ["song", ["play"]])
+    assert_equal "<p class=\"song play\">limelight</p>", str
+  end
+
+  def test_tag_builder_with_escaped_array_class
+    str = tag.p "limelight", class: ["song", "play>"]
+    assert_equal "<p class=\"song play&gt;\">limelight</p>", str
+
+    str = tag.p "limelight", class: ["song", "play"]
+    assert_equal "<p class=\"song play\">limelight</p>", str
+
+    str = tag.p "limelight", class: ["song", ["play"]]
+    assert_equal "<p class=\"song play\">limelight</p>", str
+  end
+
+  def test_content_tag_with_unescaped_array_class
+    str = content_tag("p", "limelight", { class: ["song", "play>"] }, false)
+    assert_equal "<p class=\"song play>\">limelight</p>", str
+
+    str = content_tag("p", "limelight", { class: ["song", ["play>"]] }, false)
+    assert_equal "<p class=\"song play>\">limelight</p>", str
+  end
+
+  def test_tag_builder_with_unescaped_array_class
+    str = tag.p "limelight", class: ["song", "play>"], escape_attributes: false
+    assert_equal "<p class=\"song play>\">limelight</p>", str
+
+    str = tag.p "limelight", class: ["song", ["play>"]], escape_attributes: false
+    assert_equal "<p class=\"song play>\">limelight</p>", str
+  end
+
+  def test_content_tag_with_empty_array_class
+    str = content_tag("p", "limelight", class: [])
+    assert_equal '<p class="">limelight</p>', str
+  end
+
+  def test_tag_builder_with_empty_array_class
+    assert_equal '<p class="">limelight</p>', tag.p("limelight", class: [])
+  end
+
+  def test_content_tag_with_unescaped_empty_array_class
+    str = content_tag("p", "limelight", { class: [] }, false)
+    assert_equal '<p class="">limelight</p>', str
+  end
+
+  def test_tag_builder_with_unescaped_empty_array_class
+    str = tag.p "limelight", class: [], escape_attributes: false
+    assert_equal '<p class="">limelight</p>', str
+  end
+
+  def test_content_tag_with_data_attributes
+    assert_dom_equal '<p data-number="1" data-string="hello" data-string-with-quotes="double&quot;quote&quot;party&quot;">limelight</p>',
+      content_tag("p", "limelight", data: { number: 1, string: "hello", string_with_quotes: 'double"quote"party"' })
+  end
+
+  def test_tag_builder_with_data_attributes
+    assert_dom_equal '<p data-number="1" data-string="hello" data-string-with-quotes="double&quot;quote&quot;party&quot;">limelight</p>',
+      tag.p("limelight", data: { number: 1, string: "hello", string_with_quotes: 'double"quote"party"' })
+  end
+
+  def test_cdata_section
+    assert_equal "<![CDATA[<hello world>]]>", cdata_section("<hello world>")
+  end
+
+  def test_cdata_section_with_string_conversion
+    assert_equal "<![CDATA[]]>", cdata_section(nil)
+  end
+
+  def test_cdata_section_splitted
+    assert_equal "<![CDATA[hello]]]]><![CDATA[>world]]>", cdata_section("hello]]>world")
+    assert_equal "<![CDATA[hello]]]]><![CDATA[>world]]]]><![CDATA[>again]]>", cdata_section("hello]]>world]]>again")
+  end
+
+  def test_escape_once
+    assert_equal "1 &lt; 2 &amp; 3", escape_once("1 < 2 &amp; 3")
+    assert_equal " &#X27; &#x27; &#x03BB; &#X03bb; &quot; &#39; &lt; &gt; ", escape_once(" &#X27; &#x27; &#x03BB; &#X03bb; \" ' < > ")
+  end
+
+  def test_tag_honors_html_safe_for_param_values
+    ["1&amp;2", "1 &lt; 2", "&#8220;test&#8220;"].each do |escaped|
+      assert_equal %(<a href="#{escaped}" />), tag("a", href: escaped.html_safe)
+      assert_equal %(<a href="#{escaped}"></a>), tag.a(href: escaped.html_safe)
+    end
+  end
+
+  def test_tag_honors_html_safe_with_escaped_array_class
+    assert_equal '<p class="song&gt; play>" />', tag("p", class: ["song>", raw("play>")])
+    assert_equal '<p class="song> play&gt;" />', tag("p", class: [raw("song>"), "play>"])
+  end
+
+  def test_tag_builder_honors_html_safe_with_escaped_array_class
+    assert_equal '<p class="song&gt; play>"></p>', tag.p(class: ["song>", raw("play>")])
+    assert_equal '<p class="song> play&gt;"></p>', tag.p(class: [raw("song>"), "play>"])
+  end
+
+  def test_tag_does_not_honor_html_safe_double_quotes_as_attributes
+    assert_dom_equal '<p title="&quot;">content</p>',
+      content_tag("p", "content", title: '"'.html_safe)
+  end
+
+  def test_data_tag_does_not_honor_html_safe_double_quotes_as_attributes
+    assert_dom_equal '<p data-title="&quot;">content</p>',
+      content_tag("p", "content", data: { title: '"'.html_safe })
+  end
+
+  def test_skip_invalid_escaped_attributes
+    ["&1;", "&#1dfa3;", "& #123;"].each do |escaped|
+      assert_equal %(<a href="#{escaped.gsub(/&/, '&amp;')}" />), tag("a", href: escaped)
+      assert_equal %(<a href="#{escaped.gsub(/&/, '&amp;')}"></a>), tag.a(href: escaped)
+    end
+  end
+
+  def test_disable_escaping
+    assert_equal '<a href="&amp;" />', tag("a", { href: "&amp;" }, false, false)
+  end
+
+  def test_tag_builder_disable_escaping
+    assert_equal '<a href="&amp;"></a>', tag.a(href: "&amp;", escape_attributes: false)
+    assert_equal '<a href="&amp;">cnt</a>', tag.a(href: "&amp;", escape_attributes: false) { "cnt" }
+    assert_equal '<br data-hidden="&amp;">', tag.br("data-hidden": "&amp;", escape_attributes: false)
+    assert_equal '<a href="&amp;">content</a>', tag.a("content", href: "&amp;", escape_attributes: false)
+    assert_equal '<a href="&amp;">content</a>', tag.a(href: "&amp;", escape_attributes: false) { "content" }
+  end
+
+  def test_data_attributes
+    ["data", :data].each { |data|
+      assert_dom_equal '<a data-a-float="3.14" data-a-big-decimal="-123.456" data-a-number="1" data-array="[1,2,3]" data-hash="{&quot;key&quot;:&quot;value&quot;}" data-string-with-quotes="double&quot;quote&quot;party&quot;" data-string="hello" data-symbol="foo" />',
+        tag("a", data => { a_float: 3.14, a_big_decimal: BigDecimal("-123.456"), a_number: 1, string: "hello", symbol: :foo, array: [1, 2, 3], hash: { key: "value" }, string_with_quotes: 'double"quote"party"' })
+      assert_dom_equal '<a data-a-float="3.14" data-a-big-decimal="-123.456" data-a-number="1" data-array="[1,2,3]" data-hash="{&quot;key&quot;:&quot;value&quot;}" data-string-with-quotes="double&quot;quote&quot;party&quot;" data-string="hello" data-symbol="foo" />',
+        tag.a(data: { a_float: 3.14, a_big_decimal: BigDecimal("-123.456"), a_number: 1, string: "hello", symbol: :foo, array: [1, 2, 3], hash: { key: "value" }, string_with_quotes: 'double"quote"party"' })
+    }
+  end
+
+  def test_aria_attributes
+    ["aria", :aria].each { |aria|
+      assert_dom_equal '<a aria-a-float="3.14" aria-a-big-decimal="-123.456" aria-a-number="1" aria-array="[1,2,3]" aria-hash="{&quot;key&quot;:&quot;value&quot;}" aria-string-with-quotes="double&quot;quote&quot;party&quot;" aria-string="hello" aria-symbol="foo" />',
+        tag("a", aria => { a_float: 3.14, a_big_decimal: BigDecimal("-123.456"), a_number: 1, string: "hello", symbol: :foo, array: [1, 2, 3], hash: { key: "value" }, string_with_quotes: 'double"quote"party"' })
+      assert_dom_equal '<a aria-a-float="3.14" aria-a-big-decimal="-123.456" aria-a-number="1" aria-array="[1,2,3]" aria-hash="{&quot;key&quot;:&quot;value&quot;}" aria-string-with-quotes="double&quot;quote&quot;party&quot;" aria-string="hello" aria-symbol="foo" />',
+        tag.a(aria: { a_float: 3.14, a_big_decimal: BigDecimal("-123.456"), a_number: 1, string: "hello", symbol: :foo, array: [1, 2, 3], hash: { key: "value" }, string_with_quotes: 'double"quote"party"' })
+    }
+  end
+
+  def test_link_to_data_nil_equal
+    div_type1 = content_tag(:div, "test", "data-tooltip" => nil)
+    div_type2 = content_tag(:div, "test", data: { tooltip: nil })
+    assert_dom_equal div_type1, div_type2
+  end
+
+  def test_tag_builder_link_to_data_nil_equal
+    div_type1 = tag.div "test", 'data-tooltip': nil
+    div_type2 = tag.div "test", data: { tooltip: nil }
+    assert_dom_equal div_type1, div_type2
+  end
+
+  def test_tag_builder_allow_call_via_method_object
+    assert_equal "<foo></foo>", tag.method(:foo).call
+  end
+
+  def test_tag_builder_dasherize_names
+    assert_equal "<img-slider></img-slider>", tag.img_slider
+  end
+
+  def test_respond_to
+    assert_respond_to tag, :any_tag
+  end
+end