temple 0.10.1 → 0.10.3

data/spec/filters/dynamic_inliner_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::DynamicInliner do
-  before do
-    @filter = Temple::Filters::DynamicInliner.new
-  end
-
-  it 'should compile several statics into dynamic' do
-    expect(@filter.call([:multi,
-      [:static, "Hello "],
-      [:static, "World\n "],
-      [:static, "Have a nice day"]
-    ])).to eq [:dynamic, '"Hello World\n Have a nice day"']
-  end
-
-  it 'should compile several dynamics into dynamic' do
-    expect(@filter.call([:multi,
-      [:dynamic, "@hello"],
-      [:dynamic, "@world"],
-      [:dynamic, "@yeah"]
-    ])).to eq [:dynamic, '"#{@hello}#{@world}#{@yeah}"']
-  end
-
-  it 'should compile static and dynamic into dynamic' do
-    expect(@filter.call([:multi,
-      [:static, "Hello"],
-      [:dynamic, "@world"],
-      [:dynamic, "@yeah"],
-      [:static, "Nice"]
-    ])).to eq [:dynamic, '"Hello#{@world}#{@yeah}Nice"']
-  end
-
-  it 'should merge statics and dynamics around a code' do
-    expect(@filter.call([:multi,
-      [:static, "Hello "],
-      [:dynamic, "@world"],
-      [:code, "Oh yeah"],
-      [:dynamic, "@yeah"],
-      [:static, "Once more"]
-    ])).to eq [:multi,
-      [:dynamic, '"Hello #{@world}"'],
-      [:code, "Oh yeah"],
-      [:dynamic, '"#{@yeah}Once more"']
-    ]
-  end
-
-  it 'should keep codes intact' do
-    expect(@filter.call([:multi, [:code, 'foo']])).to eq([:code, 'foo'])
-  end
-
-  it 'should keep single statics intact' do
-    expect(@filter.call([:multi, [:static, 'foo']])).to eq([:static, 'foo'])
-  end
-
-  it 'should keep single dynamic intact' do
-    expect(@filter.call([:multi, [:dynamic, 'foo']])).to eq([:dynamic, 'foo'])
-  end
-
-  it 'should inline inside multi' do
-    expect(@filter.call([:multi,
-      [:static, "Hello "],
-      [:dynamic, "@world"],
-      [:multi,
-        [:static, "Hello "],
-        [:dynamic, "@world"]],
-      [:static, "Hello "],
-      [:dynamic, "@world"]
-    ])).to eq [:multi,
-      [:dynamic, '"Hello #{@world}"'],
-      [:dynamic, '"Hello #{@world}"'],
-      [:dynamic, '"Hello #{@world}"']
-    ]
-  end
-
-  it 'should merge across newlines' do
-    exp = expect(@filter.call([:multi,
-      [:static, "Hello \n"],
-      [:newline],
-      [:dynamic, "@world"],
-      [:newline]
-    ])).to eq [:dynamic, ['"Hello \n"', '"#{@world}"', '""'].join("\\\n")]
-  end
-
-  it 'should compile static followed by newline' do
-    expect(@filter.call([:multi,
-      [:static, "Hello \n"],
-      [:newline],
-      [:code, "world"]
-    ])).to eq [:multi,
-      [:static, "Hello \n"],
-      [:newline],
-      [:code, "world"]
-    ]
-  end
-end

