asciidoctor 0.0.7 → 0.0.9

data/lib/asciidoctor/version.rb

@@ -1,3 +1,3 @@
 module Asciidoctor
-  VERSION = "0.0.7"
+  VERSION = "0.0.9"
 end

data/test/attributes_test.rb

@@ -1,91 +1,247 @@
 require 'test_helper'
 
-context "Attributes" do
-  test "creates an attribute" do
-    doc = document_from_string(":frog: Tanglefoot")
-    assert_equal doc.attributes['frog'], 'Tanglefoot'
-  end
+context 'Attributes' do
+  context 'Assignment' do
+    test 'creates an attribute' do
+      doc = document_from_string(':frog: Tanglefoot')
+      assert_equal 'Tanglefoot', doc.attributes['frog']
+    end
 
-  test "creates an attribute by fusing a multi-line value" do
-    str = <<-EOS
+    test 'creates an attribute by fusing a multi-line value' do
+      str = <<-EOS
 :description: This is the first +
               Ruby implementation of +
               AsciiDoc.
-    EOS
-    doc = document_from_string(str)
-    assert_equal doc.attributes['description'], 'This is the first Ruby implementation of AsciiDoc.'
-  end
+      EOS
+      doc = document_from_string(str)
+      assert_equal 'This is the first Ruby implementation of AsciiDoc.', doc.attributes['description']
+    end
 
-  test "deletes an attribute" do
-    doc = document_from_string(":frog: Tanglefoot\n:frog!:")
-    assert_equal nil, doc.attributes['frog']
-  end
+    test 'deletes an attribute' do
+      doc = document_from_string(":frog: Tanglefoot\n:frog!:")
+      assert_equal nil, doc.attributes['frog']
+    end
 
-  test "doesn't choke when deleting a non-existing attribute" do
-    doc = document_from_string(":frog!:")
-    assert_equal nil, doc.attributes['frog']
-  end
+    test "doesn't choke when deleting a non-existing attribute" do
+      doc = document_from_string(':frog!:')
+      assert_equal nil, doc.attributes['frog']
+    end
 
-  test "render properly with simple names" do
-    html = render_string(":frog: Tanglefoot\nYo, {frog}!")
-    result = Nokogiri::HTML(html)
-    assert_equal 'Yo, Tanglefoot!', result.css("p").first.content.strip
-  end
+    test "replaces special characters in attribute value" do
+      doc = document_from_string(":xml-busters: <>&")
+      assert_equal '&lt;&gt;&amp;', doc.attributes['xml-busters']
+    end
 
-  test "convert multi-word names and render" do
-    html = render_string("Main Header\n===========\n:My frog: Tanglefoot\nYo, {myfrog}!")
-    result = Nokogiri::HTML(html)
-    assert_equal 'Yo, Tanglefoot!', result.css("p").first.content.strip
-  end
+    test "performs attribute substitution on attribute value" do
+      doc = document_from_string(":version: 1.0\n:release: Asciidoctor {version}")
+      assert_equal 'Asciidoctor 1.0', doc.attributes['release']
+    end
 
-  test "ignores lines with bad attributes" do
-    html = render_string("This is\nblah blah {foobarbaz}\nall there is.")
-    result = Nokogiri::HTML(html)
-    assert_no_match /blah blah/m, result.css("p").first.content.strip
-  end
+    test "assigns attribute to empty string if substitution fails to resolve attribute" do
+      doc = document_from_string(":release: Asciidoctor {version}")
+      assert_equal '', doc.attributes['release']
+    end
 
-  # See above - AsciiDoc says we're supposed to delete lines with bad
-  # attribute refs in them. AsciiDoc is strange.
-  #
-  # test "Unknowns" do
-  #   html = render_string("Look, a {gobbledygook}")
-  #   result = Nokogiri::HTML(html)
-  #   assert_equal("Look, a {gobbledygook}", result.css("p").first.content.strip)
-  # end
-
-  test "substitutes inside unordered list items" do
-    html = render_string(":foo: bar\n* snort at the {foo}\n* yawn")
-    result = Nokogiri::HTML(html)
-    assert_match /snort at the bar/, result.css("li").first.content.strip
-  end
+    test "assigns multi-line attribute to empty string if substitution fails to resolve attribute" do
+      doc = document_from_string(":release: Asciidoctor +\n          {version}")
+      assert_equal '', doc.attributes['release']
+    end
 
