asciidoctor 0.0.7 → 0.0.9

data/test/paragraphs_test.rb

@@ -1,26 +1,27 @@
 require 'test_helper'
 
 context "Paragraphs" do
-  test "rendered correctly" do
-    assert_xpath "//p", render_string("Plain text for the win.\n\nYes, plainly."), 2
-  end
+  context 'Normal' do
+    test "rendered correctly" do
+      assert_xpath "//p", render_string("Plain text for the win.\n\nYes, plainly."), 2
+    end
 
-  test "with title" do
-    rendered = render_string(".Titled\nParagraph.\n\nWinning")
-    
-    assert_xpath "//div[@class='title']", rendered
-    assert_xpath "//p", rendered, 2
-  end
+    test "with title" do
+      rendered = render_string(".Titled\nParagraph.\n\nWinning")
+      
+      assert_xpath "//div[@class='title']", rendered
+      assert_xpath "//p", rendered, 2
+    end
 
-  test "no duplicate block before next section" do
-    rendered = render_string("Title\n=====\n\nPreamble.\n\n== First Section\n\nParagraph 1\n\nParagraph 2\n\n\n== Second Section\n\nLast words")
-    assert_xpath '//p[text()="Paragraph 2"]', rendered, 1
+    test "no duplicate block before next section" do
+      rendered = render_string("Title\n=====\n\nPreamble.\n\n== First Section\n\nParagraph 1\n\nParagraph 2\n\n\n== Second Section\n\nLast words")
+      assert_xpath '//p[text()="Paragraph 2"]', rendered, 1
+    end
   end
 
   context "code" do
     test "single-line literal paragraphs" do
-      output = render_string("    LITERALS\n\n    ARE LITERALLY\n\n    AWESOMMMME.")
-      assert_xpath "//pre/tt", render_string("    LITERALS\n\n    ARE LITERALLY\n\n    AWESOMMMME.")
+      assert_xpath "//pre", render_string("    LITERALS\n\n    ARE LITERALLY\n\n    AWESOMMMME.")
     end
 
     test "multi-line literal paragraph" do
@@ -33,16 +34,16 @@ Install instructions:
 You're good to go!
       EOS
       output = render_string(input)
-      assert_xpath "//pre/tt", output, 1
-      assert_match /^gem install asciidoctor/, output, "Indentation should be trimmed from literal block"
+      assert_xpath "//pre", output, 1
+      assert_match(/^gem install asciidoctor/, output, "Indentation should be trimmed from literal block")
     end
 
     test "listing paragraph" do
-      assert_xpath "//div[@class='highlight']", render_string("----\nblah blah blah\n----")
+      assert_xpath "//pre[@class='highlight']/code", render_string("[source]\n----\nblah blah blah\n----")
     end
 
     test "source code paragraph" do
-      assert_xpath "//div[@class='highlight']", render_string("[source, perl]\ndie 'zomg perl sucks';")
+      assert_xpath "//pre[@class='highlight']/code[@class='perl']", render_string("[source, perl]\ndie 'zomg perl sucks';")
     end
   end
 
@@ -54,10 +55,10 @@ You're good to go!
     end
 
     test "quote block with attribution" do
-      output = render_string("[quote, A famous person, A famous book]\n____\nFamous quote.\n____")
+      output = render_string("[quote, A famous person, A famous book (1999)]\n____\nFamous quote.\n____")
       assert_xpath '//*[@class = "quoteblock"]', output, 1
       assert_xpath '//*[@class = "quoteblock"]/*[@class = "attribution"]', output, 1
-      assert_xpath '//*[@class = "quoteblock"]/*[@class = "attribution"]/em[text() = "A famous book"]', output, 1
+      assert_xpath '//*[@class = "quoteblock"]/*[@class = "attribution"]/em[text() = "A famous book (1999)"]', output, 1
       # TODO I can't seem to match the attribution (author) w/ xpath
     end
 
@@ -140,14 +141,4 @@ Content goes here
       assert_xpath "//*[@class='sidebarblock']//p", result, 1
     end
   end
