asciidoctor 2.0.10 → 2.0.17

data/lib/asciidoctor/parser.rb

@@ -89,10 +89,10 @@ class Parser
   #
   # returns the Document object
   def self.parse(reader, document, options = {})
-    block_attributes = parse_document_header(reader, document)
+    block_attributes = parse_document_header(reader, document, (header_only = options[:header_only]))
 
     # NOTE don't use a postfix conditional here as it's known to confuse JRuby in certain circumstances
-    unless options[:header_only]
+    unless header_only
       while reader.has_more_lines?
         new_section, block_attributes = next_section(reader, document, block_attributes)
         if new_section
@@ -117,14 +117,15 @@ class Parser
   # which are automatically removed by the reader.
   #
   # returns the Hash of orphan block attributes captured above the header
-  def self.parse_document_header(reader, document)
+  def self.parse_document_header(reader, document, header_only = false)
     # capture lines of block-level metadata and plow away comment lines that precede first block
-    block_attrs = parse_block_metadata_lines reader, document
+    block_attrs = reader.skip_blank_lines ? (parse_block_metadata_lines reader, document) : {}
     doc_attrs = document.attributes
 
     # special case, block title is not allowed above document title,
     # carry attributes over to the document body
     if (implicit_doctitle = is_next_line_doctitle? reader, block_attrs, doc_attrs['leveloffset']) && block_attrs['title']
+      doc_attrs['authorcount'] = 0
       return document.finalize_header block_attrs, false
     end
 
@@ -144,7 +145,10 @@ class Parser
         l0_section_title = nil
       else
         document.title = l0_section_title
-        doc_attrs['doctitle'] = doctitle_attr_val = document.apply_header_subs l0_section_title
+        if (doc_attrs['doctitle'] = doctitle_attr_val = document.sub_specialchars l0_section_title).include? ATTR_REF_HEAD
+          # QUESTION should we defer substituting attributes until the end of the header? or should we substitute again if necessary?
+          doc_attrs['doctitle'] = doctitle_attr_val = document.sub_attributes doctitle_attr_val, attribute_missing: 'skip'
+        end
       end
       document.header.source_location = source_location if source_location
       # default to compat-mode if document has setext doctitle
@@ -165,7 +169,7 @@ class Parser
       end
       block_attrs.clear
       (modified_attrs = document.instance_variable_get :@attributes_modified).delete 'doctitle'
-      parse_header_metadata reader, document
+      parse_header_metadata reader, document, nil
       if modified_attrs.include? 'doctitle'
         if (val = doc_attrs['doctitle']).nil_or_empty? || val == doctitle_attr_val
           doc_attrs['doctitle'] = doctitle_attr_val
@@ -176,10 +180,19 @@ class Parser
         modified_attrs << 'doctitle'
       end
       document.register :refs, [doc_id, document] if doc_id
+    elsif (author = doc_attrs['author'])
+      author_metadata = process_authors author, true, false
+      author_metadata.delete 'authorinitials' if doc_attrs['authorinitials']
+      doc_attrs.update author_metadata
+    elsif (author = doc_attrs['authors'])
+      author_metadata = process_authors author, true
+      doc_attrs.update author_metadata
+    else
+      doc_attrs['authorcount'] = 0
     end
 
     # parse title and consume name section of manpage document
-    parse_manpage_header reader, document, block_attrs if document.doctype == 'manpage'
+    parse_manpage_header reader, document, block_attrs, header_only if document.doctype == 'manpage'
 
     # NOTE block_attrs are the block-level attributes (not document attributes) that
     # precede the first line of content (document title, first section or first block)
@@ -189,7 +202,7 @@ class Parser
   # Public: Parses the manpage header of the AsciiDoc source read from the Reader
   #
   # returns Nothing
-  def self.parse_manpage_header(reader, document, block_attributes)
+  def self.parse_manpage_header(reader, document, block_attributes, header_only = false)
     if ManpageTitleVolnumRx =~ (doc_attrs = document.attributes)['doctitle']
       doc_attrs['manvolnum'] = manvolnum = $2
       doc_attrs['mantitle'] = (((mantitle = $1).include? ATTR_REF_HEAD) ? (document.sub_attributes mantitle) : mantitle).downcase