-  test "renders attribute until it's deleted" do
-    pending "Not working yet (will require adding element-specific attributes or early attr substitution during parsing)"
-    # html = render_string(":foo: bar\nCrossing the {foo}\n\n:foo!:\nBelly up to the {foo}")
-    # result = Nokogiri::HTML(html)
-    # assert_match /Crossing the bar/, result.css("p").first.content.strip
-    # assert_no_match /Belly up to the bar/, result.css("p").last.content.strip
-  end
+    test "apply custom substitutions to text in passthrough macro and assign to attribute" do
+      doc = document_from_string(":xml-busters: pass:[<>&]")
+      assert_equal '<>&', doc.attributes['xml-busters']
+      doc = document_from_string(":xml-busters: pass:none[<>&]")
+      assert_equal '<>&', doc.attributes['xml-busters']
+      doc = document_from_string(":xml-busters: pass:specialcharacters[<>&]")
+      assert_equal '&lt;&gt;&amp;', doc.attributes['xml-busters']
+    end
 
-  test "doesn't disturb attribute-looking things escaped with backslash" do
-    html = render_string(":foo: bar\nThis is a \\{foo} day.")
-    result = Nokogiri::HTML(html)
-    assert_equal 'This is a {foo} day.', result.css('p').first.content.strip
-  end
+    test "attribute is treated as defined until it's not" do
+      input = <<-EOS
+:holygrail:
+ifdef::holygrail[]
+The holy grail has been found!
+endif::holygrail[]
+
+:holygrail!:
+ifndef::holygrail[]
+Buggers! What happened to the grail?
+endif::holygrail[]
+      EOS
+      output = render_string input
+      assert_xpath '//p', output, 2
+      assert_xpath '(//p)[1][text() = "The holy grail has been found!"]', output, 1
+      assert_xpath '(//p)[2][text() = "Buggers! What happened to the grail?"]', output, 1
+    end
+
+    # Validates requirement: "Header attributes are overridden by command-line attributes."
+    test 'attribute defined in document options overrides attribute in document' do
+      doc = document_from_string(':cash: money', :attributes => {'cash' => 'heroes'})
+      assert_equal 'heroes', doc.attributes['cash']
+    end
+
+    test 'attribute defined in document options cannot be unassigned in document' do
+      doc = document_from_string(':cash!:', :attributes => {'cash' => 'heroes'})
+      assert_equal 'heroes', doc.attributes['cash']
+    end
+
+    test 'attribute undefined in document options cannot be assigned in document' do
+      doc = document_from_string(':cash: money', :attributes => {'cash!' => 1 })
+      assert_equal nil, doc.attributes['cash']
+      doc = document_from_string(':cash: money', :attributes => {'cash' => nil })
+      assert_equal nil, doc.attributes['cash']
+    end
+
+    test 'backend attributes are updated if backend attribute is defined in document' do
+      doc = document_from_string(':backend: docbook45')
+      assert_equal 'docbook45', doc.attributes['backend']
+      assert doc.attributes.has_key? 'backend-docbook45'
+      assert_equal 'docbook', doc.attributes['basebackend']
+      assert doc.attributes.has_key? 'basebackend-docbook'
+    end
+
+    test 'backend attributes defined in document options overrides backend attribute in document' do
+      doc = document_from_string(':backend: docbook45', :attributes => {'backend' => 'html5'})
+      assert_equal 'html5', doc.attributes['backend']
+      assert doc.attributes.has_key? 'backend-html5'
+      assert_equal 'html', doc.attributes['basebackend']
+      assert doc.attributes.has_key? 'basebackend-html'
+    end
 
-  test "doesn't disturb attribute-looking things escaped with literals" do
-    html = render_string(":foo: bar\nThis is a +++{foo}+++ day.")
-    result = Nokogiri::HTML(html)
-    #assert_equal 'This is a {foo} day.', result.css('p').first.content.strip
-    pending "Don't yet have inline passthrough working"
   end
 