-
-  context "comments" do
-    test "line comment" do
-      assert_no_match /comment/, render_string("first paragraph\n\n//comment\n\nsecond paragraph")
-    end
-
-    test "comment block" do
-      assert_no_match /comment/, render_string("first paragraph\n\n////\ncomment\n////\n\nsecond paragraph")
-    end
-  end
 end

data/test/preamble_test.rb

@@ -85,4 +85,28 @@ Section paragraph 1.
     assert_xpath '//h2[@id="_first_section"]/preceding::p', result, 1
   end
 
+  test 'preamble in book doctype' do
+      input = <<-EOS
+Book
+====
+:doctype: book
+
+Back then...
+
+= Chapter One
+
+It was a dark and stormy night...
+
+= Chapter Two
+
+They couldn't believe their eyes when...
+      EOS
+
+      d = document_from_string(input)
+      assert_equal 'book', d.doctype 
+      output = d.render
+      assert_xpath '//h1', output, 3
+      assert_xpath %{//*[@id="preamble"]//p[text() = "Back then#{[8230].pack('U*')}"]}, output, 1
+  end
+
 end

data/test/reader_test.rb

@@ -9,7 +9,7 @@ class ReaderTest < Test::Unit::TestCase
 
   context "has_lines?" do
     test "returns false for empty document" do
-      assert ! Asciidoctor::Reader.new.has_lines?
+      assert !Asciidoctor::Reader.new.has_lines?
     end
 
     test "returns true with lines remaining" do
@@ -35,22 +35,258 @@ class ReaderTest < Test::Unit::TestCase
       second = reader.peek_line
       assert_equal "foo", second
     end
+
+    test "unshift puts line onto Reader instance for the next get_line" do
+      reader = Asciidoctor::Reader.new(["foo"])
+      reader.unshift("bar")
+      assert_equal "bar", reader.get_line
+      assert_equal "foo", reader.get_line
+    end
+  end
+
+  context "Grab lines" do
+    test "Grab until end" do
+      input = <<-EOS
+This is one paragraph.
+
+This is another paragraph.
+      EOS
+
+      lines = input.lines.entries
+      reader = Asciidoctor::Reader.new(lines)
+      result = reader.grab_lines_until
+      assert_equal 3, result.size
+      assert_equal lines, result
+      assert !reader.has_lines?
+      assert reader.empty?
+    end
+
+    test "Grab until blank line" do
+      input = <<-EOS
+This is one paragraph.
+
+This is another paragraph.
+      EOS
+
+      lines = input.lines.entries
+      reader = Asciidoctor::Reader.new(lines)
+      result = reader.grab_lines_until :break_on_blank_lines => true
+      assert_equal 1, result.size
+      assert_equal lines.first, result.first
+      assert_equal lines.last, reader.peek_line
+    end
+
+    test "Grab until blank line preserving last line" do
+      input = <<-EOS
+This is one paragraph.
+
+This is another paragraph.
+      EOS
+
+      lines = input.lines.entries
+      reader = Asciidoctor::Reader.new(lines)
+      result = reader.grab_lines_until :break_on_blank_lines => true, :preserve_last_line => true
+      assert_equal 1, result.size
+      assert_equal lines.first, result.first
+      assert_equal "\n", reader.peek_line
+    end
+
+    test "Grab until condition" do
+      input = <<-EOS
+--
+This is one paragraph inside the block.
+
+This is another paragraph inside the block.
+--
+
+This is a paragraph outside the block.
+      EOS
+
+      lines = input.lines.entries
+      reader = Asciidoctor::Reader.new(lines)
+      reader.get_line
+      result = reader.grab_lines_until {|line| line.chomp == '--' }
+      assert_equal 3, result.size
+      assert_equal lines[1, 3], result
+      assert_equal "\n", reader.peek_line
+    end
+
+    test "Grab until condition with last line" do
+      input = <<-EOS
+--
+This is one paragraph inside the block.
+
+This is another paragraph inside the block.
+--
+
+This is a paragraph outside the block.
+      EOS
+
+      lines = input.lines.entries
+      reader = Asciidoctor::Reader.new(lines)
+      reader.get_line
+      result = reader.grab_lines_until(:grab_last_line => true) {|line| line.chomp == '--' }
+      assert_equal 4, result.size
+      assert_equal lines[1, 4], result
+      assert_equal "\n", reader.peek_line
+    end
+
+    test "Grab until condition with last line and preserving last line" do
+      input = <<-EOS
+--
+This is one paragraph inside the block.
+
+This is another paragraph inside the block.
+--
+
+This is a paragraph outside the block.
+      EOS
+
+      lines = input.lines.entries
+      reader = Asciidoctor::Reader.new(lines)
+      reader.get_line
+      result = reader.grab_lines_until(:grab_last_line => true, :preserve_last_line => true) {|line| line.chomp == '--' }
+      assert_equal 4, result.size
+      assert_equal lines[1, 4], result
+      assert_equal "--\n", reader.peek_line
+    end
   end
 
-  test "unshift puts line onto Reader instance for the next get_line" do
-    reader = Asciidoctor::Reader.new(["foo"])
-    reader.unshift("bar")
-    assert_equal "bar", reader.get_line
-    assert_equal "foo", reader.get_line
+  context 'Include Macro' do
+    test 'include macro is disabled by default' do
+      input = <<-EOS
+include::include-file.asciidoc[]
+      EOS
+      para = block_from_string input, :attributes => { 'include-depth' => 0 }
+      assert_equal 1, para.buffer.size
+      assert_equal 'include::include-file.asciidoc[]', para.buffer.join
+    end
+
+    test 'include macro is enabled when safe mode is less than SECURE' do
+      input = <<-EOS
+include::fixtures/include-file.asciidoc[]
+      EOS
+
+      doc = document_from_string input, :safe => Asciidoctor::SafeMode::SAFE, :attributes => {'docdir' => File.dirname(__FILE__)}
+      output = doc.render
+      assert_match(/included content/, output)
+    end
+
+    test "block is called to handle an include macro" do
+      input = <<-EOS
+first line
+
+include::include-file.asciidoc[]
+
+last line
+      EOS
+      doc = Asciidoctor::Document.new [], :safe => Asciidoctor::SafeMode::SAFE
+      Asciidoctor::Reader.new(input.lines.entries, doc) {|inc|
+        ":file: #{inc}\n\nmiddle line".lines.entries
+      }
+      assert_equal 'include-file.asciidoc', doc.attributes['file']
+    end
+
+    test 'escaped include macro is left unprocessed' do
+      input = <<-EOS
+\\include::include-file.asciidoc[]
+      EOS
+      para = block_from_string input
+      assert_equal 1, para.buffer.size
+      assert_equal 'include::include-file.asciidoc[]', para.buffer.join
+    end
+
+    test 'include macro not at start of line is ignored' do
+      input = <<-EOS
+ include::include-file.asciidoc[]
+      EOS
+      para = block_from_string input
+      assert_equal 1, para.buffer.size
+      # NOTE the space gets stripped because the line is treated as an inline literal
+      assert_equal :literal, para.context
+      assert_equal 'include::include-file.asciidoc[]', para.buffer.join
+    end
+
+    test 'include macro is disabled when include-depth attribute is 0' do
+      input = <<-EOS
+include::include-file.asciidoc[]
+      EOS
+      para = block_from_string input, :safe => Asciidoctor::SafeMode::SAFE, :attributes => { 'include-depth' => 0 }
+      assert_equal 1, para.buffer.size
+      assert_equal 'include::include-file.asciidoc[]', para.buffer.join
+    end
+
+    test 'include-depth cannot be set by document' do
+      input = <<-EOS
+:include-depth: 1
+
+include::include-file.asciidoc[]
+      EOS
+      para = block_from_string input, :safe => Asciidoctor::SafeMode::SAFE, :attributes => { 'include-depth' => 0 }
+      assert_equal 1, para.buffer.size
+      assert_equal 'include::include-file.asciidoc[]', para.buffer.join
+    end
   end
 
-  def test_grab_lines_until
-    pending "Not tested yet"
+  context 'build secure asset path' do
+    test 'allows us to specify a path relative to the current dir' do
+      doc = Asciidoctor::Document.new
+      reader = Asciidoctor::Reader.new(["foo"], doc)
+      legit_path = Dir.pwd + "/foo"
+      assert_equal legit_path, doc.normalize_asset_path(legit_path)
+    end
+
+    test "keeps naughty absolute paths from getting outside" do
+      naughty_path = "/etc/passwd"
+      doc = Asciidoctor::Document.new
+      reader = Asciidoctor::Reader.new(["foo"], doc)
+      secure_path = doc.normalize_asset_path(naughty_path)
+      assert naughty_path != secure_path
+      assert_match(/^#{doc.base_dir}/, secure_path)
+    end
+
+    test "keeps naughty relative paths from getting outside" do
+      naughty_path = "safe/ok/../../../../../etc/passwd"
+      doc = Asciidoctor::Document.new
+      reader = Asciidoctor::Reader.new(["foo"], doc)
+      secure_path = doc.normalize_asset_path(naughty_path)
+      assert naughty_path != secure_path
+      assert_match(/^#{doc.base_dir}/, secure_path)
+    end
   end
 
-  def test_sanitize_attribute_name
-    assert_equal 'foobar', @reader.sanitize_attribute_name("Foo Bar")
-    assert_equal 'foo', @reader.sanitize_attribute_name("foo")
-    assert_equal 'foo3-bar', @reader.sanitize_attribute_name("Foo 3^ # - Bar[")
+  # TODO these tests could be expanded
+  context 'Conditional blocks' do
+    test 'ifdef with defined attribute includes block' do
+      input = <<-EOS
+:holygrail:
+
+ifdef::holygrail[]
+There is a holy grail!
+endif::holygrail[]
+      EOS
+       
+      reader = Asciidoctor::Reader.new(input.lines.entries, Asciidoctor::Document.new)
+      assert_match(/There is a holy grail!/, reader.lines.join)
+    end
+
+    test 'ifndef with undefined attribute includes block' do
+      input = <<-EOS
+ifndef::holygrail[]
+Our quest continues to find the holy grail!
+endif::holygrail[]
+      EOS
+
+      reader = Asciidoctor::Reader.new(input.lines.entries, Asciidoctor::Document.new)
+      assert_match(/Our quest continues to find the holy grail!/, reader.lines.join)
+    end
+  end
+
+  context 'Text processing' do
+    test 'sanitize attribute name' do
+      assert_equal 'foobar', @reader.sanitize_attribute_name("Foo Bar")
+      assert_equal 'foo', @reader.sanitize_attribute_name("foo")
+      assert_equal 'foo3-bar', @reader.sanitize_attribute_name("Foo 3^ # - Bar[")
+    end
   end
 end

data/test/renderer_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+context 'Renderer' do
+
+  test 'should extract view mapping from built-in template with one segment and backend' do
+    view_name, view_backend = Asciidoctor::Renderer.extract_view_mapping('Asciidoctor::HTML5::DocumentTemplate') 
+    assert_equal 'document', view_name
+    assert_equal 'html5', view_backend
+  end
+
+  test 'should extract view mapping from built-in template with two segments and backend' do
+    view_name, view_backend = Asciidoctor::Renderer.extract_view_mapping('Asciidoctor::DocBook45::BlockSidebarTemplate') 
+    assert_equal 'block_sidebar', view_name
+    assert_equal 'docbook45', view_backend
+  end
+
+  test 'should extract view mapping from built-in template without backend' do
+    view_name, view_backend = Asciidoctor::Renderer.extract_view_mapping('Asciidoctor::DocumentTemplate') 
+    assert_equal 'document', view_name
+    assert view_backend.nil?
+  end
+end

data/test/substitutions_test.rb

@@ -0,0 +1,414 @@
+require 'test_helper'
+
+# TODO
+# - test negatives
+# - test role on every quote type
+context 'Substitutions' do
+  context 'Dispatcher' do
+    test 'apply normal substitutions' do
+      para = block_from_string("[blue]'http://asciidoc.org[AsciiDoc]' & [red]*Ruby*\n&#167; Making +++<u>documentation</u>+++ together +\nsince (C) {inception_year}.")
+      para.document.attributes['inception_year'] = '2012'
+      result = para.apply_normal_subs(para.buffer) 
+      assert_equal %{<em><span class="blue"><a href="http://asciidoc.org">AsciiDoc</a></span></em> &amp; <strong><span class="red">Ruby</span></strong>\n&#167; Making <u>documentation</u> together<br>\nsince &#169; 2012.}, result
+    end
+  end
+
+  context 'Quotes' do
+    test 'single-line double-quoted string' do
+      para = block_from_string(%q{``a few quoted words''})
+      assert_equal '&#8220;a few quoted words&#8221;', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line double-quoted string' do
+      para = block_from_string(%q{\``a few quoted words''})
+      assert_equal %q(&#8216;`a few quoted words&#8217;'), para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line double-quoted string' do
+      para = block_from_string(%Q{``a few\nquoted words''})
+      assert_equal "&#8220;a few\nquoted words&#8221;", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'double-quoted string with inline single quote' do
+      para = block_from_string(%q{``Here's Johnny!''})
+      assert_equal %q{&#8220;Here's Johnny!&#8221;}, para.sub_quotes(para.buffer.join)
+    end
+
+    test 'double-quoted string with inline backquote' do
+      para = block_from_string(%q{``Here`s Johnny!''})
+      assert_equal %q{&#8220;Here`s Johnny!&#8221;}, para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line single-quoted string' do
+      para = block_from_string(%q{`a few quoted words'})
+      assert_equal '&#8216;a few quoted words&#8217;', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line single-quoted string' do
+      para = block_from_string(%q{\`a few quoted words'})
+      assert_equal %(`a few quoted words'), para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line single-quoted string' do
+      para = block_from_string(%Q{`a few\nquoted words'})
+      assert_equal "&#8216;a few\nquoted words&#8217;", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-quoted string with inline single quote' do
+      para = block_from_string(%q{`That isn't what I did.'})
+      assert_equal %q{&#8216;That isn't what I did.&#8217;}, para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-quoted string with inline backquote' do
+      para = block_from_string(%q{`Here`s Johnny!'})
+      assert_equal %q{&#8216;Here`s Johnny!&#8217;}, para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line constrained unquoted string' do
+      para = block_from_string(%q{#a few words#})
+      assert_equal 'a few words', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line constrained unquoted string' do
+      para = block_from_string(%q{\#a few words#})
+      assert_equal '#a few words#', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line constrained unquoted string' do
+      para = block_from_string(%Q{#a few\nwords#})
+      assert_equal "a few\nwords", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line unconstrained unquoted string' do
+      para = block_from_string(%q{##--anything goes ##})
+      assert_equal '--anything goes ', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line unconstrained unquoted string' do
+      para = block_from_string(%q{\##--anything goes ##})
+      assert_equal '#--anything goes #', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line unconstrained unquoted string' do
+      para = block_from_string(%Q{##--anything\ngoes ##})
+      assert_equal "--anything\ngoes ", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line constrained strong string' do
+      para = block_from_string(%q{*a few strong words*})
+      assert_equal '<strong>a few strong words</strong>', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line constrained strong string' do
+      para = block_from_string(%q{\*a few strong words*})
+      assert_equal '*a few strong words*', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line constrained strong string' do
+      para = block_from_string(%Q{*a few\nstrong words*})
+      assert_equal "<strong>a few\nstrong words</strong>", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'constrained strong string containing an asterisk' do
+      para = block_from_string(%q{*bl*ck*-eye})
+      assert_equal '<strong>bl*ck</strong>-eye', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line constrained quote variation emphasized string' do
+      para = block_from_string(%q{'a few emphasized words'})
+      assert_equal '<em>a few emphasized words</em>', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line constrained quote variation emphasized string' do
+      para = block_from_string(%q{\'a few emphasized words'})
+      assert_equal %q('a few emphasized words'), para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line constrained emphasized quote variation string' do
+      para = block_from_string(%Q{'a few\nemphasized words'})
+      assert_equal "<em>a few\nemphasized words</em>", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-quoted string containing an emphasized phrase' do
+      para = block_from_string(%q{`I told him, 'Just go for it!''})
+      assert_equal '&#8216;I told him, <em>Just go for it!</em>&#8217;', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-quotes inside emphasized words are restored' do
+      para = block_from_string(%q{'Here\'s Johnny!'})
+      # NOTE the \' is replaced with ' by the :replacements substitution, later in the substitution pipeline
+      assert_equal %q{<em>Here\'s Johnny!</em>}, para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line constrained emphasized underline variation string' do
+      para = block_from_string(%q{_a few emphasized words_})
+      assert_equal '<em>a few emphasized words</em>', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line constrained emphasized underline variation string' do
+      para = block_from_string(%q{\_a few emphasized words_})
+      assert_equal '_a few emphasized words_', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line constrained emphasized underline variation string' do
+      para = block_from_string(%Q{_a few\nemphasized words_})
+      assert_equal "<em>a few\nemphasized words</em>", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line constrained monospaced string' do
+      para = block_from_string(%q{`a few <\{monospaced\}> words`})
+      # NOTE must use apply_normal_subs because constrained monospaced is handled as a passthrough
+      assert_equal '<tt>a few &lt;{monospaced}&gt; words</tt>', para.apply_normal_subs(para.buffer)
+    end
+
+    test 'escaped single-line constrained monospaced string' do
+      para = block_from_string(%q{\`a few <monospaced> words`})
+      # NOTE must use apply_normal_subs because constrained monospaced is handled as a passthrough
+      assert_equal '`a few &lt;monospaced&gt; words`', para.apply_normal_subs(para.buffer)
+    end
+
+    test 'multi-line constrained monospaced string' do
+      para = block_from_string(%Q{`a few\n<\{monospaced\}> words`})
+      # NOTE must use apply_normal_subs because constrained monospaced is handled as a passthrough
+      assert_equal "<tt>a few\n&lt;{monospaced}&gt; words</tt>", para.apply_normal_subs(para.buffer)
+    end
+
+    test 'single-line unconstrained strong chars' do
+      para = block_from_string(%q{**Git**Hub})
+      assert_equal '<strong>Git</strong>Hub', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line unconstrained strong chars' do
+      para = block_from_string(%q{\**Git**Hub})
+      assert_equal '<strong>*Git</strong>*Hub', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line unconstrained strong chars' do
+      para = block_from_string(%Q{**G\ni\nt\n**Hub})
+      assert_equal "<strong>G\ni\nt\n</strong>Hub", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'unconstrained strong chars with inline asterisk' do
+      para = block_from_string(%q{**bl*ck**-eye})
+      assert_equal '<strong>bl*ck</strong>-eye', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'unconstrained strong chars with role' do
+      para = block_from_string(%q{Git[blue]**Hub**})
+      assert_equal %q{Git<strong><span class="blue">Hub</span></strong>}, para.sub_quotes(para.buffer.join)
+    end
+
+    # TODO this is not the same result as AsciiDoc, though I don't understand why AsciiDoc gets what it gets
+    test 'escaped unconstrained strong chars with role' do
+      para = block_from_string(%q{Git\[blue]**Hub**})
+      assert_equal %q{Git[blue]<strong>*Hub</strong>*}, para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line unconstrained emphasized chars' do
+      para = block_from_string(%q{__Git__Hub})
+      assert_equal '<em>Git</em>Hub', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line unconstrained emphasized chars' do
+      para = block_from_string(%q{\__Git__Hub})
+      assert_equal '__Git__Hub', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line unconstrained emphasized chars' do
+      para = block_from_string(%Q{__G\ni\nt\n__Hub})
+      assert_equal "<em>G\ni\nt\n</em>Hub", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'unconstrained emphasis chars with role' do
+      para = block_from_string(%q{[gray]__Git__Hub})
+      assert_equal %q{<em><span class="gray">Git</span></em>Hub}, para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped unconstrained emphasis chars with role' do
+      para = block_from_string(%q{\[gray]__Git__Hub})
+      assert_equal %q{[gray]__Git__Hub}, para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line unconstrained monospaced chars' do
+      para = block_from_string(%q{Git++Hub++})
+      assert_equal 'Git<tt>Hub</tt>', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line unconstrained monospaced chars' do
+      para = block_from_string(%q{Git\++Hub++})
+      assert_equal 'Git+<tt>Hub</tt>+', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line unconstrained monospaced chars' do
+      para = block_from_string(%Q{Git++\nH\nu\nb++})
+      assert_equal "Git<tt>\nH\nu\nb</tt>", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line superscript chars' do
+      para = block_from_string(%q{x^2^ = x * x, e = mc^2^, there's a 1^st^ time for everything})
+      assert_equal 'x<sup>2</sup> = x * x, e = mc<sup>2</sup>, there\'s a 1<sup>st</sup> time for everything', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line superscript chars' do
+      para = block_from_string(%q{x\^2^ = x * x})
+      assert_equal 'x^2^ = x * x', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line superscript chars' do
+      para = block_from_string(%Q{x^(n\n+\n1)^})
+      assert_equal "x<sup>(n\n+\n1)</sup>", para.sub_quotes(para.buffer.join)
+    end
+
+    test 'single-line subscript chars' do
+      para = block_from_string(%q{H~2~O})
+      assert_equal 'H<sub>2</sub>O', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'escaped single-line subscript chars' do
+      para = block_from_string(%q{H\~2~O})
+      assert_equal 'H~2~O', para.sub_quotes(para.buffer.join)
+    end
+
+    test 'multi-line subscript chars' do
+      para = block_from_string(%Q{project~ view\non\nGitHub~})
+      assert_equal "project<sub> view\non\nGitHub</sub>", para.sub_quotes(para.buffer.join)
+    end
+  end
+
+  context 'Macros' do
+    test 'a single-line link macro should be interpreted as a link' do
+      para = block_from_string('link:/home.html[]')
+      assert_equal %q{<a href="/home.html">/home.html</a>}, para.sub_macros(para.buffer.join)
+    end
+
+    test 'a single-line link macro with text should be interpreted as a link' do
+      para = block_from_string('link:/home.html[Home]')
+      assert_equal %q{<a href="/home.html">Home</a>}, para.sub_macros(para.buffer.join)
+    end
+
+    test 'a single-line raw url should be interpreted as a link' do
+      para = block_from_string('http://google.com')
+      assert_equal %q{<a href="http://google.com">http://google.com</a>}, para.sub_macros(para.buffer.join)
+    end
+
+    test 'a single-line raw url with text should be interpreted as a link' do
+      para = block_from_string('http://google.com[Google]')
+      assert_equal %q{<a href="http://google.com">Google</a>}, para.sub_macros(para.buffer.join)
+    end
+
+    test 'a multi-line raw url with text should be interpreted as a link' do
+      para = block_from_string("http://google.com[Google\nHomepage]")
+      assert_equal %{<a href="http://google.com">Google\nHomepage</a>}, para.sub_macros(para.buffer.join)
+    end
+
+    test 'a multi-line raw url with attribute as text should be interpreted as a link with resolved attribute' do
+      para = block_from_string("http://google.com[{google_homepage}]")
+      para.document.attributes['google_homepage'] = 'Google Homepage'
+      assert_equal %q{<a href="http://google.com">Google Homepage</a>}, para.sub_macros(para.buffer.join)
+    end
+
+    test 'a single-line escaped raw url should not be interpreted as a link' do
+      para = block_from_string('\http://google.com')
+      assert_equal %q{http://google.com}, para.sub_macros(para.buffer.join)
+    end
+
+    test 'a single-line image macro should be interpreted as an image' do
+      para = block_from_string('image:tiger.png[]')
+      assert_equal %{<span class="image">\n  <img src="tiger.png" alt="tiger">\n</span>}, para.sub_macros(para.buffer.join)
+    end
+
+    test 'a single-line image macro with text should be interpreted as an image with alt text' do
+      para = block_from_string('image:tiger.png[Tiger]')
+      assert_equal %{<span class="image">\n  <img src="tiger.png" alt="Tiger">\n</span>}, para.sub_macros(para.buffer.join)
+    end
+
+    test 'a single-line image macro with text and dimensions should be interpreted as an image with alt text and dimensions' do
+      para = block_from_string('image:tiger.png[Tiger, 200, 100]')
+      assert_equal %{<span class="image">\n  <img src="tiger.png" alt="Tiger" width="200" height="100">\n</span>}, para.sub_macros(para.buffer.join)
+    end
+
+    test 'a single-line image macro with text and link should be interpreted as a linked image with alt text' do
+      para = block_from_string('image:tiger.png[Tiger, link="http://en.wikipedia.org/wiki/Tiger"]')
+      assert_equal %{<span class="image">\n  <a class="image" href="http://en.wikipedia.org/wiki/Tiger"><img src="tiger.png" alt="Tiger"></a>\n</span>}, para.sub_macros(para.buffer.join)
+    end
+  end
+
+  context 'Passthroughs' do
+    test 'collect inline triple plus passthroughs' do
+      para = block_from_string('+++<code>inline code</code>+++')
+      result = para.extract_passthroughs(para.buffer.join)
+      assert_equal "\x0" + '0' + "\x0", result
+      assert_equal 1, para.passthroughs.size
+      assert_equal '<code>inline code</code>', para.passthroughs.first[:text]
+      assert para.passthroughs.first[:subs].empty?
+    end
+
+    test 'collect multi-line inline triple plus passthroughs' do
+      para = block_from_string("+++<code>inline\ncode</code>+++")
+      result = para.extract_passthroughs(para.buffer.join)
+      assert_equal "\x0" + '0' + "\x0", result
+      assert_equal 1, para.passthroughs.size
+      assert_equal "<code>inline\ncode</code>", para.passthroughs.first[:text]
+      assert para.passthroughs.first[:subs].empty?
+    end
+
+    test 'collect inline double dollar passthroughs' do
+      para = block_from_string('$$<code>{code}</code>$$')
+      result = para.extract_passthroughs(para.buffer.join)
+      assert_equal "\x0" + '0' + "\x0", result
+      assert_equal 1, para.passthroughs.size
+      assert_equal '<code>{code}</code>', para.passthroughs.first[:text]
+      assert_equal [:specialcharacters], para.passthroughs.first[:subs]
+    end
+
+    test 'collect multi-line inline double dollar passthroughs' do
+      para = block_from_string("$$<code>\n{code}\n</code>$$")
+      result = para.extract_passthroughs(para.buffer.join)
+      assert_equal "\x0" + '0' + "\x0", result
+      assert_equal 1, para.passthroughs.size
+      assert_equal "<code>\n{code}\n</code>", para.passthroughs.first[:text]
+      assert_equal [:specialcharacters], para.passthroughs.first[:subs]
+    end
+
+    test 'collect passthroughs from inline pass macro' do
+      para = block_from_string(%Q{pass:specialcharacters,quotes[<code>['code'\\]</code>]})
+      result = para.extract_passthroughs(para.buffer.join)
+      assert_equal "\x0" + '0' + "\x0", result
+      assert_equal 1, para.passthroughs.size
+      assert_equal %q{<code>['code']</code>}, para.passthroughs.first[:text]
+      assert_equal [:specialcharacters, :quotes], para.passthroughs.first[:subs]
+    end
+
+    test 'collect multi-line passthroughs from inline pass macro' do
+      para = block_from_string(%Q{pass:specialcharacters,quotes[<code>['more\ncode'\\]</code>]})
+      result = para.extract_passthroughs(para.buffer.join)
+      assert_equal "\x0" + '0' + "\x0", result
+      assert_equal 1, para.passthroughs.size
+      assert_equal %Q{<code>['more\ncode']</code>}, para.passthroughs.first[:text]
+      assert_equal [:specialcharacters, :quotes], para.passthroughs.first[:subs]
+    end
+
+    test 'restore inline passthroughs without subs' do
+      para = block_from_string("\x0" + '0' + "\x0")
+      para.passthroughs << {:text => '<code>inline code</code>', :subs => []}
+      result = para.restore_passthroughs(para.buffer.join)
+      assert_equal '<code>inline code</code>', result
+    end
+
+    # TODO add two entries to ensure index lookup is working correctly (0 indx could be ambiguous)
+    test 'restore inline passthroughs with subs' do
+      para = block_from_string("\x0" + '0' + "\x0")
+      para.passthroughs << {:text => '<code>{code}</code>', :subs => [:specialcharacters]}
+      result = para.restore_passthroughs(para.buffer.join)
+      assert_equal '&lt;code&gt;{code}&lt;/code&gt;', result
+    end
+  end
+
+  context 'Post replacements' do
+    test 'line break' do
+      para = block_from_string("First line +\nSecond line")
+      result = para.apply_subs(para.buffer, :post_replacements)
+      assert_equal "First line<br>\n", result.first
+    end
+  end
+end