@@ -206,6 +219,8 @@ class Parser
         doc_attrs['docname'] = manname
         doc_attrs['outfilesuffix'] = %(.#{manvolnum})
       end
+    elsif header_only
+      # done
     else
       reader.skip_blank_lines
       reader.save
@@ -215,9 +230,6 @@ class Parser
           name_section = initialize_section reader, document, {}
           name_section_buffer = (reader.read_lines_until break_on_blank_lines: true, skip_line_comments: true).map {|l| l.lstrip }.join ' '
           if ManpageNamePurposeRx =~ name_section_buffer
-            doc_attrs['manname-title'] ||= name_section.title
-            doc_attrs['manname-id'] = name_section.id if name_section.id
-            doc_attrs['manpurpose'] = $2
             if (manname = $1).include? ATTR_REF_HEAD
               manname = document.sub_attributes manname
             end
@@ -226,8 +238,14 @@ class Parser
             else
               mannames = [manname]
             end
+            if (manpurpose = $2).include? ATTR_REF_HEAD
+              manpurpose = document.sub_attributes manpurpose
+            end
+            doc_attrs['manname-title'] ||= name_section.title
+            doc_attrs['manname-id'] = name_section.id if name_section.id
             doc_attrs['manname'] = manname
             doc_attrs['mannames'] = mannames
+            doc_attrs['manpurpose'] = manpurpose
             if document.backend == 'manpage'
               doc_attrs['docname'] = manname
               doc_attrs['outfilesuffix'] = %(.#{manvolnum})
@@ -327,7 +345,7 @@ class Parser
       if current_level == 0
         part = book
       elsif current_level == 1 && section.special
-        # NOTE technically preface and abstract sections are only permitted in the book doctype
+        # NOTE technically preface sections are only permitted in the book doctype
         unless (sectname = section.sectname) == 'appendix' || sectname == 'preface' || sectname == 'abstract'
           expected_next_level = nil
         end
@@ -415,9 +433,6 @@ class Parser
 
           (intro || section).blocks << new_block
           attributes.clear
-        #else
-        #  # don't clear attributes if we don't find a block because they may
-        #  # be trailing attributes that didn't get associated with a block
         end
       end
 
@@ -433,8 +448,10 @@ class Parser
     # is treated like an untitled section
     elsif preamble # implies parent == document
       if preamble.blocks?
+        if book || document.blocks[1] || !Compliance.unwrap_standalone_preamble
+          preamble.source_location = preamble.blocks[0].source_location if document.sourcemap
         # unwrap standalone preamble (i.e., document has no sections) except for books, if permissible
-        unless book || document.blocks[1] || !Compliance.unwrap_standalone_preamble
+        else
           document.blocks.shift
           while (child_block = preamble.blocks.shift)
             document << child_block
@@ -447,10 +464,10 @@ class Parser
     end
 
     # The attributes returned here are orphaned attributes that fall at the end
-    # of a section that need to get transfered to the next section
+    # of a section that need to get transferred to the next section
     # see "trailing block attributes transfer to the following section" in
     # test/attributes_test.rb for an example
-    [section != parent ? section : nil, attributes.merge]
+    [section == parent ? nil : section, attributes.merge]
   end
 
   # Public: Parse and return the next Block at the Reader's current location
@@ -642,7 +659,7 @@ class Parser
                 if (default_attrs = ext_config[:default_attrs])
                   attributes.update(default_attrs) {|_, old_v| old_v }
                 end
-                if (block = extension.process_method[parent, target, attributes])
+                if (block = extension.process_method[parent, target, attributes]) && block != parent
                   attributes.replace block.attributes
                   break
                 else
@@ -818,8 +835,8 @@ class Parser
             if comma_idx > 0
               language = (language.slice 0, comma_idx).strip
               attributes['linenums'] = '' if comma_idx < ll - 4
-            else
-              attributes['linenums'] = '' if ll > 4
+            elsif ll > 4
+              attributes['linenums'] = ''
             end
           else
             language = language.lstrip
@@ -858,6 +875,7 @@ class Parser
       when :literal
         block = build_block(block_context, :verbatim, terminator, parent, reader, attributes)
       when :example
+        attributes['caption'] = '' if attributes['collapsible-option']
         block = build_block(block_context, :compound, terminator, parent, reader, attributes)
       when :quote, :verse
         AttributeList.rekey(attributes, [nil, 'attribution', 'citetitle'])
@@ -899,9 +917,7 @@ class Parser
     # FIXME title and caption should be assigned when block is constructed (though we need to handle all cases)
     if attributes['title']
       block.title = block_title = attributes.delete 'title'
-      if (caption_attr_name = CAPTION_ATTR_NAMES[block.context]) && document.attributes[caption_attr_name]
-        block.assign_caption (attributes.delete 'caption')
-      end
+      block.assign_caption attributes.delete 'caption' if CAPTION_ATTRIBUTE_NAMES[block.context]
     end
     # TODO eventually remove the style attribute from the attributes hash
     #block.style = attributes.delete 'style'
@@ -963,17 +979,12 @@ class Parser
       # special case for fenced code blocks
       if Compliance.markdown_syntax && (tip.start_with? '`')
         if tip_len == 4
-          if tip == '````'
-            return
-          elsif (tip = tip.chop) == '```'
-            line = tip
-            line_len = tip_len = 3
-          else
+          if tip == '````' || (tip = tip.chop) != '```'
             return
           end
-        elsif tip == '```'
-          # keep it
-        else
+          line = tip
+          line_len = tip_len = 3
+        elsif tip != '```'
           return
         end
       elsif tip_len == 3
@@ -991,9 +1002,10 @@ class Parser
   # if terminator is false, that means the all the lines in the reader should be parsed
   # NOTE could invoke filter in here, before and after parsing
   def self.build_block(block_context, content_model, terminator, parent, reader, attributes, options = {})
-    if content_model == :skip
+    case content_model
+    when :skip
       skip_processing, parse_as_content_model = true, :simple
-    elsif content_model == :raw
+    when :raw
       skip_processing, parse_as_content_model = false, :simple
     else
       skip_processing, parse_as_content_model = false, content_model
@@ -1022,14 +1034,15 @@ class Parser
       block_reader = Reader.new reader.read_lines_until(terminator: terminator, skip_processing: skip_processing, context: block_context, cursor: :at_mark), block_cursor
     end
 
-    if content_model == :verbatim
+    case content_model
+    when :verbatim
       tab_size = (attributes['tabsize'] || parent.document.attributes['tabsize']).to_i
       if (indent = attributes['indent'])
         adjust_indentation! lines, indent.to_i, tab_size
       elsif tab_size > 0
         adjust_indentation! lines, -1, tab_size
       end
-    elsif content_model == :skip
+    when :skip
       # QUESTION should we still invoke process method if extension is specified?
       return
     end
@@ -1037,12 +1050,12 @@ class Parser
     if (extension = options[:extension])
       # QUESTION do we want to delete the style?
       attributes.delete('style')
-      if (block = extension.process_method[parent, block_reader || (Reader.new lines), attributes.merge])
+      if (block = extension.process_method[parent, block_reader || (Reader.new lines), attributes.merge]) && block != parent
         attributes.replace block.attributes
         # FIXME if the content model is set to compound, but we only have simple in this context, then
         # forcefully set the content_model to simple to prevent parsing blocks from children
         # TODO document this behavior!!
-        if block.content_model == :compound && !(lines = block.lines).empty?
+        if block.content_model == :compound && Block === block && !(lines = block.lines).empty?
           content_model = :compound
           block_reader = Reader.new lines
         end
@@ -1148,14 +1161,16 @@ class Parser
   def self.catalog_inline_anchors text, block, document, reader
     text.scan InlineAnchorScanRx do
       if (id = $1)
-        if (reftext = $2)
-          next if (reftext.include? ATTR_REF_HEAD) && (reftext = document.sub_attributes reftext).empty?
-        end
+        next if (reftext = $2) && (reftext.include? ATTR_REF_HEAD) && (reftext = document.sub_attributes reftext).empty?
       else
         id = $3
         if (reftext = $4)
-          reftext = reftext.gsub '\]', ']' if reftext.include? ']'
-          next if (reftext.include? ATTR_REF_HEAD) && (reftext = document.sub_attributes reftext).empty?
+          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
+          end
         end
       end
       unless document.register :refs, [id, (Inline.new block, :anchor, reftext, type: :ref, id: id)]
@@ -1288,7 +1303,8 @@ class Parser
       has_text = true
       list_item = ListItem.new(list_block, (item_text = match[2]))
       list_item.source_location = reader.cursor if list_block.document.sourcemap
-      if list_type == :ulist
+      case list_type
+      when :ulist
         list_item.marker = sibling_trait
         if item_text.start_with?('[')
           if style && style == 'bibliography'
@@ -1306,13 +1322,13 @@ class Parser
             list_item.text = item_text.slice(4, item_text.length)
           end
         end
-      elsif list_type == :olist
+      when :olist
         sibling_trait, implicit_style = resolve_ordered_list_marker(sibling_trait, (ordinal = list_block.items.size), true, reader)
         list_item.marker = sibling_trait
         if ordinal == 0 && !style
           # using list level makes more sense, but we don't track it
-          # basing style on marker level is compliant with AsciiDoc Python
-          list_block.style = implicit_style || ((ORDERED_LIST_STYLES[sibling_trait.length - 1] || 'arabic').to_s)
+          # basing style on marker level is compliant with AsciiDoc.py
+          list_block.style = implicit_style || (ORDERED_LIST_STYLES[sibling_trait.length - 1] || 'arabic').to_s
         end
         if item_text.start_with?('[[') && LeadingInlineAnchorRx =~ item_text
           catalog_inline_anchor $1, $2, list_item, reader
@@ -1438,95 +1454,89 @@ class Parser
       # 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
-      else
-        if continuation == :active && !this_line.empty?
-          # literal paragraphs have special considerations (and this is one of
-          # two entry points into one)
-          # if we don't process it as a whole, then a line in it that looks like a
-          # list item will throw off the exit from it
-          if LiteralParagraphRx.match? this_line
-            reader.unshift_line this_line
-            if dlist
-              # we may be in an indented list disguised as a literal paragraph
-              # so we need to make sure we don't slurp up a legitimate sibling
-              buffer.concat reader.read_lines_until(preserve_last_line: true, break_on_blank_lines: true, break_on_list_continuation: true) {|line| is_sibling_list_item? line, list_type, sibling_trait }
-            else
-              buffer.concat reader.read_lines_until(preserve_last_line: true, break_on_blank_lines: true, break_on_list_continuation: true)
-            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)
-            buffer << this_line
+      elsif continuation == :active && !this_line.empty?
+        # literal paragraphs have special considerations (and this is one of
+        # two entry points into one)
+        # if we don't process it as a whole, then a line in it that looks like a
+        # list item will throw off the exit from it
+        if LiteralParagraphRx.match? this_line
+          reader.unshift_line this_line
+          if dlist
+            # we may be in an indented list disguised as a literal paragraph
+            # so we need to make sure we don't slurp up a legitimate sibling
+            buffer.concat reader.read_lines_until(preserve_last_line: true, break_on_blank_lines: true, break_on_list_continuation: true) {|line| is_sibling_list_item? line, list_type, sibling_trait }
           else
-            if nested_list_type = (within_nested_list ? [:dlist] : NESTABLE_LIST_CONTEXTS).find {|ctx| ListRxMap[ctx].match? this_line }
-              within_nested_list = true
-              if nested_list_type == :dlist && $3.nil_or_empty?
-                # get greedy again
-                has_text = false
-              end
-            end
-            buffer << this_line
-            continuation = :inactive
+            buffer.concat reader.read_lines_until(preserve_last_line: true, break_on_blank_lines: true, break_on_list_continuation: true)
           end
-        elsif prev_line && prev_line.empty?
-          # advance to the next line of content
-          if this_line.empty?
-            # stop reading if we reach eof
-            break unless (this_line = reader.skip_blank_lines && reader.read_line)
-            # stop reading if we hit a sibling list item
-            break if is_sibling_list_item? this_line, list_type, sibling_trait
+          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)
+          buffer << this_line
+        else
+          if (nested_list_type = (within_nested_list ? [:dlist] : NESTABLE_LIST_CONTEXTS).find {|ctx| ListRxMap[ctx].match? this_line })
+            within_nested_list = true
+            if nested_list_type == :dlist && $3.nil_or_empty?
+              # get greedy again
+              has_text = false
+            end
           end