data/spec/filters/eraser_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::Eraser do
-  it 'should respect keep' do
-    eraser = Temple::Filters::Eraser.new(keep: [:a])
-    expect(eraser.call([:multi,
-      [:a],
-      [:b],
-      [:c]
-    ])).to eq [:multi,
-      [:a],
-      [:multi],
-      [:multi]
-    ]
-  end
-
-  it 'should respect erase' do
-    eraser = Temple::Filters::Eraser.new(erase: [:a])
-    expect(eraser.call([:multi,
-      [:a],
-      [:b],
-      [:c]
-    ])).to eq [:multi,
-      [:multi],
-      [:b],
-      [:c]
-    ]
-  end
-
-  it 'should choose erase over keep' do
-    eraser = Temple::Filters::Eraser.new(keep: [:a, :b], erase: [:a])
-    expect(eraser.call([:multi,
-      [:a],
-      [:b],
-      [:c]
-    ])).to eq [:multi,
-      [:multi],
-      [:b],
-      [:multi]
-    ]
-  end
-
-  it 'should erase nested types' do
-    eraser = Temple::Filters::Eraser.new(erase: [[:a, :b]])
-    expect(eraser.call([:multi,
-      [:a, :a],
-      [:a, :b],
-      [:b]
-    ])).to eq [:multi,
-      [:a, :a],
-      [:multi],
-      [:b]
-    ]
-  end
-end

data/spec/filters/escapable_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::Escapable do
-  before do
-    @filter = Temple::Filters::Escapable.new
-  end
-
-  it 'should handle escape expressions' do
-    expect(@filter.call([:escape, true,
-                  [:multi,
-                   [:static, "a < b"],
-                   [:dynamic, "ruby_method"]]
-    ])).to eq [:multi,
-      [:static, "a &lt; b"],
-      [:dynamic, "::Temple::Utils.escape_html((ruby_method))"],
-    ]
-  end
-
-  it 'should keep codes intact' do
-    exp = [:multi, [:code, 'foo']]
-    expect(@filter.call(exp)).to eq(exp)
-  end
-
-  it 'should keep statics intact' do
-    exp = [:multi, [:static, '<']]
-    expect(@filter.call(exp)).to eq(exp)
-  end
-
-  it 'should keep dynamic intact' do
-    exp = [:multi, [:dynamic, 'foo']]
-    expect(@filter.call(exp)).to eq(exp)
-  end
-
-  it 'should have use_html_safe option' do
-    with_html_safe do
-      filter = Temple::Filters::Escapable.new(use_html_safe: true)
-      expect(filter.call([:escape, true,
-        [:static, Temple::HTML::SafeString.new("a < b")]
-      ])).to eq [:static, "a < b"]
-    end
-  end
-
-  it 'should support censoring' do
-    filter = Temple::Filters::Escapable.new(escape_code: '(%s).gsub("Temple sucks", "Temple rocks")')
-    expect(filter.call([:escape, true,
-      [:static, "~~ Temple sucks ~~"]
-    ])).to eq [:static, "~~ Temple rocks ~~"]
-  end
-end

data/spec/filters/multi_flattener_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::MultiFlattener do
-  before do
-    @filter = Temple::Filters::MultiFlattener.new
-  end
-
-  it 'should flatten nested multi expressions' do
-    expect(@filter.call([:multi,
-      [:static, "a"],
-      [:multi,
-       [:dynamic, "aa"],
-       [:multi,
-        [:static, "aaa"],
-        [:static, "aab"],
-       ],
-       [:dynamic, "ab"],
-      ],
-      [:static, "b"],
-    ])).to eq [:multi,
-      [:static, "a"],
-      [:dynamic, "aa"],
-      [:static, "aaa"],
-      [:static, "aab"],
-      [:dynamic, "ab"],
-      [:static, "b"],
-    ]
-  end
-
-  it 'should return first element' do
-    expect(@filter.call([:multi, [:code, 'foo']])).to eq([:code, 'foo'])
-  end
-end

