asciidoctor 2.0.10 → 2.0.17

data/lib/asciidoctor/path_resolver.rb

@@ -109,7 +109,7 @@ class PathResolver
   SLASH = '/'
   BACKSLASH = '\\'
   DOUBLE_SLASH = '//'
-  WindowsRootRx = /^(?:[a-zA-Z]:)?[\\\/]/
+  WindowsRootRx = %r(^(?:[a-zA-Z]:)?[\\/])
 
   attr_accessor :file_separator
   attr_accessor :working_dir
@@ -290,8 +290,8 @@ class PathResolver
       # ex. ./sample/path
       elsif posix_path.start_with? DOT_SLASH
         root = DOT_SLASH
-      # else ex. sample/path
       end
+      # otherwise ex. sample/path
     elsif root? posix_path
       # ex. //sample/path
       if unc? posix_path
@@ -306,8 +306,8 @@ class PathResolver
     # ex. ./sample/path
     elsif posix_path.start_with? DOT_SLASH
       root = DOT_SLASH
-    # else ex. sample/path
     end
+    # otherwise ex. sample/path
 
     path_segments = (root ? (posix_path.slice root.length, posix_path.length) : posix_path).split SLASH
     # strip out all dot entries
@@ -331,11 +331,12 @@ class PathResolver
 
   # Public: Securely resolve a system path
   #
-  # Resolve a system path from the target relative to the start path, jail path, or working
-  # directory (specified in the constructor), in that order. If a jail path is specified, enforce
-  # that the resolved path descends from the jail path. If a jail path is not provided, the resolved
-  # path may be any location on the system. If the resolved path is absolute, use it as is (unless
-  # it breaches the jail path). Expand all parent and self references in the resolved path.
+  # Resolves the target to an absolute path on the current filesystem. The target is assumed to be
+  # relative to the start path, jail path, or working directory (specified in the constructor), in
+  # that order. If a jail path is specified, the resolved path is forced to descend from the jail
+  # path. If a jail path is not provided, the resolved path may be any location on the system. If
+  # the target is an absolute path, use it as is (unless it breaches the jail path). Expands all
+  # parent and self references in the resolved path.
   #
   # target - the String target path
   # start  - the String start path from which to resolve a relative target; falls back to jail, if
@@ -347,8 +348,9 @@ class PathResolver
   #            automatically recover when an illegal path is encountered
   #          * :target_name is used in messages to refer to the path being resolved
   #