+          buffer << this_line
+          continuation = :inactive
+        end
+      elsif prev_line && prev_line.empty?
+        # advance to the next line of content
+        if this_line.empty?
+          # stop reading if we reach eof
+          break unless (this_line = reader.skip_blank_lines && reader.read_line)
+          # stop reading if we hit a sibling list item
+          break if is_sibling_list_item? this_line, list_type, sibling_trait
+        end
 
-          if this_line == LIST_CONTINUATION
-            detached_continuation = buffer.size
+        if this_line == LIST_CONTINUATION
+          detached_continuation = buffer.size
+          buffer << this_line
+        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?
+          if is_sibling_list_item?(this_line, list_type, sibling_trait)
+            break
+          elsif (nested_list_type = NESTABLE_LIST_CONTEXTS.find {|ctx| ListRxMap[ctx] =~ this_line })
             buffer << this_line
-          else
-            # has_text is only relevant for dlist, which is more greedy until it has text for an item
-            # for all other lists, has_text is always true
-            # in this block, we have to see whether we stay in the list
-            if has_text
-              # TODO any way to combine this with the check after skipping blank lines?
-              if is_sibling_list_item?(this_line, list_type, sibling_trait)
-                break
-              elsif nested_list_type = NESTABLE_LIST_CONTEXTS.find {|ctx| ListRxMap[ctx] =~ this_line }
-                buffer << this_line
-                within_nested_list = true
-                if nested_list_type == :dlist && $3.nil_or_empty?
-                  # get greedy again
-                  has_text = false
-                end
-              # slurp up any literal paragraph offset by blank lines
-              # NOTE we have to check for indented list items first
-              elsif LiteralParagraphRx.match? this_line
-                reader.unshift_line this_line
-                if dlist
-                  # we may be in an indented list disguised as a literal paragraph
-                  # so we need to make sure we don't slurp up a legitimate sibling
-                  buffer.concat reader.read_lines_until(preserve_last_line: true, break_on_blank_lines: true, break_on_list_continuation: true) {|line| is_sibling_list_item? line, list_type, sibling_trait }
-                else
-                  buffer.concat reader.read_lines_until(preserve_last_line: true, break_on_blank_lines: true, break_on_list_continuation: true)
-                end
-              else
-                break
-              end
-            else # only dlist in need of item text, so slurp it up!
-              # pop the blank line so it's not interpretted as a list continuation
-              buffer.pop unless within_nested_list
-              buffer << this_line
-              has_text = true
-            end
-          end
-        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 }
             within_nested_list = true
             if nested_list_type == :dlist && $3.nil_or_empty?
               # get greedy again
               has_text = false
             end