data/spec/filters/static_analyzer_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::StaticAnalyzer do
-  before do
-    @filter = Temple::Filters::StaticAnalyzer.new
-    @generator = Temple::Generator.new
-  end
-
-  if Temple::StaticAnalyzer.available?
-    it 'should convert :dynamic to :static if code is static' do
-      expect(@filter.call([:dynamic, '"#{"hello"}#{100}"'])).to eq([:static, 'hello100'])
-    end
-
-    it 'should not convert :dynamic if code is dynamic' do
-      exp = [:dynamic, '"#{hello}#{100}"']
-      expect(@filter.call(exp)).to eq(exp)
-    end
-
-    it 'should not change number of newlines in generated code' do
-      exp = [:dynamic, "[100,\n200,\n]"]
-      expect(@filter.call(exp)).to eq([:multi, [:static, '[100, 200]'], [:newline], [:newline]])
-
-      expect(@generator.call(@filter.call(exp)).count("\n")).to eq(@generator.call(exp).count("\n"))
-    end
-  else
-    it 'should do nothing' do
-      [
-        [:dynamic, '"#{"hello"}#{100}"'],
-        [:dynamic, '"#{hello}#{100}"'],
-      ].each do |exp|
-        expect(@filter.call(exp)).to eq(exp)
-      end
-    end
-  end
-end

data/spec/filters/static_merger_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Filters::StaticMerger do
-  before do
-    @filter = Temple::Filters::StaticMerger.new
-  end
-
-  it 'should merge serveral statics' do
-    expect(@filter.call([:multi,
-      [:static, "Hello "],
-      [:static, "World, "],
-      [:static, "Good night"]
-    ])).to eq [:static, "Hello World, Good night"]
-  end
-
-  it 'should merge serveral statics around code' do
-    expect(@filter.call([:multi,
-      [:static, "Hello "],
-      [:static, "World!"],
-      [:code, "123"],
-      [:static, "Good night, "],
-      [:static, "everybody"]
-    ])).to eq [:multi,
-      [:static, "Hello World!"],
-      [:code, "123"],
-      [:static, "Good night, everybody"]
-    ]
-  end
-
-  it 'should merge serveral statics across newlines' do
-    expect(@filter.call([:multi,
-      [:static, "Hello "],
-      [:static, "World, "],
-      [:newline],
-      [:static, "Good night"]
-    ])).to eq [:multi,
-      [:static, "Hello World, Good night"],
-      [:newline]
-    ]
-  end
-end

