asciidoctor 0.1.4 → 1.5.0

data/lib/asciidoctor/renderer.rb

@@ -1,259 +0,0 @@
-module Asciidoctor
-# Public: Methods for rendering Asciidoc Documents, Sections, and Blocks
-# using eRuby templates.
-class Renderer
-  RE_ASCIIDOCTOR_NAMESPACE = /^Asciidoctor::/
-  RE_TEMPLATE_CLASS_SUFFIX = /Template$/
-  RE_CAMELCASE_BOUNDARY_1 = /([[:upper:]]+)([[:upper:]][[:alpha:]])/
-  RE_CAMELCASE_BOUNDARY_2 = /([[:lower:]])([[:upper:]])/
-
-  attr_reader :compact
-  attr_reader :cache
-
-  @@global_cache = nil
-
-  # Public: Initialize an Asciidoctor::Renderer object.
-  #
-  def initialize(options={})
-    @debug = !!options[:debug]
-
-    @views = {}
-    @compact = options[:compact]
-    @cache = nil
-
-    backend = options[:backend]
-    case backend
-    when 'html5', 'docbook45', 'docbook5'
-      eruby = load_eruby options[:eruby]
-      #Helpers.require_library 'asciidoctor/backends/' + backend
-      require 'asciidoctor/backends/' + backend
-      # Load up all the template classes that we know how to render for this backend
-      BaseTemplate.template_classes.each do |tc|
-        if tc.to_s.downcase.include?('::' + backend + '::') # optimization
-          view_name, view_backend = self.class.extract_view_mapping(tc)
-          if view_backend == backend
-            @views[view_name] = tc.new(view_name, backend, eruby)
-          end
-        end
-      end
-    else
-      Debug.debug { "No built-in templates for backend: #{backend}" }
-    end
-
-    # If user passed in a template dir, let them override our base templates
-    if (template_dirs = options.delete(:template_dirs))
-      Helpers.require_library 'tilt', true
-
-      if (template_cache = options[:template_cache]) === true
-        # FIXME probably want to use our own cache object for more control
-        @cache = (@@global_cache ||= TemplateCache.new)
-      elsif template_cache
-        @cache = template_cache
-      end
-
-      view_opts = {
-        :erb =>  { :trim => '<>' },
-        :haml => { :format => :xhtml, :attr_wrapper => '"', :ugly => true, :escape_attrs => false },
-        :slim => { :disable_escape => true, :sort_attrs => false, :pretty => false }
-      }
-
-      # workaround until we have a proper way to configure
-      if {'html5' => true, 'dzslides' => true, 'deckjs' => true, 'revealjs' => true}.has_key? backend
-        view_opts[:haml][:format] = view_opts[:slim][:format] = :html5
-      end
-
-      slim_loaded = false
-      path_resolver = PathResolver.new
-      engine = options[:template_engine]
-
-      template_dirs.each do |template_dir|
-        # TODO need to think about safe mode restrictions here
-        template_dir = path_resolver.system_path template_dir, nil
-        template_glob = '*'
-        if engine
-          template_glob = "*.#{engine}"
-          # example: templates/haml
-          if File.directory? File.join(template_dir, engine)
-            template_dir = File.join template_dir, engine
-          end
-        end
-
-        # example: templates/html5 or templates/haml/html5
-        if File.directory? File.join(template_dir, backend)
-          template_dir = File.join template_dir, backend
-        end
-
-        # skip scanning folder if we've already done it for same backend/engine
-        if @cache && @cache.cached?(:scan, template_dir, template_glob)
-          @views.update(@cache.fetch :scan, template_dir, template_glob)
-          next
-        end
-
-        helpers = nil
-        scan_result = {}
-        # Grab the files in the top level of the directory (we're not traversing)
-        Dir.glob(File.join(template_dir, template_glob)).
-            select{|f| File.file? f }.each do |template|
-          basename = File.basename(template)
-          if basename == 'helpers.rb'
-            helpers = template
-            next
-          end
-          name_parts = basename.split('.')
-          next if name_parts.size < 2
-          view_name = name_parts.first 
-          ext_name = name_parts.last
-          if ext_name == 'slim' && !slim_loaded
-            # slim doesn't get loaded by Tilt
-            Helpers.require_library 'slim', true
-          end
-          next unless Tilt.registered? ext_name
-          opts = view_opts[ext_name.to_sym]
-          if @cache
-            @views[view_name] = scan_result[view_name] = @cache.fetch(:view, template) {
-              Tilt.new(template, nil, opts)
-            }
-          else
-            @views[view_name] = Tilt.new template, nil, opts
-          end
-        end
-
-        require helpers unless helpers.nil?
-        @cache.store(scan_result, :scan, template_dir, template_glob) if @cache
-      end
-    end
-  end
-
-  # Public: Render an Asciidoc object with a specified view template.
-  #
-  # view   - the String view template name.
-  # object - the Object to be used as an evaluation scope.
-  # locals - the optional Hash of locals to be passed to Tilt (default {}) (also ignored, really)
-  def render(view, object, locals = {})
-    if !@views.has_key? view
-      raise "Couldn't find a view in @views for #{view}"
-    end
-    
-    @views[view].render(object, locals)
-  end
-
-  def views
-    readonly_views = @views.dup
-    readonly_views.freeze
-    readonly_views
-  end
-
-  def register_view(view_name, tilt_template)
-    # TODO need to figure out how to cache this
-    @views[view_name] = tilt_template
-  end
-
-  # Internal: Load the eRuby implementation
-  #
-  # name - the String name of the eRuby implementation (default: 'erb')
-  #
-  # returns the eRuby implementation class
-  def load_eruby(name)
-    if name.nil? || !['erb', 'erubis'].include?(name)
-      name = 'erb'
-    end
-
-    if name == 'erb'
-      Helpers.require_library 'erb'
-      ::ERB
-    elsif name == 'erubis'
-      Helpers.require_library 'erubis', true
-      ::Erubis::FastEruby
-    end
-  end
-
-  # TODO better name for this method (and/or field)
-  def self.global_cache
-    @@global_cache
-  end
-
-  # TODO better name for this method (and/or field)
-  def self.reset_global_cache
-    @@global_cache.clear if @@global_cache
-  end
-
-  # Internal: Extracts the view name and backend from a qualified Ruby class
-  #
-  # The purpose of this method is to determine the view name and backend to
-  # which a built-in template class maps. We can make certain assumption since
-  # we have control over these class names. The Asciidoctor:: prefix and
-  # Template suffix are stripped as the first step in the conversion.
-  #
-  # qualified_class - The Class or String qualified class name from which to extract the view name and backend
-  #
-  # Examples
-  #
-  #   Renderer.extract_view_mapping(Asciidoctor::HTML5::DocumentTemplate)
-  #   # => ['document', 'html5']
-  #
-  #   Renderer.extract_view_mapping(Asciidoctor::DocBook45::BlockSidebarTemplate)
-  #   # => ['block_sidebar', 'docbook45']
-  #
-  # Returns A two-element String Array mapped as [view_name, backend], where backend may be nil
-  def self.extract_view_mapping(qualified_class)
-    view_name, backend = qualified_class.to_s.
-        sub(RE_ASCIIDOCTOR_NAMESPACE, '').
-        sub(RE_TEMPLATE_CLASS_SUFFIX, '').
-        split('::').reverse
-    view_name = camelcase_to_underscore(view_name)
-    backend = backend.downcase unless backend.nil?
-    [view_name, backend]
-  end
-
-  # Internal: Convert a CamelCase word to an underscore-delimited word
-  #
-  # Examples
-  #
-  #   Renderer.camelcase_to_underscore('BlockSidebar')
-  #   # => 'block_sidebar'
-  #
-  #   Renderer.camelcase_to_underscore('BlockUlist')
-  #   # => 'block_ulist'
-  #
-  # Returns the String converted from CamelCase to underscore-delimited
-  def self.camelcase_to_underscore(str)
-    str.gsub(RE_CAMELCASE_BOUNDARY_1, '\1_\2').
-        gsub(RE_CAMELCASE_BOUNDARY_2, '\1_\2').downcase
-  end
-
-end
-
-class TemplateCache
-  attr_reader :cache
-
-  def initialize
-    @cache = {}
-  end
-
-  # check if a key is available in the cache
-  def cached? *key
-    @cache.has_key? key
-  end
-
-  # retrieves an item from the cache stored in the cache key
-  # if a block is given, the block is called and the return
-  # value stored in the cache under the specified key
-  def fetch(*key)
-    if block_given?
-      @cache[key] ||= yield
-    else
-      @cache[key]
-    end
-  end
-
-  # stores an item in the cache under the specified key
-  def store(value, *key)
-    @cache[key] = value
-  end
-
-  # Clears the cache
-  def clear
-    @cache = {}
-  end
-end
-end

