radiant 0.9.0.rc2 → 0.9.1

data/vendor/extensions/markdown_filter/vendor/kramdown/lib/kramdown/parser/kramdown/eob.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown.
 #
@@ -29,7 +29,7 @@ module Kramdown
       # Parse the EOB marker at the current location.
       def parse_eob_marker
         @src.pos += @src.matched_size
-        @tree.children << Element.new(:eob)
+        @tree.children << new_block_el(:eob)
         true
       end
       define_parser(:eob_marker, EOB_MARKER)

data/vendor/extensions/markdown_filter/vendor/kramdown/lib/kramdown/parser/kramdown/escaped_chars.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown.
 #
@@ -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/vendor/extensions/markdown_filter/vendor/kramdown/lib/kramdown/parser/kramdown/extension.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown.
 #
@@ -26,83 +26,75 @@ module Kramdown
   module Parser
     class Kramdown
 
-      # The base extension class.
-      #
-      # This class provides implementations for the default extensions defined in the kramdown
-      # specification.
-      #
-      # An extension is a method called <tt>parse_EXTNAME</tt> where +EXTNAME+ is the extension name.
-      # These methods are called with three parameters:
-      #
-      # [+parser+]
-      #    The parser instance from which the extension method is called.
-      # [+opts+]
-      #    A hash containing the options set in the extension.
-      # [+body+]
-      #    A string containing the body of the extension. If no body is available, this is +nil+.
-      class Extension
+      def parse_extension_start_tag(type)
+        @src.pos += @src.matched_size
 
-        # Just ignore everything and do nothing.
-        def parse_comment(parser, opts, body)
-          nil
+        if @src[4] || @src.matched == '{:/}'
+          name = (@src[4] ? "for '#{@src[4]}' " : '')
+          warning("Invalid extension stop tag #{name}found - ignoring it")
+          return
         end
 
-        # Add the body (if available) as <tt>:raw</tt> Element to the +parser.tree+.
-        def parse_nomarkdown(parser, opts, body)
-          parser.tree.children << Element.new(:raw, body) if body.kind_of?(String)
+        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, '')
+          else
+            warning("No stop tag for extension '#{ext}' found - treating it as extension without body")
+          end
         end
 
-        # Update the document and parser options with the options set in +opts+.
-        def parse_options(parser, opts, body)
+        handle_extension(ext, opts, body, type)
+      end
+
+      def handle_extension(name, opts, body, type)
+        case name
+        when 'comment'
+          # nothing to do
+        when 'nomarkdown'
+          @tree.children << Element.new(:raw, body, :category => type) if body.kind_of?(String)
+        when 'options'
           opts.select do |k,v|
             k = k.to_sym
             if Kramdown::Options.defined?(k)
-              parser.doc.options[k] = Kramdown::Options.parse(k, v) rescue parser.doc.options[k]
+              @doc.options[k] = Kramdown::Options.parse(k, v) rescue @doc.options[k]
               false
             else
               true
             end
           end.each do |k,v|
-            parser.warning("Unknown kramdown option '#{k}'")
+            warning("Unknown kramdown option '#{k}'")
           end
+        else
+          warning("Invalid extension name '#{name}' specified - ignoring extension")
         end
-
       end
 
 
-      EXT_BLOCK_START_STR = "^#{OPT_SPACE}\\{::(%s):(:)?(#{ALD_ANY_CHARS}*)\\}\s*?\n"
-      EXT_BLOCK_START = /#{EXT_BLOCK_START_STR % ALD_ID_NAME}/
+      EXT_STOP_STR = "\\{:/(%s)?\\}"
+      EXT_START_STR = "\\{::(\\w+)(?:\\s(#{ALD_ANY_CHARS}*?)|)(\\/)?\\}"
+      EXT_SPAN_START = /#{EXT_START_STR}|#{EXT_STOP_STR % ALD_ID_NAME}/
+      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"
 
       # Parse the extension block at the current location.