+          # slurp up any literal paragraph offset by blank lines
+          # NOTE we have to check for indented list items first
+          elsif LiteralParagraphRx.match? this_line
+            reader.unshift_line this_line
+            if dlist
+              # we may be in an indented list disguised as a literal paragraph
+              # so we need to make sure we don't slurp up a legitimate sibling
+              buffer.concat reader.read_lines_until(preserve_last_line: true, break_on_blank_lines: true, break_on_list_continuation: true) {|line| is_sibling_list_item? line, list_type, sibling_trait }
+            else
+              buffer.concat reader.read_lines_until(preserve_last_line: true, break_on_blank_lines: true, break_on_list_continuation: true)
+            end
+          else
+            break
           end
+        else # only dlist in need of item text, so slurp it up!
+          # pop the blank line so it's not interpreted as a list continuation
+          buffer.pop unless within_nested_list
           buffer << this_line
+          has_text = true
+        end
+      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 })
+          within_nested_list = true
+          if nested_list_type == :dlist && $3.nil_or_empty?
+            # get greedy again
+            has_text = false
+          end
         end
+        buffer << this_line
       end
       this_line = nil
     end
@@ -1567,12 +1577,6 @@ class Parser
     sect_style = attributes[1]
     sect_id, sect_reftext, sect_title, sect_level, sect_atx = parse_section_title reader, document, attributes['id']
 
