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 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(%q{**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(%Q{**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(%q{**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(%q{Git[blue]**Hub**})
assert_equal %q{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 %q{Git[blue]*Hub*}, para.sub_quotes(para.source)
end
test 'single-line unconstrained emphasized chars' do
para = block_from_string(%q{__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(%Q{__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(%q{[gray]__Git__Hub})
assert_equal %q{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 %q{[gray]__Git__Hub}, para.sub_quotes(para.source)
end
test 'single-line constrained monospaced chars' do
para = block_from_string(%q{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(%q{call [x-]+save()+ to persist the changes})
assert_equal 'call save() to persist the changes', para.apply_subs(para.source)
para = block_from_string(%q{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(%q{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(%q{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(%q{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
test 'single-line unconstrained monospaced chars' do
para = block_from_string(%q{Git++Hub++}, :attributes => {'compat-mode' => ''})
assert_equal 'GitHub', para.sub_quotes(para.source)
para = block_from_string(%q{Git[x-]++Hub++})
assert_equal 'GitHub', para.apply_subs(para.source)
para = block_from_string(%q{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(%Q{Git++\nH\nu\nb++}, :attributes => {'compat-mode' => ''})
assert_equal "Git\nH\nu\nb", para.sub_quotes(para.source)
para = block_from_string(%Q{Git[x-]++\nH\nu\nb++})
assert_equal %(Git\nH\nu\nb), para.apply_subs(para.source)
para = block_from_string(%Q{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(%Q{x^(n\n-\n1)^})
assert_equal para.source, para.sub_quotes(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(%Q{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(%q{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(%Q{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(%Q{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(%q{[.white.red-background]#alert#})
assert_equal 'alert', para.sub_quotes(para.source)
end
test 'quoted text with id shorthand' do
para = block_from_string(%q{[#bond]#007#})
assert_equal '007', para.sub_quotes(para.source)
end
test 'quoted text with id and role shorthand' do
para = block_from_string(%q{[#bond.white.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(%q{[#bond.white.red-background]#007#}, :backend => 'docbook45')
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 '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 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)
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 '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 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 endline' 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 an xref macro' 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 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 = <<-EOS
foofootnote:[+http://example.com+]barfootnote:[+http://acme.com+]baz
EOS
result = convert_string_to_embedded input, :doctype => 'inline', :backend => 'docbook'
assert_equal 'fooinline code+++')
result = para.extract_passthroughs(para.source)
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, para.passthroughs.size
assert_equal 'inline code', para.passthroughs[0][:text]
assert_empty para.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)
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, para.passthroughs.size
assert_equal "inline\ncode", para.passthroughs[0][:text]
assert_empty para.passthroughs[0][:subs]
end
test 'collect inline double dollar passthroughs' do
para = block_from_string('$${code}$$')
result = para.extract_passthroughs(para.source)
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, para.passthroughs.size
assert_equal '{code}', para.passthroughs[0][:text]
assert_equal [:specialcharacters], para.passthroughs[0][:subs]
end
test 'collect inline double plus passthroughs' do
para = block_from_string('++{code}++')
result = para.extract_passthroughs(para.source)
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, para.passthroughs.size
assert_equal '{code}', para.passthroughs[0][:text]
assert_equal [:specialcharacters], para.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)
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, para.passthroughs.size
assert_equal "\n{code}\n", para.passthroughs[0][:text]
assert_equal [:specialcharacters], para.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)
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, para.passthroughs.size
assert_equal "\n{code}\n", para.passthroughs[0][:text]
assert_equal [:specialcharacters], para.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)
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, para.passthroughs.size
assert_equal %q{['code']}, para.passthroughs[0][:text]
assert_equal [:specialcharacters, :quotes], para.passthroughs[0][:subs]
end
test 'collect multi-line passthroughs from inline pass macro' do
para = block_from_string(%Q{pass:specialcharacters,quotes[['more\ncode'\\]]})
result = para.extract_passthroughs(para.source)
assert_equal Asciidoctor::Substitutors::PASS_START + '0' + Asciidoctor::Substitutors::PASS_END, result
assert_equal 1, para.passthroughs.size
assert_equal %Q{['more\ncode']}, para.passthroughs[0][:text]
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 = 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
assert_equal 1, para.passthroughs.size
assert_equal [:quotes, :attributes], para.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.passthroughs[0] = {:text => '{code}', :subs => [:specialcharacters]}
para.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 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)
assert_equal 1, para.passthroughs.size
assert_equal text_to_escape, para.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)
assert_equal 1, para.passthroughs.size
assert_equal text_to_escape, para.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
input = 'asciimath:[x/x={(1,if x!=0),(text{undefined},if x=0):}]'
para = block_from_string input
assert_equal '\$x/x={(1,if x!=0),(text{undefined},if x=0):}\$', para.content
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 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
assert_equal 'use +{author}+ 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|
input = 'stem:[x/x={(1,if x!=0),(text{undefined},if x=0):}]'
para = block_from_string input, :attributes => attributes
assert_equal '\$x/x={(1,if x!=0),(text{undefined},if x=0):}\$', para.content
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
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) <=> 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 '< " ∴ " " >'
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
para = block_from_string %(-- foo foo--bar foo\\--bar foo -- bar foo \\-- bar
stuff in between
-- foo
stuff in between
foo --
stuff in between
foo --)
expected = ' — foo foo—bar foo--bar foo — bar foo -- bar
stuff in between — foo
stuff in between
foo — stuff in between
foo — '
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 if ::RUBY_MIN_VERSION_1_9
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 {|i|
para = block_from_string given[i]
assert_equal expected[i], para.sub_replacements(para.source)
}
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 block = Asciidoctor::Block.new(empty_document, :paragraph) block.attributes['subs'] = 'quotes,normal' block.lock_in_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'} block = Asciidoctor::Block.new(doc, :listing, :content_model => :verbatim) block.style = 'source' block.attributes['subs'] = 'specialcharacters' block.attributes['language'] = 'ruby' block.lock_in_subs assert_equal [:highlight], block.subs end test 'should resolve specialcharacters sub as highlight for source block when source highlighter is pygments' do doc = empty_document :attributes => {'source-highlighter' => 'pygments'} block = Asciidoctor::Block.new(doc, :listing, :content_model => :verbatim) block.style = 'source' block.attributes['subs'] = 'specialcharacters' block.attributes['language'] = 'ruby' block.lock_in_subs assert_equal [:highlight], block.subs end test 'should not resolve specialcharacters sub as highlight for source block when source highlighter is not set' do doc = empty_document block = Asciidoctor::Block.new(doc, :listing, :content_model => :verbatim) block.style = 'source' block.attributes['subs'] = 'specialcharacters' block.attributes['language'] = 'ruby' block.lock_in_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 block = Asciidoctor::Block.new doc, :paragraph, :source => '*bold* _italic_', :subs => nil, :attributes => {'subs' => 'quotes'} assert_empty block.subs block.lock_in_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 block = Asciidoctor::Block.new doc, :paragraph, :source => '*bold* _italic_', :subs => [], :attributes => {'subs' => 'quotes'} assert_empty block.subs block.lock_in_subs assert_empty block.subs end test 'should use subs from subs option passed to block constructor' do doc = empty_document block = Asciidoctor::Block.new doc, :paragraph, :source => '*bold* _italic_', :subs => [:specialcharacters], :attributes => {'subs' => 'quotes'} assert_equal [:specialcharacters], block.subs block.lock_in_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 block = Asciidoctor::Block.new doc, :paragraph, :source => '*bold* _italic_', :attributes => {'subs' => 'quotes'} assert_empty block.subs # in this case, we have to call lock_in_subs to resolve the subs block.lock_in_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 block = Asciidoctor::Block.new doc, :paragraph, :source => '*bold* _italic_', :subs => :default, :attributes => {'subs' => 'quotes'} assert_equal [:quotes], block.subs block.lock_in_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 block = Asciidoctor::Block.new doc, :paragraph, :source => '*bold* _italic_', :subs => :default assert_equal [:specialcharacters, :quotes, :attributes, :replacements, :macros, :post_replacements], block.subs block.lock_in_subs assert_equal [:specialcharacters, :quotes, :attributes, :replacements, :macros, :post_replacements], block.subs end end # TODO move to helpers_test.rb context 'Helpers' do test 'should URI encode non-word characters generally' do given = ' /%&?\\' expect = '%20%2F%25%26%3F%5C' 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.uri_encode given) end end end