data/spec/filters/string_splitter_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-begin
-  require 'ripper'
-rescue LoadError
-end
-
-if defined?(Ripper)
-  describe Temple::Filters::StringSplitter do
-    before do
-      @filter = Temple::Filters::StringSplitter.new
-    end
-
-    {
-      %q|''|                     => [:multi],
-      %q|""|                     => [:multi],
-      %q|"hello"|                => [:multi, [:static, 'hello']],
-      %q|"hello #{}world"|       => [:multi, [:static, 'hello '], [:static, 'world']],
-      %q|"#{hello}"|             => [:multi, [:dynamic, 'hello']],
-      %q|"nya#{123}"|            => [:multi, [:static, 'nya'], [:dynamic, '123']],
-      %q|"#{()}()"|              => [:multi, [:dynamic, '()'], [:static, '()']],
-      %q|" #{ " #{ '#{}' } " }"| => [:multi, [:static, ' '], [:multi, [:static, ' '], [:multi, [:static, '#{}']], [:static, ' ']]],
-      %q|%Q[a#{b}c#{d}e]|        => [:multi, [:static, 'a'], [:dynamic, 'b'], [:static, 'c'], [:dynamic, 'd'], [:static, 'e']],
-      %q|%q[a#{b}c#{d}e]|        => [:multi, [:static, 'a#{b}c#{d}e']],
-      %q|"\#{}#{123}"|           => [:multi, [:static, '#{}'], [:dynamic, '123']],
-      %q|"#{ '}' }"|             => [:multi, [:multi, [:static, '}']]],
-      %q| "a" # hello |          => [:multi, [:static, 'a']],
-      %q|"\""|                   => [:multi, [:static, '"']],
-      %q|"\\\\\\""|              => [:multi, [:static, '\\"']],
-      %q|'\"'|                   => [:multi, [:static, '\"']],
-      %q|'\\\"'|                 => [:multi, [:static, '\\"']],
-      %q|"static#{dynamic}"|     => [:multi, [:static, 'static'], [:dynamic, 'dynamic']],
-    }.each do |code, expected|
-      it "should split #{code}" do
-        actual = @filter.call([:dynamic, code])
-        expect(actual).to eq(expected)
-      end
-    end
-
-    describe '.compile' do
-      it 'should raise CompileError for non-string literals' do
-        expect { Temple::Filters::StringSplitter.compile('1') }.to raise_error(Temple::FilterError)
-      end
-
-      it 'should compile strings quoted with parenthesis' do
-        tokens = Temple::Filters::StringSplitter.compile('%Q(href("#{1 + 1}");)')
-        expect(tokens).to eq([[:static, "href(\""], [:dynamic, "1 + 1"], [:static, "\");"]])
-      end
-    end
-  end
-end

data/spec/generator_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-
-class SimpleGenerator < Temple::Generator
-  def preamble
-    "#{buffer} = BUFFER"
-  end
-
-  def postamble
-    buffer
-  end
-
-  def on_static(s)
-    concat "S:#{s}"
-  end
-
-  def on_dynamic(s)
-    concat "D:#{s}"
-  end
-
-  def on_code(s)
-    "C:#{s}"
-  end
-end
-
-class SimpleCaptureGenerator < SimpleGenerator
-  def preamble
-    "#{buffer} = CAPTURE_BUFFER"
-  end
-end
-
-describe Temple::Generator do
-  it 'should compile simple expressions' do
-    gen = SimpleGenerator.new
-
-    expect(gen.call([:static,  'test'])).to eq('_buf = BUFFER; _buf << (S:test); _buf')
-    expect(gen.call([:dynamic, 'test'])).to eq('_buf = BUFFER; _buf << (D:test); _buf')
-    expect(gen.call([:code,    'test'])).to eq('_buf = BUFFER; C:test; _buf')
-  end
-
-  it 'should compile multi expression' do
-    gen = SimpleGenerator.new(buffer: "VAR")
-    expect(gen.call([:multi,
-      [:static, "static"],
-      [:dynamic, "dynamic"],
-      [:code, "code"]
-    ])).to eq('VAR = BUFFER; VAR << (S:static); VAR << (D:dynamic); C:code; VAR')
-  end
-
-  it 'should compile capture' do
-    gen = SimpleGenerator.new(buffer: "VAR", capture_generator: SimpleGenerator)
-    expect(gen.call([:capture, "foo",
-      [:static, "test"]
-    ])).to eq('VAR = BUFFER; foo = BUFFER; foo << (S:test); foo; VAR')
-  end
-
-  it 'should compile capture with multi' do
-    gen = SimpleGenerator.new(buffer: "VAR", capture_generator: SimpleGenerator)
-    expect(gen.call([:multi,
-      [:static, "before"],
-
-      [:capture, "foo", [:multi,
-        [:static, "static"],
-        [:dynamic, "dynamic"],
-        [:code, "code"]]],
-
-      [:static, "after"]
-    ])).to eq('VAR = BUFFER; VAR << (S:before); foo = BUFFER; foo << (S:static); ' +
-      'foo << (D:dynamic); C:code; foo; VAR << (S:after); VAR')
-  end
-
-  it 'should compile nested captures with the same capture_generator' do
-    gen = SimpleGenerator.new(buffer: "VAR", capture_generator: SimpleCaptureGenerator)
-    expect(gen.call(
-      [:capture, "foo", [:multi,
-        [:static, "a"],
-        [:capture, "bar", [:multi,
-          [:static, "b"],
-          [:capture, "baz", [:multi,
-            [:static, "c"],
-          ]]
-        ]]
-      ]]
-    )).to eq "VAR = BUFFER; foo = CAPTURE_BUFFER; foo << (S:a); bar = CAPTURE_BUFFER; bar << (S:b); baz = CAPTURE_BUFFER; baz << (S:c); baz; bar; foo; VAR"
-  end
-
-  it 'should compile newlines' do
-    gen = SimpleGenerator.new(buffer: "VAR")
-    expect(gen.call([:multi,
-      [:static, "static"],
-      [:newline],
-      [:dynamic, "dynamic"],
-      [:newline],
-      [:code, "code"]
-    ])).to eq("VAR = BUFFER; VAR << (S:static); \n; " +
-      "VAR << (D:dynamic); \n; C:code; VAR")
-  end
-end
-
-describe Temple::Generators::Array do
-  it 'should compile simple expressions' do
-    gen = Temple::Generators::Array.new(freeze_static: false)
-    expect(gen.call([:static,  'test'])).to eq('_buf = []; _buf << ("test"); _buf')
-    expect(gen.call([:dynamic, 'test'])).to eq('_buf = []; _buf << (test); _buf')
-    expect(gen.call([:code,    'test'])).to eq('_buf = []; test; _buf')
-
-    expect(gen.call([:multi, [:static, 'a'], [:static,  'b']])).to eq('_buf = []; _buf << ("a"); _buf << ("b"); _buf')
-    expect(gen.call([:multi, [:static, 'a'], [:dynamic, 'b']])).to eq('_buf = []; _buf << ("a"); _buf << (b); _buf')
-  end
-
-  it 'should freeze static' do
-    gen = Temple::Generators::Array.new(freeze_static: true)
-    expect(gen.call([:static,  'test'])).to eq('_buf = []; _buf << ("test".freeze); _buf')
-  end
-end
-
-describe Temple::Generators::ArrayBuffer do
-  it 'should compile simple expressions' do
-    gen = Temple::Generators::ArrayBuffer.new(freeze_static: false)
-    expect(gen.call([:static,  'test'])).to eq('_buf = "test"')
-    expect(gen.call([:dynamic, 'test'])).to eq('_buf = (test).to_s')
-    expect(gen.call([:code,    'test'])).to eq('_buf = []; test; _buf = _buf.join("")')
-
-    expect(gen.call([:multi, [:static, 'a'], [:static,  'b']])).to eq('_buf = []; _buf << ("a"); _buf << ("b"); _buf = _buf.join("")')
-    expect(gen.call([:multi, [:static, 'a'], [:dynamic, 'b']])).to eq('_buf = []; _buf << ("a"); _buf << (b); _buf = _buf.join("")')
-  end
-
-  it 'should freeze static' do
-    gen = Temple::Generators::ArrayBuffer.new(freeze_static: true)
-    expect(gen.call([:static,  'test'])).to eq('_buf = "test"')
-    expect(gen.call([:multi, [:dynamic, '1'], [:static,  'test']])).to eq('_buf = []; _buf << (1); _buf << ("test".freeze); _buf = _buf.join("".freeze)')
-  end
-end
-
-describe Temple::Generators::StringBuffer do
-  it 'should compile simple expressions' do
-    gen = Temple::Generators::StringBuffer.new(freeze_static: false)
-    expect(gen.call([:static,  'test'])).to eq('_buf = "test"')
-    expect(gen.call([:dynamic, 'test'])).to eq('_buf = (test).to_s')
-    expect(gen.call([:code,    'test'])).to eq('_buf = \'\'.dup; test; _buf')
-
-    expect(gen.call([:multi, [:static, 'a'], [:static,  'b']])).to eq('_buf = \'\'.dup; _buf << ("a"); _buf << ("b"); _buf')
-    expect(gen.call([:multi, [:static, 'a'], [:dynamic, 'b']])).to eq('_buf = \'\'.dup; _buf << ("a"); _buf << ((b).to_s); _buf')
-  end
-
-  it 'should freeze static' do
-    gen = Temple::Generators::StringBuffer.new(freeze_static: true)
-    expect(gen.call([:static,  'test'])).to eq('_buf = "test"')
-    expect(gen.call([:multi, [:dynamic, '1'], [:static,  'test']])).to eq('_buf = \'\'.dup; _buf << ((1).to_s); _buf << ("test".freeze); _buf')
-  end
-end
-
-describe Temple::Generators::ERB do
-  it 'should compile simple expressions' do
-    gen = Temple::Generators::ERB.new
-    expect(gen.call([:static,  'test'])).to eq('test')
-    expect(gen.call([:dynamic, 'test'])).to eq('<%= test %>')
-    expect(gen.call([:code,    'test'])).to eq('<% test %>')
-
-    expect(gen.call([:multi, [:static, 'a'], [:static,  'b']])).to eq('ab')
-    expect(gen.call([:multi, [:static, 'a'], [:dynamic, 'b']])).to eq('a<%= b %>')
-  end
-end
-
-describe Temple::Generators::RailsOutputBuffer do
-  it 'should compile simple expressions' do
-    gen = Temple::Generators::RailsOutputBuffer.new(freeze_static: false)
-    expect(gen.call([:static,  'test'])).to eq('@output_buffer = output_buffer || ActionView::OutputBuffer.new; ' +
-      '@output_buffer.safe_concat(("test")); @output_buffer')
-    expect(gen.call([:dynamic, 'test'])).to eq('@output_buffer = output_buffer || ActionView::OutputBuffer.new; ' +
-      '@output_buffer.safe_concat(((test).to_s)); @output_buffer')
-    expect(gen.call([:code,    'test'])).to eq('@output_buffer = output_buffer || ActionView::OutputBuffer.new; ' +
-      'test; @output_buffer')
-  end
-
-  it 'should freeze static' do
-    gen = Temple::Generators::RailsOutputBuffer.new(freeze_static: true)
-    expect(gen.call([:static,  'test'])).to eq('@output_buffer = output_buffer || ActionView::OutputBuffer.new; @output_buffer.safe_concat(("test".freeze)); @output_buffer')
-  end
-end

data/spec/grammar_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe Temple::Grammar do
-  it 'should match core expressions' do
-    expect(Temple::Grammar).to be_match([:multi])
-    expect(Temple::Grammar).to be_match([:multi, [:multi]])
-    expect(Temple::Grammar).to be_match([:static, 'Text'])
-    expect(Temple::Grammar).to be_match([:dynamic, 'Text'])
-    expect(Temple::Grammar).to be_match([:code, 'Text'])
-    expect(Temple::Grammar).to be_match([:capture, 'Text', [:multi]])
-    expect(Temple::Grammar).to be_match([:newline])
-  end
-
-  it 'should not match invalid core expressions' do
-    expect(Temple::Grammar).not_to be_match([:multi, 'String'])
-    expect(Temple::Grammar).not_to be_match([:static])
-    expect(Temple::Grammar).not_to be_match([:dynamic, 1])
-    expect(Temple::Grammar).not_to be_match([:code, :sym])
-    expect(Temple::Grammar).not_to be_match([:capture, [:multi]])
-    expect(Temple::Grammar).not_to be_match([:newline, [:multi]])
-  end
-
-  it 'should match control flow expressions' do
-    expect(Temple::Grammar).to be_match([:if, 'Condition', [:multi]])
-    expect(Temple::Grammar).to be_match([:if, 'Condition', [:multi], [:multi]])
-    expect(Temple::Grammar).to be_match([:block, 'Loop', [:multi]])
-    expect(Temple::Grammar).to be_match([:case, 'Arg', ['Cond1', [:multi]], ['Cond1', [:multi]], [:else, [:multi]]])
-    expect(Temple::Grammar).not_to be_match([:case, 'Arg', [:sym, [:multi]]])
-    expect(Temple::Grammar).to be_match([:cond, ['Cond1', [:multi]], ['Cond2', [:multi]], [:else, [:multi]]])
-    expect(Temple::Grammar).not_to be_match([:cond, [:sym, [:multi]]])
-  end
-
-  it 'should match escape expression' do
-    expect(Temple::Grammar).to be_match([:escape, true, [:multi]])
-    expect(Temple::Grammar).to be_match([:escape, false, [:multi]])
-  end
-
-  it 'should match html expressions' do
-    expect(Temple::Grammar).to be_match([:html, :doctype, 'Doctype'])
-    expect(Temple::Grammar).to be_match([:html, :comment, [:multi]])
-    expect(Temple::Grammar).to be_match([:html, :tag, 'Tag', [:multi]])
-    expect(Temple::Grammar).to be_match([:html, :tag, 'Tag', [:multi], [:multi]])
-    expect(Temple::Grammar).to be_match([:html, :tag, 'Tag', [:multi], [:static, 'Text']])
-    expect(Temple::Grammar).to be_match([:html, :tag, 'Tag', [:html, :attrs, [:html, :attr, 'id',
-                                  [:static, 'val']]], [:static, 'Text']])
-  end
-end

data/spec/html/attribute_merger_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe Temple::HTML::AttributeMerger do
-  before do
-    @merger = Temple::HTML::AttributeMerger.new
-  end
-
-  it 'should pass static attributes through' do
-    expect(@merger.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'class', [:static, 'b']]],
-      [:content]
-    ])).to eq [:html, :tag, "div",
-                     [:html, :attrs,
-                      [:html, :attr, "class", [:static, "b"]]],
-                     [:content]]
-  end
-
-  it 'should preserve the order of html attributes' do
-    expect(@merger.call([:html, :tag,
-      'meta',
-      [:html, :attrs, [:html, :attr, 'c', [:static, '1']],
-                      [:html, :attr, 'd', [:static, '2']],
-                      [:html, :attr, 'a', [:static, '3']],
-                      [:html, :attr, 'b', [:static, '4']]]
-    ])).to eq [:html, :tag, 'meta',
-                     [:html, :attrs,
-                      [:html, :attr, 'c', [:static, '1']],
-                      [:html, :attr, 'd', [:static, '2']],
-                      [:html, :attr, 'a', [:static, '3']],
-                      [:html, :attr, 'b', [:static, '4']]]]
-
-    # Use case:
-    expect(@merger.call([:html, :tag,
-      'meta',
-      [:html, :attrs, [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
-                      [:html, :attr, 'content', [:static, '']]]
-    ])).to eq [:html, :tag, 'meta',
-                     [:html, :attrs,
-                      [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
-                      [:html, :attr, 'content', [:static, '']]]]
-  end
-
-  it 'should merge ids' do
-    expect(@merger.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'id', [:dynamic, 'a']], [:html, :attr, 'id', [:dynamic, 'b']]],
-      [:content]
-    ])).to eq [:html, :tag, "div",
-                     [:html, :attrs,
-                      [:html, :attr, "id",
-                       [:multi,
-                        [:code, "_temple_html_attributemerger1 = []"],
-                        [:capture, "_temple_html_attributemerger1[0]", [:dynamic, "a"]],
-                        [:capture, "_temple_html_attributemerger1[1]", [:dynamic, "b"]],
-                        [:dynamic, "_temple_html_attributemerger1.reject(&:empty?).join(\"_\")"]]]],
-                     [:content]]
-  end
-
-  it 'should merge classes' do
-    expect(@merger.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'class', [:static, 'a']], [:html, :attr, 'class', [:dynamic, 'b']]],
-      [:content]
-    ])).to eq [:html, :tag, "div",
-                     [:html, :attrs,
-                      [:html, :attr, "class",
-                       [:multi,
-                        [:code, "_temple_html_attributemerger1 = []"],
-                        [:capture, "_temple_html_attributemerger1[0]", [:static, "a"]],
-                        [:capture, "_temple_html_attributemerger1[1]", [:dynamic, "b"]],
-                        [:dynamic, "_temple_html_attributemerger1.reject(&:empty?).join(\" \")"]]]],
-                     [:content]]
-  end
-end
-