data/lib/asciidoctor/substituters.rb

@@ -1,1083 +0,0 @@
-module Asciidoctor
-# Public: Methods to perform substitutions on lines of AsciiDoc text. This module
-# is intented to be mixed-in to Section and Block to provide operations for performing
-# the necessary substitutions.
-module Substituters
-
-  SUBS = {
-    :basic    => [:specialcharacters],
-    :normal   => [:specialcharacters, :quotes, :attributes, :replacements, :macros, :post_replacements],
-    :verbatim => [:specialcharacters, :callouts],
-    :title    => [:specialcharacters, :quotes, :replacements, :macros, :attributes, :post_replacements],
-    :header   => [:specialcharacters, :attributes],
-    :pass     => [:attributes, :macros]
-  }
-
-  COMPOSITE_SUBS = {
-    :none => [],
-    :normal => SUBS[:normal],
-    :verbatim => SUBS[:verbatim]
-  }
-
-  SUB_OPTIONS = {
-    :block  => COMPOSITE_SUBS.keys + SUBS[:normal] + [:callouts],
-    :inline => COMPOSITE_SUBS.keys + SUBS[:normal]
-  }
-
-  # Internal: A String Array of passthough (unprocessed) text captured from this block
-  attr_reader :passthroughs
-
-  # Public: Apply the specified substitutions to the lines of text
-  #
-  # source  - The String or String Array of text to process
-  # subs    - The substitutions to perform. Can be a Symbol or a Symbol Array (default: :normal)
-  # expand -  A Boolean to control whether sub aliases are expanded (default: true)
-  #
-  # returns Either a String or String Array, whichever matches the type of the first argument
-  def apply_subs source, subs = :normal, expand = false
-    if subs == :normal
-      subs = SUBS[:normal]
-    elsif subs.nil?
-      return source
-    elsif expand
-      if subs.is_a? Symbol
-        subs = COMPOSITE_SUBS[subs] || [subs]
-      else
-        effective_subs = []
-        subs.each do |key|
-          if COMPOSITE_SUBS.has_key? key
-            effective_subs.push(*COMPOSITE_SUBS[key])
-          else
-            effective_subs << key
-          end
-        end
-
-        subs = effective_subs
-      end
-    end
-
-    return source if subs.empty?
-
-    multiline = source.is_a?(Array)
-    text = multiline ? source.join : source
-
-    if (has_passthroughs = subs.include?(:macros))
-      text = extract_passthroughs(text)
-    end
-
-    subs.each do |type|
-      case type
-      when :specialcharacters
-        text = sub_specialcharacters(text)
-      when :quotes
-        text = sub_quotes(text)
-      when :attributes
-        text = sub_attributes(text.lines.entries).join
-      when :replacements
-        text = sub_replacements(text)
-      when :macros
-        text = sub_macros(text)
-      when :highlight
-        text = highlight_source(text, subs.include?(:callouts))
-      when :callouts
-        text = sub_callouts(text) unless subs.include?(:highlight)
-      when :post_replacements
-        text = sub_post_replacements(text)
-      else
-        warn "asciidoctor: WARNING: unknown substitution type #{type}"
-      end
-    end
-    text = restore_passthroughs(text) if has_passthroughs
-
-    multiline ? text.lines.entries : text
-  end
-
-  # Public: Apply normal substitutions.
-  #
-  # lines  - The lines of text to process. Can be a String or a String Array
-  #
-  # returns - A String with normal substitutions performed
-  def apply_normal_subs(lines)
-    apply_subs lines.is_a?(Array) ? lines.join : lines
-  end
-
-  # Public: Apply substitutions for titles.
-  #
-  # title  - The String title to process
-  #
-  # returns - A String with title substitutions performed
-  def apply_title_subs(title)
-    apply_subs title, SUBS[:title]
-  end
-
-  # Public: Apply substitutions for header metadata and attribute assignments
-  #
-  # text    - String containing the text process
-  #
-  # returns - A String with header substitutions performed
-  def apply_header_subs(text)
-    apply_subs text, SUBS[:header]
-  end
-
-=begin
-  # Public: Apply explicit substitutions, if specified, otherwise normal substitutions.
-  #
-  # lines  - The lines of text to process. Can be a String or a String Array
-  #
-  # returns - A String with substitutions applied
-  def apply_para_subs(lines)
-    if (subs = attr('subs', nil, false))
-      apply_subs lines.join, resolve_subs(subs)
-    else
-      apply_subs lines.join
-    end
-  end
-
-  # Public: Apply substitutions for titles
-  #
-  # lines  - A String Array containing the lines of text process
-  #
-  # returns - A String with literal (verbatim) substitutions performed
-  def apply_literal_subs(lines)
-    if (subs = attr('subs', nil, false))
-      apply_subs lines.join, resolve_subs(subs)
-    elsif @style == 'source' && @document.attributes['basebackend'] == 'html' &&
-      ((highlighter = @document.attributes['source-highlighter']) == 'coderay' ||
-      highlighter == 'pygments') && attr?('language')
-      highlight_source lines.join, highlighter, callouts
-    else
-      apply_subs lines.join, SUBS[:verbatim]
-    end
-  end
-
-  # Public: Apply substitutions for passthrough text
-  #
-  # lines  - A String Array containing the lines of text process
-  #
-  # returns - A String with passthrough substitutions performed
-  def apply_passthrough_subs(lines)
-    if (subs = attr('subs', nil, false))
-      subs = resolve_subs(subs)
-    else
-      subs = SUBS[:pass]
-    end
-    apply_subs lines.join, subs
-  end
-=end
-
-  # Internal: Extract the passthrough text from the document for reinsertion after processing.
-  #
-  # text - The String from which to extract passthrough fragements
-  #
-  # returns - The text with the passthrough region substituted with placeholders
-  def extract_passthroughs(text)
-    result = text.dup
-
-    result.gsub!(REGEXP[:pass_macro]) {
-      # alias match for Ruby 1.8.7 compat
-      m = $~
-      # honor the escape
-      if m[0].start_with? '\\'
-        next m[0][1..-1]
-      end
-
-      if m[1] == '$$'
-        subs = [:specialcharacters]
-      elsif m[3].nil? || m[3].empty?
-        subs = []
-      else
-        subs = resolve_pass_subs m[3]
-      end
-
-      # TODO move unescaping closing square bracket to an operation
-      @passthroughs << {:text => m[2] || m[4].gsub('\]', ']'), :subs => subs}
-      index = @passthroughs.size - 1
-      "\e#{index}\e"
-    } unless !(result.include?('+++') || result.include?('$$') || result.include?('pass:'))
-
-    result.gsub!(REGEXP[:pass_lit]) {
-      # alias match for Ruby 1.8.7 compat
-      m = $~
-
-      unescaped_attrs = nil
-      # honor the escape
-      if m[3].start_with? '\\'
-        next m[2].nil? ? "#{m[1]}#{m[3][1..-1]}" : "#{m[1]}[#{m[2]}]#{m[3][1..-1]}"
-      elsif m[1] == '\\' && !m[2].nil?
-        unescaped_attrs = "[#{m[2]}]"
-      end
-
-      if unescaped_attrs.nil? && !m[2].nil?
-        attributes = parse_attributes(m[2])
-      else
-        attributes = {}
-      end
-
-      @passthroughs << {:text => m[4], :subs => [:specialcharacters], :attributes => attributes, :literal => true}
-      index = @passthroughs.size - 1
-      "#{unescaped_attrs || m[1]}\e#{index}\e"
-    } unless !result.include?('`')
-
-    result
-  end
-
-  # Internal: Restore the passthrough text by reinserting into the placeholder positions
-  #
-  # text - The String text into which to restore the passthrough text
-  #
-  # returns The String text with the passthrough text restored
-  def restore_passthroughs(text)
-    return text if @passthroughs.nil? || @passthroughs.empty? || !text.include?("\e")
-
-    text.gsub(REGEXP[:pass_placeholder]) {
-      pass = @passthroughs[$1.to_i];
-      text = apply_subs(pass[:text], pass.fetch(:subs, []))
-      pass[:literal] ? Inline.new(self, :quoted, text, :type => :monospaced, :attributes => pass.fetch(:attributes, {})).render : text
-    }
-  end
-
-  # Public: Substitute special characters (i.e., encode XML)
-  #
-  # Special characters are defined in the Asciidoctor::SPECIAL_CHARS Array constant
-  #
-  # text - The String text to process
-  #
-  # returns The String text with special characters replaced
-  def sub_specialcharacters(text)
-    # this syntax only available in Ruby 1.9
-    #text.gsub(SPECIAL_CHARS_PATTERN, SPECIAL_CHARS)
-
-    text.gsub(SPECIAL_CHARS_PATTERN) { SPECIAL_CHARS[$&] }
-  end
-  alias :sub_specialchars :sub_specialcharacters
-
-  # Public: Substitute quoted text (includes emphasis, strong, monospaced, etc)
-  #
-  # text - The String text to process
-  #
-  # returns The String text with quoted text rendered using the backend templates
-  def sub_quotes(text)
-    result = text.dup
-
-    QUOTE_SUBS.each {|type, scope, pattern|
-      result.gsub!(pattern) { transform_quoted_text($~, type, scope) }
-    }
-
-    result
-  end
-
-  # Public: Substitute replacement characters (e.g., copyright, trademark, etc)
-  #
-  # text - The String text to process
-  #
-  # returns The String text with the replacement characters substituted
-  def sub_replacements(text)
-    result = text.dup
-
-    REPLACEMENTS.each {|pattern, replacement, restore|
-      result.gsub!(pattern) {
-        matched = $&
-        head = $1
-        tail = $2
-        if matched.include?('\\')
-          matched.tr('\\', '')
-        else
-          case restore
-          when :none
-            replacement
-          when :leading
-            "#{head}#{replacement}"
-          when :bounding
-            "#{head}#{replacement}#{tail}"
-          end
-        end
-      }
-    }
-
-    result
-  end
-
-  # Public: Substitute attribute references
-  #
-  # Attribute references are in the format {name}.
-  #
-  # If an attribute referenced in the line is missing, the line is dropped.
-  #
-  # text     - The String text to process
-  #
-  # returns The String text with the attribute references replaced with attribute values
-  #--
-  # NOTE it's necessary to perform this substitution line-by-line
-  # so that a missing key doesn't wipe out the whole block of data
-  def sub_attributes(data, opts = {})
-    return data if data.nil? || data.empty?
-
-    string_data = data.is_a? String
-    # normalizes data type to an array (string becomes single-element array)
-    lines = string_data ? [data] : data
-
-    result = []
-    lines.each {|line|
-      reject = false
-      line = line.gsub(REGEXP[:attr_ref]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # escaped attribute, return unescaped
-        if !m[1].nil? || !m[4].nil?
-          "{#{m[2]}}"
-        elsif (directive = m[3])
-          offset = directive.length + 1
-          expr = m[2][offset..-1]
-          case directive
-          when 'set'
-            args = expr.split(':')
-            _, value = Lexer::store_attribute(args[0], args[1] || '', @document)
-            if value.nil?
-              # since this is an assignment, only drop-line applies here (skip and drop imply the same result)
-              if @document.attributes.fetch('attribute-undefined', COMPLIANCE[:attribute_undefined]) == 'drop-line'
-                Debug.debug { "Undefining attribute: #{key}, line marked for removal" }
-                break ''
-              end
-            end
-            ''
-          when 'counter', 'counter2'
-            args = expr.split(':')
-            val = @document.counter(args[0], args[1])
-            directive == 'counter2' ? '' : val
-          else
-            # if we get here, our attr_ref regex is too loose
-            warn "asciidoctor: WARNING: illegal attribute directive: #{m[2]}"
-            ''
-          end
-        elsif (key = m[2].downcase) && @document.attributes.has_key?(key)
-          @document.attributes[key]
-        elsif INTRINSICS.has_key? key
-          INTRINSICS[key]
-        else
-          case (opts[:attribute_missing] || @document.attributes.fetch('attribute-missing', COMPLIANCE[:attribute_missing]))
-          when 'skip'
-            "{#{key}}"
-          when 'drop-line'
-            Debug.debug { "Missing attribute: #{key}, line marked for removal" }
-            break ''
-          else # 'drop'
-            ''
-          end
-        end
-      } if line.include? '{'
-
-      result << line unless reject
-    }
-
-    string_data ? result.join : result
-  end
-
-  # Public: Substitute inline macros (e.g., links, images, etc)
-  #
-  # Replace inline macros, which may span multiple lines, in the provided text
-  #
-  # text - The String text to process
-  #
-  # returns The String with the inline macros rendered using the backend templates
-  def sub_macros(text)
-    return text if text.nil? || text.empty?
-
-    result = text.dup
-
-    # some look ahead assertions to cut unnecessary regex calls
-    found = {}
-    found[:square_bracket] = result.include?('[')
-    found[:round_bracket] = result.include?('(')
-    found[:colon] = result.include?(':')
-    found[:at] = result.include?('@')
-    found[:macroish] = (found[:square_bracket] && found[:colon])
-    found[:macroish_short_form] = (found[:square_bracket] && found[:colon] && result.include?(':['))
-    found[:uri] = (found[:colon] && result.include?('://'))
-    use_link_attrs = @document.attributes.has_key?('linkattrs')
-    experimental = @document.attributes.has_key?('experimental')
-
-    if experimental
-      if found[:macroish_short_form] && (result.include?('kbd:') || result.include?('btn:'))
-        result.gsub!(REGEXP[:kbd_btn_macro]) {
-          # alias match for Ruby 1.8.7 compat
-          m = $~
-          # honor the escape
-          if (captured = m[0]).start_with? '\\'
-            next captured[1..-1]
-          end
-
-          if captured.start_with?('kbd')
-            keys = unescape_bracketed_text m[1]
-
-            if keys == '+'
-              keys = ['+']
-            else
-              # need to use closure to work around lack of negative lookbehind
-              keys = keys.split(REGEXP[:kbd_delim]).inject([]) {|c, key|
-                if key.end_with?('++')
-                  c << key[0..-3].strip
-                  c << '+'
-                else
-                  c << key.strip
-                end
-                c
-              }
-            end
-            Inline.new(self, :kbd, nil, :attributes => {'keys' => keys}).render
-          elsif captured.start_with?('btn')
-            label = unescape_bracketed_text m[1]
-            Inline.new(self, :button, label).render
-          end
-        }
-      end
-
-      if found[:macroish] && result.include?('menu:')
-        result.gsub!(REGEXP[:menu_macro]) {
-          # alias match for Ruby 1.8.7 compat
-          m = $~
-          # honor the escape
-          if (captured = m[0]).start_with? '\\'
-            next captured[1..-1]
-          end
-
-          menu = m[1]
-          items = m[2]
-
-          if items.nil?
-            submenus = []
-            menuitem = nil
-          else
-            if (delim = items.include?('&gt;') ? '&gt;' : (items.include?(',') ? ',' : nil))
-              submenus = items.split(delim).map(&:strip)
-              menuitem = submenus.pop
-            else
-              submenus = []
-              menuitem = items.rstrip
-            end
-          end
-
-          Inline.new(self, :menu, nil, :attributes => {'menu' => menu, 'submenus' => submenus, 'menuitem' => menuitem}).render
-        }
-      end
-
-      if result.include?('"') && result.include?('&gt;')
-        result.gsub!(REGEXP[:menu_inline_macro]) {
-          # alias match for Ruby 1.8.7 compat
-          m = $~
-          # honor the escape
-          if (captured = m[0]).start_with? '\\'
-            next captured[1..-1]
-          end
-
-          input = m[1]
-
-          menu, *submenus = input.split('&gt;').map(&:strip)
-          menuitem = submenus.pop
-          Inline.new(self, :menu, nil, :attributes => {'menu' => menu, 'submenus' => submenus, 'menuitem' => menuitem}).render
-        }
-      end
-    end
-
-    # FIXME this location is somewhat arbitrary, probably need to be able to control ordering
-    # TODO this handling needs some cleanup
-    if (extensions = @document.extensions) && extensions.inline_macros? && found[:macroish]
-      extensions.load_inline_macro_processors(@document).each do |processor|
-        result.gsub!(processor.regexp) {
-          # alias match for Ruby 1.8.7 compat
-          m = $~
-          # honor the escape
-          if m[0].start_with? '\\'
-            next m[0][1..-1]
-          end
-
-          target = m[1]
-          if processor.options[:short_form]
-            attributes = {}
-          else
-            posattrs = processor.options.fetch(:pos_attrs, [])
-            attributes = parse_attributes(m[2], posattrs, :sub_input => true, :unescape_input => true)
-          end
-          processor.process self, target, attributes
-        }
-      end
-    end
-
-    if found[:macroish] && (result.include?('image:') || result.include?('icon:'))
-      # image:filename.png[Alt Text]
-      result.gsub!(REGEXP[:image_macro]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
-        end
-
-        raw_attrs = unescape_bracketed_text m[2]
-        if m[0].start_with? 'icon:'
-          type = 'icon'
-          posattrs = ['size']
-        else
-          type = 'image'
-          posattrs = ['alt', 'width', 'height']
-        end
-        target = sub_attributes(m[1])
-        unless type == 'icon'
-          @document.register(:images, target)
-        end
-        attrs = parse_attributes(raw_attrs, posattrs)
-        if !attrs['alt']
-          attrs['alt'] = File.basename(target, File.extname(target))
-        end
-        Inline.new(self, :image, nil, :type => type, :target => target, :attributes => attrs).render
-      }
-    end
-
-    if found[:macroish_short_form] || found[:round_bracket]
-      # indexterm:[Tigers,Big cats]
-      # (((Tigers,Big cats)))
-      result.gsub!(REGEXP[:indexterm_macro]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
-        end
-
-        terms = unescape_bracketed_text(m[1] || m[2]).split(',').map(&:strip)
-        @document.register(:indexterms, [*terms])
-        Inline.new(self, :indexterm, text, :attributes => {'terms' => terms}).render
-      }
-
-      # indexterm2:[Tigers]
-      # ((Tigers))
-      result.gsub!(REGEXP[:indexterm2_macro]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
-        end
-
-        text = unescape_bracketed_text(m[1] || m[2])
-        @document.register(:indexterms, [text])
-        Inline.new(self, :indexterm, text, :type => :visible).render
-      }
-    end
-
-    if found[:uri]
-      # inline urls, target[text] (optionally prefixed with link: and optionally surrounded by <>)
-      result.gsub!(REGEXP[:link_inline]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # honor the escape
-        if m[2].start_with? '\\'
-          next "#{m[1]}#{m[2][1..-1]}#{m[3]}"
-        # not a valid macro syntax w/o trailing square brackets
-        # we probably shouldn't even get here...our regex is doing too much
-        elsif m[1] == 'link:' && m[3].nil?
-          next m[0]
-        end
-        prefix = (m[1] != 'link:' ? m[1] : '')
-        target = m[2]
-        suffix = ''
-        # strip the <> around the link
-        if prefix.start_with?('&lt;') && target.end_with?('&gt;')
-          prefix = prefix[4..-1]
-          target = target[0..-5]
-        elsif prefix.start_with?('(') && target.end_with?(')')
-          target = target[0..-2]
-          suffix = ')'
-        elsif target.end_with?('):')
-          target = target[0..-3]
-          suffix = '):'
-        end
-        @document.register(:links, target)
-
-        attrs = nil
-        #text = !m[3].nil? ? sub_attributes(m[3].gsub('\]', ']')) : ''
-        if !m[3].to_s.empty?
-          if use_link_attrs && (m[3].start_with?('"') || m[3].include?(','))
-            attrs = parse_attributes(sub_attributes(m[3].gsub('\]', ']')), [])
-            text = attrs[1]
-          else
-            text = sub_attributes(m[3].gsub('\]', ']'))
-          end
-
-          if text.end_with? '^'
-            text = text.chop
-            attrs ||= {}
-            attrs['window'] = '_blank' unless attrs.has_key?('window')
-          end
-        else
-          text = ''
-        end
-
-        "#{prefix}#{Inline.new(self, :anchor, (!text.empty? ? text : target), :type => :link, :target => target, :attributes => attrs).render}#{suffix}"
-      }
-    end
-
-    if found[:macroish] && (result.include?('link:') || result.include?('mailto:'))
-      # inline link macros, link:target[text]
-      result.gsub!(REGEXP[:link_macro]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
-        end
-        raw_target = m[1]
-        mailto = m[0].start_with?('mailto:')
-        target = mailto ? "mailto:#{raw_target}" : raw_target
-
-        attrs = nil
-        #text = sub_attributes(m[2].gsub('\]', ']'))
-        if use_link_attrs && (m[2].start_with?('"') || m[2].include?(','))
-          attrs = parse_attributes(sub_attributes(m[2].gsub('\]', ']')), [])
-          text = attrs[1]
-          if mailto
-            if attrs.has_key? 2
-              target = "#{target}?subject=#{Helpers.encode_uri(attrs[2])}"
-
-              if attrs.has_key? 3
-                target = "#{target}&amp;body=#{Helpers.encode_uri(attrs[3])}"
-              end
-            end
-          end
-        else
-          text = sub_attributes(m[2].gsub('\]', ']'))
-        end
-
-        if text.end_with? '^'
-          text = text.chop
-          attrs ||= {}
-          attrs['window'] = '_blank' unless attrs.has_key?('window')
-        end
-
-        # QUESTION should a mailto be registered as an e-mail address?
-        @document.register(:links, target)
-
-        Inline.new(self, :anchor, (!text.empty? ? text : raw_target), :type => :link, :target => target, :attributes => attrs).render
-      }
-    end
-
-    if found[:at]
-      result.gsub!(REGEXP[:email_inline]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        address = m[0]
-        case address[0..0]
-        when '\\'
-          next address[1..-1]
-        when '>', ':'
-          next address
-        end
-
-        target = "mailto:#{address}"
-        # QUESTION should this be registered as an e-mail address?
-        @document.register(:links, target)
-
-        Inline.new(self, :anchor, address, :type => :link, :target => target).render
-      }
-    end
-
-    if found[:macroish_short_form] && result.include?('footnote')
-      result.gsub!(REGEXP[:footnote_macro]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
-        end
-        if m[1] == 'footnote'
-          # hmmmm
-          text = restore_passthroughs(m[2])
-          id = nil
-          index = @document.counter('footnote-number')
-          @document.register(:footnotes, Document::Footnote.new(index, id, text))
-          type = nil
-          target = nil
-        else
-          id, text = m[2].split(',', 2).map(&:strip)
-          if !text.nil?
-            # hmmmm
-            text = restore_passthroughs(text)
-            index = @document.counter('footnote-number')
-            @document.register(:footnotes, Document::Footnote.new(index, id, text))
-            type = :ref
-            target = nil
-          else
-            footnote = @document.references[:footnotes].find {|fn| fn.id == id }
-            target = id
-            id = nil
-            index = footnote.index
-            text = footnote.text
-            type = :xref
-          end
-        end
-        Inline.new(self, :footnote, text, :attributes => {'index' => index}, :id => id, :target => target, :type => type).render
-      }
-    end
-
-    if found[:macroish] || result.include?('&lt;&lt;')
-      result.gsub!(REGEXP[:xref_macro]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
-        end
-        if !m[1].nil?
-          id, reftext = m[1].split(',', 2).map(&:strip)
-          id.sub!(REGEXP[:dbl_quoted], '\2')
-          reftext.sub!(REGEXP[:m_dbl_quoted], '\2') unless reftext.nil?
-        else
-          id = m[2]
-          reftext = !m[3].empty? ? m[3] : nil
-        end
-
-        if id.include? '#'
-          path, fragment = id.split('#')
-        else
-          path = nil
-          fragment = id
-        end
-
-        # handles form: id
-        if path.nil?
-          refid = fragment
-          target = "##{fragment}"
-        # handles forms: doc#, doc.adoc#, doc#id and doc.adoc#id
-        else
-          path = Helpers.rootname(path)
-          # the referenced path is this document, or its contents has been included in this document
-          if @document.attr?('docname', path) || @document.references[:includes].include?(path)
-            refid = fragment
-            path = nil
-            target = "##{fragment}"
-          else
-            refid = fragment.nil? ? path : "#{path}##{fragment}"
-            path = "#{path}#{@document.attr 'outfilesuffix', '.html'}"
-            target = fragment.nil? ? path : "#{path}##{fragment}"
-          end
-        end
-        Inline.new(self, :anchor, reftext, :type => :xref, :target => target, :attributes => {'path' => path, 'fragment' => fragment, 'refid' => refid}).render
-      }
-    end
-
-    if found[:square_bracket] && result.include?('[[[')
-      result.gsub!(REGEXP[:biblio_macro]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
-        end
-        id = reftext = m[1]
-        Inline.new(self, :anchor, reftext, :type => :bibref, :target => id).render
-      }
-    end
-
-    if found[:square_bracket] && result.include?('[[')
-      result.gsub!(REGEXP[:anchor_macro]) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
-        end
-        id, reftext = m[1].split(',').map(&:strip)
-        id.sub!(REGEXP[:dbl_quoted], '\2')
-        if reftext.nil?
-          reftext = "[#{id}]"
-        else
-          reftext.sub!(REGEXP[:m_dbl_quoted], '\2')
-        end
-        # NOTE the reftext should also match what's in our references dic
-        if !@document.references[:ids].has_key? id
-          Debug.debug { "Missing reference for anchor #{id}" }
-        end
-        Inline.new(self, :anchor, reftext, :type => :ref, :target => id).render
-      }
-    end
-
-    result
-  end
-
-  # Public: Substitute callout references
-  #
-  # text - The String text to process
-  #
-  # returns The String with the callout references rendered using the backend templates
-  def sub_callouts(text)
-    text.gsub(REGEXP[:callout_render]) {
-      # alias match for Ruby 1.8.7 compat
-      m = $~
-      # honor the escape
-      if m[1] == '\\'
-        # we have to do a sub since we aren't sure it's the first char
-        next m[0].sub('\\', '')
-      end
-      Inline.new(self, :callout, m[3], :id => @document.callouts.read_next_id).render
-    }
-  end
-
-  # Public: Substitute post replacements
-  #
-  # text - The String text to process
-  #
-  # returns The String with the post replacements rendered using the backend templates
-  def sub_post_replacements(text)
-    if @document.attributes['hardbreaks']
-      lines = text.lines.entries
-      return text if lines.size == 1
-      last = lines.pop
-      lines.map {|line| Inline.new(self, :break, line.rstrip.chomp(LINE_BREAK), :type => :line).render }.push(last) * EOL
-    else
-      text.gsub(REGEXP[:line_break]) { Inline.new(self, :break, $1, :type => :line).render }
-    end
-  end
-
-  # Internal: Transform (render) a quoted text region
-  #
-  # match  - The MatchData for the quoted text region
-  # type   - The quoting type (single, double, strong, emphasis, monospaced, etc)
-  # scope  - The scope of the quoting (constrained or unconstrained)
-  #
-  # returns The rendered text for the quoted text region
-  def transform_quoted_text(match, type, scope)
-    unescaped_attrs = nil
-    if match[0].start_with? '\\'
-      if scope == :constrained && !match[2].nil?
-        unescaped_attrs = "[#{match[2]}]"
-      else
-        return match[0][1..-1]
-      end
-    end
-
-    if scope == :constrained
-      if unescaped_attrs.nil?
-        attributes = parse_quoted_text_attributes(match[2])
-        id = attributes.nil? ? nil : attributes.delete('id')
-        "#{match[1]}#{Inline.new(self, :quoted, match[3], :type => type, :id => id, :attributes => attributes).render}"
-      else
-        "#{unescaped_attrs}#{Inline.new(self, :quoted, match[3], :type => type, :attributes => {}).render}"
-      end
-    else
-      attributes = parse_quoted_text_attributes(match[1])
-      id = attributes.nil? ? nil : attributes.delete('id')
-      Inline.new(self, :quoted, match[2], :type => type, :id => id, :attributes => attributes).render
-    end
-  end
-
-  # Internal: Parse the attributes that are defined on quoted text
-  #
-  # str       - A String of unprocessed attributes (space-separated roles or the id/role shorthand syntax)
-  #
-  # returns nil if str is nil, an empty Hash if str is empty, otherwise a Hash of attributes (role and id only)
-  def parse_quoted_text_attributes(str)
-    return nil if str.nil?
-    return {} if str.empty?
-    str = sub_attributes(str) if str.include?('{')
-    str = str.strip
-    # for compliance, only consider first positional attribute
-    str, _ = str.split(',', 2) if str.include?(',')
-
-    if str.empty?
-      {}
-    elsif str.start_with?('.') || str.start_with?('#')
-      segments = str.split('#', 2)
-
-      if segments.length > 1
-        id, *more_roles = segments[1].split('.')
-      else
-        id = nil
-        more_roles = []
-      end
-
-      roles = segments[0].empty? ? [] : segments[0].split('.')
-      if roles.length > 1
-        roles.shift
-      end
-
-      if more_roles.length > 0
-        roles.concat more_roles
-      end
-
-      attrs = {}
-      attrs['id'] = id unless id.nil?
-      attrs['role'] = roles.empty? ? nil : (roles * ' ')
-      attrs
-    else
-      {'role' => str}
-    end
-  end
-
-  # Internal: Parse the attributes in the attribute line
-  #
-  # attrline  - A String of unprocessed attributes (key/value pairs)
-  # posattrs  - The keys for positional attributes
-  #
-  # 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 nil if attrline.nil?
-    return {} if attrline.empty?
-    attrline = @document.sub_attributes(attrline) if opts[:sub_input]
-    attrline = unescape_bracketed_text(attrline) if opts[:unescape_input]
-    block = nil
-    if opts.fetch(:sub_result, true)
-      # substitutions are only performed on attribute values if block is not nil
-      block = self
-    end
-
-    if opts.has_key?(:into)
-      AttributeList.new(attrline, block).parse_into(opts[:into], posattrs)
-    else
-      AttributeList.new(attrline, block).parse(posattrs)
-    end
-  end
-
-  # Internal: Strip bounding whitespace, fold endlines and unescaped closing
-  # square brackets from text extracted from brackets
-  def unescape_bracketed_text(text)
-    return '' if text.empty?
-    text.strip.tr(EOL, ' ').gsub('\]', ']')
-  end
-
-  # Internal: Resolve the list of comma-delimited subs against the possible options.
-  #
-  # subs - A comma-delimited String of substitution aliases
-  #
-  # returns An Array of Symbols representing the substitution operation
-  def resolve_subs subs, type = :block, subject = nil
-    return [] if subs.nil? || subs.empty?
-    candidates = []
-    subs.split(',').each do |val|
-      key = val.strip.to_sym
-      # special case to disable callouts for inline subs
-      if key == :verbatim && type == :inline
-        candidates << :specialcharacters
-      elsif COMPOSITE_SUBS.has_key? key
-        candidates.push(*COMPOSITE_SUBS[key])
-      else
-        candidates << key
-      end
-    end
-    # weed out invalid options and remove duplicates (first wins)
-    resolved = candidates & SUB_OPTIONS[type]
-    if (invalid = candidates - resolved).size > 0
-      warn "asciidoctor: WARNING: invalid substitution type#{invalid.size > 1 ? 's' : ''}#{subject ? ' for ' : nil}#{subject}: #{invalid * ', '}"
-    end
-    resolved
-  end
-
-  def resolve_block_subs subs, subject
-    resolve_subs subs, :block, subject
-  end
-
-  def resolve_pass_subs subs
-    resolve_subs subs, :inline, 'passthrough macro'
-  end
-
-  # Public: Highlight the source code if a source highlighter is defined
-  # on the document, otherwise return the text unprocessed
-  #
-  # Callout marks are stripped from the source prior to passing it to the
-  # highlighter, then later restored in rendered form, so they are not
-  # incorrectly processed by the source highlighter.
-  #
-  # source - the source code String to highlight
-  # sub_callouts - a Boolean flag indicating whether callout marks should be substituted
-  #
-  # returns the highlighted source code, if a source highlighter is defined
-  # on the document, otherwise the unprocessed text
-  def highlight_source(source, sub_callouts, highlighter = nil)
-    highlighter ||= @document.attributes['source-highlighter']
-    Helpers.require_library highlighter, (highlighter == 'pygments' ? 'pygments.rb' : highlighter)
-    callout_marks = {}
-    lineno = 0
-    callout_on_last = false
-    if sub_callouts
-      last = -1
-      # extract callout marks, indexed by line number
-      source = source.split(EOL).map {|line|
-        lineno = lineno + 1
-        line.gsub(REGEXP[:callout_scan]) {
-          # alias match for Ruby 1.8.7 compat
-          m = $~
-          # honor the escape
-          if m[1] == '\\'
-            m[0].sub('\\', '')
-          else
-            (callout_marks[lineno] ||= []) << m[3]
-            last = lineno
-            nil
-          end
-        }
-      } * EOL
-      callout_on_last = (last == lineno)
-    end
-
-    linenums_mode = nil
-
-    case highlighter
-      when 'coderay'
-        result = ::CodeRay::Duo[attr('language', 'text').to_sym, :html, {
-            :css => @document.attributes.fetch('coderay-css', 'class').to_sym,
-            :line_numbers => (linenums_mode = (attr?('linenums') ? @document.attributes.fetch('coderay-linenums-mode', 'table').to_sym : nil)),
-            :line_number_anchors => false}].highlight(source)
-      when 'pygments'
-        lexer = ::Pygments::Lexer[attr('language')]
-        if lexer
-          opts = { :cssclass => 'pyhl', :classprefix => 'tok-', :nobackground => true }
-          opts[:noclasses] = true unless @document.attributes.fetch('pygments-css', 'class') == 'class'
-          if attr? 'linenums'
-            opts[:linenos] = (linenums_mode = @document.attributes.fetch('pygments-linenums-mode', 'table').to_sym).to_s
-          end
-
-          # FIXME stick these regexs into constants
-          if linenums_mode == :table
-            result = lexer.highlight(source, :options => opts).
-                sub(/<div class="pyhl">(.*)<\/div>/m, '\1').
-                gsub(/<pre[^>]*>(.*?)<\/pre>\s*/m, '\1')
-          else
-            result = lexer.highlight(source, :options => opts).
-                sub(/<div class="pyhl"><pre[^>]*>(.*?)<\/pre><\/div>/m, '\1')
-          end
-        else
-          result = source
-        end
-    end
-
-    if !sub_callouts || callout_marks.empty?
-      result
-    else
-      lineno = 0
-      reached_code = linenums_mode != :table
-      result.split(EOL).map {|line|
-        unless reached_code
-          unless line.include?('<td class="code">')
-            next line
-          end
-          reached_code = true
-        end
-        lineno = lineno + 1
-        if (conums = callout_marks.delete(lineno))
-          tail = nil
-          if callout_on_last && callout_marks.empty? && (pos = line.index '</pre>')
-            tail = line[pos..-1]
-            line = line[0...pos]
-          end
-          if conums.size == 1
-            %(#{line}#{Inline.new(self, :callout, conums.first, :id => @document.callouts.read_next_id).render }#{tail})
-          else
-            conums_markup = conums.map {|conum| Inline.new(self, :callout, conum, :id => @document.callouts.read_next_id).render } * ' '
-            %(#{line}#{conums_markup}#{tail})
-          end
-        else
-          line
-        end
-      } * EOL
-    end
-  end
-end
-end