kramdown 0.11.0 → 0.12.0

data/lib/kramdown/parser/kramdown.rb

@@ -32,7 +32,7 @@ module Kramdown
 
     # Used for parsing a document in kramdown format.
     #
-    # If you want to extend the functionality of the parser, you need to the following:
+    # If you want to extend the functionality of the parser, you need to do the following:
     #
     # * Create a new subclass
     # * add the needed parser methods
@@ -40,15 +40,15 @@ module Kramdown
     #   methods
     #
     # Here is a small example for an extended parser class that parses ERB style tags as raw text if
-    # they are used as span level elements (an equivalent block level parser should probably also be
+    # they are used as span-level elements (an equivalent block-level parser should probably also be
     # made to handle the block case):
     #
     #   require 'kramdown/parser/kramdown'
     #
     #   class Kramdown::Parser::ERBKramdown < Kramdown::Parser::Kramdown
     #
-    #      def initialize(doc)
-    #        super(doc)
+    #      def initialize(source, options)
+    #        super
     #        @span_parsers.unshift(:erb_tags)
     #      end
     #
@@ -73,47 +73,35 @@ module Kramdown
 
       include ::Kramdown
 
-      attr_reader :tree
-      attr_reader :doc
-      attr_reader :options
+      # Create a new Kramdown parser object with the given +options+.
+      def initialize(source, options)
+        super
 
-      # Create a new Kramdown parser object for the Kramdown::Document +doc+.
-      def initialize(doc)
-        super(doc)
+        reset_env
 
-        @src = nil
-        @tree = nil
-        @stack = []
-        @text_type = :raw_text
-        @block_ial = nil
-
-        @doc.parse_infos[:ald] = {}
-        @doc.parse_infos[:link_defs] = {}
-        @doc.parse_infos[:abbrev_defs] = {}
-        @doc.parse_infos[:footnotes] = {}
+        @root.options[:abbrev_defs] = {}
+        @alds = {}
+        @link_defs = {}
+        @footnotes = {}
 
         @block_parsers = [:blank_line, :codeblock, :codeblock_fenced, :blockquote, :table, :atx_header,
                           :setext_header, :horizontal_rule, :list, :definition_list, :link_definition, :block_html,
-                          :footnote_definition, :abbrev_definition, :ald, :block_math,
-                          :block_extension, :block_ial, :eob_marker, :paragraph]
+                          :footnote_definition, :abbrev_definition, :block_extensions, :block_math,
+                          :eob_marker, :paragraph]
         @span_parsers =  [:emphasis, :codespan, :autolink, :span_html, :footnote_marker, :link, :smart_quotes, :inline_math,
-                         :span_extension, :span_ial, :html_entity, :typographic_syms, :line_break, :escaped_chars]
+                         :span_extensions, :html_entity, :typographic_syms, :line_break, :escaped_chars]
 
       end
       private_class_method(:new, :allocate)
 
 
-      # The source string provided on initialization is parsed and the created +tree+ is returned.
-      def parse(source)
+      # The source string provided on initialization is parsed into the <tt>@root</tt> element.
+      def parse
         configure_parser
-        tree = Element.new(:root)
-        parse_blocks(tree, adapt_source(source))
-        update_tree(tree)
-        replace_abbreviations(tree)
-        @doc.parse_infos[:footnotes].each do |name, data|
-          update_tree(data[:content])
-        end
-        tree
+        parse_blocks(@root, adapt_source(source))
+        update_tree(@root)
+        replace_abbreviations(@root)
+        @footnotes.each {|name,data| update_tree(data[:marker].value) if data[:marker]}
       end
 
       #######
