asciidoctor 1.5.7.1 → 1.5.8

data/lib/asciidoctor/path_resolver.rb

@@ -109,7 +109,7 @@ class PathResolver
   SLASH = '/'
   BACKSLASH = '\\'
   DOUBLE_SLASH = '//'
-  WindowsRootRx = /^[a-zA-Z]:(?:\\|\/)/
+  WindowsRootRx = /^(?:[a-zA-Z]:)?[\\\/]/
 
   attr_accessor :file_separator
   attr_accessor :working_dir
@@ -132,11 +132,11 @@ class PathResolver
 
   # Public: Check whether the specified path is an absolute path.
   #
-  # This operation considers both posix paths and Windows paths. It does not
-  # consider URIs.
+  # This operation considers both posix paths and Windows paths. The path does
+  # not have to be posixified beforehand. This operation does not handle URIs.
   #
-  # Unix absolute paths and UNC paths both start with slash. Windows roots can
-  # start with a drive letter.
+  # Unix absolute paths start with a slash. UNC paths can start with a slash or
+  # backslash. Windows roots can start with a drive letter.
   #
   # path - the String path to check
   #
@@ -214,7 +214,15 @@ class PathResolver
   #
   # Return the [String] relative path of the specified path calculated from the base directory.
   def relative_path path, base
-    (root? path) && (offset = descends_from? path, base) ? (path.slice offset, path.length) : path
+    if root? path
+      if (offset = descends_from? path, base)
+        path.slice offset, path.length
+      else
+        (Pathname.new path).relative_path_from(Pathname.new base).to_s
+      end
+    else
+      path
+    end
   end
 
   # Public: Normalize path by converting any backslashes to forward slashes
@@ -313,7 +321,7 @@ class PathResolver
   # returns a String path formed by joining the segments using the posix file
   # separator and prepending the root, if specified
   def join_path segments, root = nil
