asciidoctor 2.0.18 → 2.0.23

data/lib/asciidoctor/parser.rb

@@ -43,6 +43,12 @@ class Parser
 
   AuthorKeys = ['author', 'authorinitials', 'firstname', 'middlename', 'lastname', 'email']
 
+  ListContinuationMarker = ::Module.new
+
+  ListContinuationPlaceholder = ::String.new.extend ListContinuationMarker
+
+  ListContinuationString = (::String.new LIST_CONTINUATION).extend ListContinuationMarker
+
   # Internal: A Hash mapping horizontal alignment abbreviations to alignments
   # that can be applied to a table cell (or to all cells in a column)
   TableCellHorzAlignments = {
@@ -398,18 +404,22 @@ class Parser
           # REVIEW this may be doing too much
           if part
             if !section.blocks?
-              # if this block wasn't marked as [partintro], emulate behavior as if it had
+              # if this not a [partintro] open block, enclose it in a [partintro] open block
               if new_block.style != 'partintro'
-                # emulate [partintro] paragraph
-                if new_block.context == :paragraph
-                  new_block.context = :open
+                # if this is already a normal open block, simply add the partintro style
+                if new_block.style == 'open' && new_block.context == :open
                   new_block.style = 'partintro'
-                # emulate [partintro] open block
                 else
                   new_block.parent = (intro = Block.new section, :open, content_model: :compound)
                   intro.style = 'partintro'
                   section.blocks << intro
                 end
+              # if this is a [partintro] paragraph, convert it to a [partintro] open block w/ single paragraph
+              elsif new_block.content_model == :simple
+                new_block.content_model = :compound
+                new_block << (Block.new new_block, :paragraph, source: new_block.lines, subs: new_block.subs)
+                new_block.lines.clear
+                new_block.subs.clear
               end
             elsif section.blocks.size == 1
               first_block = section.blocks[0]
@@ -419,12 +429,11 @@ class Parser
               # rebuild [partintro] paragraph as an open block
               elsif first_block.content_model != :compound
                 new_block.parent = (intro = Block.new section, :open, content_model: :compound)
-                intro.style = 'partintro'
-                section.blocks.shift
-                if first_block.style == 'partintro'
+                if first_block.style == (intro.style = 'partintro')
                   first_block.context = :paragraph
                   first_block.style = nil
                 end
+                section.blocks.shift
                 intro << first_block
                 section.blocks << intro
               end
@@ -552,6 +561,7 @@ class Parser
       # process lines verbatim
       if style && Compliance.strict_verbatim_paragraphs && (VERBATIM_STYLES.include? style)
         block_context = style.to_sym
+        cloaked_context = :paragraph
         reader.unshift_line this_line
         # advance to block parsing =>
         break
@@ -809,16 +819,17 @@ class Parser
     unless block
       case block_context
       when :listing, :source
-        if block_context == :source || (!attributes[1] && (language = attributes[2] || doc_attrs['source-language']))
-          if language
+        if block_context == :source || (language = attributes[1] ? nil : attributes[2] || doc_attrs['source-language'])
+          if language # :listing
             attributes['style'] = 'source'
             attributes['language'] = language
             AttributeList.rekey attributes, [nil, nil, 'linenums']
-          else
+          else # :source
             AttributeList.rekey attributes, [nil, 'language', 'linenums']
             if doc_attrs.key? 'source-language'
               attributes['language'] = doc_attrs['source-language']
             end unless attributes.key? 'language'
+            attributes['cloaked-context'] = cloaked_context unless cloaked_context == :listing
           end
           if attributes['linenums-option'] || doc_attrs['source-linenums-option']
             attributes['linenums'] = ''
@@ -847,6 +858,7 @@ class Parser
         else
           attributes['language'] = language
         end
+        attributes['cloaked-context'] = cloaked_context
         if attributes['linenums-option'] || doc_attrs['source-linenums-option']
           attributes['linenums'] = ''
         end unless attributes.key? 'linenums'
@@ -1168,8 +1180,8 @@ class Parser
           if reftext.include? ']'
             reftext = reftext.gsub '\]', ']'
             reftext = document.sub_attributes reftext if reftext.include? ATTR_REF_HEAD
-          elsif (reftext.include? ATTR_REF_HEAD) && (reftext = document.sub_attributes reftext).empty?
-            next
+          elsif reftext.include? ATTR_REF_HEAD
+            reftext = nil if (reftext = document.sub_attributes reftext).empty?
           end
         end
       end
@@ -1417,17 +1429,18 @@ class Parser
       # the termination of the list
       break if is_sibling_list_item?(this_line, list_type, sibling_trait)
 
+      this_line = ListContinuationString if this_line == LIST_CONTINUATION
       prev_line = buffer.empty? ? nil : buffer[-1]
 
-      if prev_line == LIST_CONTINUATION
+      if ListContinuationMarker === prev_line
         if continuation == :inactive
           continuation = :active
           has_text = true
-          buffer[-1] = '' unless within_nested_list
+          buffer[-1] = ListContinuationPlaceholder unless within_nested_list
         end
 
         # dealing with adjacent list continuations (which is really a syntax error)
-        if this_line == LIST_CONTINUATION
+        if ListContinuationMarker === this_line
           if continuation != :frozen
             continuation = :frozen
             buffer << this_line
@@ -1439,21 +1452,34 @@ class Parser
 
       # a delimited block immediately breaks the list unless preceded
       # by a list continuation (they are harsh like that ;0)
-      if (match = is_delimited_block?(this_line, true))
-        if continuation == :active
-          buffer << this_line
-          # grab all the lines in the block, leaving the delimiters in place
-          # we're being more strict here about the terminator, but I think that's a good thing
-          buffer.concat reader.read_lines_until(terminator: match.terminator, read_last_line: true, context: nil)
-          continuation = :inactive
-        else
+      if (match = is_delimited_block? this_line, true)
+        break unless continuation == :active
+        buffer << this_line
+        # grab all the lines in the block, leaving the delimiters in place
+        # we're being more strict here about the terminator, but I think that's a good thing
+        buffer.concat reader.read_lines_until terminator: match.terminator, read_last_line: true, context: nil
+        continuation = :inactive
+      # BlockAttributeLineRx only breaks dlist if ensuing line is not a list item
+      elsif dlist && continuation != :active && (this_line.start_with? '[') && (BlockAttributeLineRx.match? this_line)
+        block_attribute_lines = [this_line]
+        while (next_line = reader.peek_line)
+          if is_delimited_block? next_line
+            interrupt = true
+          elsif next_line.empty? || ((next_line.start_with? '[') && (BlockAttributeLineRx.match? next_line))
+            block_attribute_lines << reader.read_line
+            next
+          elsif (AnyListRx.match? next_line) && !(is_sibling_list_item? next_line, list_type, sibling_trait)
+            buffer.concat block_attribute_lines
+          else # rubocop:disable Lint/DuplicateBranch
+            interrupt = true
+          end
+          break
+        end
+        if interrupt
+          this_line = nil
+          reader.unshift_lines block_attribute_lines
           break
         end
-      # technically BlockAttributeLineRx only breaks if ensuing line is not a list item
-      # which really means BlockAttributeLineRx only breaks if it's acting as a block delimiter
-      # FIXME to be AsciiDoc compliant, we shouldn't break if style in attribute line is "literal" (i.e., [literal])
-      elsif dlist && continuation != :active && (BlockAttributeLineRx.match? this_line)
-        break
       elsif continuation == :active && !this_line.empty?
         # literal paragraphs have special considerations (and this is one of
         # two entry points into one)
@@ -1470,10 +1496,11 @@ class Parser
           end
           continuation = :inactive
         # let block metadata play out until we find the block
-        elsif (BlockTitleRx.match? this_line) || (BlockAttributeLineRx.match? this_line) || (AttributeEntryRx.match? this_line)
+        elsif ((ch0 = this_line.chr) == '.' && (BlockTitleRx.match? this_line)) ||
+            (ch0 == '[' && (BlockAttributeLineRx.match? this_line)) || (ch0 == ':' && (AttributeEntryRx.match? this_line))
           buffer << this_line
         else
-          if (nested_list_type = (within_nested_list ? [:dlist] : NESTABLE_LIST_CONTEXTS).find {|ctx| ListRxMap[ctx].match? this_line })
+          if (nested_list_type = (within_nested_list ? [:dlist] : NESTABLE_LIST_CONTEXTS).find {|ctx| ListRxMap[ctx] =~ this_line })
             within_nested_list = true
             if nested_list_type == :dlist && $3.nil_or_empty?
               # get greedy again
@@ -1494,7 +1521,7 @@ class Parser
 
         if this_line == LIST_CONTINUATION
           detached_continuation = buffer.size
-          buffer << this_line
+          buffer << ListContinuationString
         elsif has_text # has_text only relevant for dlist, which is more greedy until it has text for an item; has_text is always true for all other lists
           # in this block, we have to see whether we stay in the list
           # TODO any way to combine this with the check after skipping blank lines?
@@ -1527,6 +1554,9 @@ class Parser
           buffer << this_line
           has_text = true
         end
+      elsif ListContinuationMarker === this_line
+        has_text = true
+        buffer << this_line
       else
         has_text = true unless this_line.empty?
         if (nested_list_type = (within_nested_list ? [:dlist] : NESTABLE_LIST_CONTEXTS).find {|ctx| ListRxMap[ctx] =~ this_line })
@@ -1543,16 +1573,17 @@ class Parser
 
     reader.unshift_line this_line if this_line
 
-    buffer[detached_continuation] = '' if detached_continuation
+    buffer[detached_continuation] = ListContinuationPlaceholder if detached_continuation
 
     until buffer.empty?
+      # drop optional trailing continuation
+      if ListContinuationMarker === (last_line = buffer[-1])
+        buffer.pop
+        break
       # strip trailing blank lines to prevent empty blocks
-      if (last_line = buffer[-1]).empty?
+      elsif last_line.empty?
         buffer.pop
       else
-        # drop optional trailing continuation
-        # (a blank line would have served the same purpose in the document)
-        buffer.pop if last_line == LIST_CONTINUATION
         break
       end
     end
@@ -2383,6 +2414,7 @@ class Parser
       end
     end
 
+    parser_ctx.close_table
     table.assign_column_widths unless (table.attributes['colcount'] ||= table.columns.size) == 0 || explicit_colspecs
     table.has_header_option = true if implicit_header
     table.partition_header_footer attributes

data/lib/asciidoctor/path_resolver.rb

@@ -109,6 +109,7 @@ class PathResolver
   SLASH = '/'
   BACKSLASH = '\\'
   DOUBLE_SLASH = '//'
+  URI_CLASSLOADER = 'uri:classloader:'
   WindowsRootRx = %r(^(?:[a-zA-Z]:)?[\\/])
 
   attr_accessor :file_separator
@@ -148,8 +149,9 @@ class PathResolver
   # Public: Check if the specified path is an absolute root path (or, in the
   # browser environment, an absolute URI as well)
   #
-  # This operation considers both posix paths and Windows paths. If the JavaScript IO
-  # module is xmlhttprequest, this operation also considers absolute URIs.
+  # This operation considers both POSIX and Windows paths. If the JavaScript IO module
+  # is xmlhttprequest, this operation also considers absolute URIs. If running on JRuby,
+  # this operation also considers classloader URIs (starts with uri:classloader:).
   #
   # Unix absolute paths and UNC paths start with slash. Windows roots can
   # start with a drive letter. When the IO module is xmlhttprequest (Opal
@@ -164,6 +166,10 @@ class PathResolver
     def root? path
       (absolute_path? path) || (path.start_with? 'file://', 'http://', 'https://')
     end
+  elsif ::RUBY_ENGINE == 'jruby'
+    def root? path
+      (absolute_path? path) || (path.start_with? URI_CLASSLOADER)
+    end
   else
     alias root? absolute_path?
   end
@@ -299,6 +305,9 @@ class PathResolver
       # ex. /sample/path
       elsif posix_path.start_with? SLASH
         root = SLASH
+      # ex. uri:classloader:sample/path (or uri:classloader:/sample/path)
+      elsif posix_path.start_with? URI_CLASSLOADER
+        root = posix_path.slice 0, URI_CLASSLOADER.length
       # ex. C:/sample/path (or file:///sample/path in browser environment)
       else
         root = posix_path.slice 0, (posix_path.index SLASH) + 1

data/lib/asciidoctor/reader.rb

@@ -125,16 +125,21 @@ class Reader
   # Returns the next line of the source data as a String if there are lines remaining.
   # Returns nothing if there is no more data.
   def peek_line direct = false
-    if direct || @look_ahead > 0
-      @unescape_next_line ? ((line = @lines[-1]).slice 1, line.length) : @lines[-1]
-    elsif @lines.empty?
-      @look_ahead = 0
-      nil
-    else
-      # FIXME the problem with this approach is that we aren't
-      # retaining the modified line (hence the @unescape_next_line tweak)
-      # perhaps we need a stack of proxied lines
-      (process_line @lines[-1]) || peek_line
+    while true
+      next_line = @lines[-1]
+      if direct || @look_ahead > 0
+        return @unescape_next_line ? (next_line.slice 1, next_line.length) : next_line
+      elsif next_line
+        # FIXME the problem with this approach is that we aren't
+        # retaining the modified line (hence the @unescape_next_line tweak)
+        # perhaps we need a stack of proxied lines
+        if (line = process_line next_line)
+          return line
+        end
+      else
+        @look_ahead = 0
+        return
+      end
     end
   end
 
@@ -815,6 +820,10 @@ class PreprocessorReader < Reader
     return line unless @process_lines
 
     if line.empty?
+      if @skipping
+        shift
+        return
+      end
       @look_ahead += 1
       return line
     end
@@ -1034,6 +1043,7 @@ class PreprocessorReader < Reader
     # if running in SafeMode::SECURE or greater, don't process this directive
     # however, be friendly and at least make it a link to the source document
     elsif doc.safe >= SafeMode::SECURE
+      expanded_target = %(pass:c[#{expanded_target}]) if expanded_target.include? ' '
       # FIXME we don't want to use a link macro if we are in a verbatim context
       replace_next_line %(link:#{expanded_target}[role=include])
     elsif @maxdepth
@@ -1197,15 +1207,16 @@ class PreprocessorReader < Reader
           push_include inc_lines, inc_path, relpath, inc_offset, parsed_attrs
         end
       else
+        inc_content = nil
         begin
           # NOTE read content before shift so cursor is only advanced if IO operation succeeds
           inc_content = reader.call(inc_path, read_mode) {|f| f.read }
           shift
-          push_include inc_content, inc_path, relpath, 1, parsed_attrs
         rescue
           logger.error message_with_context %(include #{target_type} not readable: #{inc_path}), source_location: cursor
           return replace_next_line %(Unresolved directive in #{@path} - include::#{expanded_target}[#{attrlist}])
         end
+        push_include inc_content, inc_path, relpath, 1, parsed_attrs
       end
       true
     end
@@ -1232,7 +1243,10 @@ class PreprocessorReader < Reader
   def resolve_include_path target, attrlist, attributes
     doc = @document
     if (Helpers.uriish? target) || (::String === @dir ? nil : (target = %(#{@dir}/#{target})))
-      return replace_next_line %(link:#{target}[role=include]) unless doc.attr? 'allow-uri-read'
+      unless doc.attr? 'allow-uri-read'
+        target = %(pass:c[#{target}]) if target.include? ' '
+        return replace_next_line %(link:#{target}[role=include])
+      end
       if doc.attr? 'cache-uri'
         # caching requires the open-uri-cached gem to be installed
         # processing will be automatically aborted if these libraries can't be opened

data/lib/asciidoctor/rx.rb

@@ -89,7 +89,7 @@ module Asciidoctor
   #   include::chapter1.ad[]
   #   include::example.txt[lines=1;2;5..10]
   #
-  IncludeDirectiveRx = /^(\\)?include::([^\[][^\[]*)\[(#{CC_ANY}+)?\]$/
+  IncludeDirectiveRx = /^(\\)?include::([^\s\[](?:[^\[]*[^\s\[])?)\[(#{CC_ANY}+)?\]$/
 
   # Matches a trailing tag directive in an include file.
   #
@@ -103,6 +103,7 @@ module Asciidoctor
   #   }
   #   // end::try-catch[]
   # NOTE m flag is required for Asciidoctor.js
+  # NOTE the regex checks for \r to account of include files that use Windows newlines
   TagDirectiveRx = /\b(?:tag|(e)nd)::(\S+?)\[\](?=$|[ \r])/m
 
   ## Attribute entries and references
@@ -513,12 +514,17 @@ module Asciidoctor
   #
   #   https://github.com
   #   https://github.com[GitHub]
-  #   <https://github.com>
+  #   <https://github.com> <= angle brackets not included in autolink
   #   link:https://github.com[]
   #   "https://github.com[]"
+  #   (https://github.com) <= parenthesis not included in autolink
   #
-  # FIXME revisit! the main issue is we need different rules for implicit vs explicit
-  InlineLinkRx = %r((^|link:|#{CG_BLANK}|&lt;|[>\(\)\[\];"'])(\\?(?:https?|file|ftp|irc)://[^\s\[\]<]*([^\s.,\[\]<]))(?:\[(|#{CC_ALL}*?[^\\])\])?)m
+  if RUBY_ENGINE == 'opal'
+    # NOTE In JavaScript, a back reference succeeds if not set; invert the logic to give it a match to refute
+    InlineLinkRx = %r((^|link:|#{CG_BLANK}|\\?&lt;(?=\\?(?:https?|file|ftp|irc)(:))|[>\(\)\[\];"'])(\\?(?:https?|file|ftp|irc)://)(?:([^\s\[\]]+)\[(|#{CC_ALL}*?[^\\])\]|(?!\2)([^\s]+?)&gt;|([^\s\[\]<]*([^\s,.?!\[\]<\)]))))
+  else
+    InlineLinkRx = %r((^|link:|#{CG_BLANK}|\\?&lt;()|[>\(\)\[\];"'])(\\?(?:https?|file|ftp|irc)://)(?:([^\s\[\]]+)\[(|#{CC_ALL}*?[^\\])\]|\2([^\s]+?)&gt;|([^\s\[\]<]*([^\s,.?!\[\]<\)]))))m
+  end
 
   # Match a link or e-mail inline macro.
   #
@@ -568,23 +574,17 @@ module Asciidoctor
   # Examples
   #
   #   +text+
-  #   `text` (compat)
+  #   [x-]+text+
+  #   [x-]`text`
+  #   `text` (compat only)
+  #   [role]`text` (compat only)
   #
   # NOTE we always capture the attributes so we know when to use compatible (i.e., legacy) behavior
   InlinePassRx = {
-    false => ['+', '`', /(^|[^#{CC_WORD};:])(?:\[([^\]]+)\])?(\\?(\+|`)(\S|\S#{CC_ALL}*?\S)\4)(?!#{CG_WORD})/m],
-    true  => ['`', nil, /(^|[^`#{CC_WORD}])(?:\[([^\]]+)\])?(\\?(`)([^`\s]|[^`\s]#{CC_ALL}*?\S)\4)(?![`#{CC_WORD}])/m]
+    false => ['+', '-]', /((?:^|[^#{CC_WORD};:\\])(?=(\[)|\+)|\\(?=\[)|(?=\\\+))(?:\2(x-|[^\]]+ x-)\]|(?:\[([^\]]+)\])?(?=(\\)?\+))(\5?(\+|`)(\S|\S#{CC_ALL}*?\S)\7)(?!#{CG_WORD})/m],
+    true => ['`', nil, /(^|[^`#{CC_WORD}])(?:(\Z)()|\[([^\]]+)\](?=(\\))?)?(\5?(`)([^`\s]|[^`\s]#{CC_ALL}*?\S)\7)(?![`#{CC_WORD}])/m],
   }
 
-  # Matches an inline plus passthrough spanning multiple lines, but only when it occurs directly
-  # inside constrained monospaced formatting in non-compat mode.
-  #
-  # Examples
-  #
-  #   +text+
-  #
-  SinglePlusInlinePassRx = /^(\\)?\+(\S|\S#{CC_ALL}*?\S)\+$/m
-
   # Matches several variants of the passthrough inline macro, which may span multiple lines.
   #
   # Examples