@@ -139,10 +127,10 @@ module Kramdown
         [span_start, /(?=#{span_start})/]
       end
 
-      # Parse all block level elements in +text+ into the element +el+.
+      # Parse all block-level elements in +text+ into the element +el+.
       def parse_blocks(el, text = nil)
-        @stack.push([@tree, @src])
-        @tree, @src = el, (text.nil? ? @src : StringScanner.new(text))
+        @stack.push([@tree, @src, @block_ial])
+        @tree, @src, @block_ial = el, (text.nil? ? @src : StringScanner.new(text)), nil
 
         status = catch(:stop_block_parsing) do
           while !@src.eos?
@@ -161,26 +149,25 @@ module Kramdown
           end
         end
 
-        @tree, @src = *@stack.pop
+        @tree, @src, @block_ial = *@stack.pop
         status
       end
 
-      # Update the tree by parsing all <tt>:raw_text</tt> elements with the span level parser
-      # (resets +@tree+, +@src+ and the +@stack+) and by updating the attributes from the IALs.
+      # Update the tree by parsing all <tt>:raw_text</tt> elements with the span-level parser
+      # (resets the environment) and by updating the attributes from the IALs.
       def update_tree(element)
         last_blank = nil
         element.children.map! do |child|
           if child.type == :raw_text
             last_blank = nil
-            @stack, @tree, @text_type = [], nil, :text
-            @src = StringScanner.new(child.value)
+            reset_env(:src => StringScanner.new(child.value), :text_type => :text)
             parse_spans(child)
             child.children
           elsif child.type == :eob
             []
           elsif child.type == :blank
             if last_blank
-              last_blank.value += child.value
+              last_blank.value << child.value
               []
             else
               last_blank = child
@@ -195,7 +182,15 @@ module Kramdown
         end.flatten!
       end
 
-      # Parse all span level elements in the source string.
+      # Parse all span-level elements in the source string of <tt>@src</tt> into +el+.
+      #
+      # If the parameter +stop_re+ (a regexp) is used, parsing is immediately stopped if the regexp
+      # matches and if no block is given or if a block is given and it returns +true+.
+      #
+      # The parameter +parsers+ can be used to specify the (span-level) parsing methods that should
+      # be used for parsing.
+      #
+      # The parameter +text_type+ specifies the type which should be used for created text nodes.
       def parse_spans(el, stop_re = nil, parsers = nil, text_type = @text_type)
         @stack.push([@tree, @text_type]) unless @tree.nil?
         @tree, @text_type = el, text_type
@@ -221,9 +216,9 @@ module Kramdown
                 false
               end
             end unless stop_re_found
-            add_text(@src.scan(/./)) if !processed && !stop_re_found
+            add_text(@src.getch) if !processed && !stop_re_found
           else
-            add_text(@src.scan(/.*/m)) unless stop_re
+            (add_text(@src.rest); @src.terminate) unless stop_re
             break
           end
         end
@@ -233,31 +228,54 @@ module Kramdown
         stop_re_found
       end
 
-      # Update the attributes with the information from the inline attribute list and all referenced ALDs.
+      # Reset the current parsing environment. The parameter +env+ can be used to set initial
+      # values for one or more environment variables.
+      def reset_env(opts = {})
+        opts = {:text_type => :raw_text, :stack => []}.merge(opts)
+        @src = opts[:src]
+        @tree = opts[:tree]
+        @block_ial = opts[:block_ial]
+        @stack = opts[:stack]
+        @text_type = opts[:text_type]
+      end
+
+      # Return the current parsing environment.
+      def save_env
+        [@src, @tree, @block_ial, @stack,  @text_type]
+      end
+
+      # Restore the current parsing environment.
+      def restore_env(env)
+        @src, @tree, @block_ial, @stack,  @text_type = *env
+      end
+
+      # Update the given attributes hash +attr+ with the information from the inline attribute list
+      # +ial+ and all referenced ALDs.
       def update_attr_with_ial(attr, ial)
         ial[:refs].each do |ref|
-          update_attr_with_ial(attr, ref) if ref = @doc.parse_infos[:ald][ref]
+          update_attr_with_ial(attr, ref) if ref = @alds[ref]
         end if ial[:refs]
         ial.each do |k,v|
-          if k == 'class'
-            attr[k] = ((attr[k] || '') + " #{v}").lstrip
+          if k == IAL_CLASS_ATTR
+            attr[k] = (attr[k] || '') << " #{v}"
+            attr[k].lstrip!
           elsif k.kind_of?(String)
             attr[k] = v
           end
         end
       end
 
-      # Create a new block level element, taking care of applying a preceding block IAL if it exists.
+      # Create a new block-level element, taking care of applying a preceding block IAL if it
+      # exists. This method should always be used for creating a block-level element!
       def new_block_el(*args)
         el = Element.new(*args)
-        el.options[:category] ||= :block
         el.options[:ial] = @block_ial if @block_ial && el.type != :blank && el.type != :eob
         el
       end
 
       @@parsers = {}
 
-      # Holds all the needed data for one block/span level parser.
+      # Struct class holding all the needed data for one block/span-level parser method.
       Data = Struct.new(:name, :start_re, :span_start, :method)
 
       # Add a parser method
@@ -284,7 +302,9 @@ module Kramdown
         @@parsers.has_key?(name)
       end
 
+      # Regexp for matching indentation (one tab or four spaces)
       INDENT = /^(?:\t| {4})/
+      # Regexp for matching the optional space (zero or up to three spaces)
       OPT_SPACE = / {0,3}/
 
       require 'kramdown/parser/kramdown/blank_line'
@@ -297,8 +317,7 @@ module Kramdown
       require 'kramdown/parser/kramdown/horizontal_rule'
       require 'kramdown/parser/kramdown/list'
       require 'kramdown/parser/kramdown/link'
-      require 'kramdown/parser/kramdown/attribute_list'
-      require 'kramdown/parser/kramdown/extension'
+      require 'kramdown/parser/kramdown/extensions'
       require 'kramdown/parser/kramdown/footnote'
       require 'kramdown/parser/kramdown/html'
       require 'kramdown/parser/kramdown/escaped_chars'

data/lib/kramdown/parser/kramdown/abbreviation.rb

@@ -29,9 +29,10 @@ module Kramdown
       # Parse the link definition at the current location.
       def parse_abbrev_definition
         @src.pos += @src.matched_size
-        abbrev_id, abbrev_text = @src[1], @src[2].strip
-        warning("Duplicate abbreviation ID '#{abbrev_id}' - overwriting") if @doc.parse_infos[:abbrev_defs][abbrev_id]
-        @doc.parse_infos[:abbrev_defs][abbrev_id] = abbrev_text
+        abbrev_id, abbrev_text = @src[1], @src[2]
+        abbrev_text.strip!
+        warning("Duplicate abbreviation ID '#{abbrev_id}' - overwriting") if @root.options[:abbrev_defs][abbrev_id]
+        @root.options[:abbrev_defs][abbrev_id] = abbrev_text
         @tree.children << Element.new(:eob, :abbrev_def)
         true
       end
@@ -39,21 +40,25 @@ module Kramdown
 
       # Replace the abbreviation text with elements.
       def replace_abbreviations(el, regexps = nil)
-        return if @doc.parse_infos[:abbrev_defs].empty?
+        return if @root.options[:abbrev_defs].empty?
         if !regexps
-          regexps = [Regexp.union(*@doc.parse_infos[:abbrev_defs].keys.map {|k| /#{Regexp.escape(k)}/})]
+          regexps = [Regexp.union(*@root.options[:abbrev_defs].keys.map {|k| /#{Regexp.escape(k)}/})]
           regexps << /(?=(?:\W|^)#{regexps.first}(?!\w))/ # regexp should only match on word boundaries
         end
         el.children.map! do |child|
           if child.type == :text
-            result = []
-            strscan = StringScanner.new(child.value)
-            while temp = strscan.scan_until(regexps.last)
-              temp += strscan.scan(/\W|^/)
-              abbr = strscan.scan(regexps.first)
-              result += [Element.new(:text, temp), Element.new(:abbreviation, abbr)]
+            if child.value =~ regexps.first
+              result = []
+              strscan = StringScanner.new(child.value)
+              while temp = strscan.scan_until(regexps.last)
+                temp << strscan.scan(/\W|^/)
+                abbr = strscan.scan(regexps.first)
+                result << Element.new(:text, temp) << Element.new(:abbreviation, abbr)
+              end
+              result << Element.new(:text, strscan.rest)
+            else
+              child
             end
-            result + [Element.new(:text, extract_string(strscan.pos..-1, strscan))]
           else
             replace_abbreviations(child, regexps)
             child

data/lib/kramdown/parser/kramdown/autolink.rb

@@ -31,7 +31,7 @@ module Kramdown
       else
         ACHARS = '[[:alnum:]]'
       end
-      AUTOLINK_START_STR = "<((mailto|https?|ftps?):.+?|[-.#{ACHARS}]+@[-#{ACHARS}]+(\.[-#{ACHARS}]+)*\.[a-z]+)>"
+      AUTOLINK_START_STR = "<((mailto|https?|ftps?):.+?|[-.#{ACHARS}]+@[-#{ACHARS}]+(?:\.[-#{ACHARS}]+)*\.[a-z]+)>"
       if RUBY_VERSION < '1.9.0'
         AUTOLINK_START = /#{AUTOLINK_START_STR}/u
       else
@@ -41,8 +41,7 @@ module Kramdown
       # Parse the autolink at the current location.
       def parse_autolink
         @src.pos += @src.matched_size
-        href = @src[1]
-        href= "mailto:#{href}" if @src[2].nil?
+        href = (@src[2].nil? ? "mailto:#{@src[1]}" : @src[1])
         el = Element.new(:a, nil, {'href' => href})
         add_text(@src[1].sub(/^mailto:/, ''), el)
         @tree.children << el

data/lib/kramdown/parser/kramdown/blank_line.rb

@@ -30,7 +30,7 @@ module Kramdown
       def parse_blank_line
         @src.pos += @src.matched_size
         if @tree.children.last && @tree.children.last.type == :blank
-          @tree.children.last.value += @src.matched
+          @tree.children.last.value << @src.matched
         else
           @tree.children << new_block_el(:blank, @src.matched)
         end

data/lib/kramdown/parser/kramdown/block_boundary.rb

@@ -20,7 +20,7 @@
 #++
 #
 
-require 'kramdown/parser/kramdown/attribute_list'
+require 'kramdown/parser/kramdown/extensions'
 require 'kramdown/parser/kramdown/blank_line'
 require 'kramdown/parser/kramdown/eob'
 
@@ -38,7 +38,7 @@ module Kramdown
 
       # Return +true+ if we are before a block boundary.
       def before_block_boundary?
-        @src.check(BLOCK_BOUNDARY)
+        @src.check(self.class::BLOCK_BOUNDARY)
       end
 
     end

data/lib/kramdown/parser/kramdown/blockquote.rb

@@ -21,7 +21,7 @@
 #
 
 require 'kramdown/parser/kramdown/blank_line'
-require 'kramdown/parser/kramdown/attribute_list'
+require 'kramdown/parser/kramdown/extensions'
 require 'kramdown/parser/kramdown/eob'
 
 module Kramdown
@@ -35,7 +35,7 @@ module Kramdown
       def parse_blockquote
         el = new_block_el(:blockquote)
         @tree.children << el
-        parse_blocks(el, @src.scan(BLOCKQUOTE_MATCH).gsub!(BLOCKQUOTE_START, ''))
+        parse_blocks(el, @src.scan(self.class::BLOCKQUOTE_MATCH).gsub!(BLOCKQUOTE_START, ''))
         true
       end
       define_parser(:blockquote, BLOCKQUOTE_START)

data/lib/kramdown/parser/kramdown/codeblock.rb

@@ -21,7 +21,7 @@
 #
 
 require 'kramdown/parser/kramdown/blank_line'
-require 'kramdown/parser/kramdown/attribute_list'
+require 'kramdown/parser/kramdown/extensions'
 require 'kramdown/parser/kramdown/eob'
 require 'kramdown/parser/kramdown/paragraph'
 
@@ -34,7 +34,10 @@ module Kramdown
 
       # Parse the indented codeblock at the current location.
       def parse_codeblock
-        @tree.children << new_block_el(:codeblock, @src.scan(CODEBLOCK_MATCH).gsub(/\n( {0,3}\S)/, ' \\1').gsub!(INDENT, ''))
+        data = @src.scan(self.class::CODEBLOCK_MATCH)
+        data.gsub!(/\n( {0,3}\S)/, ' \\1')
+        data.gsub!(INDENT, '')
+        @tree.children << new_block_el(:codeblock, data)
         true
       end
       define_parser(:codeblock, CODEBLOCK_START)

data/lib/kramdown/parser/kramdown/codespan.rb

@@ -37,8 +37,7 @@ module Kramdown
           return
         end
 
-        text = @src.scan_until(/#{result}/)
-        if text
+        if text = @src.scan_until(/#{result}/)
           text.sub!(/#{result}\Z/, '')
           if !simple
             text = text[1..-1] if text[0..0] == ' '

data/lib/kramdown/parser/kramdown/emphasis.rb

@@ -30,7 +30,7 @@ module Kramdown
       def parse_emphasis
         result = @src.scan(EMPHASIS_START)
         element = (result.length == 2 ? :strong : :em)
-        type = (result =~ /_/ ? '_' : '*')
+        type = result[0..0]
         reset_pos = @src.pos
 
         if (type == '_' && @src.pre_match =~ /[[:alpha:]]\z/ && @src.check(/[[:alpha:]]/)) || @src.check(/\s/) ||

data/lib/kramdown/parser/kramdown/escaped_chars.rb

@@ -24,7 +24,7 @@ module Kramdown
   module Parser
     class Kramdown
 
-      ESCAPED_CHARS = /\\([\\.*_+`()\[\]{}#!:|"'\$=-])/
+      ESCAPED_CHARS = /\\([\\.*_+`<>()\[\]{}#!:|"'\$=-])/
 
       # Parse the backslash-escaped character at the current location.
       def parse_escaped_chars

data/lib/kramdown/parser/kramdown/extensions.rb

@@ -0,0 +1,204 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown.
+#
+# kramdown is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      IAL_CLASS_ATTR = 'class'
+
+      # Parse the string +str+ and extract all attributes and add all found attributes to the hash
+      # +opts+.
+      def parse_attribute_list(str, opts)
+        str.scan(ALD_TYPE_ANY).each do |key, sep, val, id_attr, class_attr, ref|
+          if ref
+            (opts[:refs] ||= []) << ref
+          elsif class_attr
+            opts[IAL_CLASS_ATTR] = (opts[IAL_CLASS_ATTR] || '') << " #{class_attr}"
+            opts[IAL_CLASS_ATTR].lstrip!
+          elsif id_attr
+            opts['id'] = id_attr
+          else
+            val.gsub!(/\\(\}|#{sep})/, "\\1")
+            opts[key] = val
+          end
+        end
+      end
+
+      # Update the +ial+ with the information from the inline attribute list +opts+.
+      def update_ial_with_ial(ial, opts)
+        (ial[:refs] ||= []) << opts[:refs]
+        opts.each do |k,v|
+          if k == IAL_CLASS_ATTR
+            ial[k] = (ial[k] || '') << " #{v}"
+            ial[k].lstrip!
+          elsif k.kind_of?(String)
+            ial[k] = v
+          end
+        end
+      end
+
+      # Parse the generic extension at the current point. The parameter +type+ can either be
+      # <tt>:block</tt> or <tt>:span</tt> depending whether we parse a block or span extension tag.
+      def parse_extension_start_tag(type)
+        orig_pos = @src.pos
+        @src.pos += @src.matched_size
+
+        error_block = lambda do |msg|
+          warning(msg)
+          @src.pos = orig_pos
+          add_text(@src.getch) if type == :span
+          false
+        end
+
+        if @src[4] || @src.matched == '{:/}'
+          name = (@src[4] ? "for '#{@src[4]}' " : '')
+          return error_block.call("Invalid extension stop tag #{name}found - ignoring it")
+        end
+
+        ext = @src[1]
+        opts = {}
+        body = nil
+        parse_attribute_list(@src[2] || '', opts)
+
+        if !@src[3]
+          stop_re = (type == :block ? /#{EXT_BLOCK_STOP_STR % ext}/ : /#{EXT_STOP_STR % ext}/)
+          if result = @src.scan_until(stop_re)
+            body = result.sub!(stop_re, '')
+            body.chomp! if type == :block
+          else
+            return error_block.call("No stop tag for extension '#{ext}' found - ignoring it")
+          end
+        end
+
+        if !handle_extension(ext, opts, body, type)
+          error_block.call("Invalid extension with name '#{ext}' specified - ignoring it")
+        else
+          true
+        end
+      end
+
+      def handle_extension(name, opts, body, type)
+        case name
+        when 'comment'
+          @tree.children << Element.new(:comment, body, nil, :category => type) if body.kind_of?(String)
+          true
+        when 'nomarkdown'
+          @tree.children << Element.new(:raw, body, nil, :category => type, :type => opts['type'].to_s.split(/\s+/)) if body.kind_of?(String)
+          true
+        when 'options'
+          opts.select do |k,v|
+            k = k.to_sym
+            if Kramdown::Options.defined?(k)
+              begin
+                val = Kramdown::Options.parse(k, v)
+                @options[k] = val
+                (@root.options[:options] ||= {})[k] = val
+              rescue
+              end
+              false
+            else
+              true
+            end
+          end.each do |k,v|
+            warning("Unknown kramdown option '#{k}'")
+          end
+          @tree.children << Element.new(:eob, :extension) if type == :block
+          true
+        else
+          false
+        end
+      end
+
+
+      ALD_ID_CHARS = /[\w-]/
+      ALD_ANY_CHARS = /\\\}|[^\}]/
+      ALD_ID_NAME = /\w#{ALD_ID_CHARS}*/
+      ALD_TYPE_KEY_VALUE_PAIR = /(#{ALD_ID_NAME})=("|')((?:\\\}|\\\2|[^\}\2])*?)\2/
+      ALD_TYPE_CLASS_NAME = /\.(#{ALD_ID_NAME})/
+      ALD_TYPE_ID_NAME = /#(\w[\w:-]*)/
+      ALD_TYPE_REF = /(#{ALD_ID_NAME})/
+      ALD_TYPE_ANY = /(?:\A|\s)(?:#{ALD_TYPE_KEY_VALUE_PAIR}|#{ALD_TYPE_ID_NAME}|#{ALD_TYPE_CLASS_NAME}|#{ALD_TYPE_REF})(?=\s|\Z)/
+      ALD_START = /^#{OPT_SPACE}\{:(#{ALD_ID_NAME}):(#{ALD_ANY_CHARS}+)\}\s*?\n/
+
+      EXT_STOP_STR = "\\{:/(%s)?\\}"
+      EXT_START_STR = "\\{::(\\w+)(?:\\s(#{ALD_ANY_CHARS}*?)|)(\\/)?\\}"
+      EXT_BLOCK_START = /^#{OPT_SPACE}(?:#{EXT_START_STR}|#{EXT_STOP_STR % ALD_ID_NAME})\s*?\n/
+      EXT_BLOCK_STOP_STR = "^#{OPT_SPACE}#{EXT_STOP_STR}\s*?\n"
+
+      IAL_BLOCK = /\{:(?!:|\/)(#{ALD_ANY_CHARS}+)\}\s*?\n/
+      IAL_BLOCK_START = /^#{OPT_SPACE}#{IAL_BLOCK}/
+
+      BLOCK_EXTENSIONS_START = /^#{OPT_SPACE}\{:/
+
+      # Parse one of the block extensions (ALD, block IAL or generic extension) at the current
+      # location.
+      def parse_block_extensions
+        if @src.scan(ALD_START)
+          parse_attribute_list(@src[2], @alds[@src[1]] ||= Utils::OrderedHash.new)
+          @tree.children << Element.new(:eob, :ald)
+          true
+        elsif @src.check(EXT_BLOCK_START)
+          parse_extension_start_tag(:block)
+        elsif @src.scan(IAL_BLOCK_START)
+          if @tree.children.last && @tree.children.last.type != :blank && @tree.children.last.type != :eob
+            parse_attribute_list(@src[1], @tree.children.last.options[:ial] ||= Utils::OrderedHash.new)
+            @tree.children << Element.new(:eob, :ial) unless @src.check(IAL_BLOCK_START)
+          else
+            parse_attribute_list(@src[1], @block_ial = Utils::OrderedHash.new)
+          end
+          true
+        else
+          false
+        end
+      end
+      define_parser(:block_extensions, BLOCK_EXTENSIONS_START)
+
+
+      EXT_SPAN_START = /#{EXT_START_STR}|#{EXT_STOP_STR % ALD_ID_NAME}/
+      IAL_SPAN_START = /\{:(#{ALD_ANY_CHARS}+)\}/
+      SPAN_EXTENSIONS_START = /\{:/
+
+      # Parse the extension span at the current location.
+      def parse_span_extensions
+        if @src.check(EXT_SPAN_START)
+          parse_extension_start_tag(:span)
+        elsif @src.check(IAL_SPAN_START)
+          if @tree.children.last && @tree.children.last.type != :text
+            @src.pos += @src.matched_size
+            attr = Utils::OrderedHash.new
+            parse_attribute_list(@src[1], attr)
+            update_ial_with_ial(@tree.children.last.options[:ial] ||= Utils::OrderedHash.new, attr)
+            update_attr_with_ial(@tree.children.last.attr, attr)
+          else
+            warning("Found span IAL after text - ignoring it")
+            add_text(@src.getch)
+          end
+        else
+          add_text(@src.getch)
+        end
+      end
+      define_parser(:span_extensions, SPAN_EXTENSIONS_START, '\{:')
+
+    end
+  end
+end