-  test "doesn't substitute attributes inside code blocks" do
-    pending "whut?"
+  context 'Interpolation' do
+
+    test "render properly with simple names" do
+      html = render_string(":frog: Tanglefoot\n:my_super-hero: Spiderman\n\nYo, {frog}!\nBeat {my_super-hero}!")
+      result = Nokogiri::HTML(html)
+      assert_equal "Yo, Tanglefoot!\nBeat Spiderman!", result.css("p").first.content.strip
+    end
+
+    test "render properly with single character name" do
+      html = render_string(":r: Ruby\n\nR is for {r}!")
+      result = Nokogiri::HTML(html)
+      assert_equal 'R is for Ruby!', result.css("p").first.content.strip
+    end
+
+    test "convert multi-word names and render" do
+      html = render_string("Main Header\n===========\n:My frog: Tanglefoot\n\nYo, {myfrog}!")
+      result = Nokogiri::HTML(html)
+      assert_equal 'Yo, Tanglefoot!', result.css("p").first.content.strip
+    end
+
+    test "ignores lines with bad attributes" do
+      html = render_string("This is\nblah blah {foobarbaz}\nall there is.")
+      result = Nokogiri::HTML(html)
+      assert_no_match(/blah blah/m, result.css("p").first.content.strip)
+    end
+
+    test "attribute value gets interpretted when rendering" do
+      doc = document_from_string(":google: http://google.com[Google]\n\n{google}")
+      assert_equal 'http://google.com[Google]', doc.attributes['google']
+      output = doc.render
+      assert_xpath '//a[@href="http://google.com"][text() = "Google"]', output, 1
+    end
+
+    # See above - AsciiDoc says we're supposed to delete lines with bad
+    # attribute refs in them. AsciiDoc is strange.
+    #
+    # test "Unknowns" do
+    #   html = render_string("Look, a {gobbledygook}")
+    #   result = Nokogiri::HTML(html)
+    #   assert_equal("Look, a {gobbledygook}", result.css("p").first.content.strip)
+    # end
+
+    test "substitutes inside unordered list items" do
+      html = render_string(":foo: bar\n* snort at the {foo}\n* yawn")
+      result = Nokogiri::HTML(html)
+      assert_match(/snort at the bar/, result.css("li").first.content.strip)
+    end
+
+    test 'substitutes inside section title' do
+      output = render_string(":prefix: Cool\n\n== {prefix} Title\n\ncontent")
+      result = Nokogiri::HTML(output)
+      assert_match(/Cool Title/, result.css('h2').first.content)
+      assert_match(/_cool_title/, result.css('h2').first.attr('id'))
+    end
+
+    test 'substitutes inside block title' do
+      input = <<-EOS
+:gem_name: asciidoctor
+
+.Require the +{gem_name}+ gem
+To use {gem_name}, the first thing to do is to import it in your Ruby source file.
+      EOS
+      output = render_embedded_string input
+      assert_xpath '//*[@class="title"]/tt[text()="asciidoctor"]', output, 1
+    end
+
+    test 'renders attribute until it is deleted' do
+      pending 'This requires that we consume attributes as the document is being lexed, not up front'
+      #output = render_string(":foo: bar\n\nCrossing the {foo}\n\n:foo!:\nBelly up to the {foo}")
+      # result = Nokogiri::HTML(html)
+      # assert_match /Crossing the bar/, result.css("p").first.content.strip
+      # assert_no_match /Belly up to the bar/, result.css("p").last.content.strip
+    end
+
+    test 'does not disturb attribute-looking things escaped with backslash' do
+      html = render_string(":foo: bar\nThis is a \\{foo} day.")
+      result = Nokogiri::HTML(html)
+      assert_equal 'This is a {foo} day.', result.css('p').first.content.strip
+    end
+
+    test 'does not disturb attribute-looking things escaped with literals' do
+      html = render_string(":foo: bar\nThis is a +++{foo}+++ day.")
+      result = Nokogiri::HTML(html)
+      assert_equal 'This is a {foo} day.', result.css('p').first.content.strip
+    end
+
+    test 'does not substitute attributes inside listing blocks' do
+      input = <<-EOS
+:forecast: snow 
+
+----
+puts 'The forecast for today is {forecast}'
+----
+      EOS
+      output = render_string(input)
+      assert_match(/\{forecast\}/, output)
+    end
+
+    test 'does not substitute attributes inside literal blocks' do
+       input = <<-EOS
+:foo: bar
+
+....
+You insert the text {foo} to expand the value
+of the attribute named foo in your document.
+....
+       EOS
+      output = render_string(input)
+      assert_match(/\{foo\}/, output)
+    end
   end
 
