asciidoctor 1.5.5 → 1.5.6

data/test/substitutions_test.rb

@@ -8,18 +8,39 @@ end
 # - test negatives
 # - test role on every quote type
 context 'Substitutions' do
+  BACKSLASH = %(\x5c)
   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.lines)
+      result = para.apply_subs(para.source)
       assert_equal %{<em class="blue"><a href="http://asciidoc.org">AsciiDoc</a></em> &amp; <strong class="red">Ruby</strong>\n&#167; Making <u>documentation</u> together<br>\nsince &#169; 2012.}, result
     end
+
+    test 'should not drop trailing blank lines when performing substitutions' do
+      para = block_from_string %([%hardbreaks]\nthis\nis\n-> {program})
+      para.lines << ''
+      para.lines << ''
+      para.document.attributes['program'] = 'Asciidoctor'
+      result = para.apply_subs(para.lines)
+      assert_equal ['this<br>', 'is<br>', '&#8594; Asciidoctor<br>', '<br>', ''], result
+      result = para.apply_subs(para.lines * "\n")
+      assert_equal %(this<br>\nis<br>\n&#8594; Asciidoctor<br>\n<br>\n), result
+    end
+
+    test 'should expand subs passed to apply_subs when expand argument is set' do
+      para = block_from_string %({program}\n*bold*\n2 > 1)
+      para.document.attributes['program'] = 'Asciidoctor'
+      result = para.apply_subs para.lines, [:specialchars], true
+      assert_equal ['{program}', '*bold*', '2 &gt; 1'], result
+      result = para.apply_subs para.lines, [:none], true
+      assert_equal ['{program}', '*bold*', '2 > 1'], result
+      result = para.apply_subs para.lines, [:normal], true
+      assert_equal ['Asciidoctor', '<strong>bold</strong>', '2 &gt; 1'], result
+    end
   end
 
   context 'Quotes' do
-    BACKSLASH = '\\'
-
     test 'single-line double-quoted string' do
       para = block_from_string(%q{``a few quoted words''}, :attributes => {'compat-mode' => ''})
       assert_equal '&#8220;a few quoted words&#8221;', para.sub_quotes(para.source)
@@ -222,10 +243,10 @@ context 'Substitutions' do
 
     test 'escaped single-quotes inside emphasized words are restored' do
       para = block_from_string(%('Here#{BACKSLASH}'s Johnny!'), :attributes => {'compat-mode' => ''})
-      assert_equal %q(<em>Here's Johnny!</em>), para.apply_normal_subs(para.lines)
+      assert_equal %q(<em>Here's Johnny!</em>), para.apply_subs(para.source)
 
       para = block_from_string(%('Here#{BACKSLASH}'s Johnny!'))
-      assert_equal %q('Here's Johnny!'), para.apply_normal_subs(para.lines)
+      assert_equal %q('Here's Johnny!'), para.apply_subs(para.source)
     end
 
     test 'single-line constrained emphasized underline variation string' do
@@ -243,67 +264,67 @@ context 'Substitutions' do
       assert_equal "<em>a few\nemphasized words</em>", para.sub_quotes(para.source)
     end
 
-    # NOTE must use apply_normal_subs because constrained monospaced is handled as a passthrough
+    # NOTE must use apply_subs because constrained monospaced is handled as a passthrough
     test 'single-line constrained monospaced string' do
       para = block_from_string(%(`a few <{monospaced}> words`), :attributes => {'monospaced' => 'monospaced', 'compat-mode' => ''})
-      assert_equal '<code>a few &lt;{monospaced}&gt; words</code>', para.apply_normal_subs(para.lines)
+      assert_equal '<code>a few &lt;{monospaced}&gt; words</code>', para.apply_subs(para.source)
 
       para = block_from_string(%(`a few <{monospaced}> words`), :attributes => {'monospaced' => 'monospaced'})
-      assert_equal '<code>a few &lt;monospaced&gt; words</code>', para.apply_normal_subs(para.lines)
+      assert_equal '<code>a few &lt;monospaced&gt; words</code>', para.apply_subs(para.source)
     end
 
-    # NOTE must use apply_normal_subs because constrained monospaced is handled as a passthrough
+    # NOTE must use apply_subs because constrained monospaced is handled as a passthrough
     test 'single-line constrained monospaced string with role' do
       para = block_from_string(%([input]`a few <{monospaced}> words`), :attributes => {'monospaced' => 'monospaced', 'compat-mode' => ''})
-      assert_equal '<code class="input">a few &lt;{monospaced}&gt; words</code>', para.apply_normal_subs(para.lines)
+      assert_equal '<code class="input">a few &lt;{monospaced}&gt; words</code>', para.apply_subs(para.source)
 
       para = block_from_string(%([input]`a few <{monospaced}> words`), :attributes => {'monospaced' => 'monospaced'})
-      assert_equal '<code class="input">a few &lt;monospaced&gt; words</code>', para.apply_normal_subs(para.lines)
+      assert_equal '<code class="input">a few &lt;monospaced&gt; words</code>', para.apply_subs(para.source)
     end
 
-    # NOTE must use apply_normal_subs because constrained monospaced is handled as a passthrough
+    # NOTE must use apply_subs because constrained monospaced is handled as a passthrough
     test 'escaped single-line constrained monospaced string' do
       para = block_from_string(%(#{BACKSLASH}`a few <monospaced> words`), :attributes => {'compat-mode' => ''})
-      assert_equal '`a few &lt;monospaced&gt; words`', para.apply_normal_subs(para.lines)
+      assert_equal '`a few &lt;monospaced&gt; words`', para.apply_subs(para.source)
 
       para = block_from_string(%(#{BACKSLASH}`a few <monospaced> words`))
-      assert_equal '`a few &lt;monospaced&gt; words`', para.apply_normal_subs(para.lines)
+      assert_equal '`a few &lt;monospaced&gt; words`', para.apply_subs(para.source)
     end
 
-    # NOTE must use apply_normal_subs because constrained monospaced is handled as a passthrough
+    # NOTE must use apply_subs because constrained monospaced is handled as a passthrough
     test 'escaped single-line constrained monospaced string with role' do
       para = block_from_string(%([input]#{BACKSLASH}`a few <monospaced> words`), :attributes => {'compat-mode' => ''})
-      assert_equal '[input]`a few &lt;monospaced&gt; words`', para.apply_normal_subs(para.lines)
+      assert_equal '[input]`a few &lt;monospaced&gt; words`', para.apply_subs(para.source)
 
       para = block_from_string(%([input]#{BACKSLASH}`a few <monospaced> words`))
-      assert_equal '[input]`a few &lt;monospaced&gt; words`', para.apply_normal_subs(para.lines)
+      assert_equal '[input]`a few &lt;monospaced&gt; words`', para.apply_subs(para.source)
     end
 
-    # NOTE must use apply_normal_subs because constrained monospaced is handled as a passthrough
+    # NOTE must use apply_subs because constrained monospaced is handled as a passthrough
     test 'escaped role on single-line constrained monospaced string' do
       para = block_from_string(%(#{BACKSLASH}[input]`a few <monospaced> words`), :attributes => {'compat-mode' => ''})
-      assert_equal '[input]<code>a few &lt;monospaced&gt; words</code>', para.apply_normal_subs(para.lines)
+      assert_equal '[input]<code>a few &lt;monospaced&gt; words</code>', para.apply_subs(para.source)
 
       para = block_from_string(%(#{BACKSLASH}[input]`a few <monospaced> words`))
-      assert_equal '[input]<code>a few &lt;monospaced&gt; words</code>', para.apply_normal_subs(para.lines)
+      assert_equal '[input]<code>a few &lt;monospaced&gt; words</code>', para.apply_subs(para.source)
     end
 
-    # NOTE must use apply_normal_subs because constrained monospaced is handled as a passthrough
+    # NOTE must use apply_subs because constrained monospaced is handled as a passthrough
     test 'escaped role on escaped single-line constrained monospaced string' do
       para = block_from_string(%(#{BACKSLASH}[input]#{BACKSLASH}`a few <monospaced> words`), :attributes => {'compat-mode' => ''})
-      assert_equal %(#{BACKSLASH}[input]`a few &lt;monospaced&gt; words`), para.apply_normal_subs(para.lines)
+      assert_equal %(#{BACKSLASH}[input]`a few &lt;monospaced&gt; words`), para.apply_subs(para.source)
 
       para = block_from_string(%(#{BACKSLASH}[input]#{BACKSLASH}`a few <monospaced> words`))
-      assert_equal %(#{BACKSLASH}[input]`a few &lt;monospaced&gt; words`), para.apply_normal_subs(para.lines)
+      assert_equal %(#{BACKSLASH}[input]`a few &lt;monospaced&gt; words`), para.apply_subs(para.source)
     end
 
-    # NOTE must use apply_normal_subs because constrained monospaced is handled as a passthrough
+    # NOTE must use apply_subs because constrained monospaced is handled as a passthrough
     test 'multi-line constrained monospaced string' do
       para = block_from_string(%(`a few\n<{monospaced}> words`), :attributes => {'monospaced' => 'monospaced', 'compat-mode' => ''})
-      assert_equal "<code>a few\n&lt;{monospaced}&gt; words</code>", para.apply_normal_subs(para.lines)
+      assert_equal "<code>a few\n&lt;{monospaced}&gt; words</code>", para.apply_subs(para.source)
 
       para = block_from_string(%(`a few\n<{monospaced}> words`), :attributes => {'monospaced' => 'monospaced'})
-      assert_equal "<code>a few\n&lt;monospaced&gt; words</code>", para.apply_normal_subs(para.lines)
+      assert_equal "<code>a few\n&lt;monospaced&gt; words</code>", para.apply_subs(para.source)
     end
 
     test 'single-line unconstrained strong chars' do
@@ -476,7 +497,7 @@ context 'Substitutions' do
 
     test 'does not confuse superscript and links with blank window shorthand' do
       para = block_from_string(%Q{http://localhost[Text^] on the 21^st^ and 22^nd^})
-      assert_equal '<a href="http://localhost" target="_blank">Text</a> on the 21<sup>st</sup> and 22<sup>nd</sup>', para.content
+      assert_equal '<a href="http://localhost" target="_blank" rel="noopener">Text</a> on the 21<sup>st</sup> and 22<sup>nd</sup>', para.content
     end
 
     test 'single-line subscript chars' do
@@ -579,7 +600,7 @@ context 'Substitutions' do
       para = block_from_string('doc.writer@asciidoc.org')
       assert_equal %q{<a href="mailto:doc.writer@asciidoc.org">doc.writer@asciidoc.org</a>}, para.sub_macros(para.source)
       para = block_from_string('<doc.writer@asciidoc.org>')
-      assert_equal %q{&lt;<a href="mailto:doc.writer@asciidoc.org">doc.writer@asciidoc.org</a>&gt;}, para.apply_normal_subs(para.lines)
+      assert_equal %q{&lt;<a href="mailto:doc.writer@asciidoc.org">doc.writer@asciidoc.org</a>&gt;}, para.apply_subs(para.source)
       para = block_from_string('author+website@4fs.no')
       assert_equal %q{<a href="mailto:author+website@4fs.no">author+website@4fs.no</a>}, para.sub_macros(para.source)
       para = block_from_string('john@domain.uk.co')
@@ -606,10 +627,21 @@ context 'Substitutions' do
       assert_equal %{<a href="http://google.com">Google\nHomepage</a>}, para.sub_macros(para.source)
     end
 
-    test 'a multi-line raw url with attribute as text should be interpreted as a link with resolved attribute' do
+    test 'a single-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.source)
+      assert_equal %q{<a href="http://google.com">Google Homepage</a>}, para.sub_macros(para.sub_attributes(para.source))
+    end
+
+    test 'should not resolve an escaped attribute in link text' do
+      {
+        'http://google.com' => "http://google.com[#{BACKSLASH}{google_homepage}]",
+        'http://google.com?q=,' => "link:http://google.com?q=,[#{BACKSLASH}{google_homepage}]"
+      }.each do |uri, macro|
+        para = block_from_string macro
+        para.document.attributes['google_homepage'] = 'Google Homepage'
+        assert_equal %(<a href="#{uri}">{google_homepage}</a>), para.sub_macros(para.sub_attributes(para.source))
+      end
     end
 
     test 'a single-line escaped raw url should not be interpreted as a link' do
@@ -637,6 +669,13 @@ context 'Substitutions' do
       assert_equal %{<span class="image"><img src="tiger.png" alt="Tiger"></span>}, para.sub_macros(para.source).gsub(/>\s+</, '><')
     end
 
+    test 'should encode special characters in alt text of inline image' do
+      input = 'A tiger\'s "roar" is < a bear\'s "growl"'
+      expected = 'A tiger&#8217;s &quot;roar&quot; is &lt; a bear&#8217;s &quot;growl&quot;'
+      output = (render_embedded_string %(image:tiger-roar.png[#{input}]), :doctype => :inline).gsub(/>\s+</, '><')
+      assert_equal %(<span class="image"><img src="tiger-roar.png" alt="#{expected}"></span>), output
+    end
+
     test 'an image macro with SVG image and text should be interpreted as an image with alt text' do
       para = block_from_string('image:tiger.svg[Tiger]')
       assert_equal %{<span class="image"><img src="tiger.svg" alt="Tiger"></span>}, para.sub_macros(para.source).gsub(/>\s+</, '><')
@@ -694,6 +733,18 @@ context 'Substitutions' do
           para.sub_macros(para.source).gsub(/>\s+</, '><')
     end
 
+    test 'rel=noopener should be added to an image with a link that targets the _blank window' do
+      para = block_from_string 'image:tiger.png[Tiger,link=http://en.wikipedia.org/wiki/Tiger,window=_blank]'
+      assert_equal %{<span class="image"><a class="image" href="http://en.wikipedia.org/wiki/Tiger" target="_blank" rel="noopener"><img src="tiger.png" alt="Tiger"></a></span>},
+          para.sub_macros(para.source).gsub(/>\s+</, '><')
+    end
+
+    test 'rel=noopener should be added to an image with a link that targets a named window when the noopener option is set' do
+      para = block_from_string 'image:tiger.png[Tiger,link=http://en.wikipedia.org/wiki/Tiger,window=name,opts=noopener]'
+      assert_equal %{<span class="image"><a class="image" href="http://en.wikipedia.org/wiki/Tiger" target="name" rel="noopener"><img src="tiger.png" alt="Tiger"></a></span>},
+          para.sub_macros(para.source).gsub(/>\s+</, '><')
+    end
+
     test 'a multi-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[Another\nAwesome\nTiger, 200,\n100]))
       assert_equal %{<span class="image"><img src="tiger.png" alt="Another Awesome Tiger" width="200" height="100"></span>},
@@ -730,7 +781,29 @@ context 'Substitutions' do
           para.sub_macros(para.source).gsub(/>\s+</, '><')
     end
 
-    test 'a block image macro should not be detected within paragraph text' do
+    test 'should match an inline image macro if target contains a space character' do
+      para = block_from_string(%(Beware of the image:big cats.png[] around here.))
+      assert_equal %(Beware of the <span class="image"><img src="big%20cats.png" alt="big cats"></span> around here.),
+          para.sub_macros(para.source).gsub(/>\s+</, '><')
+    end
+
+    test 'should not match an inline image macro if target contains an endline character' do
+      para = block_from_string(%(Fear not. There are no image:big\ncats.png[] around here.))
+      result = para.sub_macros(para.source)
+      assert !result.include?('<img ')
+      assert_includes result, %(image:big\ncats.png[])
+    end
+
+    test 'should not match an inline image macro if target begins or ends with space character' do
+      ['image: big cats.png[]', 'image:big cats.png []'].each do |input|
+        para = block_from_string %(Fear not. There are no #{input} around here.)
+        result = para.sub_macros(para.source)
+        assert !result.include?('<img ')
+        assert_includes result, input
+      end
+    end
+
+    test 'should not detect a block image macro found inline' do
       para = block_from_string(%(Not an inline image macro image::tiger.png[].))
       result = para.sub_macros(para.source)
       assert !result.include?('<img ')
@@ -770,8 +843,8 @@ context 'Substitutions' do
     test 'a single-line footnote macro should be registered and rendered as a footnote' do
       para = block_from_string('Sentence text footnote:[An example footnote.].')
       assert_equal %(Sentence text <sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>.), para.sub_macros(para.source)
-      assert_equal 1, para.document.references[:footnotes].size
-      footnote = para.document.references[:footnotes].first
+      assert_equal 1, para.document.catalog[:footnotes].size
+      footnote = para.document.catalog[:footnotes].first
       assert_equal 1, footnote.index
       assert footnote.id.nil?
       assert_equal 'An example footnote.', footnote.text
@@ -780,8 +853,8 @@ context 'Substitutions' do
     test 'a multi-line footnote macro should be registered and rendered as a footnote without endline' do
       para = block_from_string("Sentence text footnote:[An example footnote\nwith wrapped text.].")
       assert_equal %(Sentence text <sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>.), para.sub_macros(para.source)
-      assert_equal 1, para.document.references[:footnotes].size
-      footnote = para.document.references[:footnotes].first
+      assert_equal 1, para.document.catalog[:footnotes].size
+      footnote = para.document.catalog[:footnotes].first
       assert_equal 1, footnote.index
       assert footnote.id.nil?
       assert_equal "An example footnote with wrapped text.", footnote.text
@@ -790,8 +863,8 @@ context 'Substitutions' do
     test 'an escaped closing square bracket in a footnote should be unescaped when rendered' do
       para = block_from_string(%(footnote:[a #{BACKSLASH}] b].))
       assert_equal %(<sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>.), para.sub_macros(para.source)
-      assert_equal 1, para.document.references[:footnotes].size
-      footnote = para.document.references[:footnotes].first
+      assert_equal 1, para.document.catalog[:footnotes].size
+      footnote = para.document.catalog[:footnotes].first
       assert_equal "a ] b", footnote.text
     end
 
@@ -803,29 +876,29 @@ context 'Substitutions' do
     test 'a footnote macro may contain an escaped backslash' do
       para = block_from_string("footnote:[\\]]\nfootnote:[a \\] b]\nfootnote:[a \\]\\] b]")
       para.sub_macros(para.source)
-      assert_equal 3, para.document.references[:footnotes].size
-      footnote1 = para.document.references[:footnotes][0]
+      assert_equal 3, para.document.catalog[:footnotes].size
+      footnote1 = para.document.catalog[:footnotes][0]
       assert_equal ']', footnote1.text
-      footnote2 = para.document.references[:footnotes][1]
+      footnote2 = para.document.catalog[:footnotes][1]
       assert_equal 'a ] b', footnote2.text
-      footnote3 = para.document.references[:footnotes][2]
+      footnote3 = para.document.catalog[:footnotes][2]
       assert_equal 'a ]] b', footnote3.text
     end
 
     test 'a footnote macro may contain a link macro' do
-      para = block_from_string('Share your code. footnote:[http://github.com[GitHub]]')
+      para = block_from_string('Share your code. footnote:[https://github.com[GitHub]]')
       assert_equal %(Share your code. <sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>), para.sub_macros(para.source)
-      assert_equal 1, para.document.references[:footnotes].size
-      footnote1 = para.document.references[:footnotes][0]
-      assert_equal '<a href="http://github.com">GitHub</a>', footnote1.text
+      assert_equal 1, para.document.catalog[:footnotes].size
+      footnote1 = para.document.catalog[:footnotes][0]
+      assert_equal '<a href="https://github.com">GitHub</a>', footnote1.text
     end
 
     test 'a footnote macro may contain a plain URL' do
       para = block_from_string %(the JLine footnote:[https://github.com/jline/jline2]\nlibrary.)
       result = para.sub_macros para.source
       assert_equal %(the JLine <sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>\nlibrary.), result
-      assert_equal 1, para.document.references[:footnotes].size
-      fn1 = para.document.references[:footnotes].first
+      assert_equal 1, para.document.catalog[:footnotes].size
+      fn1 = para.document.catalog[:footnotes].first
       assert_equal '<a href="https://github.com/jline/jline2" class="bare">https://github.com/jline/jline2</a>', fn1.text
     end
 
@@ -833,25 +906,28 @@ context 'Substitutions' do
       para = block_from_string %(the JLine footnote:[https://github.com/jline/jline2];\nlibrary.)
       result = para.sub_macros para.source
       assert_equal %(the JLine <sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>;\nlibrary.), result
-      assert_equal 1, para.document.references[:footnotes].size
-      fn1 = para.document.references[:footnotes].first
+      assert_equal 1, para.document.catalog[:footnotes].size
+      fn1 = para.document.catalog[:footnotes].first
       assert_equal '<a href="https://github.com/jline/jline2" class="bare">https://github.com/jline/jline2</a>', fn1.text
     end
 
     test 'a footnote macro may contain an xref macro' do
       # specialcharacters escaping is simulated
-      para = block_from_string('text footnote:[&lt;&lt;_install,Install&gt;&gt;]')
+      para = block_from_string('text footnote:[&lt;&lt;_install,install&gt;&gt;]')
+      doc = para.document
+      doc.register :refs, ['_install', (Asciidoctor::Inline.new doc, :anchor, 'Install', :type => :ref, :target => '_install'), 'Install']
+      catalog = doc.catalog
       assert_equal %(text <sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>), para.sub_macros(para.source)
-      assert_equal 1, para.document.references[:footnotes].size
-      footnote1 = para.document.references[:footnotes][0]
-      assert_equal '<a href="#_install">Install</a>', footnote1.text
+      assert_equal 1, catalog[:footnotes].size
+      footnote1 = catalog[:footnotes][0]
+      assert_equal '<a href="#_install">install</a>', footnote1.text
     end
 
     test 'a footnote macro may contain an anchor macro' do
       para = block_from_string('text footnote:[a [[b\]\] \[[c\]\] d]')
       assert_equal %(text <sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>), para.sub_macros(para.source)
-      assert_equal 1, para.document.references[:footnotes].size
-      footnote1 = para.document.references[:footnotes][0]
+      assert_equal 1, para.document.catalog[:footnotes].size
+      footnote1 = para.document.catalog[:footnotes][0]
       assert_equal 'a <a id="b"></a> [[c]] d', footnote1.text
     end
 
@@ -864,23 +940,15 @@ foofootnote:[+http://example.com+]barfootnote:[+http://acme.com+]baz
       assert_equal 'foo<footnote><simpara>http://example.com</simpara></footnote>bar<footnote><simpara>http://acme.com</simpara></footnote>baz', result
     end
 
-    test 'a footnote macro may contain a bibliographic anchor macro' do
-      para = block_from_string('text footnote:[a [[[b\]\]\] c]')
-      assert_equal %(text <sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>), para.sub_macros(para.source)
-      assert_equal 1, para.document.references[:footnotes].size
-      footnote1 = para.document.references[:footnotes][0]
-      assert_equal 'a <a id="b"></a>[b] c', footnote1.text
-    end
-
     test 'should increment index of subsequent footnote macros' do
       para = block_from_string("Sentence text footnote:[An example footnote.]. Sentence text footnote:[Another footnote.].")
       assert_equal %(Sentence text <sup class="footnote">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>. Sentence text <sup class="footnote">[<a id="_footnoteref_2" class="footnote" href="#_footnote_2" title="View footnote.">2</a>]</sup>.), para.sub_macros(para.source)
-      assert_equal 2, para.document.references[:footnotes].size
-      footnote1 = para.document.references[:footnotes][0]
+      assert_equal 2, para.document.catalog[:footnotes].size
+      footnote1 = para.document.catalog[:footnotes][0]
       assert_equal 1, footnote1.index
       assert footnote1.id.nil?
       assert_equal "An example footnote.", footnote1.text
-      footnote2 = para.document.references[:footnotes][1]
+      footnote2 = para.document.catalog[:footnotes][1]
       assert_equal 2, footnote2.index
       assert footnote2.id.nil?
       assert_equal "Another footnote.", footnote2.text
@@ -889,8 +957,8 @@ foofootnote:[+http://example.com+]barfootnote:[+http://acme.com+]baz
     test 'a footnoteref macro with id and single-line text should be registered and rendered as a footnote' do
       para = block_from_string('Sentence text footnoteref:[ex1, An example footnote.].')
       assert_equal %(Sentence text <sup class="footnote" id="_footnote_ex1">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>.), para.sub_macros(para.source)
-      assert_equal 1, para.document.references[:footnotes].size
-      footnote = para.document.references[:footnotes].first
+      assert_equal 1, para.document.catalog[:footnotes].size
+      footnote = para.document.catalog[:footnotes].first
       assert_equal 1, footnote.index
       assert_equal 'ex1', footnote.id
       assert_equal 'An example footnote.', footnote.text
@@ -899,8 +967,8 @@ foofootnote:[+http://example.com+]barfootnote:[+http://acme.com+]baz
     test 'a footnoteref macro with id and multi-line text should be registered and rendered as a footnote without endlines' do
       para = block_from_string("Sentence text footnoteref:[ex1, An example footnote\nwith wrapped text.].")
       assert_equal %(Sentence text <sup class="footnote" id="_footnote_ex1">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>.), para.sub_macros(para.source)
-      assert_equal 1, para.document.references[:footnotes].size
-      footnote = para.document.references[:footnotes].first
+      assert_equal 1, para.document.catalog[:footnotes].size
+      footnote = para.document.catalog[:footnotes].first
       assert_equal 1, footnote.index
       assert_equal 'ex1', footnote.id
       assert_equal "An example footnote with wrapped text.", footnote.text
@@ -909,8 +977,8 @@ foofootnote:[+http://example.com+]barfootnote:[+http://acme.com+]baz
     test 'a footnoteref macro with id should refer to footnoteref with same id' do
       para = block_from_string('Sentence text footnoteref:[ex1, An example footnote.]. Sentence text footnoteref:[ex1].')
       assert_equal %(Sentence text <sup class="footnote" id="_footnote_ex1">[<a id="_footnoteref_1" class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>. Sentence text <sup class="footnoteref">[<a class="footnote" href="#_footnote_1" title="View footnote.">1</a>]</sup>.), para.sub_macros(para.source)
-      assert_equal 1, para.document.references[:footnotes].size
-      footnote = para.document.references[:footnotes].first
+      assert_equal 1, para.document.catalog[:footnotes].size
+      footnote = para.document.catalog[:footnotes].first
       assert_equal 1, footnote.index
       assert_equal 'ex1', footnote.id
       assert_equal 'An example footnote.', footnote.text
@@ -928,8 +996,8 @@ foofootnote:[+http://example.com+]barfootnote:[+http://acme.com+]baz
         para = block_from_string("#{sentence}#{macro}")
         output = para.sub_macros(para.source)
         assert_equal sentence, output
-        assert_equal 1, para.document.references[:indexterms].size
-        assert_equal ['Tigers'], para.document.references[:indexterms].first
+        assert_equal 1, para.document.catalog[:indexterms].size
+        assert_equal ['Tigers'], para.document.catalog[:indexterms].first
       end
     end
 
@@ -940,8 +1008,8 @@ foofootnote:[+http://example.com+]barfootnote:[+http://acme.com+]baz
         para = block_from_string("#{sentence}#{macro}")
         output = para.sub_macros(para.source)
         assert_equal sentence, output
-        assert_equal 1, para.document.references[:indexterms].size
-        assert_equal ['Big cats', 'Tigers'], para.document.references[:indexterms].first
+        assert_equal 1, para.document.catalog[:indexterms].size
+        assert_equal ['Big cats', 'Tigers'], para.document.catalog[:indexterms].first
       end
     end
 
@@ -952,8 +1020,8 @@ foofootnote:[+http://example.com+]barfootnote:[+http://acme.com+]baz
         para = block_from_string("#{sentence}#{macro}")
         output = para.sub_macros(para.source)
         assert_equal sentence, output
-        assert_equal 1, para.document.references[:indexterms].size
-        assert_equal ['Big cats', 'Tigers', 'Panthera tigris'], para.document.references[:indexterms].first
+        assert_equal 1, para.document.catalog[:indexterms].size
+        assert_equal ['Big cats', 'Tigers', 'Panthera tigris'], para.document.catalog[:indexterms].first
       end
     end
 
@@ -964,8 +1032,8 @@ foofootnote:[+http://example.com+]barfootnote:[+http://acme.com+]baz
         para = block_from_string("#{sentence}#{macro}")
         output = para.sub_macros(para.source)
         assert_equal sentence, output
-        assert_equal 1, para.document.references[:indexterms].size
-        assert_equal ['Panthera tigris'], para.document.references[:indexterms].first
+        assert_equal 1, para.document.catalog[:indexterms].size
+        assert_equal ['Panthera tigris'], para.document.catalog[:indexterms].first
       end
     end
 
@@ -986,8 +1054,8 @@ EOS
         para = block_from_string input
         output = para.sub_macros(para.source)
         assert_equal input.lines.first, output
-        assert_equal 1, para.document.references[:indexterms].size
-        terms = para.document.references[:indexterms].first
+        assert_equal 1, para.document.catalog[:indexterms].size
+        terms = para.document.catalog[:indexterms].first
         assert_equal 2, terms.size
         assert_equal 'Tigers', terms.first
         assert_equal '[Big], scary cats', terms.last
@@ -999,10 +1067,10 @@ EOS
       macros = ['indexterm:[*Tigers*]', '(((*Tigers*)))']
       macros.each do |macro|
         para = block_from_string("#{sentence}#{macro}")
-        output = para.apply_normal_subs(para.lines)
+        output = para.apply_subs(para.source)
         assert_equal sentence, output
-        assert_equal 1, para.document.references[:indexterms].size
-        assert_equal ['<strong>Tigers</strong>'], para.document.references[:indexterms].first
+        assert_equal 1, para.document.catalog[:indexterms].size
+        assert_equal ['<strong>Tigers</strong>'], para.document.catalog[:indexterms].first
       end
     end
 
@@ -1012,9 +1080,9 @@ EOS
       para = block_from_string("#{sentence}\n#{macros}")
       output = para.sub_macros(para.source)
       assert_equal sentence, output.rstrip
-      assert_equal 2, para.document.references[:indexterms].size
-      assert_equal ['Tigers'], para.document.references[:indexterms][0]
-      assert_equal ['Animals', 'Cats'], para.document.references[:indexterms][1]
+      assert_equal 2, para.document.catalog[:indexterms].size
+      assert_equal ['Tigers'], para.document.catalog[:indexterms][0]
+      assert_equal ['Animals', 'Cats'], para.document.catalog[:indexterms][1]
     end
 
     test 'an index term macro with round bracket syntax may contain round brackets in term' do
@@ -1023,8 +1091,32 @@ EOS
       para = block_from_string("#{sentence}#{macro}")
       output = para.sub_macros(para.source)
       assert_equal sentence, output
-      assert_equal 1, para.document.references[:indexterms].size
-      assert_equal ['Tiger (Panthera tigris)'], para.document.references[:indexterms].first
+      assert_equal 1, para.document.catalog[:indexterms].size
+      assert_equal ['Tiger (Panthera tigris)'], para.document.catalog[:indexterms].first
+    end
+
+    test 'visible shorthand index term macro should not consume trailing round bracket' do
+      input = '(text with ((index term)))'
+      expected = '(text with <indexterm><primary>index term</primary></indexterm>index term)'
+      expected_term = ['index term']
+      para = block_from_string input, :backend => :docbook
+      output = para.sub_macros para.source
+      indexterms_table = para.document.catalog[:indexterms]
+      assert_equal 1, indexterms_table.size
+      assert_equal expected_term, indexterms_table[0]
+      assert_equal expected, output
+    end
+
+    test 'visible shorthand index term macro should not consume leading round bracket' do
+      input = '(((index term)) for text)'
+      expected = '(<indexterm><primary>index term</primary></indexterm>index term for text)'
+      expected_term = ['index term']
+      para = block_from_string input, :backend => :docbook
+      output = para.sub_macros para.source
+      indexterms_table = para.document.catalog[:indexterms]
+      assert_equal 1, indexterms_table.size
+      assert_equal expected_term, indexterms_table[0]
+      assert_equal expected, output
     end
 
     test 'an index term macro with square bracket syntax may contain square brackets in term' do
@@ -1033,8 +1125,8 @@ EOS
       para = block_from_string("#{sentence}#{macro}")
       output = para.sub_macros(para.source)
       assert_equal sentence, output
-      assert_equal 1, para.document.references[:indexterms].size
-      assert_equal ['Tiger [Panthera tigris]'], para.document.references[:indexterms].first
+      assert_equal 1, para.document.catalog[:indexterms].size
+      assert_equal ['Tiger [Panthera tigris]'], para.document.catalog[:indexterms].first
     end
 
     test 'a single-line index term 2 macro should be registered as an index reference and retain term inline' do
@@ -1044,8 +1136,8 @@ EOS
         para = block_from_string(macro)
         output = para.sub_macros(para.source)
         assert_equal sentence, output
-        assert_equal 1, para.document.references[:indexterms].size
-        assert_equal ['tiger'], para.document.references[:indexterms].first
+        assert_equal 1, para.document.catalog[:indexterms].size
+        assert_equal ['tiger'], para.document.catalog[:indexterms].first
       end
     end
 
@@ -1056,8 +1148,8 @@ EOS
         para = block_from_string(macro)
         output = para.sub_macros(para.source)
         assert_equal sentence, output
-        assert_equal 1, para.document.references[:indexterms].size
-        assert_equal ['panthera tigris'], para.document.references[:indexterms].first
+        assert_equal 1, para.document.catalog[:indexterms].size
+        assert_equal ['panthera tigris'], para.document.catalog[:indexterms].first
       end
     end
 
@@ -1066,18 +1158,18 @@ EOS
       para = block_from_string(sentence)
       output = para.sub_macros(para.source)
       assert_equal 'The tiger (Panthera tigris) is the largest cat species.', output
-      assert_equal 2, para.document.references[:indexterms].size
-      assert_equal ['tiger'], para.document.references[:indexterms][0]
-      assert_equal ['cat'], para.document.references[:indexterms][1]
+      assert_equal 2, para.document.catalog[:indexterms].size
+      assert_equal ['tiger'], para.document.catalog[:indexterms][0]
+      assert_equal ['cat'], para.document.catalog[:indexterms][1]
     end
 
     test 'normal substitutions are performed on an index term 2 macro' do
       sentence = 'The ((*tiger*)) (Panthera tigris) is the largest cat species.'
       para = block_from_string sentence
-      output = para.apply_normal_subs(para.lines)
+      output = para.apply_subs(para.source)
       assert_equal 'The <strong>tiger</strong> (Panthera tigris) is the largest cat species.', output
-      assert_equal 1, para.document.references[:indexterms].size
-      assert_equal ['<strong>tiger</strong>'], para.document.references[:indexterms].first
+      assert_equal 1, para.document.catalog[:indexterms].size
+      assert_equal ['<strong>tiger</strong>'], para.document.catalog[:indexterms].first
     end
 
     test 'index term 2 macro with round bracket syntex should not interfer with index term macro with round bracket syntax' do
@@ -1085,7 +1177,7 @@ EOS
       para = block_from_string sentence
       output = para.sub_macros(para.source)
       assert_equal "The panthera tigris is the largest cat species.\n", output
-      terms = para.document.references[:indexterms]
+      terms = para.document.catalog[:indexterms]
       assert_equal 2, terms.size
       assert_equal ['panthera tigris'], terms[0]
       assert_equal ['Big cats', 'Tigers'], terms[1]
@@ -1097,6 +1189,11 @@ EOS
         assert_equal %q{<b class="button">Save</b>}, para.sub_macros(para.source)
       end
 
+      test 'btn macro that spans multiple lines' do
+        para = block_from_string(%(btn:[Rebase and\nmerge]), :attributes => {'experimental' => ''})
+        assert_equal %q{<b class="button">Rebase and merge</b>}, para.sub_macros(para.source)
+      end
+
       test 'btn macro for docbook backend' do
         para = block_from_string('btn:[Save]', :backend => 'docbook', :attributes => {'experimental' => ''})
         assert_equal %q{<guibutton>Save</guibutton>}, para.sub_macros(para.source)
@@ -1109,6 +1206,11 @@ EOS
         assert_equal %q{<kbd>F3</kbd>}, para.sub_macros(para.source)
       end
 
+      test 'kbd macro with single backslash key' do
+        para = block_from_string("kbd:[#{BACKSLASH} ]", :attributes => {'experimental' => ''})
+        assert_equal %q(<kbd>\</kbd>), para.sub_macros(para.source)
+      end
+
       test 'kbd macro with single key, docbook backend' do
         para = block_from_string('kbd:[F3]', :backend => 'docbook', :attributes => {'experimental' => ''})
         assert_equal %q{<keycap>F3</keycap>}, para.sub_macros(para.source)
@@ -1119,7 +1221,17 @@ EOS
         assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>T</kbd></span>}, para.sub_macros(para.source)
       end
 
-      test 'kbd macro with key combination with spaces' do
+      test 'kbd macro with key combination that spans multiple lines' do
+        para = block_from_string(%(kbd:[Ctrl +\nT]), :attributes => {'experimental' => ''})
+        assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>T</kbd></span>}, para.sub_macros(para.source)
+      end
+
+      test 'kbd macro with key combination, docbook backend' do
+        para = block_from_string('kbd:[Ctrl+Shift+T]', :backend => 'docbook', :attributes => {'experimental' => ''})
+        assert_equal %q{<keycombo><keycap>Ctrl</keycap><keycap>Shift</keycap><keycap>T</keycap></keycombo>}, para.sub_macros(para.source)
+      end
+
+      test 'kbd macro with key combination delimited by pluses with spaces' do
         para = block_from_string('kbd:[Ctrl + Shift + T]', :attributes => {'experimental' => ''})
         assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>T</kbd></span>}, para.sub_macros(para.source)
       end
@@ -1129,36 +1241,56 @@ EOS
         assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>T</kbd></span>}, para.sub_macros(para.source)
       end
 
-      test 'kbd macro with key combination containing a plus key no spaces' do
-        para = block_from_string('kbd:[Ctrl++]', :attributes => {'experimental' => ''})
-        assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>+</kbd></span>}, para.sub_macros(para.source)
+      test 'kbd macro with key combination delimited by commas with spaces' do
+        para = block_from_string('kbd:[Ctrl, Shift, T]', :attributes => {'experimental' => ''})
+        assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>T</kbd></span>}, para.sub_macros(para.source)
       end
 
-      test 'kbd macro with key combination delimited by commands containing a comma key' do
-        para = block_from_string('kbd:[Ctrl,,]', :attributes => {'experimental' => ''})
+      test 'kbd macro with key combination delimited by plus containing a comma key' do
+        para = block_from_string('kbd:[Ctrl+,]', :attributes => {'experimental' => ''})
         assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>,</kbd></span>}, para.sub_macros(para.source)
       end
 
-      test 'kbd macro with key combination containing a plus key with spaces' do
+      test 'kbd macro with key combination delimited by commas containing a plus key' do
+        para = block_from_string('kbd:[Ctrl, +, Shift]', :attributes => {'experimental' => ''})
+        assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>+</kbd>+<kbd>Shift</kbd></span>}, para.sub_macros(para.source)
+      end
+
+      test 'kbd macro with key combination where last key matches plus delimiter' do
         para = block_from_string('kbd:[Ctrl + +]', :attributes => {'experimental' => ''})
         assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>+</kbd></span>}, para.sub_macros(para.source)
       end
 
+      test 'kbd macro with key combination where last key matches comma delimiter' do
+        para = block_from_string('kbd:[Ctrl, ,]', :attributes => {'experimental' => ''})
+        assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>,</kbd></span>}, para.sub_macros(para.source)
+      end
+
       test 'kbd macro with key combination containing escaped bracket' do
         para = block_from_string('kbd:[Ctrl + \]]', :attributes => {'experimental' => ''})
         assert_equal %q{<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>]</kbd></span>}, para.sub_macros(para.source)
       end
 
-      test 'kbd macro with key combination, docbook backend' do
-        para = block_from_string('kbd:[Ctrl+Shift+T]', :backend => 'docbook', :attributes => {'experimental' => ''})
-        assert_equal %q{<keycombo><keycap>Ctrl</keycap><keycap>Shift</keycap><keycap>T</keycap></keycombo>}, para.sub_macros(para.source)
+      test 'kbd macro with key combination ending in backslash' do
+        para = block_from_string("kbd:[Ctrl + #{BACKSLASH} ]", :attributes => {'experimental' => ''})
+        assert_equal %q(<span class="keyseq"><kbd>Ctrl</kbd>+<kbd>\\</kbd></span>), para.sub_macros(para.source)
+      end
+
+      test 'kbd macro looks for delimiter beyond first character' do
+        para = block_from_string('kbd:[,te]', :attributes => {'experimental' => ''})
+        assert_equal %q(<kbd>,te</kbd>), para.sub_macros(para.source)
+      end
+
+      test 'kbd macro restores trailing delimiter as key value' do
+        para = block_from_string('kbd:[te,]', :attributes => {'experimental' => ''})
+        assert_equal %q(<kbd>te,</kbd>), para.sub_macros(para.source)
       end
     end
 
     context 'Menu macro' do
       test 'should process menu using macro sytnax' do
         para = block_from_string('menu:File[]', :attributes => {'experimental' => ''})
-        assert_equal %q{<span class="menu">File</span>}, para.sub_macros(para.source)
+        assert_equal %q{<b class="menuref">File</b>}, para.sub_macros(para.source)
       end
 
       test 'should process menu for docbook backend' do
@@ -1168,7 +1300,24 @@ EOS
 
       test 'should process menu with menu item using macro syntax' do
         para = block_from_string('menu:File[Save As&#8230;]', :attributes => {'experimental' => ''})
-        assert_equal %q{<span class="menuseq"><span class="menu">File</span>&#160;&#9656; <span class="menuitem">Save As&#8230;</span></span>}, para.sub_macros(para.source)
+        assert_equal %q{<span class="menuseq"><b class="menu">File</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">Save As&#8230;</b></span>}, para.sub_macros(para.source)
+      end
+
+      test 'should process menu macro that spans multiple lines' do
+        input = %(menu:Preferences[Compile\non\nSave])
+        para = block_from_string input, :attributes => {'experimental' => ''}
+        assert_equal %(<span class="menuseq"><b class="menu">Preferences</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">Compile\non\nSave</b></span>), para.sub_macros(para.source)
+      end
+
+      test 'should unescape escaped closing bracket in menu macro' do
+        input = 'menu:Preferences[Compile [on\\] Save]'
+        para = block_from_string input, :attributes => {'experimental' => ''}
+        assert_equal %q(<span class="menuseq"><b class="menu">Preferences</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">Compile [on] Save</b></span>), para.sub_macros(para.source)
+      end
+
+      test 'should process menu with menu item using macro syntax when fonts icons are enabled' do
+        para = block_from_string('menu:Tools[More Tools &gt; Extensions]', :attributes => {'experimental' => '', 'icons' => 'font'})
+        assert_equal %q{<span class="menuseq"><b class="menu">Tools</b>&#160;<i class="fa fa-angle-right caret"></i> <b class="submenu">More Tools</b>&#160;<i class="fa fa-angle-right caret"></i> <b class="menuitem">Extensions</b></span>}, para.sub_macros(para.source)
       end
 
       test 'should process menu with menu item for docbook backend' do
@@ -1178,7 +1327,7 @@ EOS
 
       test 'should process menu with menu item in submenu using macro syntax' do
         para = block_from_string('menu:Tools[Project &gt; Build]', :attributes => {'experimental' => ''})
-        assert_equal %q{<span class="menuseq"><span class="menu">Tools</span>&#160;&#9656; <span class="submenu">Project</span>&#160;&#9656; <span class="menuitem">Build</span></span>}, para.sub_macros(para.source)
+        assert_equal %q{<span class="menuseq"><b class="menu">Tools</b>&#160;<b class="caret">&#8250;</b> <b class="submenu">Project</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">Build</b></span>}, para.sub_macros(para.source)
       end
 
       test 'should process menu with menu item in submenu for docbook backend' do
@@ -1188,33 +1337,51 @@ EOS
 
       test 'should process menu with menu item in submenu using macro syntax and comma delimiter' do
         para = block_from_string('menu:Tools[Project, Build]', :attributes => {'experimental' => ''})
-        assert_equal %q{<span class="menuseq"><span class="menu">Tools</span>&#160;&#9656; <span class="submenu">Project</span>&#160;&#9656; <span class="menuitem">Build</span></span>}, para.sub_macros(para.source)
+        assert_equal %q{<span class="menuseq"><b class="menu">Tools</b>&#160;<b class="caret">&#8250;</b> <b class="submenu">Project</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">Build</b></span>}, para.sub_macros(para.source)
       end
 
       test 'should process menu with menu item using inline syntax' do
         para = block_from_string('"File &gt; Save As&#8230;"', :attributes => {'experimental' => ''})
-        assert_equal %q{<span class="menuseq"><span class="menu">File</span>&#160;&#9656; <span class="menuitem">Save As&#8230;</span></span>}, para.sub_macros(para.source)
+        assert_equal %q{<span class="menuseq"><b class="menu">File</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">Save As&#8230;</b></span>}, para.sub_macros(para.source)
       end
 
       test 'should process menu with menu item in submenu using inline syntax' do
         para = block_from_string('"Tools &gt; Project &gt; Build"', :attributes => {'experimental' => ''})
-        assert_equal %q{<span class="menuseq"><span class="menu">Tools</span>&#160;&#9656; <span class="submenu">Project</span>&#160;&#9656; <span class="menuitem">Build</span></span>}, para.sub_macros(para.source)
+        assert_equal %q{<span class="menuseq"><b class="menu">Tools</b>&#160;<b class="caret">&#8250;</b> <b class="submenu">Project</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">Build</b></span>}, para.sub_macros(para.source)
       end
 
-      test 'inline syntax should not closing quote of XML attribute' do
+      test 'inline menu syntax should not match closing quote of XML attribute' do
         para = block_from_string('<span class="xmltag">&lt;node&gt;</span><span class="classname">r</span>', :attributes => {'experimental' => ''})
         assert_equal %q{<span class="xmltag">&lt;node&gt;</span><span class="classname">r</span>}, para.sub_macros(para.source)
       end
 
       test 'should process menu macro with items containing multibyte characters' do
         para = block_from_string('menu:视图[放大, 重置]', :attributes => {'experimental' => ''})
-        assert_equal %q{<span class="menuseq"><span class="menu">视图</span>&#160;&#9656; <span class="submenu">放大</span>&#160;&#9656; <span class="menuitem">重置</span></span>}, para.sub_macros(para.source)
+        assert_equal %q{<span class="menuseq"><b class="menu">视图</b>&#160;<b class="caret">&#8250;</b> <b class="submenu">放大</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">重置</b></span>}, para.sub_macros(para.source)
       end if ::RUBY_MIN_VERSION_1_9
 
       test 'should process inline menu with items containing multibyte characters' do
         para = block_from_string('"视图 &gt; 放大 &gt; 重置"', :attributes => {'experimental' => ''})
-        assert_equal %q{<span class="menuseq"><span class="menu">视图</span>&#160;&#9656; <span class="submenu">放大</span>&#160;&#9656; <span class="menuitem">重置</span></span>}, para.sub_macros(para.source)
+        assert_equal %q{<span class="menuseq"><b class="menu">视图</b>&#160;<b class="caret">&#8250;</b> <b class="submenu">放大</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">重置</b></span>}, para.sub_macros(para.source)
       end if ::RUBY_MIN_VERSION_1_9
+
+      test 'should process a menu macro with a target that begins with a character reference' do
+        para = block_from_string('menu:&#8942;[More Tools, Extensions]', :attributes => {'experimental' => ''})
+        assert_equal %q{<span class="menuseq"><b class="menu">&#8942;</b>&#160;<b class="caret">&#8250;</b> <b class="submenu">More Tools</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">Extensions</b></span>}, para.sub_macros(para.source)
+      end
+
+      test 'should not process a menu macro with a target that ends with a space' do
+        input = 'menu:foo [bar] menu:File[Save]'
+        para = block_from_string input, :attributes => {'experimental' => ''}
+        result = para.sub_macros para.source
+        assert_xpath '/span[@class="menuseq"]', result, 1
+        assert_xpath '//b[@class="menu"][text()="File"]', result, 1
+      end
+
+      test 'should process an inline menu that begins with a character reference' do
+        para = block_from_string('"&#8942; &gt; More Tools &gt; Extensions"', :attributes => {'experimental' => ''})
+        assert_equal %q{<span class="menuseq"><b class="menu">&#8942;</b>&#160;<b class="caret">&#8250;</b> <b class="submenu">More Tools</b>&#160;<b class="caret">&#8250;</b> <b class="menuitem">Extensions</b></span>}, para.sub_macros(para.source)
+      end
     end
   end
 
@@ -1255,6 +1422,18 @@ EOS
       assert_equal [:specialcharacters], para.passthroughs[0][:subs]
     end
 
+    test 'should allow inline double plus passthrough to be escaped using backslash' do
+      para = block_from_string("you need to replace `int a = n#{BACKSLASH}++;` with `int a = ++n;`!")
+      result = para.apply_subs para.source
+      assert_equal 'you need to replace <code>int a = n++;</code> with <code>int a = ++n;</code>!', result
+    end
+
+    test 'should allow inline double plus passthrough with attributes to be escaped using backslash' do
+      para = block_from_string("=[attrs]#{BACKSLASH}#{BACKSLASH}++text++")
+      result = para.apply_subs para.source
+      assert_equal '=[attrs]++text++', result
+    end
+
     test 'collect multi-line inline double dollar passthroughs' do
       para = block_from_string("$$<code>\n{code}\n</code>$$")
       result = para.extract_passthroughs(para.source)
@@ -1291,6 +1470,12 @@ EOS
       assert_equal [:specialcharacters, :quotes], para.passthroughs[0][:subs]
     end
 
+    test 'should find and replace placeholder duplicated by substitution' do
+      input = %q(+first passthrough+ followed by link:$$http://example.com/__u_no_format_me__$$[] with passthrough)
+      result = render_embedded_string input, :doctype => :inline
+      assert_equal 'first passthrough followed by <a href="http://example.com/__u_no_format_me__" class="bare">http://example.com/__u_no_format_me__</a> with passthrough', result
+    end
+
     test 'resolves sub shorthands on inline pass macro' do
       para = block_from_string 'pass:q,a[*<{backend}>*]'
       result = para.extract_passthroughs para.source
@@ -1300,6 +1485,21 @@ EOS
       assert_equal '<strong><html5></strong>', result
     end
 
+    test 'should not recognize pass macro with invalid subsitution list' do
+      [',', '42', 'a,'].each do |subs|
+        para = block_from_string %(pass:#{subs}[foobar])
+        result = para.extract_passthroughs para.source
+        assert_equal %(pass:#{subs}[foobar]), result
+      end
+    end
+
+    test 'should allow content of inline pass macro to be empty' do
+      para = block_from_string 'pass:[]'
+      result = para.extract_passthroughs para.source
+      assert_equal 1, para.passthroughs.size
+      assert_equal '', para.restore_passthroughs(result)
+    end
+
     # NOTE placeholder is surrounded by text to prevent reader from stripping trailing boundary char (unique to test scenario)
     test 'restore inline passthroughs without subs' do
       para = block_from_string("some #{Asciidoctor::Substitutors::PASS_START}" + '0' + "#{Asciidoctor::Substitutors::PASS_END} to study")
@@ -1453,23 +1653,31 @@ EOS
         assert_equal '\(C = \alpha + \beta Y^{\gamma} + \epsilon\)', para.content
       end
 
-      test 'should find and replace placeholder duplicated by substitution' do
-        input = %q(+first passthrough+ followed by link:$$http://example.com/__u_no_format_me__$$[] with passthrough)
-        result = render_embedded_string input, :doctype => :inline
-        assert_equal 'first passthrough followed by <a href="http://example.com/__u_no_format_me__" class="bare">http://example.com/__u_no_format_me__</a> with passthrough', result
+      test 'should apply substitutions specified on stem macro' do
+        input = 'stem:c,a[sqrt(x) <=> {solve-for-x}]'
+        para = block_from_string input, :attributes => {'stem' => 'asciimath', 'solve-for-x' => '13'}
+        assert_equal '\$sqrt(x) &lt;=&gt; 13\$', para.content
+      end
+
+      test 'should not recognize stem macro with invalid substitution list' do
+        [',', '42', 'a,'].each do |subs|
+          input = %(stem:#{subs}[x^2])
+          para = block_from_string input, :attributes => {'stem' => 'asciimath'}
+          assert_equal %(stem:#{subs}[x^2]), para.content
+        end
       end
     end
   end
 
   context 'Replacements' do
     test 'unescapes XML entities' do
-      para = block_from_string '< &quot; &#34; &#x22; >'
-      assert_equal '&lt; &quot; &#34; &#x22; &gt;', para.apply_normal_subs(para.lines)
+      para = block_from_string '< &quot; &there4; &#34; &#x22; >'
+      assert_equal '&lt; &quot; &there4; &#34; &#x22; &gt;', para.apply_subs(para.source)
     end
 
     test 'replaces arrows' do
       para = block_from_string '<- -> <= => \<- \-> \<= \=>'
-      assert_equal '&#8592; &#8594; &#8656; &#8658; &lt;- -&gt; &lt;= =&gt;', para.apply_normal_subs(para.source)
+      assert_equal '&#8592; &#8594; &#8656; &#8658; &lt;- -&gt; &lt;= =&gt;', para.apply_subs(para.source)
     end
 
     test 'replaces dashes' do
@@ -1667,13 +1875,13 @@ foo&#8201;&#8212;&#8201;'
     test 'should URI encode non-word characters generally' do
       given = ' /%&?\\'
       expect = '%20%2F%25%26%3F%5C'
-      assert_equal expect, (Asciidoctor::Helpers.encode_uri given)
+      assert_equal expect, (Asciidoctor::Helpers.uri_encode given)
     end
 
     test 'should not URI select non-word characters' do
       given = '-.!~*\';:@=+$,()[]'
       expect = given
-      assert_equal expect, (Asciidoctor::Helpers.encode_uri given)
+      assert_equal expect, (Asciidoctor::Helpers.uri_encode given)
     end
   end
 end