-      def parse_extension_block
-        @src.pos += @src.matched_size
-
-        ext = @src[1]
-        opts = {}
-        body = nil
-        parse_attribute_list(@src[3], opts)
-
-        if !@extension.public_methods.map {|m| m.to_s}.include?("parse_#{ext}")
-          warning("No extension named '#{ext}' found - ignoring extension block")
-          body = :invalid
-        end
-
-        if !@src[2]
-          stop_re = /#{EXT_BLOCK_START_STR % ext}/
-          if result = @src.scan_until(stop_re)
-            parse_attribute_list(@src[3], opts)
-            body = result.sub!(stop_re, '') if body != :invalid
-          else
-            body = :invalid
-            warning("No ending line for extension block '#{ext}' found - ignoring extension block")
-          end
-        end
+      def parse_block_extension
+        parse_extension_start_tag(:block)
+        true
+      end
+      define_parser(:block_extension, EXT_BLOCK_START)
 
-        @extension.send("parse_#{ext}", self, opts, body) if body != :invalid
 
-        true
+      # Parse the extension span at the current location.
+      def parse_span_extension
+        parse_extension_start_tag(:span)
       end
-      define_parser(:extension_block, EXT_BLOCK_START)
+      define_parser(:span_extension, EXT_SPAN_START, '\{:[:/]')
 
     end
   end

data/vendor/extensions/markdown_filter/vendor/kramdown/lib/kramdown/parser/kramdown/footnote.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown.
 #

data/vendor/extensions/markdown_filter/vendor/kramdown/lib/kramdown/parser/kramdown/header.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown.
 #
@@ -24,19 +24,6 @@ module Kramdown
   module Parser
     class Kramdown
 