-  # returns a String path relative to the start path, if specified, and confined to the jail path,
-  # if specified. The path is posixified and all parent and self references in the path are expanded.
+  # Returns an absolute String path relative to the start path, if specified, and confined to the
+  # jail path, if specified. The path is posixified and all parent and self references in the path
+  # are expanded.
   def system_path target, start = nil, jail = nil, opts = {}
     if jail
       raise ::SecurityError, %(Jail is not an absolute path: #{jail}) unless root? jail
@@ -362,7 +364,7 @@ class PathResolver
         if jail && !(descends_from? target_path, jail)
           if opts.fetch :recover, true
             logger.warn %(#{opts[:target_name] || 'path'} is outside of jail; recovering automatically)
-            target_segments, _ = partition_path target_path
+            target_segments, = partition_path target_path
             jail_segments, jail_root = partition_path jail
             return join_path jail_segments + target_segments, jail_root
           else
@@ -371,7 +373,7 @@ class PathResolver
         end
         return target_path
       else
-        target_segments, _ = partition_path target
+        target_segments, = partition_path target
       end
     else
       target_segments = []
@@ -387,7 +389,7 @@ class PathResolver
           return expand_path start
         end
       else
-        target_segments, _ = partition_path start
+        target_segments, = partition_path start
         start = jail || @working_dir
       end
     elsif start.nil_or_empty?
@@ -419,7 +421,7 @@ class PathResolver
     if (resolved_segments = start_segments + target_segments).include? DOT_DOT
       unresolved_segments, resolved_segments = resolved_segments, []
       if jail
-        jail_segments, _ = partition_path jail unless jail_segments
+        jail_segments, = partition_path jail unless jail_segments
         warned = false
         unresolved_segments.each do |segment|
           if segment == DOT_DOT
@@ -450,7 +452,7 @@ class PathResolver
         target_path
       elsif opts.fetch :recover, true
         logger.warn %(#{opts[:target_name] || 'path'} is outside of jail; recovering automatically)
-        jail_segments, _ = partition_path jail unless jail_segments
+        jail_segments, = partition_path jail unless jail_segments
         join_path jail_segments + target_segments, jail_root
       else
         raise ::SecurityError, %(#{opts[:target_name] || 'path'} #{target} is outside of jail: #{jail} (disallowed in safe mode))

data/lib/asciidoctor/reader.rb

@@ -44,11 +44,11 @@ class Reader
       @file = nil
       @dir = '.'
       @path = '<stdin>'
-      @lineno = 1 # IMPORTANT lineno assignment must proceed prepare_lines call!
+      @lineno = 1
     elsif ::String === cursor
       @file = cursor
       @dir, @path = ::File.split @file
-      @lineno = 1 # IMPORTANT lineno assignment must proceed prepare_lines call!
+      @lineno = 1
     else
       if (@file = cursor.file)
         @dir = cursor.dir || (::File.dirname @file)
@@ -57,10 +57,9 @@ class Reader
         @dir = cursor.dir || '.'
         @path = cursor.path || '<stdin>'
       end
-      @lineno = cursor.lineno || 1 # IMPORTANT lineno assignment must proceed prepare_lines call!
+      @lineno = cursor.lineno || 1
     end
-    @lines = prepare_lines data, opts
-    @source_lines = @lines.drop 0
+    @lines = (@source_lines = prepare_lines data, opts).reverse
     @mark = nil
     @look_ahead = 0
     @process_lines = true
@@ -127,7 +126,7 @@ class Reader
   # Returns nothing if there is no more data.
   def peek_line direct = false
     if direct || @look_ahead > 0
-      @unescape_next_line ? ((line = @lines[0]).slice 1, line.length) : @lines[0]
+      @unescape_next_line ? ((line = @lines[-1]).slice 1, line.length) : @lines[-1]
     elsif @lines.empty?
       @look_ahead = 0
       nil
@@ -135,7 +134,7 @@ class Reader
       # 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
-      (line = process_line @lines[0]) ? line : peek_line
+      (process_line @lines[-1]) || peek_line
     end
   end
 
@@ -192,9 +191,7 @@ class Reader
   def read_lines
     lines = []
     # has_more_lines? triggers preprocessor
-    while has_more_lines?
-      lines << shift
-    end
+    lines << shift while has_more_lines?
     lines
   end
   alias readlines read_lines
@@ -241,7 +238,6 @@ class Reader
   # Returns nothing.
   def unshift_lines lines_to_restore
     unshift_all lines_to_restore
-    nil
   end
   alias restore_lines unshift_lines
 
@@ -334,7 +330,7 @@ class Reader
     comment_lines = []
     # optimized code for shortest execution path
     while (next_line = peek_line) && !next_line.empty?
-      if (next_line.start_with? '//')
+      if next_line.start_with? '//'
         comment_lines << shift
       else
         break
@@ -407,34 +403,22 @@ class Reader
       break_on_list_continuation = options[:break_on_list_continuation]
     end
     skip_comments = options[:skip_line_comments]
-    complete = line_read = line_restored = nil
+    line_read = line_restored = nil
     shift if options[:skip_first_line]
-    while !complete && (line = read_line)
-      complete = while true
-        break true if terminator && line == terminator
-        # QUESTION: can we get away with line.empty? here?
-        break true if break_on_blank_lines && line.empty?
-        if break_on_list_continuation && line_read && line == LIST_CONTINUATION
-          options[:preserve_last_line] = true
-          break true
-        end
-        break true if block_given? && (yield line)
-        break false
-      end
-      if complete
-        if options[:read_last_line]
-          result << line
-          line_read = true
-        end
+    while (line = read_line)
+      if terminator ? line == terminator : ((break_on_blank_lines && line.empty?) ||
+          (break_on_list_continuation && line_read && line == LIST_CONTINUATION && (options[:preserve_last_line] = true)) ||
+          (block_given? && (yield line)))
+        result << line if options[:read_last_line]
         if options[:preserve_last_line]
           unshift line
           line_restored = true
         end
-      else
-        unless skip_comments && (line.start_with? '//') && !(line.start_with? '///')
-          result << line
-          line_read = true
-        end
+        break
+      end
+      unless skip_comments && (line.start_with? '//') && !(line.start_with? '///')
+        result << line
+        line_read = true
       end
     end
     if restore_process_lines
@@ -459,21 +443,37 @@ class Reader
   def shift
     @lineno += 1
     @look_ahead -= 1 unless @look_ahead == 0
-    @lines.shift
+    @lines.pop
   end
 
   # Internal: Restore the line to the stack and decrement the lineno
   def unshift line
     @lineno -= 1
     @look_ahead += 1
-    @lines.unshift line
+    @lines.push line
+    nil
   end
 
-  # Internal: Restore the lines to the stack and decrement the lineno
-  def unshift_all lines
-    @lineno -= lines.size
-    @look_ahead += lines.size
-    @lines.unshift(*lines)
+  if ::RUBY_ENGINE == 'jruby'
+    # Internal: Restore the lines to the stack and decrement the lineno
+    def unshift_all lines_to_restore
+      @lineno -= lines_to_restore.size
+      @look_ahead += lines_to_restore.size
+      if lines_to_restore.respond_to? :reverse
+        @lines.push(*lines_to_restore.reverse)
+      else
+        lines_to_restore.reverse_each {|it| @lines.push it }
+      end
+      nil
+    end
+  else
+    # Internal: Restore the lines to the stack and decrement the lineno
+    def unshift_all lines_to_restore
+      @lineno -= lines_to_restore.size
+      @look_ahead += lines_to_restore.size
+      @lines.push(*lines_to_restore.reverse)
+      nil
+    end
   end
 
   def cursor
@@ -516,12 +516,12 @@ class Reader
   #
   # Returns A copy of the String Array of lines remaining in this Reader
   def lines
-    @lines.drop 0
+    @lines.reverse
   end
 
   # Public: Get a copy of the remaining lines managed by this Reader joined as a String
   def string
-    @lines.join LF
+    @lines.reverse.join LF
   end
 
   # Public: Get the source lines for this Reader joined as a String
@@ -570,17 +570,17 @@ class Reader
   #
   # data - A String Array or String of source data to be normalized.
   # opts - A Hash of options to control how lines are prepared.
-  #        :normalize - Enables line normalization, which coerces the encoding to UTF-8 and removes trailing whitespace
-  #        (optional, default: false).
+  #        :normalize - Enables line normalization, which coerces the encoding to UTF-8 and removes trailing whitespace;
+  #        :rstrip removes all trailing whitespace; :chomp removes trailing newline only (optional, not set).
   #
   # Returns A String Array of source lines. If the source data is an Array, this method returns a copy.
   def prepare_lines data, opts = {}
-    if opts[:normalize]
-      ::Array === data ? (Helpers.prepare_source_array data) : (Helpers.prepare_source_string data)
+    if (normalize = opts[:normalize])
+      ::Array === data ? (Helpers.prepare_source_array data, normalize != :chomp) : (Helpers.prepare_source_string data, normalize != :chomp)
     elsif ::Array === data
       data.drop 0
     elsif data
-      data.split LF, -1
+      data.chomp.split LF, -1
     else
       []
     end
@@ -689,6 +689,7 @@ class PreprocessorReader < Reader
       @path = (path ||= ::File.basename file)
       # only process lines in AsciiDoc files
       if (@process_lines = file.end_with?(*ASCIIDOC_EXTENSIONS.keys))
+        # NOTE registering the include with a nil value tracks it while not making it visible to interdocument xrefs
         @includes[path.slice 0, (path.rindex '.')] = attributes['partial-option'] ? nil : true
       end
     else
@@ -696,6 +697,7 @@ class PreprocessorReader < Reader
       # we don't know what file type we have, so assume AsciiDoc
       @process_lines = true
       if (@path = path)
+        # NOTE registering the include with a nil value tracks it while not making it visible to interdocument xrefs
         @includes[Helpers.rootname path] = attributes['partial-option'] ? nil : true
       else
         @path = '<stdin>'
@@ -717,21 +719,16 @@ class PreprocessorReader < Reader
     end
 
     # effectively fill the buffer
-    if (@lines = prepare_lines data, normalize: true, condense: false, indent: attributes['indent']).empty?
+    if (@lines = prepare_lines data, normalize: @process_lines || :chomp, condense: false, indent: attributes['indent']).empty?
       pop_include
     else
       # FIXME we eventually want to handle leveloffset without affecting the lines
       if attributes.key? 'leveloffset'
-        @lines.unshift ''
-        @lines.unshift %(:leveloffset: #{attributes['leveloffset']})
-        @lines << ''
-        if (old_leveloffset = @document.attr 'leveloffset')
-          @lines << %(:leveloffset: #{old_leveloffset})
-        else
-          @lines << ':leveloffset!:'
-        end
-        # compensate for these extra lines
+        @lines = [((leveloffset = @document.attr 'leveloffset') ? %(:leveloffset: #{leveloffset}) : ':leveloffset!:'), ''] + @lines.reverse + ['', %(:leveloffset: #{attributes['leveloffset']})]
+        # compensate for these extra lines at the top
         @lineno -= 2
+      else
+        @lines.reverse!
       end
 
       # FIXME kind of a hack
@@ -801,14 +798,11 @@ class PreprocessorReader < Reader
     result = super
 
     # QUESTION should this work for AsciiDoc table cell content? Currently it does not.
-    if @document && @document.attributes['skip-front-matter']
-      if (front_matter = skip_front_matter! result)
-        @document.attributes['front-matter'] = front_matter.join LF
-      end
+    if @document && @document.attributes['skip-front-matter'] && (front_matter = skip_front_matter! result)
+      @document.attributes['front-matter'] = front_matter.join LF
     end
 
     if opts.fetch :condense, true
-      result.shift && @lineno += 1 while (first = result[0]) && first.empty?
       result.pop while (last = result[-1]) && last.empty?
     end
 
@@ -955,11 +949,12 @@ class PreprocessorReader < Reader
         if no_target
           # the text in brackets must match a conditional expression
           if text && EvalExpressionRx =~ text.strip
+            # NOTE assignments must happen before call to resolve_expr_val for compatibility with Opal
             lhs = $1
+            # regex enforces a restricted set of math-related operations (==, !=, <=, >=, <, >)
             op = $2
             rhs = $3
-            # regex enforces a restricted set of math-related operations (==, !=, <=, >=, <, >)
-            skip = ((resolve_expr_val lhs).send op, (resolve_expr_val rhs)) ? false : true
+            skip = ((resolve_expr_val lhs).send op, (resolve_expr_val rhs)) ? false : true rescue true
           else
             logger.error message_with_context %(malformed preprocessor directive - #{text ? 'invalid expression' : 'missing expression'}: ifeval::[#{text}]), source_location: cursor
             return true
@@ -1049,10 +1044,11 @@ class PreprocessorReader < Reader
 
       parsed_attrs = doc.parse_attributes attrlist, [], sub_input: true
       inc_path, target_type, relpath = resolve_include_path expanded_target, attrlist, parsed_attrs
-      if target_type == :file
+      case target_type
+      when :file
         reader = ::File.method :open
         read_mode = FILE_READ_MODE
-      elsif target_type == :uri
+      when :uri
         reader = ::OpenURI.method :open_uri
         read_mode = URI_READ_MODE
       else
@@ -1060,14 +1056,20 @@ class PreprocessorReader < Reader
         return inc_path
       end
 
+      if (enc = parsed_attrs['encoding']) && (::Encoding.find enc rescue nil)
+        (read_mode_params = read_mode.split ':')[1] = enc
+        read_mode = read_mode_params.join ':'
+      end unless RUBY_ENGINE_OPAL
+
       inc_linenos = inc_tags = nil
+      # NOTE attrlist is nil if missing from include directive
       if attrlist
         if parsed_attrs.key? 'lines'
           inc_linenos = []
           (split_delimited_value parsed_attrs['lines']).each do |linedef|
             if linedef.include? '..'
               from, _, to = linedef.partition '..'
-              inc_linenos += (to.empty? || (to = to.to_i) < 0) ? [from.to_i, 1.0/0.0] : (from.to_i..to).to_a
+              inc_linenos += (to.empty? || (to = to.to_i) < 0) ? [from.to_i, ::Float::INFINITY] : (from.to_i..to).to_a
             else
               inc_linenos << linedef.to_i
             end
@@ -1123,17 +1125,23 @@ class PreprocessorReader < Reader
           push_include inc_lines, inc_path, relpath, inc_offset, parsed_attrs
         end
       elsif inc_tags
-        inc_lines, inc_offset, inc_lineno, tag_stack, tags_used, active_tag = [], nil, 0, [], ::Set.new, nil
+        inc_lines, inc_offset, inc_lineno, tag_stack, tags_selected, active_tag = [], nil, 0, [], ::Set.new, nil
         if inc_tags.key? '**'
+          select = base_select = inc_tags.delete '**'
           if inc_tags.key? '*'
-            select = base_select = inc_tags.delete '**'
             wildcard = inc_tags.delete '*'
+          elsif !select && inc_tags.values.first == false
+            wildcard = true
+          end
+        elsif inc_tags.key? '*'
+          if inc_tags.keys.first == '*'
+            select = base_select = !(wildcard = inc_tags.delete '*')
           else
-            select = base_select = wildcard = inc_tags.delete '**'
+            select = base_select = false
+            wildcard = inc_tags.delete '*'
           end
         else
           select = base_select = !(inc_tags.value? true)
-          wildcard = inc_tags.delete '*'
         end
         begin
           reader.call inc_path, read_mode do |f|
@@ -1148,7 +1156,7 @@ class PreprocessorReader < Reader
                     active_tag, select = tag_stack.empty? ? [nil, base_select] : tag_stack[-1]
                   elsif inc_tags.key? this_tag
                     include_cursor = create_include_cursor inc_path, expanded_target, inc_lineno
-                    if (idx = tag_stack.rindex {|key, _| key == this_tag })
+                    if (idx = tag_stack.rindex {|key,| key == this_tag })
                       idx == 0 ? tag_stack.shift : (tag_stack.delete_at idx)
                       logger.warn message_with_context %(mismatched end tag (expected '#{active_tag}' but found '#{this_tag}') at line #{inc_lineno} of include #{target_type}: #{inc_path}), source_location: cursor, include_location: include_cursor
                     else
@@ -1156,9 +1164,9 @@ class PreprocessorReader < Reader
                     end
                   end
                 elsif inc_tags.key? this_tag
-                  tags_used << this_tag
+                  tags_selected << this_tag if (select = inc_tags[this_tag])
                   # QUESTION should we prevent tag from being selected when enclosing tag is excluded?
-                  tag_stack << [(active_tag = this_tag), (select = inc_tags[this_tag]), inc_lineno]
+                  tag_stack << [(active_tag = this_tag), select, inc_lineno]
                 elsif !wildcard.nil?
                   select = active_tag && !select ? false : wildcard
                   tag_stack << [(active_tag = this_tag), select, inc_lineno]
@@ -1179,12 +1187,12 @@ class PreprocessorReader < Reader
             logger.warn message_with_context %(detected unclosed tag '#{tag_name}' starting at line #{tag_lineno} of include #{target_type}: #{inc_path}), source_location: cursor, include_location: (create_include_cursor inc_path, expanded_target, tag_lineno)
           end
         end
-        unless (missing_tags = inc_tags.keys - tags_used.to_a).empty?
+        unless (missing_tags = inc_tags.keep_if {|_, v| v }.keys - tags_selected.to_a).empty?
           logger.warn message_with_context %(tag#{missing_tags.size > 1 ? 's' : ''} '#{missing_tags.join ', '}' not found in include #{target_type}: #{inc_path}), source_location: cursor
         end
         shift
         if inc_offset
-          parsed_attrs['partial-option'] = '' unless base_select && wildcard && inc_tags.empty?
+          parsed_attrs['partial-option'] = '' unless base_select && wildcard != false && inc_tags.empty?
           # FIXME not accounting for skipped lines in reader line numbering
           push_include inc_lines, inc_path, relpath, inc_offset, parsed_attrs
         end
@@ -1255,7 +1263,7 @@ class PreprocessorReader < Reader
   end
 
   def pop_include
-    if @include_stack.size > 0
+    unless @include_stack.empty?
       @lines, @file, @dir, @path, @lineno, @maxdepth, @process_lines = @include_stack.pop
       # FIXME kind of a hack
       #Document::AttributeEntry.new('infile', @file).save_to_next_block @document

data/lib/asciidoctor/rx.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Asciidoctor
   # A collection of regular expression constants used by the parser. (For speed, these are not defined in the Rx module,
   # but rather directly in the Asciidoctor module).
@@ -269,7 +270,7 @@ module Asciidoctor
   #
   # NOTE we only have to check as far as the blank character because we know it means non-whitespace follows.
   # IMPORTANT if this regexp does not agree with the regexp for each list type, the parser will hang.
-  AnyListRx = %r(^(?:[ \t]*(?:-|\*\**|\.\.*|\u2022|\d+\.|[a-zA-Z]\.|[IVXivx]+\))[ \t]|(?!//[^/])[ \t]*[^ \t]#{CC_ANY}*?(?::::{0,2}|;;)(?:$|[ \t])|<?\d+>[ \t]))
+  AnyListRx = %r(^(?:[ \t]*(?:-|\*\**|\.\.*|\u2022|\d+\.|[a-zA-Z]\.|[IVXivx]+\))[ \t]|(?!//[^/])[ \t]*[^ \t]#{CC_ANY}*?(?::::{0,2}|;;)(?:$|[ \t])|<(?:\d+|\.)>[ \t]))
 
   # Matches an unordered list item (one level for hyphens, up to 5 levels for asterisks).
   #
@@ -406,7 +407,7 @@ module Asciidoctor
   #   gist::123456[]
   #
   #--
-  # NOTE we've relaxed the match for target to accomodate the short format (e.g., name::[attrlist])
+  # NOTE we've relaxed the match for target to accommodate the short format (e.g., name::[attrlist])
   CustomBlockMacroRx = /^(#{CG_WORD}[#{CC_WORD}-]*)::(|\S|\S#{CC_ANY}*?\S)\[(#{CC_ANY}+)?\]$/
 
   # Matches an image, video or audio block macro.
@@ -469,7 +470,7 @@ module Asciidoctor
   #   footnoteref:[id,text] (legacy)
   #   footnoteref:[id] (legacy)
   #
-  InlineFootnoteMacroRx = /\\?footnote(?:(ref):|:([#{CC_WORD}-]+)?)\[(?:|(#{CC_ALL}*?[^\\]))\]/m
+  InlineFootnoteMacroRx = %r(\\?footnote(?:(ref):|:([#{CC_WORD}-]+)?)\[(?:|(#{CC_ALL}*?[^\\]))\](?!</a>))m
 
   # Matches an image or icon inline macro.
   #
@@ -514,9 +515,10 @@ module Asciidoctor
   #   https://github.com[GitHub]
   #   <https://github.com>
   #   link:https://github.com[]
+  #   "https://github.com[]"
   #
   # 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
+  InlineLinkRx = %r((^|link:|#{CG_BLANK}|&lt;|[>\(\)\[\];"'])(\\?(?:https?|file|ftp|irc)://[^\s\[\]<]*([^\s.,\[\]<]))(?:\[(|#{CC_ALL}*?[^\\])\])?)m
 
   # Match a link or e-mail inline macro.
   #
@@ -551,7 +553,7 @@ module Asciidoctor
   #   menu:View[Page Style > No Style]
   #   menu:View[Page Style, No Style]
   #
-  InlineMenuMacroRx = /\\?menu:(#{CG_WORD}|[#{CC_WORD}&][^\n\[]*[^\s\[])\[ *(?:|(#{CC_ALL}*?[^\\]))?\]/m
+  InlineMenuMacroRx = /\\?menu:(#{CG_WORD}|[#{CC_WORD}&][^\n\[]*[^\s\[])\[ *(?:|(#{CC_ALL}*?[^\\]))\]/m
 
   # Matches an implicit menu inline macro.
   #
@@ -591,7 +593,7 @@ module Asciidoctor
   #   $$text$$
   #   pass:quotes[text]
   #
-  # NOTE we have to support an empty pass:[] for compatibility with AsciiDoc Python
+  # NOTE we have to support an empty pass:[] for compatibility with AsciiDoc.py
   InlinePassMacroRx = /(?:(?:(\\?)\[([^\]]+)\])?(\\{0,2})(\+\+\+?|\$\$)(#{CC_ALL}*?)\4|(\\?)pass:([a-z]+(?:,[a-z-]+)*)?\[(|#{CC_ALL}*?[^\\])\])/m
 
   # Matches an xref (i.e., cross-reference) inline macro, which may span multiple lines.
@@ -610,7 +612,7 @@ module Asciidoctor
   # Matches a trailing + preceded by at least one space character,
   # which forces a hard line break (<br> tag in HTML output).
   #
-  # NOTE AsciiDoc Python allows + to be preceded by TAB; Asciidoctor does not
+  # NOTE AsciiDoc.py allows + to be preceded by TAB; Asciidoctor does not
   #
   # Examples
   #

data/lib/asciidoctor/section.rb

@@ -64,6 +64,13 @@ class Section < AbstractBlock
     Section.generate_id title, @document
   end
 
+  # Public: Check whether this Section has any child Section objects.
+  #
+  # Returns A [Boolean] to indicate whether this Section has child Section objects
+  def sections?
+    @next_section_index > 0
+  end
+
   # Public: Get the section number for the current Section
   #
   # The section number is a dot-separated String that uniquely describes the position of this