-    if sect_reftext
-      attributes['reftext'] = sect_reftext
-    else
-      sect_reftext = attributes['reftext']
-    end
-
     if sect_style
       if book && sect_style == 'abstract'
         sect_name, sect_level = 'chapter', 1
@@ -1591,6 +1595,7 @@ class Parser
       sect_name = 'section'
     end
 
+    attributes['reftext'] = sect_reftext if sect_reftext
     section = Section.new parent, sect_level
     section.id, section.title, section.sectname, section.source_location = sect_id, sect_title, sect_name, source_location
     if sect_special
@@ -1598,7 +1603,7 @@ class Parser
       if sect_numbered
         section.numbered = true
       elsif document.attributes['sectnums'] == 'all'
-        section.numbered = book && sect_level == 1 ? :chapter : true
+        section.numbered = (book && sect_level == 1 ? :chapter : true)
       end
     elsif document.attributes['sectnums'] && sect_level > 0
       # NOTE a special section here is guaranteed to be nested in another section
@@ -1610,7 +1615,7 @@ class Parser
     # generate an ID if one was not embedded or specified as anchor above section title
     if (id = section.id || (section.id = (document.attributes.key? 'sectids') ? (generated_id = Section.generate_id section.title, document) : nil))
       # convert title to resolve attributes while in scope