-    root ? %(#{root}#{segments * SLASH}) : segments * SLASH
+    root ? %(#{root}#{segments.join SLASH}) : (segments.join SLASH)
   end
 
   # Public: Securely resolve a system path

data/lib/asciidoctor/reader.rb

@@ -60,12 +60,13 @@ class Reader
       @lineno = cursor.lineno || 1 # IMPORTANT lineno assignment must proceed prepare_lines call!
     end
     @lines = data ? (prepare_lines data, opts) : []
-    @source_lines = @lines.dup
+    @source_lines = @lines.drop 0
     @mark = nil
     @look_ahead = 0
     @process_lines = true
     @unescape_next_line = false
     @unterminated = nil
+    @saved = nil
   end
 
   # Internal: Prepare the lines from the provided data
@@ -91,7 +92,7 @@ class Reader
     elsif opts[:normalize]
       Helpers.normalize_lines_array data
     else
-      data.dup
+      data.drop 0
     end
   end
 
@@ -167,7 +168,7 @@ class Reader
   # Returns nothing if there is no more data.
   def peek_line direct = false
     if direct || @look_ahead > 0
-      @unescape_next_line ? @lines[0][1..-1] : @lines[0]
+      @unescape_next_line ? ((line = @lines[0]).slice 1, line.length) : @lines[0]
     elsif @lines.empty?
       @look_ahead = 0
       nil
@@ -245,7 +246,7 @@ class Reader
   #
   # Returns the lines read joined as a String
   def read
-    read_lines * LF
+    read_lines.join LF
   end
 
   # Public: Advance to the next line by discarding the line at the front of the stack
@@ -556,17 +557,39 @@ class Reader
   #
   # Returns A copy of the String Array of lines remaining in this Reader
   def lines
-    @lines.dup
+    @lines.drop 0
   end
 
   # Public: Get a copy of the remaining lines managed by this Reader joined as a String
   def string
-    @lines * LF
+    @lines.join LF
   end
 
   # Public: Get the source lines for this Reader joined as a String
   def source
-    @source_lines * LF
+    @source_lines.join LF
+  end
+
+  def save
+    accum = {}
+    instance_variables.each do |name|
+      accum[name] = ::Array === (val = instance_variable_get name) ? val.dup : val unless name == :@saved || name == :@source_lines
+    end
+    @saved = accum
+    nil
+  end
+
+  def restore_save
+    if @saved
+      @saved.each do |name, val|
+        instance_variable_set name, val
+      end
+      @saved = nil
+    end
+  end
+
+  def discard_save
+    @saved = nil
   end
 
   # Public: Get a summary of this Reader.
@@ -602,7 +625,7 @@ class PreprocessorReader < Reader
     # 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 * LF
+        @document.attributes['front-matter'] = front_matter.join LF
       end
     end
 
@@ -633,7 +656,7 @@ class PreprocessorReader < Reader
         if $1 == '\\'
           @unescape_next_line = true
           @look_ahead += 1
-          line[1..-1]
+          line.slice 1, line.length
         elsif preprocess_conditional_directive $2, $3, $4, $5
           # move the pointer past the conditional line
           shift
@@ -653,7 +676,7 @@ class PreprocessorReader < Reader
         if $1 == '\\'
           @unescape_next_line = true
           @look_ahead += 1
-          line[1..-1]
+          line.slice 1, line.length
         # QUESTION should we strip whitespace from raw attributes in Substitutors#parse_attributes? (check perf)
         elsif preprocess_include_directive $2, $3
           # peek again since the content has changed
@@ -842,21 +865,22 @@ class PreprocessorReader < Reader
   # Returns a [Boolean] indicating whether the line under the cursor was changed. To skip over the
   # directive, call shift and return true.
   def preprocess_include_directive target, attrlist
+    doc = @document
     if ((expanded_target = target).include? ATTR_REF_HEAD) &&
-        (expanded_target = @document.sub_attributes target, :attribute_missing => 'drop-line').empty?
+        (expanded_target = doc.sub_attributes target, :attribute_missing => 'drop-line').empty?
       shift
-      if (@document.attributes['attribute-missing'] || Compliance.attribute_missing) == 'skip'
+      if (doc.attributes['attribute-missing'] || Compliance.attribute_missing) == 'skip'
         unshift %(Unresolved directive in #{@path} - include::#{target}[#{attrlist}])
       end
       true
     elsif include_processors? && (ext = @include_processor_extensions.find {|candidate| candidate.instance.handles? expanded_target })
       shift
       # FIXME parse attributes only if requested by extension
-      ext.process_method[@document, self, expanded_target, attrlist ? (AttributeList.new attrlist).parse : {}]
+      ext.process_method[doc, self, expanded_target, (doc.parse_attributes attrlist, [], :sub_input => true)]
       true
     # 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 @document.safe >= SafeMode::SECURE
+    elsif doc.safe >= SafeMode::SECURE
       # FIXME we don't want to use a link macro if we are in a verbatim context
       replace_next_line %(link:#{expanded_target}[])
     elsif (abs_maxdepth = @maxdepth[:abs]) > 0
@@ -865,30 +889,30 @@ class PreprocessorReader < Reader
         return
       end
 
-      parsed_attributes = attrlist ? (AttributeList.new attrlist).parse : {}
-      inc_path, target_type, relpath = resolve_include_path expanded_target, attrlist, parsed_attributes
+      parsed_attrs = doc.parse_attributes attrlist, [], :sub_input => true
+      inc_path, target_type, relpath = resolve_include_path expanded_target, attrlist, parsed_attrs
       return inc_path unless target_type
 
       inc_linenos = inc_tags = nil
       if attrlist
-        if parsed_attributes.key? 'lines'
+        if parsed_attrs.key? 'lines'
           inc_linenos = []
-          parsed_attributes['lines'].split(DataDelimiterRx).each do |linedef|
-            if linedef.include?('..')
-              from, to = linedef.split('..', 2).map {|it| it.to_i }
-              inc_linenos += to < 0 ? [from, 1.0/0.0] : ::Range.new(from, to).to_a
+          (split_delimited_value parsed_attrs['lines']).each do |linedef|
+            if linedef.include? '..'
+              from, to = linedef.split '..', 2
+              inc_linenos += (to.empty? || (to = to.to_i) < 0) ? [from.to_i, 1.0/0.0] : ::Range.new(from.to_i, to).to_a
             else
               inc_linenos << linedef.to_i
             end
           end
           inc_linenos = inc_linenos.empty? ? nil : inc_linenos.sort.uniq
-        elsif parsed_attributes.key? 'tag'
-          unless (tag = parsed_attributes['tag']).empty? || tag == '!'
+        elsif parsed_attrs.key? 'tag'
+          unless (tag = parsed_attrs['tag']).empty? || tag == '!'
             inc_tags = (tag.start_with? '!') ? { (tag.slice 1, tag.length) => false } : { tag => true }
           end
-        elsif parsed_attributes.key? 'tags'
+        elsif parsed_attrs.key? 'tags'
           inc_tags = {}
-          parsed_attributes['tags'].split(DataDelimiterRx).each do |tagdef|
+          (split_delimited_value parsed_attrs['tags']).each do |tagdef|
             if tagdef.start_with? '!'
               inc_tags[tagdef.slice 1, tagdef.length] = false
             else
@@ -928,8 +952,8 @@ class PreprocessorReader < Reader
         shift
         # FIXME not accounting for skipped lines in reader line numbering
         if inc_offset
-          parsed_attributes['partial-option'] = true
-          push_include inc_lines, inc_path, relpath, inc_offset, parsed_attributes
+          parsed_attrs['partial-option'] = true
+          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
@@ -995,16 +1019,16 @@ class PreprocessorReader < Reader
         end
         shift
         if inc_offset
-          parsed_attributes['partial-option'] = true unless base_select && wildcard && inc_tags.empty?
+          parsed_attrs['partial-option'] = true unless base_select && wildcard && inc_tags.empty?
           # FIXME not accounting for skipped lines in reader line numbering
-          push_include inc_lines, inc_path, relpath, inc_offset, parsed_attributes
+          push_include inc_lines, inc_path, relpath, inc_offset, parsed_attrs
         end
       else
         begin
           # NOTE read content first so that we only advance cursor if IO operation succeeds
-          inc_content = target_type == :file ? (::IO.binread inc_path) : open(inc_path, 'rb') {|f| f.read }
+          inc_content = target_type == :file ? ::File.open(inc_path, 'rb') {|f| f.read } : open(inc_path, 'rb') {|f| f.read }
           shift
-          push_include inc_content, inc_path, relpath, 1, parsed_attributes
+          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}])
@@ -1182,19 +1206,24 @@ class PreprocessorReader < Reader
   def shift
     if @unescape_next_line
       @unescape_next_line = false
-      super[1..-1]
+      (line = super).slice 1, line.length
     else
       super
     end
   end
 
+  # Private: Split delimited value on comma (if found), otherwise semi-colon
+  def split_delimited_value val
+    (val.include? ',') ? (val.split ',') : (val.split ';')
+  end
+
   # Private: Ignore front-matter, commonly used in static site generators
   def skip_front_matter! data, increment_linenos = true
     front_matter = nil
     if data[0] == '---'
-      original_data = data.dup
-      front_matter = []
+      original_data = data.drop 0
       data.shift
+      front_matter = []
       @lineno += 1 if increment_linenos
       while !data.empty? && data[0] != '---'
         front_matter << data.shift
@@ -1248,7 +1277,7 @@ class PreprocessorReader < Reader
     if ((val.start_with? '"') && (val.end_with? '"')) ||
         ((val.start_with? '\'') && (val.end_with? '\''))
       quoted = true
-      val = val[1...-1]
+      val = val.slice 1, (val.length - 1)
     else
       quoted = false
     end
@@ -1289,7 +1318,7 @@ class PreprocessorReader < Reader
   end
 
   def to_s
-    %(#<#{self.class}@#{object_id} {path: #{@path.inspect}, line #: #{@lineno}, include depth: #{@include_stack.size}, include stack: [#{@include_stack.map {|inc| inc.to_s } * ', '}]}>)
+    %(#<#{self.class}@#{object_id} {path: #{@path.inspect}, line #: #{@lineno}, include depth: #{@include_stack.size}, include stack: [#{@include_stack.map {|inc| inc.to_s }.join ', '}]}>)
   end
 end
 end

data/lib/asciidoctor/section.rb

@@ -30,7 +30,8 @@ class Section < AbstractBlock
   # Public: Get/Set the flag to indicate whether this is a special section or a child of one
   attr_accessor :special
 
-  # Public: Get the state of the numbered attribute at this section (need to preserve for creating TOC)
+  # Public: Get/Set the flag to indicate whether this section should be numbered.
+  # The sectnum method should only be called if this flag is true.
   attr_accessor :numbered
 
   # Public: Get the caption for this section (only relevant for appendices)
@@ -111,11 +112,12 @@ class Section < AbstractBlock
   def sectnum(delimiter = '.', append = nil)
     append ||= (append == false ? '' : delimiter)
     if @level == 1
-      %(#{@number}#{append})
+      %(#{@numeral}#{append})
     elsif @level > 1
-      Section === @parent ? %(#{@parent.sectnum(delimiter)}#{@number}#{append}) : %(#{@number}#{append})
+      Section === @parent ? %(#{@parent.sectnum(delimiter, delimiter)}#{@numeral}#{append}) : %(#{@numeral}#{append})
     else # @level == 0
-      %(#{Helpers.int_to_roman @number}#{append})
+      # NOTE coerce @numeral to int just in case not set; can happen if section nesting is out of sequence
+      %(#{Helpers.int_to_roman @numeral.to_i}#{append})
     end
   end
 

data/lib/asciidoctor/substitutors.rb

@@ -175,6 +175,7 @@ module Substitutors
   # returns - The text with the passthrough region substituted with placeholders
   def extract_passthroughs(text)
     compat_mode = @document.compat_mode
+    passes = @passthroughs
     text = text.gsub(InlinePassMacroRx) {
       # alias match for Ruby 1.8.7 compat
       m = $~
@@ -203,9 +204,9 @@ module Substitutors
           else
             if boundary == '++' && (attributes.end_with? 'x-')
               old_behavior = true
-              attributes = attributes[0...-2]
+              attributes = attributes.slice 0, attributes.length - 2
             end
-            attributes = parse_attributes attributes
+            attributes = parse_quoted_text_attributes attributes
           end
         elsif escape_count > 0
           # NOTE we don't look for nested unconstrained pass macros
@@ -213,23 +214,23 @@ module Substitutors
         end
         subs = (boundary == '+++' ? [] : BASIC_SUBS)
 
-        pass_key = @passthroughs.size
+        pass_key = passes.size
         if attributes
           if old_behavior
-            @passthroughs[pass_key] = {:text => content, :subs => NORMAL_SUBS, :type => :monospaced, :attributes => attributes}
+            passes[pass_key] = {:text => content, :subs => NORMAL_SUBS, :type => :monospaced, :attributes => attributes}
           else
-            @passthroughs[pass_key] = {:text => content, :subs => subs, :type => :unquoted, :attributes => attributes}
+            passes[pass_key] = {:text => content, :subs => subs, :type => :unquoted, :attributes => attributes}
           end
         else
-          @passthroughs[pass_key] = {:text => content, :subs => subs}
+          passes[pass_key] = {:text => content, :subs => subs}
         end
       else # pass:[]
         if m[6] == RS
           # NOTE we don't look for nested pass:[] macros
-          next m[0][1..-1]
+          next m[0].slice 1, m[0].length
         end
 
-        @passthroughs[pass_key = @passthroughs.size] = {:text => (unescape_brackets m[8]), :subs => (m[7] ? (resolve_pass_subs m[7]) : nil)}
+        passes[pass_key = passes.size] = {:text => (unescape_brackets m[8]), :subs => (m[7] ? (resolve_pass_subs m[7]) : nil)}
       end
 
       %(#{preceding}#{PASS_START}#{pass_key}#{PASS_END})
@@ -241,7 +242,7 @@ module Substitutors
       m = $~
       preceding = m[1]
       attributes = m[2]
-      escape_mark = RS if m[3].start_with? RS
+      escape_mark = RS if (quoted_text = m[3]).start_with? RS
       format_mark = m[4]
       content = m[5]
 
@@ -249,7 +250,7 @@ module Substitutors
         old_behavior = true
       else
         if (old_behavior = (attributes && (attributes.end_with? 'x-')))
-          attributes = attributes[0...-2]
+          attributes = attributes.slice 0, attributes.length - 2
         end
       end
 
@@ -261,34 +262,34 @@ module Substitutors
 
         if escape_mark
           # honor the escape of the formatting mark
-          next %(#{preceding}[#{attributes}]#{m[3][1..-1]})
+          next %(#{preceding}[#{attributes}]#{quoted_text.slice 1, quoted_text.length})
         elsif preceding == RS
           # honor the escape of the attributes
           preceding = %([#{attributes}])
           attributes = nil
         else
-          attributes = parse_attributes attributes
+          attributes = parse_quoted_text_attributes attributes
         end
       elsif format_mark == '`' && !old_behavior
         # extract nested single-plus passthrough; otherwise return unprocessed
         next (extract_inner_passthrough content, %(#{preceding}#{escape_mark}))
       elsif escape_mark
         # honor the escape of the formatting mark
-        next %(#{preceding}#{m[3][1..-1]})
+        next %(#{preceding}#{quoted_text.slice 1, quoted_text.length})
       end
 
-      pass_key = @passthroughs.size
+      pass_key = passes.size
       if compat_mode
-        @passthroughs[pass_key] = {:text => content, :subs => BASIC_SUBS, :attributes => attributes, :type => :monospaced}
+        passes[pass_key] = {:text => content, :subs => BASIC_SUBS, :attributes => attributes, :type => :monospaced}
       elsif attributes
         if old_behavior
           subs = (format_mark == '`' ? BASIC_SUBS : NORMAL_SUBS)
-          @passthroughs[pass_key] = {:text => content, :subs => subs, :attributes => attributes, :type => :monospaced}
+          passes[pass_key] = {:text => content, :subs => subs, :attributes => attributes, :type => :monospaced}
         else
-          @passthroughs[pass_key] = {:text => content, :subs => BASIC_SUBS, :attributes => attributes, :type => :unquoted}
+          passes[pass_key] = {:text => content, :subs => BASIC_SUBS, :attributes => attributes, :type => :unquoted}
         end
       else
-        @passthroughs[pass_key] = {:text => content, :subs => BASIC_SUBS}
+        passes[pass_key] = {:text => content, :subs => BASIC_SUBS}
       end
 
       %(#{preceding}#{PASS_START}#{pass_key}#{PASS_END})
@@ -299,8 +300,8 @@ module Substitutors
       # alias match for Ruby 1.8.7 compat
       m = $~
       # honor the escape
-      if m[0].start_with? RS
-        next m[0][1..-1]
+      if $&.start_with? RS
+        next m[0].slice 1, m[0].length
       end
 
       if (type = m[1].to_sym) == :stem
@@ -308,7 +309,7 @@ module Substitutors
       end
       content = unescape_brackets m[3]
       subs = m[2] ? (resolve_pass_subs m[2]) : ((@document.basebackend? 'html') ? BASIC_SUBS : nil)
-      @passthroughs[pass_key = @passthroughs.size] = {:text => content, :subs => subs, :type => type}
+      passes[pass_key = passes.size] = {:text => content, :subs => subs, :type => type}
       %(#{PASS_START}#{pass_key}#{PASS_END})
     } if (text.include? ':') && ((text.include? 'stem:') || (text.include? 'math:'))
 
@@ -337,13 +338,15 @@ module Substitutors
   #
   # returns The String text with the passthrough text restored
   def restore_passthroughs text, outer = true
-    if outer && (@passthroughs.empty? || !text.include?(PASS_START))
-      return text
-    end
+    passes = @passthroughs
+    # passthroughs may have been eagerly restored (e.g., footnotes)
+    #if outer && (passes.empty? || !text.include?(PASS_START))
+    #  return text
+    #end
 
     text.gsub(PassSlotRx) {
       # NOTE we can't remove entry from map because placeholder may have been duplicated by other substitutions
-      pass = @passthroughs[$1.to_i]
+      pass = passes[$1.to_i]
       subbed_text = apply_subs(pass[:text], pass[:subs])
       if (type = pass[:type])
         subbed_text = Inline.new(self, :quoted, subbed_text, :type => type, :attributes => pass[:attributes]).convert
@@ -352,10 +355,9 @@ module Substitutors
     }
   ensure
     # free memory if in outer call...we don't need these anymore
-    @passthroughs.clear if outer
+    passes.clear if outer
   end
 
-
   if RUBY_ENGINE == 'opal'
     def sub_quotes text
       if QuotedTextSniffRx[compat = @document.compat_mode].match? text
@@ -463,7 +465,7 @@ module Substitutors
   def sub_attributes text, opts = {}
     doc_attrs = @document.attributes
     drop = drop_line = drop_empty_line = attribute_undefined = attribute_missing = nil
-    result = text.gsub AttributeReferenceRx do
+    text = text.gsub AttributeReferenceRx do
       # escaped attribute, return unescaped
       if $1 == RS || $4 == RS
         %({#{$2}})
@@ -504,21 +506,21 @@ module Substitutors
     end
 
     if drop
-      # drop lines from result
+      # drop lines from text
       if drop_empty_line
-        lines = (result.tr_s DEL, DEL).split LF, -1
+        lines = (text.tr_s DEL, DEL).split LF, -1
         if drop_line
           (lines.reject {|line| line == DEL || line == CAN || (line.start_with? CAN) || (line.include? CAN) }.join LF).delete DEL
         else
           (lines.reject {|line| line == DEL }.join LF).delete DEL
         end
-      elsif result.include? LF
-        (result.split LF, -1).reject {|line| line == CAN || (line.start_with? CAN) || (line.include? CAN) }.join LF
+      elsif text.include? LF
+        (text.split LF, -1).reject {|line| line == CAN || (line.start_with? CAN) || (line.include? CAN) }.join LF
       else
         ''
       end
     else
-      result
+      text
     end
   end
 
@@ -529,20 +531,19 @@ module Substitutors
   # source - The String text to process
   #
   # returns The converted String text
-  def sub_macros(source)
-    #return source if source.nil_or_empty?
+  def sub_macros(text)
+    #return text if text.nil_or_empty?
     # some look ahead assertions to cut unnecessary regex calls
     found = {}
-    found_square_bracket = found[:square_bracket] = (source.include? '[')
-    found_colon = source.include? ':'
+    found_square_bracket = found[:square_bracket] = (text.include? '[')
+    found_colon = text.include? ':'
     found_macroish = found[:macroish] = found_square_bracket && found_colon
-    found_macroish_short = found_macroish && (source.include? ':[')
+    found_macroish_short = found_macroish && (text.include? ':[')
     doc_attrs = (doc = @document).attributes
-    result = source
 
     if doc_attrs.key? 'experimental'
-      if found_macroish_short && ((result.include? 'kbd:') || (result.include? 'btn:'))
-        result = result.gsub(InlineKbdBtnMacroRx) {
+      if found_macroish_short && ((text.include? 'kbd:') || (text.include? 'btn:'))
+        text = text.gsub(InlineKbdBtnMacroRx) {
           # honor the escape
           if $1
             $&.slice 1, $&.length
@@ -570,13 +571,13 @@ module Substitutors
         }
       end
 
-      if found_macroish && (result.include? 'menu:')
-        result = result.gsub(InlineMenuMacroRx) {
+      if found_macroish && (text.include? 'menu:')
+        text = text.gsub(InlineMenuMacroRx) {
           # alias match for Ruby 1.8.7 compat
           m = $~
           # honor the escape
-          if (captured = m[0]).start_with? RS
-            next captured[1..-1]
+          if $&.start_with? RS
+            next m[0].slice 1, m[0].length
           end
 
           menu, items = m[1], m[2]
@@ -597,13 +598,13 @@ module Substitutors
         }
       end
 
-      if (result.include? '"') && (result.include? '>')
-        result = result.gsub(InlineMenuRx) {
+      if (text.include? '"') && (text.include? '>')
+        text = text.gsub(InlineMenuRx) {
           # alias match for Ruby 1.8.7 compat
           m = $~
           # honor the escape
-          if (captured = m[0]).start_with? RS
-            next captured[1..-1]
+          if $&.start_with? RS
+            next m[0].slice 1, m[0].length
           end
 
           input = m[1]
@@ -619,12 +620,12 @@ module Substitutors
     # TODO this handling needs some cleanup
     if (extensions = doc.extensions) && extensions.inline_macros? # && found_macroish
       extensions.inline_macros.each do |extension|
-        result = result.gsub(extension.instance.regexp) {
+        text = text.gsub(extension.instance.regexp) {
           # alias match for Ruby 1.8.7 compat
           m = $~
           # honor the escape
-          if m[0].start_with? RS
-            next m[0][1..-1]
+          if $&.start_with? RS
+            next m[0].slice 1, m[0].length
           end
 
           if (m.names rescue []).empty?
@@ -639,8 +640,8 @@ module Substitutors
             content = unescape_bracketed_text content
             if extconf[:content_model] == :attributes
               # QUESTION should we store the text in the _text key?
-              # QUESTION why is the sub_result option false? why isn't the unescape_input option true?
-              parse_attributes content, extconf[:pos_attrs] || [], :sub_result => false, :into => attributes
+              # NOTE bracked text has already been escaped
+              parse_attributes content, extconf[:pos_attrs] || [], :into => attributes
             else
               attributes['text'] = content
             end
@@ -652,17 +653,15 @@ module Substitutors
       end
     end
 
-    if found_macroish && ((result.include? 'image:') || (result.include? 'icon:'))
+    if found_macroish && ((text.include? 'image:') || (text.include? 'icon:'))
       # image:filename.png[Alt Text]
-      result = result.gsub(InlineImageMacroRx) {
+      text = text.gsub(InlineImageMacroRx) {
         # alias match for Ruby 1.8.7 compat
         m = $~
         # honor the escape
         if (captured = $&).start_with? RS
-          next captured[1..-1]
-        end
-
-        if captured.start_with? 'icon:'
+          next captured.slice 1, captured.length
+        elsif captured.start_with? 'icon:'
           type, posattrs = 'icon', ['size']
         else
           type, posattrs = 'image', ['alt', 'width', 'height']
@@ -671,25 +670,26 @@ module Substitutors
           # TODO remove this special case once titles use normal substitution order
           target = sub_attributes target
         end
-        doc.register(:images, target) unless type == 'icon'
-        attrs = parse_attributes(m[2], posattrs, :unescape_input => true)
+        attrs = parse_attributes m[2], posattrs, :unescape_input => true
+        doc.register :images, [target, (attrs['imagesdir'] = doc_attrs['imagesdir'])] unless type == 'icon'
         attrs['alt'] ||= (attrs['default-alt'] = Helpers.basename(target, true).tr('_-', ' '))
         Inline.new(self, :image, nil, :type => type, :target => target, :attributes => attrs).convert
       }
     end
 
-    if ((result.include? '((') && (result.include? '))')) || (found_macroish_short && (result.include? 'dexterm'))
+    if ((text.include? '((') && (text.include? '))')) || (found_macroish_short && (text.include? 'dexterm'))
       # (((Tigers,Big cats)))
       # indexterm:[Tigers,Big cats]
       # ((Tigers))
       # indexterm2:[Tigers]
-      result = result.gsub(InlineIndextermMacroRx) {
+      text = text.gsub(InlineIndextermMacroRx) {
+        captured = $&
         case $1
         when 'indexterm'
           text = $2
           # honor the escape
-          if (m0 = $&).start_with? RS
-            next m0.slice 1, m0.length
+          if captured.start_with? RS
+            next captured.slice 1, captured.length
           end
           # indexterm:[Tigers,Big cats]
           terms = split_simple_csv normalize_string text, true
@@ -698,8 +698,8 @@ module Substitutors
         when 'indexterm2'
           text = $2
           # honor the escape
-          if (m0 = $&).start_with? RS
-            next m0.slice 1, m0.length
+          if captured.start_with? RS
+            next captured.slice 1, captured.length
           end
           # indexterm2:[Tigers]
           term = normalize_string text, true
@@ -708,13 +708,13 @@ module Substitutors
         else
           text = $3
           # honor the escape
-          if (m0 = $&).start_with? RS
+          if captured.start_with? RS
             # escape concealed index term, but process nested flow index term
             if (text.start_with? '(') && (text.end_with? ')')
               text = text.slice 1, text.length - 2
               visible, before, after = true, '(', ')'
             else
-              next m0.slice 1, m0.length
+              next captured.slice 1, captured.length
             end
           else
             visible = true
@@ -732,29 +732,29 @@ module Substitutors
             # ((Tigers))
             term = normalize_string text
             doc.register :indexterms, [term]
-            result = (Inline.new self, :indexterm, term, :type => :visible).convert
+            subbed_term = (Inline.new self, :indexterm, term, :type => :visible).convert
           else
             # (((Tigers,Big cats)))
             terms = split_simple_csv(normalize_string text)
             doc.register :indexterms, terms
-            result = (Inline.new self, :indexterm, nil, :attributes => { 'terms' => terms }).convert
+            subbed_term = (Inline.new self, :indexterm, nil, :attributes => { 'terms' => terms }).convert
           end
-          before ? %(#{before}#{result}#{after}) : result
+          before ? %(#{before}#{subbed_term}#{after}) : subbed_term
         end
       }
     end
 
-    if found_colon && (result.include? '://')
+    if found_colon && (text.include? '://')
       # inline urls, target[text] (optionally prefixed with link: and optionally surrounded by <>)
-      result = result.gsub(InlineLinkRx) {
+      text = text.gsub(InlineLinkRx) {
         # alias match for Ruby 1.8.7 compat
         m = $~
         # honor the escape
-        if m[2].start_with? RS
-          next %(#{m[1]}#{m[2][1..-1]}#{m[3]})
+        if (target = $2).start_with? RS
+          next %(#{m[1]}#{target.slice 1, target.length}#{m[3]})
         end
         # NOTE if text is non-nil, then we've matched a formal macro (i.e., trailing square brackets)
-        prefix, target, text, suffix = m[1], m[2], (macro = m[3]) || '', ''
+        prefix, text, suffix = m[1], (macro = m[3]) || '', ''
         if prefix == 'link:'
           if macro
             prefix = ''
@@ -773,8 +773,8 @@ module Substitutors
           when ';'
             # strip <> around URI
             if prefix.start_with?('&lt;') && target.end_with?('&gt;')
-              prefix = prefix[4..-1]
-              target = target[0...-4]
+              prefix = prefix.slice 4, prefix.length
+              target = target.slice 0, target.length - 4
             # strip trailing ;
             # check for trailing );
             elsif (target = target.chop).end_with?(')')
@@ -825,6 +825,7 @@ module Substitutors
         end
 
         if text.empty?
+          # NOTE it's not possible for the URI scheme to be bare in this case
           text = (doc_attrs.key? 'hide-uri-scheme') ? (target.sub UriSniffRx, '') : target
           if attrs
             attrs['role'] = (attrs.key? 'role') ? %(bare #{attrs['role']}) : 'bare'
@@ -839,14 +840,14 @@ module Substitutors
       }
     end
 
-    if found_macroish && ((result.include? 'link:') || (result.include? 'mailto:'))
+    if found_macroish && ((text.include? 'link:') || (text.include? 'mailto:'))
       # inline link macros, link:target[text]
-      result = result.gsub(InlineLinkMacroRx) {
+      text = text.gsub(InlineLinkMacroRx) {
         # alias match for Ruby 1.8.7 compat
         m = $~
         # honor the escape
-        if m[0].start_with? RS
-          next m[0][1..-1]
+        if $&.start_with? RS
+          next m[0].slice 1, m[0].length
         end
         target = (mailto = m[1]) ? %(mailto:#{m[2]}) : m[2]
         attrs, link_opts = nil, { :type => :link }
@@ -893,7 +894,13 @@ module Substitutors
           if mailto
             text = m[2]
           else
-            text = (doc_attrs.key? 'hide-uri-scheme') ? (target.sub UriSniffRx, '') : target
+            if doc_attrs.key? 'hide-uri-scheme'
+              if (text = target.sub UriSniffRx, '').empty?
+                text = target
+              end
+            else
+              text = target
+            end
             if attrs
               attrs['role'] = (attrs.key? 'role') ? %(bare #{attrs['role']}) : 'bare'
             else
@@ -909,11 +916,11 @@ module Substitutors
       }
     end
 
-    if result.include? '@'
-      result = result.gsub(InlineEmailRx) {
+    if text.include? '@'
+      text = text.gsub(InlineEmailRx) {
         address, tip = $&, $1
         if tip
-          next (tip == RS ? address[1..-1] : address)
+          next (tip == RS ? (address.slice 1, address.length) : address)
         end
 
         target = %(mailto:#{address})
@@ -924,13 +931,13 @@ module Substitutors
       }
     end
 
-    if found_macroish && (result.include? 'tnote')
-      result = result.gsub(InlineFootnoteMacroRx) {
+    if found_macroish && (text.include? 'tnote')
+      text = text.gsub(InlineFootnoteMacroRx) {
         # alias match for Ruby 1.8.7 compat
         m = $~
         # honor the escape
-        if m[0].start_with? RS
-          next m[0][1..-1]
+        if $&.start_with? RS
+          next m[0].slice 1, m[0].length
         end
         if m[1] # footnoteref (legacy)
           id, text = (m[3] || '').split(',', 2)
@@ -966,7 +973,7 @@ module Substitutors
       }
     end
 
-    sub_inline_xrefs(sub_inline_anchors(result, found), found)
+    sub_inline_xrefs(sub_inline_anchors(text, found), found)
   end
 
   # Internal: Substitute normal and bibliographic anchors
@@ -1007,8 +1014,8 @@ module Substitutors
         # alias match for Ruby 1.8.7 compat
         m = $~
         # honor the escape
-        if m[0].start_with? RS
-          next m[0][1..-1]
+        if $&.start_with? RS
+          next m[0].slice 1, m[0].length
         end
         attrs, doc = {}, @document
         if (refid = m[1])
@@ -1098,14 +1105,16 @@ module Substitutors
   #
   # Returns the converted String text
   def sub_callouts(text)
-    # FIXME cache this dynamic regex
-    callout_rx = (attr? 'line-comment') ? /(?:#{::Regexp.escape(attr 'line-comment')} )?#{CalloutSourceRxt}/ : CalloutSourceRx
+    callout_rx = (attr? 'line-comment') ? CalloutSourceRxMap[attr 'line-comment'] : CalloutSourceRx
+    autonum = 0
     text.gsub(callout_rx) {
-      if $1
-        # we have to use sub since we aren't sure it's the first char
-        next $&.sub(RS, '')
+      # honor the escape
+      if $2
+        # use sub since it might be behind a line comment
+        $&.sub(RS, '')
+      else
+        Inline.new(self, :callout, $4 == '.' ? (autonum += 1).to_s : $4, :id => @document.callouts.read_next_id, :attributes => { 'guard' => $1 }).convert
       end
-      Inline.new(self, :callout, $3, :id => @document.callouts.read_next_id).convert
     }
   end
 
@@ -1121,7 +1130,7 @@ module Substitutors
       last = lines.pop
       (lines.map {|line|
         Inline.new(self, :break, (line.end_with? HARD_LINE_BREAK) ? (line.slice 0, line.length - 2) : line, :type => :line).convert
-      } << last) * LF
+      } << last).join LF
     elsif (text.include? PLUS) && (text.include? HARD_LINE_BREAK)
       text.gsub(HardLineBreakRx) { Inline.new(self, :break, $1, :type => :line).convert }
     else
@@ -1141,7 +1150,7 @@ module Substitutors
       if scope == :constrained && (attrs = match[2])
         unescaped_attrs = %([#{attrs}])
       else
-        return match[0][1..-1]
+        return match[0].slice 1, match[0].length
       end
     end
 
@@ -1172,7 +1181,7 @@ module Substitutors
   # Returns a Hash of attributes (role and id only)
   def parse_quoted_text_attributes str
     # NOTE attributes are typically resolved after quoted text, so substitute eagerly
-    str = sub_attributes str, :multiline => true if str.include? ATTR_REF_HEAD
+    str = sub_attributes str if str.include? ATTR_REF_HEAD
     # for compliance, only consider first positional attribute
     str = str.slice 0, (str.index ',') if str.include? ','
 
@@ -1199,30 +1208,37 @@ module Substitutors
 
       attrs = {}
       attrs['id'] = id if id
-      attrs['role'] = roles * ' ' unless roles.empty?
+      attrs['role'] = roles.join ' ' unless roles.empty?
       attrs
     else
       {'role' => str}
     end
   end
 
-  # Internal: Parse the attributes in the attribute line
+  # Internal: Parse attributes in name or name=value format from a comma-separated String
   #
-  # attrline  - A String of unprocessed attributes (key/value pairs)
-  # posattrs  - The keys for positional attributes
+  # attrlist - A comma-separated String list of attributes in name or name=value format.
+  # posattrs - An Array of positional attribute names (default: []).
+  # opts     - A Hash of options to control how the string is parsed (default: {}):
+  #            :into           - The Hash to parse the attributes into (optional, default: false).
+  #            :sub_input      - A Boolean that indicates whether to substitute attributes prior to
+  #                              parsing (optional, default: false).
+  #            :sub_result     - A Boolean that indicates whether to apply substitutions
+  #                              single-quoted attribute values (optional, default: true).
+  #            :unescape_input - A Boolean that indicates whether to unescape square brackets prior
+  #                              to parsing (optional, default: false).
   #
-  # returns nil if attrline is nil, an empty Hash if attrline is empty, otherwise a Hash of parsed attributes
-  def parse_attributes(attrline, posattrs = ['role'], opts = {})
-    return unless attrline
-    return {} if attrline.empty?
-    attrline = @document.sub_attributes attrline if opts[:sub_input] && (attrline.include? ATTR_REF_HEAD)
-    attrline = unescape_bracketed_text attrline if opts[:unescape_input]
+  # Returns an empty Hash if attrlist is nil or empty, otherwise a Hash of parsed attributes.
+  def parse_attributes attrlist, posattrs = [], opts = {}
+    return {} unless attrlist && !attrlist.empty?
+    attrlist = @document.sub_attributes attrlist if opts[:sub_input] && (attrlist.include? ATTR_REF_HEAD)
+    attrlist = unescape_bracketed_text attrlist if opts[:unescape_input]
     # substitutions are only performed on attribute values if block is not nil
-    block = opts.fetch(:sub_result, true) ? self : nil
+    block = self if opts[:sub_result]
     if (into = opts[:into])
-      AttributeList.new(attrline, block).parse_into(into, posattrs)
+      AttributeList.new(attrlist, block).parse_into(into, posattrs)
     else
-      AttributeList.new(attrline, block).parse(posattrs)
+      AttributeList.new(attrlist, block).parse(posattrs)
     end
   end
 
@@ -1328,10 +1344,10 @@ module Substitutors
       if modifiers_present
         if (first = key.chr) == '+'
           modifier_operation = :append
-          key = key[1..-1]
+          key = key.slice 1, key.length
         elsif first == '-'
           modifier_operation = :remove
-          key = key[1..-1]
+          key = key.slice 1, key.length
         elsif key.end_with? '+'
           modifier_operation = :prepend
           key = key.chop
@@ -1355,7 +1371,7 @@ module Substitutors
       end
 
       if modifier_operation
-        candidates ||= (defaults ? defaults.dup : [])
+        candidates ||= (defaults ? (defaults.drop 0) : [])
         case modifier_operation
         when :append
           candidates += resolved_keys
@@ -1374,7 +1390,7 @@ module Substitutors
     resolved = candidates & SUB_OPTIONS[type]
     unless (candidates - resolved).empty?
       invalid = candidates - resolved
-      logger.warn %(invalid substitution type#{invalid.size > 1 ? 's' : ''}#{subject ? ' for ' : ''}#{subject}: #{invalid * ', '})
+      logger.warn %(invalid substitution type#{invalid.size > 1 ? 's' : ''}#{subject ? ' for ' : ''}#{subject}: #{invalid.join ', '})
     end
     resolved
   end
@@ -1433,25 +1449,22 @@ module Substitutors
     if process_callouts
       callout_marks = {}
       last = -1
-      # FIXME cache this dynamic regex
-      callout_rx = (attr? 'line-comment') ? /(?:#{::Regexp.escape(attr 'line-comment')} )?#{CalloutExtractRxt}/ : CalloutExtractRx
+      callout_rx = (attr? 'line-comment') ? CalloutExtractRxMap[attr 'line-comment'] : CalloutExtractRx
       # extract callout marks, indexed by line number
       source = source.split(LF, -1).map {|line|
         lineno = lineno + 1
         line.gsub(callout_rx) {
-          # alias match for Ruby 1.8.7 compat
-          m = $~
           # honor the escape
-          if m[1] == RS
-            # we have to use sub since we aren't sure it's the first char
-            m[0].sub RS, ''
+          if $2
+            # use sub since it might be behind a line comment
+            $&.sub(RS, '')
           else
-            (callout_marks[lineno] ||= []) << m[3]
+            (callout_marks[lineno] ||= []) << [$1, $4]
             last = lineno
             nil
           end
         }
-      } * LF
+      }.join LF
       callout_on_last = (last == lineno)
       callout_marks = nil if callout_marks.empty?
     else
@@ -1464,16 +1477,19 @@ module Substitutors
     case highlighter
     when 'coderay'
       if (linenums_mode = (attr? 'linenums', nil, false) ? (@document.attributes['coderay-linenums-mode'] || :table).to_sym : nil)
+        start = 1 if (start = (attr 'start', nil, 1).to_i) < 1
         if attr? 'highlight', nil, false
-          highlight_lines = resolve_highlight_lines(attr 'highlight', nil, false)
+          highlight_lines = resolve_lines_to_highlight source, (attr 'highlight', nil, false)
         end
       end
       result = ::CodeRay::Duo[attr('language', :text, false).to_sym, :html, {
-          :css => (@document.attributes['coderay-css'] || :class).to_sym,
-          :line_numbers => linenums_mode,
-          :line_number_anchors => false,
-          :highlight_lines => highlight_lines,
-          :bold_every => false}].highlight source
+        :css => (@document.attributes['coderay-css'] || :class).to_sym,
+        :line_numbers => linenums_mode,
+        :line_number_start => start,
+        :line_number_anchors => false,
+        :highlight_lines => highlight_lines,
+        :bold_every => false
+      }].highlight source
     when 'pygments'
       lexer = ::Pygments::Lexer.find_by_alias(attr 'language', 'text', false) || ::Pygments::Lexer.find_by_mimetype('text/plain')
       opts = { :cssclass => 'pyhl', :classprefix => 'tok-', :nobackground => true, :stripnl => false }
@@ -1483,13 +1499,14 @@ module Substitutors
         opts[:style] = (@document.attributes['pygments-style'] || Stylesheets::DEFAULT_PYGMENTS_STYLE)
       end
       if attr? 'highlight', nil, false
-        unless (highlight_lines = resolve_highlight_lines(attr 'highlight', nil, false)).empty?
-          opts[:hl_lines] = highlight_lines * ' '
+        unless (highlight_lines = resolve_lines_to_highlight source, (attr 'highlight', nil, false)).empty?
+          opts[:hl_lines] = highlight_lines.join ' '
         end
       end
       # NOTE highlight can return nil if something goes wrong; fallback to source if this happens
       # TODO we could add the line numbers in ourselves instead of having to strip out the junk
-      if (attr? 'linenums', nil, false) && (opts[:linenos] = @document.attributes['pygments-linenums-mode'] || 'table') == 'table'
+      if (attr? 'linenums', nil, false) && (opts[:linenostart] = (start = attr 'start', 1, false).to_i < 1 ? 1 : start) &&
+          (opts[:linenos] = @document.attributes['pygments-linenums-mode'] || 'table') == 'table'
         linenums_mode = :table
         if (result = lexer.highlight source, :options => opts)
           result = (result.sub PygmentsWrapperDivRx, '\1').gsub PygmentsWrapperPreRx, '\1'
@@ -1510,6 +1527,7 @@ module Substitutors
 
     if process_callouts && callout_marks
       lineno = 0
+      autonum = 0
       reached_code = linenums_mode != :table
       result.split(LF, -1).map {|line|
         unless reached_code
@@ -1527,32 +1545,35 @@ module Substitutors
             end
           end
           if conums.size == 1
-            %(#{line}#{Inline.new(self, :callout, conums[0], :id => @document.callouts.read_next_id).convert}#{tail})
+            guard, conum = conums[0]
+            %(#{line}#{Inline.new(self, :callout, conum == '.' ? (autonum += 1).to_s : conum, :id => @document.callouts.read_next_id, :attributes => { 'guard' => guard }).convert}#{tail})
           else
-            conums_markup = conums.map {|conum| Inline.new(self, :callout, conum, :id => @document.callouts.read_next_id).convert } * ' '
+            conums_markup = conums.map {|guard_it, conum_it| Inline.new(self, :callout, conum_it == '.' ? (autonum += 1).to_s : conum_it, :id => @document.callouts.read_next_id, :attributes => { 'guard' => guard_it }).convert }.join ' '
             %(#{line}#{conums_markup}#{tail})
           end
         else
           line
         end
-      } * LF
+      }.join LF
     else
       result
     end
   end
 
   # e.g., highlight="1-5, !2, 10" or highlight=1-5;!2,10
-  def resolve_highlight_lines spec
+  def resolve_lines_to_highlight source, spec
     lines = []
-    ((spec.include? ' ') ? (spec.delete ' ') : spec).split(DataDelimiterRx).map do |entry|
+    spec = spec.delete ' ' if spec.include? ' '
+    ((spec.include? ',') ? (spec.split ',') : (spec.split ';')).map do |entry|
       negate = false
       if entry.start_with? '!'
-        entry = entry[1..-1]
+        entry = entry.slice 1, entry.length
         negate = true
       end
-      if entry.include? '-'
-        s, e = entry.split '-', 2
-        line_nums = (s.to_i..e.to_i).to_a
+      if (delim = (entry.include? '..') ? '..' : ((entry.include? '-') ? '-' : nil))
+        from, to = entry.split delim, 2
+        to = (source.count LF) + 1 if to.empty? || (to = to.to_i) < 0
+        line_nums = (::Range.new from.to_i, to).to_a
         if negate
           lines -= line_nums
         else
@@ -1612,7 +1633,7 @@ module Substitutors
     if (custom_subs = @attributes['subs'])
       @subs = (resolve_block_subs custom_subs, default_subs, @context) || []
     else
-      @subs = default_subs.dup
+      @subs = default_subs.drop 0
     end
 
     # QUESION delegate this logic to a method?