-      # Generate an alpha-numeric ID from the the string +str+.
-      def generate_id(str)
-        gen_id = str.gsub(/[^a-zA-Z0-9 -]/, '').gsub(/^[^a-zA-Z]*/, '').gsub(' ', '-').downcase
-        gen_id = 'section' if gen_id.length == 0
-        @used_ids ||= {}
-        if @used_ids.has_key?(gen_id)
-          gen_id += '-' + (@used_ids[gen_id] += 1).to_s
-        else
-          @used_ids[gen_id] = 0
-        end
-        gen_id
-      end
-
       HEADER_ID=/(?:[ \t]\{#((?:\w|\d)[\w\d-]*)\})?/
       SETEXT_HEADER_START = /^(#{OPT_SPACE}[^ \t].*?)#{HEADER_ID}[ \t]*?\n(-|=)+\s*?\n/
 
@@ -47,10 +34,9 @@ module Kramdown
         end
         @src.pos += @src.matched_size
         text, id, level = @src[1].strip, @src[2], @src[3]
-        el = Element.new(:header, nil, :level => (level == '-' ? 2 : 1))
+        el = new_block_el(:header, nil, :level => (level == '-' ? 2 : 1), :raw_text => text)
         add_text(text, el)
         el.options[:attr] = {'id' => id} if id
-        el.options[:attr] = {'id' => generate_id(text)} if @doc.options[:auto_ids] && !id
         @tree.children << el
         true
       end
@@ -67,10 +53,9 @@ module Kramdown
         end
         result = @src.scan(ATX_HEADER_MATCH)
         level, text, id = @src[1], @src[2].strip, @src[3]
-        el = Element.new(:header, nil, :level => level.length)
+        el = new_block_el(:header, nil, :level => level.length, :raw_text => text)
         add_text(text, el)
         el.options[:attr] = {'id' => id} if id
-        el.options[:attr] = {'id' => generate_id(text)} if @doc.options[:auto_ids] && !id
         @tree.children << el
         true
       end

data/vendor/extensions/markdown_filter/vendor/kramdown/lib/kramdown/parser/kramdown/horizontal_rule.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown.
 #
@@ -29,7 +29,7 @@ module Kramdown
       # Parse the horizontal rule at the current location.
       def parse_horizontal_rule
         @src.pos += @src.matched_size
-        @tree.children << Element.new(:hr)
+        @tree.children << new_block_el(:hr)
         true
       end
       define_parser(:horizontal_rule, HR_START)

data/vendor/extensions/markdown_filter/vendor/kramdown/lib/kramdown/parser/kramdown/html.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2010 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown.
 #
@@ -20,179 +20,102 @@
 #++
 #
 
-require 'rexml/parsers/baseparser'
+require 'kramdown/parser/html'
 
 module Kramdown
   module Parser
     class Kramdown
 
-      #:stopdoc:
-      # The following regexps are based on the ones used by REXML, with some slight modifications.
-      #:startdoc:
-      HTML_COMMENT_RE = /<!--(.*?)-->/m
-      HTML_INSTRUCTION_RE = /<\?(.*?)\?>/m
-      HTML_ATTRIBUTE_RE = /\s*(#{REXML::Parsers::BaseParser::UNAME_STR})\s*=\s*(["'])(.*?)\2/m
-      HTML_TAG_RE = /<((?>#{REXML::Parsers::BaseParser::UNAME_STR}))\s*((?>\s+#{REXML::Parsers::BaseParser::UNAME_STR}\s*=\s*(["']).*?\3)*)\s*(\/)?>/m
-      HTML_TAG_CLOSE_RE = /<\/(#{REXML::Parsers::BaseParser::NAME_STR})\s*>/m
-
-
-      HTML_PARSE_AS_BLOCK = %w{applet button blockquote colgroup dd div dl fieldset form iframe li
-                               map noscript object ol table tbody td th thead tfoot tr ul}
-      HTML_PARSE_AS_SPAN  = %w{a abbr acronym address b bdo big cite caption code del dfn dt em
-                               h1 h2 h3 h4 h5 h6 i ins kbd label legend optgroup p pre q rb rbc
-                               rp rt rtc ruby samp select small span strong sub sup tt var}
-      HTML_PARSE_AS_RAW   = %w{script math option textarea}
-
-      HTML_PARSE_AS = Hash.new {|h,k| h[k] = :raw}
-      HTML_PARSE_AS_BLOCK.each {|i| HTML_PARSE_AS[i] = :block}
-      HTML_PARSE_AS_SPAN.each {|i| HTML_PARSE_AS[i] = :span}
-      HTML_PARSE_AS_RAW.each {|i| HTML_PARSE_AS[i] = :raw}
-
-      #:stopdoc:
-      # Some HTML elements like script belong to both categories (i.e. are valid in block and
-      # span HTML) and don't appear therefore!
-      #:startdoc:
-      HTML_SPAN_ELEMENTS = %w{a abbr acronym b big bdo br button cite code del dfn em i img input
-                              ins kbd label option q rb rbc rp rt rtc ruby samp select small span
-                              strong sub sup textarea tt var}
-      HTML_BLOCK_ELEMENTS = %w{address applet button blockquote caption col colgroup dd div dl dt fieldset
-                               form h1 h2 h3 h4 h5 h6 hr iframe legend li map ol optgroup p pre table tbody
-                               td th thead tfoot tr ul}
-      HTML_ELEMENTS_WITHOUT_BODY = %w{area br col hr img input}
-
-      HTML_BLOCK_START = /^#{OPT_SPACE}<(#{REXML::Parsers::BaseParser::UNAME_STR}|\?|!--|\/)/
-      HTML_RAW_START = /(?=<(#{REXML::Parsers::BaseParser::UNAME_STR}|\/))/
-
-      # Parse the HTML at the current position as block level HTML.
-      def parse_block_html
-        if result = @src.scan(HTML_COMMENT_RE)
-          @tree.children << Element.new(:xml_comment, result, :type => :block)
-          @src.scan(/[ \t]*\n/)
-          true
-        elsif result = @src.scan(HTML_INSTRUCTION_RE)
-          @tree.children << Element.new(:xml_pi, result, :type => :block)
-          @src.scan(/[ \t]*\n/)
-          true
-        else
-          if result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
-            @src.pos += @src.matched_size
-            handle_html_start_tag
-            true
-          elsif result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_CLOSE_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
-            @src.pos += @src.matched_size
-            name = @src[1]
-
-            if @tree.type ==:html_element && @tree.value == name
-              throw :stop_block_parsing, :found
-            else
-              warning("Found invalidly used HTML closing tag for '#{name}' - ignoring it")
-              true
-            end
-          else
-            false
-          end
-        end
-      end
-      define_parser(:block_html, HTML_BLOCK_START)
-
-
-      # Return the HTML parse type defined by the string +val+, i.e. raw when "0", default parsing
-      # (return value +nil+) when "1", span parsing when "span" and block parsing when "block". If
-      # +val+ is nil, then the default parsing mode is used.
-      def get_parse_type(val)
-        case val
-        when "0" then :raw
-        when "1" then :default
-        when "span" then :span
-        when "block" then :block
-        when NilClass then nil
-        else
-          warning("Invalid markdown attribute val '#{val}', using default")
-          nil
-        end
-      end
-
-      # Process the HTML start tag that has already be scanned/checked.
-      def handle_html_start_tag
-        curpos = @src.pos
-        name = @src[1]
-        closed = !@src[4].nil?
-        attrs = {}
-        @src[2].scan(HTML_ATTRIBUTE_RE).each {|attr,sep,val| attrs[attr] = val}
+      include Kramdown::Parser::Html::Parser
 
+      def handle_kramdown_html_tag(el, closed)
         parse_type = if @tree.type != :html_element || @tree.options[:parse_type] != :raw
-                       (@doc.options[:parse_block_html] ? HTML_PARSE_AS[name] : :raw)
+                       (@doc.options[:parse_block_html] ? HTML_PARSE_AS[el.value] : :raw)
                      else
                        :raw
                      end
-        if val = get_parse_type(attrs.delete('markdown'))
-          parse_type = (val == :default ? HTML_PARSE_AS[name] : val)
+        if val = html_parse_type(el.options[:attr].delete('markdown'))
+          parse_type = (val == :default ? HTML_PARSE_AS[el.value] : val)
         end
 
         @src.scan(/[ \t]*\n/) if parse_type == :block
-
-        el = Element.new(:html_element, name, :attr => attrs, :type => :block, :parse_type => parse_type)
         el.options[:outer_element] = true if @tree.type != :html_element
         el.options[:parent_is_raw] = true if @tree.type == :html_element && @tree.options[:parse_type] == :raw
-        @tree.children << el
+        el.options[:parse_type] = parse_type
 
-        if !closed && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
-          warning("The HTML tag '#{el.value}' cannot have any content - auto-closing it")
-        elsif !closed
+        if !closed
           if parse_type == :block
             end_tag_found = parse_blocks(el)
             if !end_tag_found
               warning("Found no end tag for '#{el.value}' - auto-closing it")
             end
           elsif parse_type == :span
+            curpos = @src.pos
             if result = @src.scan_until(/(?=<\/#{el.value}\s*>)/m)
-              add_text(extract_string(curpos...@src.pos), el)
+              add_text(extract_string(curpos...@src.pos, @src), el)
               @src.scan(HTML_TAG_CLOSE_RE)
             else
               add_text(@src.scan(/.*/m), el)
               warning("Found no end tag for '#{el.value}' - auto-closing it")
             end
           else
-            parse_raw_html(el)
+            parse_raw_html(el, &method(:handle_kramdown_html_tag))
           end
           @src.scan(/[ \t]*\n/) unless (@tree.type == :html_element && @tree.options[:parse_type] == :raw)
         end
       end
 
-      # Parse raw HTML until the matching end tag for +el+ is found or until the end of the
-      # document.
-      def parse_raw_html(el)
-        @stack.push(@tree)
-        @tree = el
-
-        done = false
-        endpos = nil
-        while !@src.eos? && !done
-          if result = @src.scan_until(HTML_RAW_START)
-            endpos = @src.pos
-            add_text(result, @tree, :html_text)
-            if @src.scan(HTML_TAG_RE)
-              handle_html_start_tag
-            elsif @src.scan(HTML_TAG_CLOSE_RE)
-              if @tree.value == @src[1]
-                done = true
-              else
-                warning("Found invalidly used HTML closing tag for '#{@src[1]}' - ignoring it")
-              end
+      # Return the HTML parse type defined by the string +val+, i.e. raw when "0", default parsing
+      # (return value +nil+) when "1", span parsing when "span" and block parsing when "block". If
+      # +val+ is nil, then the default parsing mode is used.
+      def html_parse_type(val)
+        case val
+        when "0" then :raw
+        when "1" then :default
+        when "span" then :span
+        when "block" then :block
+        when NilClass then nil
+        else
+          warning("Invalid markdown attribute val '#{val}', using default")
+          nil
+        end
+      end
+
+
+      HTML_BLOCK_START = /^#{OPT_SPACE}<(#{REXML::Parsers::BaseParser::UNAME_STR}|\?|!--|\/)/
+
+      # Parse the HTML at the current position as block level HTML.
+      def parse_block_html
+        if result = @src.scan(HTML_COMMENT_RE)
+          @tree.children << Element.new(:xml_comment, result, :category => :block)
+          @src.scan(/[ \t]*\n/)
+          true
+        elsif result = @src.scan(HTML_INSTRUCTION_RE)
+          @tree.children << Element.new(:xml_pi, result, :category => :block)
+          @src.scan(/[ \t]*\n/)
+          true
+        else
+          if result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
+            @src.pos += @src.matched_size
+            handle_html_start_tag(&method(:handle_kramdown_html_tag))
+            Kramdown::Parser::Html::ElementConverter.new.process(@tree.children.last) if @doc.options[:html_to_native]
+            true
+          elsif result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_CLOSE_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
+            @src.pos += @src.matched_size
+            name = @src[1]
+
+            if @tree.type == :html_element && @tree.value == name
+              throw :stop_block_parsing, :found
             else
-              add_text(@src.scan(/./), @tree, :html_text)
+              warning("Found invalidly used HTML closing tag for '#{name}' - ignoring it")
+              true
             end
           else
-            result = @src.scan(/.*/m)
-            add_text(result, @tree, :html_text)
-            warning("Found no end tag for '#{@tree.value}' - auto-closing it")
-            done = true
+            false
           end
         end
-
-        @tree = @stack.pop
-        endpos
       end
+      define_parser(:block_html, HTML_BLOCK_START)
 
 
       HTML_SPAN_START = /<(#{REXML::Parsers::BaseParser::UNAME_STR}|\?|!--|\/)/
@@ -200,9 +123,9 @@ module Kramdown
       # Parse the HTML at the current position as span level HTML.
       def parse_span_html
         if result = @src.scan(HTML_COMMENT_RE)
-          @tree.children << Element.new(:xml_comment, result, :type => :span)
+          @tree.children << Element.new(:xml_comment, result, :category => :span)
         elsif result = @src.scan(HTML_INSTRUCTION_RE)
-          @tree.children << Element.new(:xml_pi, result, :type => :span)
+          @tree.children << Element.new(:xml_pi, result, :category => :span)
         elsif result = @src.scan(HTML_TAG_CLOSE_RE)
           warning("Found invalidly used HTML closing tag for '#{@src[1]}' - ignoring it")
         elsif result = @src.scan(HTML_TAG_RE)
@@ -212,36 +135,33 @@ module Kramdown
           attrs = {}
           @src[2].scan(HTML_ATTRIBUTE_RE).each {|name,sep,val| attrs[name] = val.gsub(/\n+/, ' ')}
 
-          do_parsing = (HTML_PARSE_AS_RAW.include?(@src[1]) ? false : @doc.options[:parse_span_html])
-          if val = get_parse_type(attrs.delete('markdown'))
+          do_parsing = (HTML_PARSE_AS_RAW.include?(@src[1]) || @tree.options[:parse_type] == :raw ? false : @doc.options[:parse_span_html])
+          if val = html_parse_type(attrs.delete('markdown'))
             if val == :block
               warning("Cannot use block level parsing in span level HTML tag - using default mode")
             elsif val == :span
               do_parsing = true
             elsif val == :default
-              (HTML_PARSE_AS_RAW.include?(@src[1]) ? false : true)
+              do_parsing = !HTML_PARSE_AS_RAW.include?(@src[1])
             elsif val == :raw
               do_parsing = false
             end
           end
 
-          el = Element.new(:html_element, @src[1], :attr => attrs, :type => :span)
+          el = Element.new(:html_element, @src[1], :attr => attrs, :category => :span, :parse_type => (do_parsing ? :span : :raw))
+          @tree.children << el
           stop_re = /<\/#{Regexp.escape(@src[1])}\s*>/
-          if @src[4]
-            @tree.children << el
-          elsif HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
+          if !@src[4] && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
             warning("The HTML tag '#{el.value}' cannot have any content - auto-closing it")
-            @tree.children << el
-          else
-            if parse_spans(el, stop_re, (do_parsing ? nil : [:span_html]), (do_parsing ? :text : :html_text))
-              end_pos = @src.pos
+          elsif !@src[4]
+            if parse_spans(el, stop_re, (do_parsing ? nil : [:span_html]))
               @src.scan(stop_re)
             else
               warning("Found no end tag for '#{el.value}' - auto-closing it")
-              add_text(@src.scan(/.*/m))
+              add_text(@src.scan(/.*/m), el)
             end
-            @tree.children << el
           end
+          Kramdown::Parser::Html::ElementConverter.new.process(el) if @doc.options[:html_to_native]
         else
           add_text(@src.scan(/./))
         end