a few <monospaced> words', para.apply_subs(para.source)
para = block_from_string %(#{BACKSLASH}[input]`a few a few <monospaced> words', para.apply_subs(para.source)
end
# 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 leave it alone', para.apply_subs(para.source)
end
# NOTE must use apply_subs because constrained monospaced is handled as a passthrough
test 'escaped single-line constrained monospace string with forced compat role' do
para = block_from_string %([x-]#{BACKSLASH}`leave it alone`)
assert_equal '[x-]`leave it alone`', para.apply_subs(para.source)
end
# NOTE must use apply_subs because constrained monospaced is handled as a passthrough
test 'escaped forced compat role on single-line constrained monospace string' do
para = block_from_string %(#{BACKSLASH}[x-]`just *mono*`)
assert_equal '[x-]just mono', para.apply_subs(para.source)
end
# 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 "a few\n<{monospaced}> words", para.apply_subs(para.source)
para = block_from_string %(`a few\n<{monospaced}> words`), attributes: { 'monospaced' => 'monospaced' }
assert_equal "a few\n<monospaced> words", para.apply_subs(para.source)
end
test 'single-line unconstrained strong chars' do
para = block_from_string '**Git**Hub'
assert_equal 'GitHub', para.sub_quotes(para.source)
end
test 'escaped single-line unconstrained strong chars' do
para = block_from_string %(#{BACKSLASH}**Git**Hub)
assert_equal '*Git*Hub', para.sub_quotes(para.source)
end
test 'multi-line unconstrained strong chars' do
para = block_from_string %(**G\ni\nt\n**Hub)
assert_equal %(G\ni\nt\nHub), para.sub_quotes(para.source)
end
test 'unconstrained strong chars with inline asterisk' do
para = block_from_string '**bl*ck**-eye'
assert_equal 'bl*ck-eye', para.sub_quotes(para.source)
end
test 'unconstrained strong chars with role' do
para = block_from_string 'Git[blue]**Hub**'
assert_equal 'GitHub', para.sub_quotes(para.source)
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 %(Git#{BACKSLASH}[blue]**Hub**)
assert_equal 'Git[blue]*Hub*', para.sub_quotes(para.source)
end
test 'single-line unconstrained emphasized chars' do
para = block_from_string '__Git__Hub'
assert_equal 'GitHub', para.sub_quotes(para.source)
end
test 'escaped single-line unconstrained emphasized chars' do
para = block_from_string %(#{BACKSLASH}__Git__Hub)
assert_equal '__Git__Hub', para.sub_quotes(para.source)
end
test 'escaped single-line unconstrained emphasized chars around word' do
para = block_from_string %(#{BACKSLASH}#{BACKSLASH}__GitHub__)
assert_equal '__GitHub__', para.sub_quotes(para.source)
end
test 'multi-line unconstrained emphasized chars' do
para = block_from_string %(__G\ni\nt\n__Hub)
assert_equal %(G\ni\nt\nHub), para.sub_quotes(para.source)
end
test 'unconstrained emphasis chars with role' do
para = block_from_string '[gray]__Git__Hub'
assert_equal 'GitHub', para.sub_quotes(para.source)
end
test 'escaped unconstrained emphasis chars with role' do
para = block_from_string %(#{BACKSLASH}[gray]__Git__Hub)
assert_equal '[gray]__Git__Hub', para.sub_quotes(para.source)
end
test 'single-line constrained monospaced chars' do
para = block_from_string 'call +save()+ to persist the changes', attributes: { 'compat-mode' => '' }
assert_equal 'call save() to persist the changes', para.sub_quotes(para.source)
para = block_from_string 'call [x-]+save()+ to persist the changes'
assert_equal 'call save() to persist the changes', para.apply_subs(para.source)
para = block_from_string 'call `save()` to persist the changes'
assert_equal 'call save() to persist the changes', para.sub_quotes(para.source)
end
test 'single-line constrained monospaced chars with role' do
para = block_from_string 'call [method]+save()+ to persist the changes', attributes: { 'compat-mode' => '' }
assert_equal 'call save() to persist the changes', para.sub_quotes(para.source)
para = block_from_string 'call [method x-]+save()+ to persist the changes'
assert_equal 'call save() to persist the changes', para.apply_subs(para.source)
para = block_from_string 'call [method]`save()` to persist the changes'
assert_equal 'call save() to persist the changes', para.sub_quotes(para.source)
end
test 'escaped single-line constrained monospaced chars' do
para = block_from_string %(call #{BACKSLASH}+save()+ to persist the changes), attributes: { 'compat-mode' => '' }
assert_equal 'call +save()+ to persist the changes', para.sub_quotes(para.source)
para = block_from_string %(call #{BACKSLASH}`save()` to persist the changes)
assert_equal 'call `save()` to persist the changes', para.sub_quotes(para.source)
end
test 'escaped single-line constrained monospaced chars with role' do
para = block_from_string %(call [method]#{BACKSLASH}+save()+ to persist the changes), attributes: { 'compat-mode' => '' }
assert_equal 'call [method]+save()+ to persist the changes', para.sub_quotes(para.source)
para = block_from_string %(call [method]#{BACKSLASH}`save()` to persist the changes)
assert_equal 'call [method]`save()` to persist the changes', para.sub_quotes(para.source)
end
test 'escaped role on single-line constrained monospaced chars' do
para = block_from_string %(call #{BACKSLASH}[method]+save()+ to persist the changes), attributes: { 'compat-mode' => '' }
assert_equal 'call [method]save() to persist the changes', para.sub_quotes(para.source)
para = block_from_string %(call #{BACKSLASH}[method]`save()` to persist the changes)
assert_equal 'call [method]save() to persist the changes', para.sub_quotes(para.source)
end
test 'escaped role on escaped single-line constrained monospaced chars' do
para = block_from_string %(call #{BACKSLASH}[method]#{BACKSLASH}+save()+ to persist the changes), attributes: { 'compat-mode' => '' }
assert_equal %(call #{BACKSLASH}[method]+save()+ to persist the changes), para.sub_quotes(para.source)
para = block_from_string %(call #{BACKSLASH}[method]#{BACKSLASH}`save()` to persist the changes)
assert_equal %(call #{BACKSLASH}[method]`save()` to persist the changes), para.sub_quotes(para.source)
end
# NOTE must use apply_subs because constrained monospaced is handled as a passthrough
test 'escaped single-line constrained passthrough string with forced compat role' do
para = block_from_string %([x-]#{BACKSLASH}+leave it alone+)
assert_equal '[x-]+leave it alone+', para.apply_subs(para.source)
end
test 'single-line unconstrained monospaced chars' do
para = block_from_string 'Git++Hub++', attributes: { 'compat-mode' => '' }
assert_equal 'GitHub', para.sub_quotes(para.source)
para = block_from_string 'Git[x-]++Hub++'
assert_equal 'GitHub', para.apply_subs(para.source)
para = block_from_string 'Git``Hub``'
assert_equal 'GitHub', para.sub_quotes(para.source)
end
test 'escaped single-line unconstrained monospaced chars' do
para = block_from_string %(Git#{BACKSLASH}++Hub++), attributes: { 'compat-mode' => '' }
assert_equal 'Git+Hub+', para.sub_quotes(para.source)
para = block_from_string %(Git#{BACKSLASH * 2}++Hub++), attributes: { 'compat-mode' => '' }
assert_equal 'Git++Hub++', para.sub_quotes(para.source)
para = block_from_string %(Git#{BACKSLASH}``Hub``)
assert_equal 'Git``Hub``', para.sub_quotes(para.source)
end
test 'multi-line unconstrained monospaced chars' do
para = block_from_string %(Git++\nH\nu\nb++), attributes: { 'compat-mode' => '' }
assert_equal %(Git\nH\nu\nb), para.sub_quotes(para.source)
para = block_from_string %(Git[x-]++\nH\nu\nb++)
assert_equal %(Git\nH\nu\nb), para.apply_subs(para.source)
para = block_from_string %(Git``\nH\nu\nb``)
assert_equal %(Git\nH\nu\nb), para.sub_quotes(para.source)
end
test 'single-line superscript chars' do
para = block_from_string %(x^2^ = x * x, e = mc^2^, there's a 1^st^ time for everything)
assert_equal %(x2 = x * x, e = mc2, there\'s a 1st time for everything), para.sub_quotes(para.source)
end
test 'escaped single-line superscript chars' do
para = block_from_string %(x#{BACKSLASH}^2^ = x * x)
assert_equal 'x^2^ = x * x', para.sub_quotes(para.source)
end
test 'does not match superscript across whitespace' do
para = block_from_string %(x^(n\n-\n1)^)
assert_equal para.source, para.sub_quotes(para.source)
end
test 'allow spaces in superscript if spaces are inserted using an attribute reference' do
para = block_from_string 'Night ^A{sp}poem{sp}by{sp}Jane{sp}Kondo^.'
assert_equal 'Night A poem by Jane Kondo.', para.apply_subs(para.source)
end
test 'allow spaces in superscript if text is wrapped in a passthrough' do
para = block_from_string 'Night ^+A poem by Jane Kondo+^.'
assert_equal 'Night A poem by Jane Kondo.', para.apply_subs(para.source)
end
test 'does not match adjacent superscript chars' do
para = block_from_string 'a ^^ b'
assert_equal 'a ^^ b', para.sub_quotes(para.source)
end
test 'does not confuse superscript and links with blank window shorthand' do
para = block_from_string 'http://localhost[Text^] on the 21^st^ and 22^nd^'
assert_equal 'Text on the 21st and 22nd', para.content
end
test 'single-line subscript chars' do
para = block_from_string 'H~2~O'
assert_equal 'H2O', para.sub_quotes(para.source)
end
test 'escaped single-line subscript chars' do
para = block_from_string %(H#{BACKSLASH}~2~O)
assert_equal 'H~2~O', para.sub_quotes(para.source)
end
test 'does not match subscript across whitespace' do
para = block_from_string %(project~ view\non\nGitHub~)
assert_equal para.source, para.sub_quotes(para.source)
end
test 'does not match adjacent subscript chars' do
para = block_from_string 'a ~~ b'
assert_equal 'a ~~ b', para.sub_quotes(para.source)
end
test 'does not match subscript across distinct URLs' do
para = block_from_string 'http://www.abc.com/~def[DEF] and http://www.abc.com/~ghi[GHI]'
assert_equal para.source, para.sub_quotes(para.source)
end
test 'quoted text with role shorthand' do
para = block_from_string '[.white.red-background]#alert#'
assert_equal 'alert', para.sub_quotes(para.source)
end
test 'quoted text with id shorthand' do
para = block_from_string '[#bond]#007#'
assert_equal '007', para.sub_quotes(para.source)
end
test 'quoted text with id and role shorthand' do
para = block_from_string '[#bond.white.red-background]#007#'
assert_equal '007', para.sub_quotes(para.source)
end
test 'quoted text with id and role shorthand with roles before id' do
para = block_from_string '[.white.red-background#bond]#007#'
assert_equal '007', para.sub_quotes(para.source)
end
test 'quoted text with id and role shorthand with roles around id' do
para = block_from_string '[.white#bond.red-background]#007#'
assert_equal '007', para.sub_quotes(para.source)
end
test 'quoted text with id and role shorthand using docbook backend' do
para = block_from_string '[#bond.white.red-background]#007#', backend: 'docbook'
assert_equal '
', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'should replace underscore and hyphen with space in generated alt text for an inline image' do
para = block_from_string 'image:tiger-with-family_1.png[]'
assert_equal '
', para.sub_macros(para.source).gsub(/>\s+<')
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 '', 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’s "roar" is < a bear’s "growl"'
output = (convert_inline_string %(image:tiger-roar.png[#{input}])).gsub(/>\s+<')
assert_equal %(
), 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 '
', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an image macro with an interactive SVG image and alt text should be converted to an object element' do
para = block_from_string 'image:tiger.svg[Tiger,opts=interactive]', safe: Asciidoctor::SafeMode::SERVER, attributes: { 'imagesdir' => 'images' }
assert_equal '', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an image macro with an interactive SVG image, fallback and alt text should be converted to an object element' do
para = block_from_string 'image:tiger.svg[Tiger,fallback=tiger.png,opts=interactive]', safe: Asciidoctor::SafeMode::SERVER, attributes: { 'imagesdir' => 'images' }
assert_equal '', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an image macro with an inline SVG image should be converted to an svg element' do
para = block_from_string 'image:circle.svg[Tiger,100,opts=inline]', safe: Asciidoctor::SafeMode::SERVER, attributes: { 'imagesdir' => 'fixtures', 'docdir' => testdir }
result = para.sub_macros(para.source).gsub(/>\s+<')
assert_match(/
', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'a single-line image macro with text containing escaped square bracket should be interpreted as an image with alt text' do
para = block_from_string %(image:tiger.png[[Another#{BACKSLASH}] Tiger])
assert_equal '', para.sub_macros(para.source).gsub(/>\s+<')
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 '',
para.sub_macros(para.source).gsub(/>\s+<')
end
test 'a single-line image macro with text and dimensions should be interpreted as an image with alt text and dimensions in docbook' do
para = block_from_string 'image:tiger.png[Tiger, 200, 100]', backend: 'docbook'
assert_equal '',
para.sub_macros(para.source).gsub(/>\s+<')
end
test 'a single-line image macro with text and link to self should be interpreted as a self-referencing image with alt text' do
para = block_from_string 'image:tiger.png[Tiger, link=self]', attributes: { 'imagesdir' => 'img' }
assert_equal '
',
para.sub_macros(para.source).gsub(/>\s+<')
end
test 'should link to data URI if value of link attribute is self and inline image is embedded' do
para = block_from_string 'image:circle.svg[Tiger,100,link=self]', safe: Asciidoctor::SafeMode::SERVER, attributes: { 'data-uri' => '', 'imagesdir' => 'fixtures', 'docdir' => testdir }
output = para.sub_macros(para.source).gsub(/>\s+<')
assert_xpath '//a[starts-with(@href,"data:image/svg+xml;base64,")]', output, 1
assert_xpath '//img[starts-with(@src,"data:image/svg+xml;base64,")]', output, 1
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 '',
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 '',
para.sub_macros(para.source).gsub(/>\s+<')
end
test 'rel=nofollow should be added to an image with a link when the nofollow option is set' do
para = block_from_string 'image:tiger.png[Tiger,link=http://en.wikipedia.org/wiki/Tiger,opts=nofollow]'
assert_equal '',
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 '',
para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an inline image macro with a url target should be interpreted as an image' do
para = block_from_string %(Beware of the image:http://example.com/images/tiger.png[tiger].)
assert_equal 'Beware of the 
.',
para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an inline image macro with a float attribute should be interpreted as a floating image' do
para = block_from_string %(image:http://example.com/images/tiger.png[tiger, float="right"] Beware of the tigers!)
assert_equal ' Beware of the tigers!',
para.sub_macros(para.source).gsub(/>\s+<')
end
test 'should prepend value of imagesdir attribute to inline image target if target is relative path' do
para = block_from_string %(Beware of the image:tiger.png[tiger].), attributes: { 'imagesdir' => './images' }
assert_equal 'Beware of the 
.',
para.sub_macros(para.source).gsub(/>\s+<')
end
test 'should not prepend value of imagesdir attribute to inline image target if target is absolute path' do
para = block_from_string %(Beware of the image:/tiger.png[tiger].), attributes: { 'imagesdir' => './images' }
assert_equal 'Beware of the 
.',
para.sub_macros(para.source).gsub(/>\s+<')
end
test 'should not prepend value of imagesdir attribute to inline image target if target is url' do
para = block_from_string %(Beware of the image:http://example.com/images/tiger.png[tiger].), attributes: { 'imagesdir' => './images' }
assert_equal 'Beware of the .',
para.sub_macros(para.source).gsub(/>\s+<')
end
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 
around here.),
para.sub_macros(para.source).gsub(/>\s+<')
end
test 'should not match an inline image macro if target contains a newline character' do
para = block_from_string %(Fear not. There are no image:big\ncats.png[] around here.)
result = para.sub_macros para.source
refute_includes result, '
', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an icon macro should be interpreted as alt text if icons are disabled' do
para = block_from_string 'icon:github[]'
assert_equal '[github]', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'should not mangle icon with link if icons are disabled' do
para = block_from_string 'icon:github[link=https://github.com]'
assert_equal '[github]', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'should not mangle icon inside link if icons are disabled' do
para = block_from_string 'https://github.com[icon:github[] GitHub]'
assert_equal '[github] GitHub', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an icon macro should output alt text if icons are disabled and alt is given' do
para = block_from_string 'icon:github[alt="GitHub"]'
assert_equal '[GitHub]', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an icon macro should be interpreted as a font-based icon when icons=font' do
para = block_from_string 'icon:github[]', attributes: { 'icons' => 'font' }
assert_equal '', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an icon macro with a size should be interpreted as a font-based icon with a size when icons=font' do
para = block_from_string 'icon:github[4x]', attributes: { 'icons' => 'font' }
assert_equal '', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an icon macro with flip should be interpreted as a flipped font-based icon when icons=font' do
para = block_from_string 'icon:shield[fw,flip=horizontal]', attributes: { 'icons' => 'font' }
assert_equal '', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an icon macro with rotate should be interpreted as a rotated font-based icon when icons=font' do
para = block_from_string 'icon:shield[fw,rotate=90]', attributes: { 'icons' => 'font' }
assert_equal '', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'an icon macro with a role and title should be interpreted as a font-based icon with a class and title when icons=font' do
para = block_from_string 'icon:heart[role="red", title="Heart me"]', attributes: { 'icons' => 'font' }
assert_equal '', para.sub_macros(para.source).gsub(/>\s+<')
end
test 'a single-line footnote macro should be registered and output as a footnote' do
para = block_from_string 'Sentence text footnote:[An example footnote.].'
assert_equal %(Sentence text [1].), para.sub_macros(para.source)
assert_equal 1, para.document.catalog[:footnotes].size
footnote = para.document.catalog[:footnotes].first
assert_equal 1, footnote.index
assert_nil footnote.id
assert_equal 'An example footnote.', footnote.text
end
test 'a multi-line footnote macro should be registered and output as a footnote without newline' do
para = block_from_string "Sentence text footnote:[An example footnote\nwith wrapped text.]."
assert_equal %(Sentence text [1].), para.sub_macros(para.source)
assert_equal 1, para.document.catalog[:footnotes].size
footnote = para.document.catalog[:footnotes].first
assert_equal 1, footnote.index
assert_nil footnote.id
assert_equal 'An example footnote with wrapped text.', footnote.text
end
test 'an escaped closing square bracket in a footnote should be unescaped when converted' do
para = block_from_string %(footnote:[a #{BACKSLASH}] b].)
assert_equal %([1].), para.sub_macros(para.source)
assert_equal 1, para.document.catalog[:footnotes].size
footnote = para.document.catalog[:footnotes].first
assert_equal 'a ] b', footnote.text
end
test 'a footnote macro can be directly adjacent to preceding word' do
para = block_from_string 'Sentence textfootnote:[An example footnote.].'
assert_equal 'Sentence text[1].', para.sub_macros(para.source)
end
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.catalog[:footnotes].size
footnote1 = para.document.catalog[:footnotes][0]
assert_equal ']', footnote1.text
footnote2 = para.document.catalog[:footnotes][1]
assert_equal 'a ] b', footnote2.text
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:[https://github.com[GitHub]]'
assert_equal %(Share your code. [1]), para.sub_macros(para.source)
assert_equal 1, para.document.catalog[:footnotes].size
footnote1 = para.document.catalog[:footnotes][0]
assert_equal 'GitHub', 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 [1]\nlibrary.), result
assert_equal 1, para.document.catalog[:footnotes].size
fn1 = para.document.catalog[:footnotes].first
assert_equal 'https://github.com/jline/jline2', fn1.text
end
test 'a footnote macro followed by a semi-colon 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 [1];\nlibrary.), result
assert_equal 1, para.document.catalog[:footnotes].size
fn1 = para.document.catalog[:footnotes].first
assert_equal 'https://github.com/jline/jline2', fn1.text
end
test 'a footnote macro may contain text formatting' do
para = block_from_string 'You can download patches from the product page.footnote:[Only available with an _active_ subscription.]'
para.convert
footnotes = para.document.catalog[:footnotes]
assert_equal 1, footnotes.size
assert_equal 'Only available with an active subscription.', footnotes[0].text
end
test 'an externalized footnote macro may contain text formatting' do
input = <<~'EOS'
:fn-disclaimer: pass:q[footnote:[Only available with an _active_ subscription.]]
You can download patches from the production page.{fn-disclaimer}
EOS
doc = document_from_string input
doc.convert
footnotes = doc.catalog[:footnotes]
assert_equal 1, footnotes.size
assert_equal 'Only available with an active subscription.', footnotes[0].text
end
test 'a footnote macro may contain a shorthand xref' do
# specialcharacters escaping is simulated
para = block_from_string 'text footnote:[<<_install,install>>]'
doc = para.document
doc.register :refs, ['_install', (Asciidoctor::Inline.new doc, :anchor, 'Install', type: :ref, target: '_install'), 'Install']
catalog = doc.catalog
assert_equal %(text [1]), para.sub_macros(para.source)
assert_equal 1, catalog[:footnotes].size
footnote1 = catalog[:footnotes][0]
assert_equal 'install', footnote1.text
end
test 'a footnote macro may contain an xref macro' do
para = block_from_string 'text footnote:[xref:_install[install]]'
doc = para.document
doc.register :refs, ['_install', (Asciidoctor::Inline.new doc, :anchor, 'Install', type: :ref, target: '_install'), 'Install']
catalog = doc.catalog
assert_equal %(text [1]), para.sub_macros(para.source)
assert_equal 1, catalog[:footnotes].size
footnote1 = catalog[:footnotes][0]
assert_equal 'install', 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 [1]), para.sub_macros(para.source)
assert_equal 1, para.document.catalog[:footnotes].size
footnote1 = para.document.catalog[:footnotes][0]
assert_equal 'a [[c]] d', footnote1.text
end
test 'subsequent footnote macros with escaped URLs should be restored in DocBook' do
input = 'foofootnote:[+http://example.com+]barfootnote:[+http://acme.com+]baz'
result = convert_string_to_embedded input, doctype: 'inline', backend: 'docbook'
assert_equal 'fooinline code+++'
result = para.extract_passthroughs para.source
passthroughs = para.instance_variable_get :@passthroughs
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, passthroughs.size
assert_equal 'inline code', passthroughs[0][:text]
assert_empty passthroughs[0][:subs]
end
test 'collect multi-line inline triple plus passthroughs' do
para = block_from_string "+++inline\ncode+++"
result = para.extract_passthroughs para.source
passthroughs = para.instance_variable_get :@passthroughs
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, passthroughs.size
assert_equal "inline\ncode", passthroughs[0][:text]
assert_empty passthroughs[0][:subs]
end
test 'collect inline double dollar passthroughs' do
para = block_from_string '$${code}$$'
result = para.extract_passthroughs para.source
passthroughs = para.instance_variable_get :@passthroughs
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, passthroughs.size
assert_equal '{code}', passthroughs[0][:text]
assert_equal [:specialcharacters], passthroughs[0][:subs]
end
test 'collect inline double plus passthroughs' do
para = block_from_string '++{code}++'
result = para.extract_passthroughs para.source
passthroughs = para.instance_variable_get :@passthroughs
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, passthroughs.size
assert_equal '{code}', passthroughs[0][:text]
assert_equal [:specialcharacters], passthroughs[0][:subs]
end
test 'should not crash if role on passthrough is enclosed in quotes' do
%W(
['role']#{BACKSLASH}++This++++++++++++
['role']#{BACKSLASH}+++++++++This++++++++++++
).each do |input|
para = block_from_string input
assert_includes para.content, %()
end
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 int a = n++; with int a = ++n;!', 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 "$$\n{code}\n$$"
result = para.extract_passthroughs para.source
passthroughs = para.instance_variable_get :@passthroughs
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, passthroughs.size
assert_equal "\n{code}\n", passthroughs[0][:text]
assert_equal [:specialcharacters], passthroughs[0][:subs]
end
test 'collect multi-line inline double plus passthroughs' do
para = block_from_string "++\n{code}\n++"
result = para.extract_passthroughs para.source
passthroughs = para.instance_variable_get :@passthroughs
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, passthroughs.size
assert_equal "\n{code}\n", passthroughs[0][:text]
assert_equal [:specialcharacters], passthroughs[0][:subs]
end
test 'collect passthroughs from inline pass macro' do
para = block_from_string %q(pass:specialcharacters,quotes[['code'\\]])
result = para.extract_passthroughs para.source
passthroughs = para.instance_variable_get :@passthroughs
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, passthroughs.size
assert_equal %q(['code']), passthroughs[0][:text]
assert_equal [:specialcharacters, :quotes], passthroughs[0][:subs]
end
test 'collect multi-line passthroughs from inline pass macro' do
para = block_from_string %(pass:specialcharacters,quotes[['more\ncode'\\]])
result = para.extract_passthroughs para.source
passthroughs = para.instance_variable_get :@passthroughs
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, passthroughs.size
assert_equal %(['more\ncode']), passthroughs[0][:text]
assert_equal [:specialcharacters, :quotes], passthroughs[0][:subs]
end
test 'should find and replace placeholder duplicated by substitution' do
input = '+first passthrough+ followed by link:$$http://example.com/__u_no_format_me__$$[] with passthrough'
result = convert_inline_string input
assert_equal 'first passthrough followed by http://example.com/__u_no_format_me__ 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
passthroughs = para.instance_variable_get :@passthroughs
assert_equal 1, passthroughs.size
assert_equal [:quotes, :attributes], passthroughs[0][:subs]
result = para.restore_passthroughs result
assert_equal 'inline code', subs: [] }
result = para.restore_passthroughs para.source
assert_equal 'some inline code to study', result
end
# NOTE placeholder is surrounded by text to prevent reader from stripping trailing boundary char (unique to test scenario)
test 'restore inline passthroughs with subs' do
para = block_from_string "some #{Asciidoctor::Substitutors::PASS_START}" + '0' + "#{Asciidoctor::Substitutors::PASS_END} to study in the #{Asciidoctor::Substitutors::PASS_START}" + '1' + "#{Asciidoctor::Substitutors::PASS_END} programming language"
para.extract_passthroughs ''
passthroughs = para.instance_variable_get :@passthroughs
passthroughs[0] = { text: '{code}', subs: [:specialcharacters] }
passthroughs[1] = { text: '{language}', subs: [:specialcharacters] }
result = para.restore_passthroughs para.source
assert_equal 'some <code>{code}</code> to study in the {language} programming language', result
end
test 'should restore nested passthroughs' do
result = convert_inline_string %q(+Sometimes you feel pass:q[`mono`].+ Sometimes you +$$don't$$+.)
assert_equal %q(Sometimes you feel mono. Sometimes you don't.), result
end
test 'should not fail to restore remaining passthroughs after processing inline passthrough with macro substitution' do
input = 'pass:m[.] pass:[.]'
assert_equal '. .', (convert_inline_string input)
end
test 'should honor role on double plus passthrough' do
result = convert_inline_string 'Print the version using [var]++{asciidoctor-version}++.'
assert_equal 'Print the version using {asciidoctor-version}.', result
end
test 'complex inline passthrough macro' do
text_to_escape = %q([(] <'basic form'> <'logical operator'> <'basic form'> [)])
para = block_from_string %($$#{text_to_escape}$$)
para.extract_passthroughs para.source
passthroughs = para.instance_variable_get :@passthroughs
assert_equal 1, passthroughs.size
assert_equal text_to_escape, passthroughs[0][:text]
text_to_escape_escaped = %q([(\] <'basic form'> <'logical operator'> <'basic form'> [)\])
para = block_from_string %(pass:specialcharacters[#{text_to_escape_escaped}])
para.extract_passthroughs para.source
passthroughs = para.instance_variable_get :@passthroughs
assert_equal 1, passthroughs.size
assert_equal text_to_escape, passthroughs[0][:text]
end
test 'inline pass macro with a composite sub' do
para = block_from_string %(pass:verbatim[<{backend}>])
assert_equal '<{backend}>', para.content
end
context 'Math macros' do
test 'should passthrough text in asciimath macro and surround with AsciiMath delimiters' do
using_memory_logger do |logger|
input = 'asciimath:[x/x={(1,if x!=0),(text{undefined},if x=0):}]'
para = block_from_string input, attributes: { 'attribute-missing' => 'warn' }
assert_equal '\$x/x={(1,if x!=0),(text{undefined},if x=0):}\$', para.content
assert_empty logger
end
end
test 'should not recognize asciimath macro with no content' do
input = 'asciimath:[]'
para = block_from_string input
assert_equal 'asciimath:[]', para.content
end
test 'should perform specialcharacters subs on asciimath macro content in html backend by default' do
input = 'asciimath:[a < b]'
para = block_from_string input
assert_equal '\$a < b\$', para.content
end
test 'should convert contents of asciimath macro to MathML in DocBook output if asciimath gem is available' do
asciimath_available = !(Asciidoctor::Helpers.require_library 'asciimath', true, :ignore).nil?
input = 'asciimath:[a < b]'
expected = 'asciimath:[x = y] should be passed through as literal text', para.content
input = 'the text [x-]`asciimath:[x = y]` should be passed through as `literal` text'
para = block_from_string input
assert_equal 'the text asciimath:[x = y] should be passed through as literal text', para.content
input = 'the text `+asciimath:[x = y]+` should be passed through as `literal` text'
para = block_from_string input
assert_equal 'the text asciimath:[x = y] should be passed through as literal text', para.content
end
test 'should support constrained passthrough in middle of monospace span' do
input = 'a `foo +bar+ baz` kind of thing'
para = block_from_string input
assert_equal 'a foo bar baz kind of thing', para.content
end
test 'should support constrained passthrough in monospace span preceded by escaped boxed attrlist with transitional role' do
input = %(#{BACKSLASH}[x-]`foo +bar+ baz`)
para = block_from_string input
assert_equal '[x-]foo bar baz', para.content
end
test 'should treat monospace phrase with escaped boxed attrlist with transitional role as monospace' do
input = %(#{BACKSLASH}[x-]`*foo* +bar+ baz`)
para = block_from_string input
assert_equal '[x-]foo bar baz', para.content
end
test 'should ignore escaped attrlist with transitional role on monospace phrase if not proceeded by [' do
input = %(#{BACKSLASH}x-]`*foo* +bar+ baz`)
para = block_from_string input
assert_equal %(#{BACKSLASH}x-]foo bar baz), para.content
end
test 'should not process passthrough inside transitional literal monospace span' do
input = 'a [x-]`foo +bar+ baz` kind of thing'
para = block_from_string input
assert_equal 'a foo +bar+ baz kind of thing', para.content
end
test 'should support constrained passthrough in monospace phrase with attrlist' do
input = '[.role]`foo +bar+ baz`'
para = block_from_string input
assert_equal 'foo bar baz', para.content
end
test 'should support attrlist on a literal monospace phrase' do
input = '[.baz]`+foo--bar+`'
para = block_from_string input
assert_equal 'foo--bar', para.content
end
test 'should not process an escaped passthrough macro inside a monospaced phrase' do
input = 'use the `\pass:c[]` macro'
para = block_from_string input
assert_equal 'use the pass:c[] macro', para.content
end
test 'should not process an escaped passthrough macro inside a monospaced phrase with attributes' do
input = 'use the [syntax]`\pass:c[]` macro'
para = block_from_string input
assert_equal 'use the pass:c[] macro', para.content
end
test 'should honor an escaped single plus passthrough inside a monospaced phrase' do
input = 'use `\+{author}+` to show an attribute reference'
para = block_from_string input, attributes: { 'author' => 'Dan' }
assert_equal 'use +Dan+ to show an attribute reference', para.content
end
test 'should not recognize stem macro with no content' do
input = 'stem:[]'
para = block_from_string input
assert_equal input, para.content
end
test 'should passthrough text in stem macro and surround with AsciiMath delimiters if stem attribute is asciimath, empty, or not set' do
[
{},
{ 'stem' => '' },
{ 'stem' => 'asciimath' },
{ 'stem' => 'bogus' },
].each do |attributes|
using_memory_logger do |logger|
input = 'stem:[x/x={(1,if x!=0),(text{undefined},if x=0):}]'
para = block_from_string input, attributes: (attributes.merge 'attribute-missing' => 'warn')
assert_equal '\$x/x={(1,if x!=0),(text{undefined},if x=0):}\$', para.content
assert_empty logger
end
end
end
test 'should passthrough text in stem macro and surround with LaTeX math delimiters if stem attribute is latexmath, latex, or tex' do
[
{ 'stem' => 'latexmath' },
{ 'stem' => 'latex' },
{ 'stem' => 'tex' },
].each do |attributes|
input = 'stem:[C = \alpha + \beta Y^{\gamma} + \epsilon]'
para = block_from_string input, attributes: attributes
assert_equal '\(C = \alpha + \beta Y^{\gamma} + \epsilon\)', para.content
end
end
test 'should apply substitutions specified on stem macro' do
['stem:c,a[sqrt(x) <=> {solve-for-x}]', 'stem:n,-r[sqrt(x) <=> {solve-for-x}]'].each do |input|
para = block_from_string input, attributes: { 'stem' => 'asciimath', 'solve-for-x' => '13' }
assert_equal '\$sqrt(x) <=> 13\$', para.content
end
end
test 'should replace passthroughs inside stem expression' do
[
['stem:[+1+]', '\$1\$'],
['stem:[+\infty-(+\infty)]', '\$\infty-(\infty)\$'],
['stem:[+++\infty-(+\infty)++]', '\$+\infty-(+\infty)\$'],
].each do |input, expected|
para = block_from_string input, attributes: { 'stem' => '' }
assert_equal expected, para.content
end
end
test 'should allow passthrough inside stem expression to be escaped' do
[
['stem:[\+] and stem:[+]', '\$+\$ and \$+\$'],
['stem:[\+1+]', '\$+1+\$'],
].each do |input, expected|
para = block_from_string input, attributes: { 'stem' => '' }
assert_equal expected, para.content
end
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 '< " ∴ " " >'
assert_equal '< " ∴ " " >', para.apply_subs(para.source)
end
test 'replaces arrows' do
para = block_from_string '<- -> <= => \<- \-> \<= \=>'
assert_equal '← → ⇐ ⇒ <- -> <= =>', para.apply_subs(para.source)
end
test 'replaces dashes' do
input = <<~'EOS'
-- foo foo--bar foo\--bar foo -- bar foo \-- bar
stuff in between
-- foo
stuff in between
foo --
stuff in between
foo --
EOS
expected = <<~'EOS'.chop
— foo foo—bar foo--bar foo — bar foo -- bar
stuff in between — foo
stuff in between
foo — stuff in between
foo —
EOS
para = block_from_string input
assert_equal expected, para.sub_replacements(para.source)
end
test 'replaces dashes between multibyte word characters' do
para = block_from_string %(富--巴)
expected = '富—巴'
assert_equal expected, para.sub_replacements(para.source)
end
test 'replaces marks' do
para = block_from_string '(C) (R) (TM) \(C) \(R) \(TM)'
assert_equal '© ® ™ (C) (R) (TM)', para.sub_replacements(para.source)
end
test 'preserves entity references' do
input = '& © ✔ 😀 • 😀'
result = convert_inline_string input
assert_equal input, result
end
test 'only preserves named entities with two or more letters' do
input = '& &a; >'
result = convert_inline_string input
assert_equal '& &a; >', result
end
test 'replaces punctuation' do
para = block_from_string %(John's Hideout is the Whites`' place... foo\\'bar)
assert_equal "John’s Hideout is the Whites’ place… foo'bar", para.sub_replacements(para.source)
end
test 'should replace right single quote marks' do
given = [
%(`'Twas the night),
%(a `'57 Chevy!),
%(the whites`' place),
%(the whites`'.),
%(the whites`'--where the wild things are),
%(the whites`'\nhave),
%(It's Mary`'s little lamb.),
%(consecutive single quotes '' are not modified),
%(he is 6' tall),
%(\\`'),
]
expected = [
%(’Twas the night),
%(a ’57 Chevy!),
%(the whites’ place),
%(the whites’.),
%(the whites’--where the wild things are),
%(the whites’\nhave),
%(It’s Mary’s little lamb.),
%(consecutive single quotes '' are not modified),
%(he is 6' tall),
%(`'),
]
given.size.times do |i|
para = block_from_string given[i]
assert_equal expected[i], para.sub_replacements(para.source)
end
end
end
context 'Post replacements' do
test 'line break inserted after line with line break character' do
para = block_from_string "First line +\nSecond line"
result = para.apply_subs para.lines, (para.expand_subs :post_replacements)
assert_equal 'First line', result.first end test 'line break inserted after line wrap with hardbreaks enabled' do para = block_from_string "First line\nSecond line", attributes: { 'hardbreaks' => '' } result = para.apply_subs para.lines, (para.expand_subs :post_replacements) assert_equal 'First line
', result.first end test 'line break character stripped from end of line with hardbreaks enabled' do para = block_from_string "First line +\nSecond line", attributes: { 'hardbreaks' => '' } result = para.apply_subs para.lines, (para.expand_subs :post_replacements) assert_equal 'First line
', result.first end test 'line break not inserted for single line with hardbreaks enabled' do para = block_from_string 'First line', attributes: { 'hardbreaks' => '' } result = para.apply_subs para.lines, (para.expand_subs :post_replacements) assert_equal 'First line', result.first end end context 'Resolve subs' do test 'should resolve subs for block' do doc = empty_document parse: true block = Asciidoctor::Block.new doc, :paragraph block.attributes['subs'] = 'quotes,normal' block.commit_subs assert_equal [:quotes, :specialcharacters, :attributes, :replacements, :macros, :post_replacements], block.subs end test 'should resolve specialcharacters sub as highlight for source block when source highlighter is coderay' do doc = empty_document attributes: { 'source-highlighter' => 'coderay' }, parse: true block = Asciidoctor::Block.new doc, :listing, content_model: :verbatim block.style = 'source' block.attributes['subs'] = 'specialcharacters' block.attributes['language'] = 'ruby' block.commit_subs assert_equal [:highlight], block.subs end test 'should resolve specialcharacters sub as highlight for source block when source highlighter is pygments', if: ENV['PYGMENTS_VERSION'] do doc = empty_document attributes: { 'source-highlighter' => 'pygments' }, parse: true block = Asciidoctor::Block.new doc, :listing, content_model: :verbatim block.style = 'source' block.attributes['subs'] = 'specialcharacters' block.attributes['language'] = 'ruby' block.commit_subs assert_equal [:highlight], block.subs end test 'should not replace specialcharacters sub with highlight for source block when source highlighter is not set' do doc = empty_document parse: true block = Asciidoctor::Block.new doc, :listing, content_model: :verbatim block.style = 'source' block.attributes['subs'] = 'specialcharacters' block.attributes['language'] = 'ruby' block.commit_subs assert_equal [:specialcharacters], block.subs end test 'should not use subs if subs option passed to block constructor is nil' do doc = empty_document parse: true block = Asciidoctor::Block.new doc, :paragraph, source: '*bold* _italic_', subs: nil, attributes: { 'subs' => 'quotes' } assert_empty block.subs block.commit_subs assert_empty block.subs end test 'should not use subs if subs option passed to block constructor is empty array' do doc = empty_document parse: true block = Asciidoctor::Block.new doc, :paragraph, source: '*bold* _italic_', subs: [], attributes: { 'subs' => 'quotes' } assert_empty block.subs block.commit_subs assert_empty block.subs end test 'should use subs from subs option passed to block constructor' do doc = empty_document parse: true block = Asciidoctor::Block.new doc, :paragraph, source: '*bold* _italic_', subs: [:specialcharacters], attributes: { 'subs' => 'quotes' } assert_equal [:specialcharacters], block.subs block.commit_subs assert_equal [:specialcharacters], block.subs end test 'should use subs from subs attribute if subs option is not passed to block constructor' do doc = empty_document parse: true block = Asciidoctor::Block.new doc, :paragraph, source: '*bold* _italic_', attributes: { 'subs' => 'quotes' } assert_empty block.subs # in this case, we have to call commit_subs to resolve the subs block.commit_subs assert_equal [:quotes], block.subs end test 'should use subs from subs attribute if subs option passed to block constructor is :default' do doc = empty_document parse: true block = Asciidoctor::Block.new doc, :paragraph, source: '*bold* _italic_', subs: :default, attributes: { 'subs' => 'quotes' } assert_equal [:quotes], block.subs block.commit_subs assert_equal [:quotes], block.subs end test 'should use built-in subs if subs option passed to block constructor is :default and subs attribute is absent' do doc = empty_document parse: true block = Asciidoctor::Block.new doc, :paragraph, source: '*bold* _italic_', subs: :default assert_equal [:specialcharacters, :quotes, :attributes, :replacements, :macros, :post_replacements], block.subs block.commit_subs assert_equal [:specialcharacters, :quotes, :attributes, :replacements, :macros, :post_replacements], block.subs end end end