-      section.title if sect_title.include? ATTR_REF_HEAD unless generated_id
+      section.title unless generated_id || !(sect_title.include? ATTR_REF_HEAD)
       unless document.register :refs, [id, section]
         logger.warn message_with_context %(id assigned to section already in use: #{id}), source_location: (reader.cursor_at_line reader.lineno - (sect_atx ? 1 : 2))
       end
@@ -1629,9 +1634,8 @@ class Parser
   #
   # Returns the Integer section level if the Reader is positioned at a section title or nil otherwise
   def self.is_next_line_section?(reader, attributes)
-    if (style = attributes[1]) && (style == 'discrete' || style == 'float')
-      return
-    elsif Compliance.underline_style_section_titles
+    return if (style = attributes[1]) && (style == 'discrete' || style == 'float')
+    if Compliance.underline_style_section_titles
       next_lines = reader.peek_lines 2, style && style == 'comment'
       is_section_title?(next_lines[0] || '', next_lines[1])
     else
@@ -1777,38 +1781,31 @@ class Parser
   #  parse_header_metadata(Reader.new data, nil, normalize: true)
   #  # => { 'author' => 'Author Name', 'firstname' => 'Author', 'lastname' => 'Name', 'email' => 'author@example.org',
   #  #       'revnumber' => '1.0', 'revdate' => '2012-12-21', 'revremark' => 'Coincide w/ end of world.' }
-  def self.parse_header_metadata(reader, document = nil)
+  def self.parse_header_metadata reader, document = nil, retrieve = true
     doc_attrs = document && document.attributes
     # NOTE this will discard any comment lines, but not skip blank lines
     process_attribute_entries reader, document
 
-    metadata, implicit_author, implicit_authorinitials = implicit_authors = {}, nil, nil
-
     if reader.has_more_lines? && !reader.next_line_empty?
-      unless (author_metadata = process_authors reader.read_line).empty?
-        if document
-          # apply header subs and assign to document
-          author_metadata.each do |key, val|
-            # NOTE the attributes substitution only applies for the email record
-            doc_attrs[key] = ::String === val ? (document.apply_header_subs val) : val unless doc_attrs.key? key
-          end
-
-          implicit_author = doc_attrs['author']
-          implicit_authorinitials = doc_attrs['authorinitials']
-          implicit_authors = doc_attrs['authors']
+      authorcount = (implicit_author_metadata = process_authors reader.read_line).delete 'authorcount'
+      if document && (doc_attrs['authorcount'] = authorcount) > 0
+        implicit_author_metadata.each do |key, val|
+          # apply header subs and assign to document; attributes substitution only relevant for email
+          doc_attrs[key] = document.apply_header_subs val unless doc_attrs.key? key
         end
-
-        metadata = author_metadata
+        implicit_author = doc_attrs['author']
+        implicit_authorinitials = doc_attrs['authorinitials']
+        implicit_authors = doc_attrs['authors']
       end
+      implicit_author_metadata['authorcount'] = authorcount
 
       # NOTE this will discard any comment lines, but not skip blank lines
       process_attribute_entries reader, document
 
-      rev_metadata = {}
-
       if reader.has_more_lines? && !reader.next_line_empty?
         rev_line = reader.read_line
-        if (match = RevisionInfoLineRx.match(rev_line))
+        if (match = RevisionInfoLineRx.match rev_line)
+          rev_metadata = {}
           rev_metadata['revnumber'] = match[1].rstrip if match[1]
           unless (component = match[2].strip).empty?
             # version must begin with 'v' if date is absent
@@ -1819,31 +1816,24 @@ class Parser
             end
           end
           rev_metadata['revremark'] = match[3].rstrip if match[3]
+          if document && !rev_metadata.empty?
+            # apply header subs and assign to document
+            rev_metadata.each do |key, val|
+              doc_attrs[key] = document.apply_header_subs val unless doc_attrs.key? key
+            end
+          end
         else
           # throw it back
           reader.unshift_line rev_line
         end
       end
 
-      unless rev_metadata.empty?
-        if document
-          # apply header subs and assign to document
-          rev_metadata.each do |key, val|
-            unless doc_attrs.key? key
-              doc_attrs[key] = document.apply_header_subs val
-            end
-          end
-        end
-
-        metadata.update rev_metadata
-      end
-
       # NOTE this will discard any comment lines, but not skip blank lines
       process_attribute_entries reader, document
 
       reader.skip_blank_lines
     else
-      author_metadata = {}
+      implicit_author_metadata = {}
     end
 
     # process author attribute entries that override (or stand in for) the implicit author line
@@ -1860,7 +1850,7 @@ class Parser
         while doc_attrs.key? author_key
           # only use indexed author attribute if value is different
           # leaves corner case if line matches with underscores converted to spaces; use double space to force
-          if (author_override = doc_attrs[author_key]) == author_metadata[author_key]
+          if (author_override = doc_attrs[author_key]) == implicit_author_metadata[author_key]
             authors << nil
             sparse = true
           else
@@ -1872,23 +1862,26 @@ class Parser
         if explicit
           # rebuild implicit author names to reparse
           authors.each_with_index do |author, idx|
-            unless author
-              authors[idx] = [
-                author_metadata[%(firstname_#{name_idx = idx + 1})],
-                author_metadata[%(middlename_#{name_idx})],
-                author_metadata[%(lastname_#{name_idx})]
-              ].compact.map {|it| it.tr ' ', '_' }.join ' '
-            end
+            next if author
+            authors[idx] = [
+              implicit_author_metadata[%(firstname_#{name_idx = idx + 1})],
+              implicit_author_metadata[%(middlename_#{name_idx})],
+              implicit_author_metadata[%(lastname_#{name_idx})]
+            ].compact.map {|it| it.tr ' ', '_' }.join ' '
           end if sparse
           # process as names only
           author_metadata = process_authors authors, true, false
         else
-          author_metadata = {}
+          author_metadata = { 'authorcount' => 0 }
         end
       end
 
-      if author_metadata.empty?
-        metadata['authorcount'] ||= (doc_attrs['authorcount'] = 0)
+      if author_metadata['authorcount'] == 0
+        if authorcount
+          author_metadata = nil
+        else
+          doc_attrs['authorcount'] = 0
+        end
       else
         doc_attrs.update author_metadata
 
@@ -1899,7 +1892,7 @@ class Parser
       end
     end
 
-    metadata
+    implicit_author_metadata.merge rev_metadata.to_h, author_metadata.to_h if retrieve
   end
 
   # Internal: Parse the author line into a Hash of author metadata
@@ -2061,6 +2054,7 @@ class Parser
         return true
       end
     end
+    nil
   end
 
   # Process consecutive attribute entry lines, ignoring adjacent line comments and comment blocks.
@@ -2119,6 +2113,8 @@ class Parser
       name = 'sectnums'
     elsif name == 'hardbreaks'
       name = 'hardbreaks-option'
+    elsif name == 'showtitle'
+      store_attribute 'notitle', (value ? nil : ''), doc, attrs
     end
 
     if doc
@@ -2163,9 +2159,10 @@ class Parser
   #
   # Returns the String 0-index marker for this list item
   def self.resolve_list_marker(list_type, marker, ordinal = 0, validate = false, reader = nil)
-    if list_type == :ulist
+    case list_type
+    when :ulist
       marker
-    elsif list_type == :olist
+    when :olist
       resolve_ordered_list_marker(marker, ordinal, validate, reader)[0]
     else # :colist
       '<1>'
@@ -2273,9 +2270,15 @@ class Parser
     end
 
     skipped = table_reader.skip_blank_lines || 0
+    if attributes['header-option']
+      table.has_header_option = true
+    elsif skipped == 0 && !attributes['noheader-option']
+      # NOTE: assume table has header until we know otherwise; if it doesn't (nil), cells in first row get reprocessed
+      table.has_header_option = :implicit
+      implicit_header = true
+    end
     parser_ctx = Table::ParserContext.new table_reader, table, attributes
     format, loop_idx, implicit_header_boundary = parser_ctx.format, -1, nil
-    implicit_header = true unless skipped > 0 || attributes['header-option'] || attributes['noheader-option']
 
     while (line = table_reader.read_line)
       if (beyond_first = (loop_idx += 1) > 0) && line.empty?
@@ -2295,7 +2298,7 @@ class Parser
             implicit_header_boundary = nil if implicit_header_boundary
           # otherwise, the cell continues from previous line
           elsif implicit_header_boundary && implicit_header_boundary == loop_idx
-            implicit_header, implicit_header_boundary = false, nil
+            table.has_header_option = implicit_header = implicit_header_boundary = nil
           end
         end
       end
@@ -2307,7 +2310,7 @@ class Parser
           if table_reader.has_more_lines? && table_reader.peek_line.empty?
             implicit_header_boundary = 1
           else
-            implicit_header = false
+            table.has_header_option = implicit_header = nil
           end
         end
       end
@@ -2358,7 +2361,7 @@ class Parser
           case format
           when 'csv'
             if parser_ctx.buffer_has_unclosed_quotes?
-              implicit_header, implicit_header_boundary = false, nil if implicit_header_boundary && loop_idx == 0
+              table.has_header_option = implicit_header = implicit_header_boundary = nil if implicit_header_boundary && loop_idx == 0
               parser_ctx.keep_cell_open
             else
               parser_ctx.close_cell true
@@ -2380,15 +2383,8 @@ class Parser
       end
     end
 
-    unless (table.attributes['colcount'] ||= table.columns.size) == 0 || explicit_colspecs
-      table.assign_column_widths
-    end
-
-    if implicit_header
-      table.has_header_option = true
-      attributes['header-option'] = ''
-    end
-
+    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
 
     table
@@ -2469,7 +2465,7 @@ class Parser
 
     if pos == :start
       if line.include? delimiter
-        spec_part, delimiter, rest = line.partition delimiter
+        spec_part, _, rest = line.partition delimiter
         if (m = CellSpecStartRx.match spec_part)
           return [{}, rest] if m[0].empty?
         else
@@ -2478,14 +2474,12 @@ class Parser
       else
         return [nil, line]
       end
-    else # pos == :end
-      if (m = CellSpecEndRx.match line)
-        # NOTE return the line stripped of trailing whitespace if no cellspec is found in this case
-        return [{}, line.rstrip] if m[0].lstrip.empty?
-        rest = m.pre_match
-      else
-        return [{}, line]
-      end
+    elsif (m = CellSpecEndRx.match line) # when pos == :end
+      # NOTE return the line stripped of trailing whitespace if no cellspec is found in this case
+      return [{}, line.rstrip] if m[0].lstrip.empty?
+      rest = m.pre_match
+    else
+      return [{}, line]
     end
 
     spec = {}
@@ -2493,10 +2487,11 @@ class Parser
       colspec, rowspec = m[1].split '.'
       colspec = colspec.nil_or_empty? ? 1 : colspec.to_i
       rowspec = rowspec.nil_or_empty? ? 1 : rowspec.to_i
-      if m[2] == '+'
+      case m[2]
+      when '+'
         spec['colspan'] = colspec unless colspec == 1
         spec['rowspan'] = rowspec unless rowspec == 1
-      elsif m[2] == '*'
+      when '*'
         spec['repeatcol'] = colspec unless colspec == 1
       end
     end
@@ -2521,7 +2516,7 @@ class Parser
   # Public: Parse the first positional attribute and assign named attributes
   #
   # Parse the first positional attribute to extract the style, role and id
-  # parts, assign the values to their cooresponding attribute keys and return
+  # parts, assign the values to their corresponding attribute keys and return
   # the parsed style from the first positional attribute.
   #
   # attributes - The Hash of attributes to process and update
@@ -2561,7 +2556,7 @@ class Parser
           accum = ''
           name = :option
         else
-          accum = accum + c
+          accum += c
         end
       end
 
@@ -2579,9 +2574,7 @@ class Parser
           attributes['role'] = (existing_role = attributes['role']).nil_or_empty? ? (parsed_attrs[:role].join ' ') : %(#{existing_role} #{parsed_attrs[:role].join ' '})
         end
 
-        if parsed_attrs.key? :option
-          (opts = parsed_attrs[:option]).each {|opt| attributes[%(#{opt}-option)] = '' }
-        end
+        parsed_attrs[:option].each {|opt| attributes[%(#{opt}-option)] = '' } if parsed_attrs.key? :option
 
         parsed_style
       else
@@ -2654,9 +2647,9 @@ class Parser
     if tab_size > 0 && lines.any? {|line| line.include? TAB }
       full_tab_space = ' ' * tab_size
       lines.map! do |line|
-        if line.empty?
+        if line.empty? || (tab_idx = line.index TAB).nil?
           line
-        elsif (tab_idx = line.index TAB)
+        else
           if tab_idx == 0
             leading_tabs = 0
             line.each_byte do |b|
@@ -2674,22 +2667,20 @@ class Parser
             if c == TAB
               # calculate how many spaces this tab represents, then replace tab with spaces
               if (offset = idx + spaces_added) % tab_size == 0
-                spaces_added += (tab_size - 1)
-                result = result + full_tab_space
+                spaces_added += tab_size - 1
+                result += full_tab_space
               else
                 unless (spaces = tab_size - offset % tab_size) == 1
-                  spaces_added += (spaces - 1)
+                  spaces_added += spaces - 1
                 end
-                result = result + (' ' * spaces)
+                result += ' ' * spaces
               end
             else
-              result = result + c
+              result += c
             end
             idx += 1
           end
           result
-        else
-          line
         end
       end
     end