-  test "doesn't substitute attributes inside literal blocks" do
-    pending "whut?"
+  context "Intrinsic attributes" do
+
+    test "substitute intrinsics" do
+      Asciidoctor::INTRINSICS.each_pair do |key, value|
+        html = render_string("Look, a {#{key}} is here")
+        # can't use Nokogiri because it interprets the HTML entities and we can't match them
+        assert_match(/Look, a #{Regexp.escape(value)} is here/, html)
+      end
+    end
+
+    test "don't escape intrinsic substitutions" do
+      html = render_string('happy{nbsp}together')
+      assert_match(/happy&#160;together/, html)
+    end
+
+    test "escape special characters" do
+      html = render_string('<node>&</node>')
+      assert_match(/&lt;node&gt;&amp;&lt;\/node&gt;/, html)
+    end
+    
   end
 
   context "Block attributes" do
@@ -97,13 +253,40 @@ A famous quote.
 ____
       EOS
       doc = document_from_string(input)
-      qb = doc.elements.first
+      qb = doc.blocks.first
       assert_equal 'quote', qb.attributes['style']
       assert_equal 'quote', qb.attr(:style)
       assert_equal 'Name', qb.attributes['attribution']
       assert_equal 'Source', qb.attributes['citetitle']
     end
 
+    test "Normal substitutions are performed on single-quoted attributes" do
+      input = <<-EOS
+[quote, Name, 'http://wikipedia.org[Source]']
+____
+A famous quote.
+____
+      EOS
+      doc = document_from_string(input)
+      qb = doc.blocks.first
+      assert_equal 'quote', qb.attributes['style']
+      assert_equal 'quote', qb.attr(:style)
+      assert_equal 'Name', qb.attributes['attribution']
+      assert_equal '<a href="http://wikipedia.org">Source</a>', qb.attributes['citetitle']
+    end
+
+    test "Attribute substitutions are performed on attribute list before parsing attributes" do
+      input = <<-EOS
+:lead: role="lead"
+
+[{lead}]
+A paragraph
+      EOS
+      doc = document_from_string(input)
+      para = doc.blocks.first
+      assert_equal 'lead', para.attributes['role']
+    end
+
     test "Block attributes are additive" do
       input = <<-EOS
 [id='foo']
@@ -111,32 +294,63 @@ ____
 A paragraph.
       EOS
       doc = document_from_string(input)
-      para = doc.elements.first
+      para = doc.blocks.first
       assert_equal 'foo', para.id
       assert_equal 'lead', para.attributes['role']
     end
-  end
 
-  context "intrinsics" do
+    test "Last wins for id attribute" do
+      input = <<-EOS
+[[bar]]
+[[foo]]
+== Section
 
-    test "substitute intrinsics" do
-      Asciidoctor::INTRINSICS.each_pair do |key, value|
-        html = render_string("Look, a {#{key}} is here")
-        # can't use Nokogiri because it interprets the HTML entities and we can't match them
-        assert_match /Look, a #{Regexp.escape(value)} is here/, html
-      end
-    end
+paragraph
 
-    test "don't escape intrinsic substitutions" do
-      html = render_string('happy{nbsp}together')
-      assert_match /happy&#160;together/, html
+[[baz]]
+[id='coolio']
+=== Section
+      EOS
+      doc = document_from_string(input)
+      sec = doc.first_section
+      assert_equal 'foo', sec.id
+      subsec = sec.blocks.last
+      assert_equal 'coolio', subsec.id
     end
 
-    test "escape special characters" do
-      html = render_string('<node>&</node>')
-      assert_match /&lt;node&gt;&amp;&lt;\/node&gt;/, html
+    test "trailing block attributes tranfer to the following section" do
+      input = <<-EOS
+[[one]]
+
+== Section One
+
+paragraph
+
+[[sub]]
+// try to mess this up!
+
+=== Sub-section
+
+paragraph
+
+[role='classy']
+
+////
+block comment
+////
+
+== Section Two
+
+content
+      EOS
+      doc = document_from_string(input)
+      section_one = doc.blocks.first
+      assert_equal 'one', section_one.id
+      subsection = section_one.blocks.last
+      assert_equal 'sub', subsection.id
+      section_two = doc.blocks.last
+      assert_equal 'classy', section_two.attr(:role)
     end
-    
   end
 
 end

data/test/blocks_test.rb

@@ -0,0 +1,568 @@
+require 'test_helper'
+
+context "Blocks" do
+  context "Rulers" do
+    test "ruler" do
+      output = render_string("'''")
+      assert_xpath '//*[@id="content"]/hr', output, 1
+      assert_xpath '//*[@id="content"]/*', output, 1
+    end
+
+    test "ruler between blocks" do
+      output = render_string("Block above\n\n'''\n\nBlock below")
+      assert_xpath '//*[@id="content"]/hr', output, 1
+      assert_xpath '//*[@id="content"]/hr/preceding-sibling::*', output, 1
+      assert_xpath '//*[@id="content"]/hr/following-sibling::*', output, 1
+    end
+  end
+
+  context 'Comments' do
+    test 'line comment between paragraphs offset by blank lines' do
+      input = <<-EOS
+first paragraph
+
+// line comment
+
+second paragraph
+      EOS
+      output = render_embedded_string input
+      assert_no_match(/line comment/, output)
+      assert_xpath '//p', output, 2
+    end
+
+    test 'adjacent line comment between paragraphs' do
+      input = <<-EOS
+first line
+// line comment
+second line
+      EOS
+      output = render_embedded_string input
+      assert_no_match(/line comment/, output)
+      assert_xpath '//p', output, 1
+      assert_xpath "//p[1][text()='first line\nsecond line']", output, 1
+    end
+
+    test 'comment block between paragraphs offset by blank lines' do
+      input = <<-EOS
+first paragraph
+
+////
+block comment
+////
+
+second paragraph
+      EOS
+      output = render_embedded_string input
+      assert_no_match(/block comment/, output)
+      assert_xpath '//p', output, 2
+    end
+
+    test 'adjacent comment block between paragraphs' do
+      input = <<-EOS
+first paragraph
+////
+block comment
+////
+second paragraph
+      EOS
+      output = render_embedded_string input
+      assert_no_match(/block comment/, output)
+      assert_xpath '//p', output, 2
+    end
+
+    test "can render with block comment at end of document with trailing endlines" do
+      input = <<-EOS
+paragraph
+
+////
+block comment
+////
+
+
+      EOS
+      output = render_embedded_string input
+      assert_no_match(/block comment/, output)
+    end
+
+    test "trailing endlines after block comment at end of document does not create paragraph" do
+      input = <<-EOS
+paragraph
+
+////
+block comment
+////
+
+
+      EOS
+      d = document_from_string input
+      assert_equal 1, d.blocks.size
+      assert_xpath '//p', d.render, 1
+    end
+  end
+
+  context "Example Blocks" do
+    test "can render example block" do
+      input = <<-EOS
+====
+This is an example of an example block.
+
+How crazy is that?
+====
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="exampleblock"]//p', output, 2
+    end
+  end
+
+  context "Preformatted Blocks" do
+    test 'should separate adjacent paragraphs and listing into blocks' do
+      input = <<-EOS
+paragraph 1
+----
+listing content
+----
+paragraph 2
+      EOS
+      
+      output = render_embedded_string input
+      assert_xpath '/*[@class="paragraph"]/p', output, 2
+      assert_xpath '/*[@class="listingblock"]', output, 1
+      assert_xpath '(/*[@class="paragraph"]/following-sibling::*)[1][@class="listingblock"]', output, 1
+    end
+
+    test "should preserve endlines in literal block" do
+      input = <<-EOS
+....
+line one
+
+line two
+
+line three
+....
+EOS
+      [true, false].each {|compact|
+        output = render_string input, :compact => compact
+        assert_xpath '//pre', output, 1
+        assert_xpath '//pre/text()', output, 1
+        text = xmlnodes_at_xpath('//pre/text()', output, 1).text
+        lines = text.lines.entries
+        assert_equal 5, lines.size
+        expected = "line one\n\nline two\n\nline three".lines.entries
+        assert_equal expected, lines
+        blank_lines = output.scan(/\n[[:blank:]]*\n/).size
+        if compact
+          assert_equal 2, blank_lines
+        else
+          assert blank_lines > 2
+        end
+      }
+    end
+
+    test "should preserve endlines in listing block" do
+      input = <<-EOS
+[source]
+----
+line one
+
+line two
+
+line three
+----
+EOS
+      [true, false].each {|compact|
+        output = render_string input, :compact => compact
+        assert_xpath '//pre/code', output, 1
+        assert_xpath '//pre/code/text()', output, 1
+        text = xmlnodes_at_xpath('//pre/code/text()', output, 1).text
+        lines = text.lines.entries
+        assert_equal 5, lines.size
+        expected = "line one\n\nline two\n\nline three".lines.entries
+        assert_equal expected, lines
+        blank_lines = output.scan(/\n[[:blank:]]*\n/).size
+        if compact
+          assert_equal 2, blank_lines
+        else
+          assert blank_lines > 2
+        end
+      }
+    end
+
+    test "should preserve endlines in verse block" do
+      input = <<-EOS
+[verse]
+____
+line one
+
+line two
+
+line three
+____
+EOS
+      [true, false].each {|compact|
+        output = render_string input, :compact => compact
+        assert_xpath '//*[@class="verseblock"]/pre', output, 1
+        assert_xpath '//*[@class="verseblock"]/pre/text()', output, 1
+        text = xmlnodes_at_xpath('//*[@class="verseblock"]/pre/text()', output, 1).text
+        lines = text.lines.entries
+        assert_equal 5, lines.size
+        expected = "line one\n\nline two\n\nline three".lines.entries
+        assert_equal expected, lines
+        blank_lines = output.scan(/\n[[:blank:]]*\n/).size
+        if compact
+          assert_equal 2, blank_lines
+        else
+          assert blank_lines > 2
+        end
+      }
+    end
+  end
+
+  context "Open Blocks" do
+    test "can render open block" do
+      input = <<-EOS
+--
+This is an open block.
+
+It can span multiple lines.
+--
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="openblock"]//p', output, 2
+    end
+
+    test "open block can contain another block" do
+      input = <<-EOS
+--
+This is an open block.
+
+It can span multiple lines.
+
+____
+It can hold great quotes like this one.
+____
+--
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="openblock"]//p', output, 3
+      assert_xpath '//*[@class="openblock"]//*[@class="quoteblock"]', output, 1
+    end
+  end
+
+  context 'Passthrough Blocks' do
+    test 'can parse a passthrough block' do
+      input = <<-EOS
+++++
+This is a passthrough block.
+++++
+      EOS
+
+      block = block_from_string input
+      assert !block.nil?
+      assert_equal 1, block.buffer.size
+      assert_equal 'This is a passthrough block.', block.buffer.first
+    end
+
+    test 'performs passthrough subs on a passthrough block' do
+      input = <<-EOS
+:type: passthrough
+
+++++
+This is a '{type}' block.
+http://asciidoc.org
+++++
+      EOS
+
+      expected = %(This is a 'passthrough' block.\n<a href="http://asciidoc.org">http://asciidoc.org</a>)
+      output = render_embedded_string input
+      assert_equal expected, output.strip
+    end
+
+    test 'passthrough block honors explicit subs list' do
+      input = <<-EOS
+:type: passthrough
+
+[subs="attributes, quotes"]
+++++
+This is a '{type}' block.
+http://asciidoc.org
+++++
+      EOS
+
+      expected = %(This is a <em>passthrough</em> block.\nhttp://asciidoc.org)
+      output = render_embedded_string input
+      assert_equal expected, output.strip
+    end
+  end
+
+  context 'Metadata' do
+    test 'block title above section gets carried over to first block in section' do
+      input = <<-EOS
+.Title
+== Section
+
+paragraph
+      EOS
+      output = render_string input
+      assert_xpath '//*[@class="paragraph"]', output, 1
+      assert_xpath '//*[@class="paragraph"]/*[@class="title"][text() = "Title"]', output, 1
+      assert_xpath '//*[@class="paragraph"]/p[text() = "paragraph"]', output, 1
+    end
+  end
+
+  context "Images" do
+    test "can render block image with alt text" do
+      input = <<-EOS
+image::images/tiger.png[Tiger]
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="imageblock"]//img[@src="images/tiger.png"][@alt="Tiger"]', output, 1
+    end
+
+    test "can render block image with auto-generated alt text" do
+      input = <<-EOS
+image::images/tiger.png[]
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="imageblock"]//img[@src="images/tiger.png"][@alt="tiger"]', output, 1
+    end
+
+    test "can render block image with alt text and height and width" do
+      input = <<-EOS
+image::images/tiger.png[Tiger, 200, 300]
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="imageblock"]//img[@src="images/tiger.png"][@alt="Tiger"][@width="200"][@height="300"]', output, 1
+    end
+
+    test "can render block image with link" do
+      input = <<-EOS
+image::images/tiger.png[Tiger, link='http://en.wikipedia.org/wiki/Tiger']
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="imageblock"]//a[@class="image"][@href="http://en.wikipedia.org/wiki/Tiger"]/img[@src="images/tiger.png"][@alt="Tiger"]', output, 1
+    end
+
+    test "can render block image with caption" do
+      input = <<-EOS
+.The AsciiDoc Tiger
+image::images/tiger.png[Tiger]
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="imageblock"]//img[@src="images/tiger.png"][@alt="Tiger"]', output, 1
+      assert_xpath '//*[@class="imageblock"]/*[@class="title"][text() = "The AsciiDoc Tiger"]', output, 1
+    end
+
+    test 'can resolve image relative to imagesdir' do
+      input = <<-EOS
+:imagesdir: images
+
+image::tiger.png[Tiger]
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="imageblock"]//img[@src="images/tiger.png"][@alt="Tiger"]', output, 1
+    end
+
+    test 'embeds base64-encoded data uri for image when data-uri attribute is set' do
+      input = <<-EOS
+:data-uri:
+:imagesdir: fixtures
+
+image::dot.gif[Dot]
+      EOS
+
+      doc = document_from_string input, :safe => Asciidoctor::SafeMode::SAFE, :attributes => {'docdir' => File.dirname(__FILE__)}
+      assert_equal 'fixtures', doc.attributes['imagesdir']
+      output = doc.render
+      assert_xpath '//*[@class="imageblock"]//img[@src="data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="][@alt="Dot"]', output, 1
+    end
+
+    # this test will cause a warning to be printed to the console (until we have a message facility)
+    test 'cleans reference to ancestor directories before reading image if safe mode level is at least SAFE' do
+      input = <<-EOS
+:data-uri:
+:imagesdir: ../fixtures
+
+image::dot.gif[Dot]
+      EOS
+
+      doc = document_from_string input, :safe => Asciidoctor::SafeMode::SAFE, :attributes => {'docdir' => File.dirname(__FILE__)}
+      assert_equal '../fixtures', doc.attributes['imagesdir']
+      output = doc.render
+      assert_xpath '//*[@class="imageblock"]//img[@src="data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="][@alt="Dot"]', output, 1
+    end
+  end
+
+  context 'Admonition icons' do
+    test 'can resolve icon relative to default iconsdir' do
+      input = <<-EOS
+:icons:
+
+[TIP]
+You can use icons for admonitions by setting the 'icons' attribute.
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="admonitionblock"]//*[@class="icon"]/img[@src="images/icons/tip.png"][@alt="Tip"]', output, 1
+    end
+
+    test 'can resolve icon relative to custom iconsdir' do
+      input = <<-EOS
+:icons:
+:iconsdir: icons
+
+[TIP]
+You can use icons for admonitions by setting the 'icons' attribute.
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="admonitionblock"]//*[@class="icon"]/img[@src="icons/tip.png"][@alt="Tip"]', output, 1
+    end
+
+    test 'embeds base64-encoded data uri of icon when data-uri attribute is set and safe mode level is less than SECURE' do
+      input = <<-EOS
+:icons:
+:iconsdir: fixtures
+:iconstype: gif
+:data-uri:
+
+[TIP]
+You can use icons for admonitions by setting the 'icons' attribute.
+      EOS
+
+      output = render_string input, :safe => Asciidoctor::SafeMode::SAFE, :attributes => {'docdir' => File.dirname(__FILE__)}
+      assert_xpath '//*[@class="admonitionblock"]//*[@class="icon"]/img[@src="data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="][@alt="Tip"]', output, 1
+    end
+
+    test 'does not embed base64-encoded data uri of icon when safe mode level is at least SECURE' do
+      input = <<-EOS
+:icons:
+:iconsdir: fixtures
+:iconstype: gif
+:data-uri:
+
+[TIP]
+You can use icons for admonitions by setting the 'icons' attribute.
+      EOS
+
+      output = render_string input
+      assert_xpath '//*[@class="admonitionblock"]//*[@class="icon"]/img[@src="fixtures/tip.gif"][@alt="Tip"]', output, 1
+    end
+
+    test 'cleans reference to ancestor directories before reading icon if safe mode level is at least SAFE' do
+      input = <<-EOS
+:icons:
+:iconsdir: ../fixtures
+:iconstype: gif
+:data-uri:
+
+[TIP]
+You can use icons for admonitions by setting the 'icons' attribute.
+      EOS
+
+      output = render_string input, :safe => Asciidoctor::SafeMode::SAFE, :attributes => {'docdir' => File.dirname(__FILE__)}
+      assert_xpath '//*[@class="admonitionblock"]//*[@class="icon"]/img[@src="data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="][@alt="Tip"]', output, 1
+    end
+  end
+
+  context 'Image paths' do
+
+    test 'restricts access to ancestor directories when safe mode level is at least SAFE' do
+      input = <<-EOS
+image::asciidoctor.png[Asciidoctor]
+      EOS
+      basedir = File.dirname(__FILE__)
+      block = block_from_string input, :attributes => {'docdir' => basedir}
+      doc = block.document
+      assert doc.safe >= Asciidoctor::SafeMode::SAFE
+
+      assert_equal File.join(basedir, 'images'), block.normalize_asset_path('images')
+      assert_equal File.join(basedir, 'etc/images'), block.normalize_asset_path('/etc/images')
+      assert_equal File.join(basedir, 'images'), block.normalize_asset_path('../../images')
+    end
+
+    test 'does not restrict access to ancestor directories when safe mode is disabled' do
+      input = <<-EOS
+image::asciidoctor.png[Asciidoctor]
+      EOS
+      basedir = File.dirname(__FILE__)
+      block = block_from_string input, :safe => Asciidoctor::SafeMode::UNSAFE, :attributes => {'docdir' => basedir}
+      doc = block.document
+      assert doc.safe == Asciidoctor::SafeMode::UNSAFE
+
+      assert_equal File.join(basedir, 'images'), block.normalize_asset_path('images')
+      assert_equal '/etc/images', block.normalize_asset_path('/etc/images')
+      assert_equal File.expand_path(File.join(basedir, '../../images')), block.normalize_asset_path('../../images')
+    end
+
+  end
+
+  context 'Source code' do
+    test 'should highlight source if source-highlighter attribute is coderay' do
+      input = <<-EOS
+:source-highlighter: coderay
+
+[source, ruby]
+----
+require 'coderay'
+
+html = CodeRay.scan("puts 'Hello, world!'", :ruby).div(:line_numbers => :table)
+----
+      EOS
+      output = render_string input, :safe => Asciidoctor::SafeMode::SAFE
+      assert_xpath '//pre[@class="highlight CodeRay"]/code[@class="ruby"]//span[@class = "constant"][text() = "CodeRay"]', output, 1
+      assert_match(/\.CodeRay \{/, output)
+    end
+
+    test 'should highlight source inline if source-highlighter attribute is coderay and coderay-css is style' do
+      input = <<-EOS
+:source-highlighter: coderay
+:coderay-css: style
+
+[source, ruby]
+----
+require 'coderay'
+
+html = CodeRay.scan("puts 'Hello, world!'", :ruby).div(:line_numbers => :table)
+----
+      EOS
+      output = render_string input, :safe => Asciidoctor::SafeMode::SAFE
+      assert_xpath '//pre[@class="highlight CodeRay"]/code[@class="ruby"]//span[@style = "color:#036;font-weight:bold"][text() = "CodeRay"]', output, 1
+      assert_no_match(/\.CodeRay \{/, output)
+    end
+
+    test 'should include remote highlight.js assets if source-highlighter attribute is highlightjs' do
+      input = <<-EOS
+:source-highlighter: highlightjs
+
+[source, javascript]
+----
+<link rel="stylesheet" href="styles/default.css">
+<script src="highlight.pack.js"></script>
+<script>hljs.initHighlightingOnLoad();</script>
+----
+      EOS
+      output = render_string input, :safe => Asciidoctor::SafeMode::SAFE
+      assert_match(/<link .*highlight\.js/, output)
+      assert_match(/<script .*highlight\.js/, output)
+      assert_match(/hljs.initHighlightingOnLoad/, output)
+    end
+
+    test 'document cannot turn on source highlighting if safe mode is at least SECURE' do
+      input = <<-EOS
+:source-highlighter: coderay
+      EOS
+      doc = document_from_string input
+      assert doc.attributes['source-highlighter'].nil?
+    end
+  end
+
+end