textpow 0.10.1 → 1.3.0

data/lib/textpow.rb

@@ -1,10 +1,50 @@
 require 'yaml'
-require 'oniguruma'
 require 'textpow/syntax'
 require 'textpow/debug_processor'
+require 'textpow/recording_processor'
 require 'textpow/score_manager'
-
+require 'textpow/version'
 
 module Textpow
-   class ParsingError < Exception; end
+  class ParsingError < Exception; end
+
+  def self.syntax_path
+    File.join(File.dirname(__FILE__), 'textpow', 'syntax')
+  end
+
+  @@syntax = {}
+  def self.syntax(syntax_name)
+    syntax_name = syntax_name.downcase
+    if @@syntax.has_key?(syntax_name)
+      @@syntax[syntax_name]
+    else
+      @@syntax[syntax_name] = uncached_syntax(syntax_name)
+    end
+  end
+
+private
+
+  def self.uncached_syntax(name)
+    path = (
+      find_syntax_by_path(name) ||
+      find_syntax_by_scope_name(name) ||
+      find_syntax_by_fuzzy_name(name)
+    )
+    SyntaxNode.load(path) if path
+  end
+
+  def self.find_syntax_by_scope_name(name)
+    path = File.join(syntax_path, "#{name}.syntax")
+    path if File.exist?(path)
+  end
+
+  def self.find_syntax_by_fuzzy_name(name)
+    path = Dir.glob(File.join(syntax_path, "*.#{name}.*")).sort_by(&:size).first
+    path if path and File.exist?(path)
+  end
+
+  def self.find_syntax_by_path(path)
+    path if File.file?(path)
+  end
 end
+

data/lib/textpow/debug_processor.rb

@@ -1,36 +1,36 @@
-module Textpow   
-   class DebugProcessor
-      def initialize
-         @line_number = 0
-         @printable_line = ""
-      end
-      
-      def pprint line, string, position = 0
-         line.replace line.ljust( position + string.size, " ")
-         line[position,string.size] = string
-         line
-      end
-      
-      def open_tag name, position
-         STDERR.puts pprint( "", "{#{name}", position + @line_marks.size)
-      end
-      
-      def close_tag name, position
-         STDERR.puts pprint( "", "}#{name}", position + @line_marks.size)
-      end
-      
-      def new_line line
-         @line_number += 1
-         @line_marks = "[#{@line_number.to_s.rjust( 4, '0' )}] "
-         STDERR.puts "#{@line_marks}#{line}"
-      end
-      
-      def start_parsing name
-         STDERR.puts "{#{name}"
-      end
-      
-      def end_parsing name
-         STDERR.puts "}#{name}"
-      end
-   end
+module Textpow
+  class DebugProcessor
+    def initialize
+      @line_number = 0
+      @printable_line = ""
+    end
+
+    def pprint line, string, position = 0
+      line.replace line.ljust( position + string.size, " ")
+      line[position,string.size] = string
+      line
+    end
+
+    def open_tag name, position
+      STDERR.puts pprint( "", "{#{name}", position + @line_marks.size)
+    end
+
+    def close_tag name, position
+      STDERR.puts pprint( "", "}#{name}", position + @line_marks.size)
+    end
+
+    def new_line line
+      @line_number += 1
+      @line_marks = "[#{@line_number.to_s.rjust( 4, '0' )}] "
+      STDERR.puts "#{@line_marks}#{line}"
+    end
+
+    def start_parsing name
+      STDERR.puts "{#{name}"
+    end
+
+    def end_parsing name
+      STDERR.puts "}#{name}"
+    end
+  end
 end

data/lib/textpow/recording_processor.rb

@@ -0,0 +1,13 @@
+module Textpow
+  class RecordingProcessor
+    attr_accessor :stack
+
+    def initialize
+      @stack = []
+    end
+
+    def method_missing(name, *args)
+      @stack << [name, *args]
+    end
+  end
+end

data/lib/textpow/score_manager.rb

@@ -1,65 +1,65 @@
 module Textpow
-   class ScoreManager
-      POINT_DEPTH    = 4
-      NESTING_DEPTH  = 40
-      START_VALUE    = 2 ** ( POINT_DEPTH * NESTING_DEPTH )
-      BASE           = 2 ** POINT_DEPTH
-      
-      def initialize
-         @scores = {}
-      end
-      
-      def score search_scope, reference_scope
-         max = 0
-         search_scope.split( ',' ).each do |scope|
-            arrays = scope.split(/\B-/)
-            if arrays.size == 1
-               max = [max, score_term( arrays[0], reference_scope )].max
-            elsif arrays.size > 1
-               excluded = false
-               arrays[1..-1].each do |a| 
-                  if score_term( arrays[1], reference_scope ) > 0
-                     excluded = true
-                     break
-                  end
-               end
-               max = [max, score_term( arrays[0], reference_scope )].max unless excluded
-            else
-               raise ParsingError, "Error in scope string: '#{search_scope}' #{arrays.size} is not a valid number of operands" if arrays.size < 1
+  class ScoreManager
+    POINT_DEPTH    = 4
+    NESTING_DEPTH  = 40
+    START_VALUE    = 2 ** ( POINT_DEPTH * NESTING_DEPTH )
+    BASE           = 2 ** POINT_DEPTH
+
+    def initialize
+      @scores = {}
+    end
+
+    def score search_scope, reference_scope
+      max = 0
+      search_scope.split( ',' ).each do |scope|
+        arrays = scope.split(/\B-/)
+        if arrays.size == 1
+          max = [max, score_term( arrays[0], reference_scope )].max
+        elsif arrays.size > 1
+          excluded = false
+          arrays[1..-1].each do |a|
+            if score_term( arrays[1], reference_scope ) > 0
+              excluded = true
+              break
             end
-         end
-         max
-      end   
-      
-      private
-      
-      def score_term search_scope, reference_scope
-         unless @scores[reference_scope] && @scores[reference_scope][search_scope]
-            @scores[reference_scope] ||= {}
-            @scores[reference_scope][search_scope] = score_array( search_scope.split(' '), reference_scope.split( ' ' ) )
-         end
-         @scores[reference_scope][search_scope]
+          end
+          max = [max, score_term( arrays[0], reference_scope )].max unless excluded
+        else
+          raise ParsingError, "Error in scope string: '#{search_scope}' #{arrays.size} is not a valid number of operands" if arrays.size < 1
+        end
       end
-      
-      def score_array search_array, reference_array
-         pending = search_array
-         current = reference_array.last
-         reg = Regexp.new( "^#{Regexp.escape( pending.last )}" )
-         multiplier = START_VALUE
-         result = 0
-         while pending.size > 0 && current
-            if reg =~ current
-               point_score = (2**POINT_DEPTH) - current.count( '.' ) + Regexp.last_match[0].count( '.' )
-               result += point_score * multiplier
-               pending.pop
-               reg = Regexp.new( "^#{Regexp.escape( pending.last )}" ) if pending.size > 0
-            end
-            multiplier = multiplier / BASE
-            reference_array.pop
-            current = reference_array.last
-         end
-         result = 0 if pending.size > 0
-         result
+      max
+    end
+
+    private
+
+    def score_term search_scope, reference_scope
+      unless @scores[reference_scope] && @scores[reference_scope][search_scope]
+        @scores[reference_scope] ||= {}
+        @scores[reference_scope][search_scope] = score_array( search_scope.split(' '), reference_scope.split( ' ' ) )
+      end
+      @scores[reference_scope][search_scope]
+    end
+
+    def score_array search_array, reference_array
+      pending = search_array
+      current = reference_array.last
+      reg = Regexp.new( "^#{Regexp.escape( pending.last )}" )
+      multiplier = START_VALUE
+      result = 0
+      while pending.size > 0 && current
+        if reg =~ current
+          point_score = (2**POINT_DEPTH) - current.count( '.' ) + Regexp.last_match[0].count( '.' )
+          result += point_score * multiplier
+          pending.pop
+          reg = Regexp.new( "^#{Regexp.escape( pending.last )}" ) if pending.size > 0
+        end
+        multiplier = multiplier / BASE
+        reference_array.pop
+        current = reference_array.last
       end
-   end
+      result = 0 if pending.size > 0
+      result
+    end
+  end
 end

data/lib/textpow/syntax.rb

@@ -1,286 +1,327 @@
-require 'plist'
+module Textpow
+  RUBY_19 = (RUBY_VERSION > "1.9.0")
+end
+require 'oniguruma' unless Textpow::RUBY_19
 
 module Textpow
+  # at load time we do not know all patterns / all syntaxes
+  # so we store a proxy, that tries to find the correct syntax at runtime
+  class SyntaxProxy
+    def initialize(included_name, syntax)
+      @syntax = syntax
+      @included_name = included_name
+    end
 
-   class SyntaxProxy
-      def initialize hash, syntax
-         @syntax = syntax
-         @proxy = hash["include"]
+    def method_missing method, *args, &block
+      if @proxy ||= proxy
+        @proxy.send(method, *args, &block)
+      else
+        STDERR.puts "Failed proxying #{@proxy_name}.#{method}(#{args.join(', ')})" if $DEBUG
       end
-      
-      def method_missing method, *args, &block
-         if @proxy 
-            @proxy_value = proxy unless @proxy_value
-            if @proxy_value
-               @proxy_value.send(method, *args, &block)
-            else
-               STDERR.puts "Failed proxying #{@proxy}.#{method}(#{args.join(', ')})"
-            end
-         end
+    end
+
+  private
+
+    def proxy
+      case @included_name
+      when /^#/
+        @syntax.repository and @syntax.repository[@included_name[1..-1]]
+      when "$self", "$base"
+        @syntax
+      else
+        @syntax.syntaxes[@included_name] || Textpow.syntax(@included_name)
       end
-      
-      def proxy
-         case @proxy 
-         when /^#/
-            if @syntax.repository && @syntax.repository[@proxy[1..-1]]
-               #puts "Repository"
-               #@table["syntax"].repository.each_key{|k| puts k}
-               return @syntax.repository[@proxy[1..-1]]
-            end
-         when "$self"
-            return @syntax
-         when "$base"
-            return @syntax
-         else
-            return @syntax.syntaxes[@proxy]
-         end
+    end
+  end
+
+  class SyntaxNode
+    @@syntaxes = {}
+
+    attr_accessor :syntax
+    attr_accessor :firstLineMatch
+    attr_accessor :foldingStartMarker
+    attr_accessor :foldingStopMarker
+    attr_accessor :match
+    attr_accessor :begin
+    attr_accessor :content
+    attr_accessor :fileTypes
+    attr_accessor :name
+    attr_accessor :contentName
+    attr_accessor :end
+    attr_accessor :scopeName
+    attr_accessor :keyEquivalent
+    attr_accessor :captures
+    attr_accessor :beginCaptures
+    attr_accessor :endCaptures
+    attr_accessor :repository
+    attr_accessor :patterns
+
+    def self.load(file, options={})
+      table = convert_file_to_table(file)
+      SyntaxNode.new(table, options)
+    end
+
+    def initialize(table, options={})
+      @syntax = options[:syntax] || self
+      @name_space = options[:name_space]
+
+      register_in_syntaxes(table["scopeName"])
+      parse_and_store_syntax_info(table)
+    end
+
+    def syntaxes
+      @@syntaxes[@name_space]
+    end
+
+    def parse(string, processor = RecordingProcessor.new)
+      processor.start_parsing scopeName
+      stack = [[self, nil]]
+      string.each_line do |line|
+        parse_line stack, line, processor
       end
-   end
-
-   class SyntaxNode
-      OPTIONS = {:options => Oniguruma::OPTION_CAPTURE_GROUP}
-      
-      @@syntaxes = {}
-      
-      attr_accessor :syntax
-      attr_accessor :firstLineMatch
-      attr_accessor :foldingStartMarker
-      attr_accessor :foldingStopMarker
-      attr_accessor :match
-      attr_accessor :begin
-      attr_accessor :content
-      attr_accessor :fileTypes
-      attr_accessor :name
-      attr_accessor :contentName
-      attr_accessor :end
-      attr_accessor :scopeName
-      attr_accessor :keyEquivalent
-      attr_accessor :captures
-      attr_accessor :beginCaptures
-      attr_accessor :endCaptures
-      attr_accessor :repository
-      attr_accessor :patterns
-      
-      def self.load filename, name_space = :default
-         table = nil
-         case filename
-         when /(\.tmSyntax|\.plist)$/
-            table = Plist::parse_xml( filename )
-         else
-            File.open( filename ) do |f|
-               table = YAML.load( f )
-            end
-         end
-         if table
-            SyntaxNode.new( table, nil, name_space )
-         else
-            nil
-         end
+      processor.end_parsing scopeName
+
+      processor
+    end
+
+  protected
+
+    def parse_and_store_syntax_info(table)
+      table.each do |key, value|
+        case key
+        when "firstLineMatch", "foldingStartMarker", "foldingStopMarker", "match", "begin"
+          instance_variable_set("@#{key}", parse_regex(value))
+        when "content", "fileTypes", "name", "contentName", "end", "scopeName", "keyEquivalent"
+          instance_variable_set("@#{key}", value)
+        when "captures", "beginCaptures", "endCaptures"
+          instance_variable_set("@#{key}", value.sort)
+        when "repository"
+          parse_repository value
+        when "patterns"
+          create_children value
+        when "comment"
+        else
+          STDERR.puts "Ignoring: #{key} => #{value.gsub("\n", "\n>>")}" if $DEBUG
+        end
       end
-      
-      def initialize hash, syntax = nil, name_space = :default
-         @name_space = name_space
-         @@syntaxes[@name_space] ||= {}
-         @@syntaxes[@name_space][hash["scopeName"]] = self if hash["scopeName"]
-         @syntax = syntax || self
-         hash.each do |key, value|
-            case key
-            when "firstLineMatch", "foldingStartMarker", "foldingStopMarker", "match", "begin"
-               begin
-                  instance_variable_set( "@#{key}", Oniguruma::ORegexp.new( value, OPTIONS ) )
-               rescue ArgumentError => e
-                  raise ParsingError, "Parsing error in #{value}: #{e.to_s}"
-               end
-            when "content", "fileTypes", "name", "contentName", "end", "scopeName", "keyEquivalent"
-               instance_variable_set( "@#{key}", value )
-            when "captures", "beginCaptures", "endCaptures"
-               instance_variable_set( "@#{key}", value.sort )
-            when "repository"
-               parse_repository value
-            when "patterns"
-               create_children value
-            else
-               STDERR.puts "Ignoring: #{key} => #{value.gsub("\n", "\n>>")}" if $DEBUG
-            end
-         end
+    end
+
+    def parse_regex(value)
+      if Textpow::RUBY_19
+        parse_regex_with_invalid_chars(value)
+      else
+        Oniguruma::ORegexp.new(value, :options => Oniguruma::OPTION_CAPTURE_GROUP)
       end
-      
-      
-      def syntaxes
-         @@syntaxes[@name_space]
+    rescue RegexpError, ArgumentError => e
+      raise ParsingError, "Parsing error in #{value}: #{e.to_s}"
+    end
+
+    def parse_regex_with_invalid_chars(value)
+      Regexp.new(value.force_encoding('UTF-8'))
+    rescue RegexpError => e
+      if e.message =~ /UTF-8/ or e.message =~ /invalid multibyte escape/
+        puts "Ignored utf8 regex error #{$!}"
+        /INVALID_UTF8/
+      else
+        raise e
       end
-      
-      def parse( string, processor = nil )
-         processor.start_parsing self.scopeName if processor
-         stack = [[self, nil]]
-         string.each_line do |line|
-            parse_line stack, line, processor
-         end
-         processor.end_parsing self.scopeName if processor
-         processor
+    end
+
+    # register in global syntax list -> can be found by include
+    def register_in_syntaxes(scope)
+      @@syntaxes[@name_space] ||= {}
+      @@syntaxes[@name_space][scope] = self if scope
+    end
+
+    def self.convert_file_to_table(file)
+      raise "File not found: #{file}" unless File.exist?(file)
+      case file
+      when /(\.tmSyntax|\.plist)$/
+        require 'plist'
+        Plist::parse_xml(file)
+      else
+        YAML.load_file(file)
       end
-      
-      protected
-    
-      def parse_repository repository
-         @repository = {}
-         repository.each do |key, value|
-            if value["include"]
-               @repository[key] = SyntaxProxy.new( value, self.syntax )
-            else
-               @repository[key] = SyntaxNode.new( value, self.syntax, @name_space )
-            end
-         end
+    end
+
+    def parse_repository(repository)
+      @repository = {}
+      repository.each do |key, value|
+        if value["include"]
+          @repository[key] = SyntaxProxy.new(value["include"], syntax)
+        else
+          @repository[key] = SyntaxNode.new(value, :syntax => syntax, :name_space => @name_space)
+        end
       end
-      
-      def create_children patterns
-         @patterns = []
-         patterns.each do |p|
-            if p["include"]
-               @patterns << SyntaxProxy.new( p, self.syntax )
-            else
-               @patterns << SyntaxNode.new( p, self.syntax, @name_space )
-            end
-         end
+    end
+
+    def create_children(patterns)
+      @patterns = patterns.map do |pattern|
+        if pattern["include"]
+          SyntaxProxy.new(pattern["include"], syntax)
+        else
+          SyntaxNode.new(pattern, :syntax => syntax, :name_space => @name_space)
+        end
+      end
+    end
+
+    def parse_captures name, pattern, match, processor
+      captures = pattern.match_captures( name, match )
+      captures.reject! { |group, range, name| ! range.first || range.first == range.last }
+      starts = []
+      ends = []
+      captures.each do |group, range, name|
+        starts << [range.first, group, name]
+        ends   << [range.last, -group, name]
       end
 
-      def parse_captures name, pattern, match, processor
-         captures = pattern.match_captures( name, match )
-         captures.reject! { |group, range, name| ! range.first || range.first == range.last }
-         starts = []
-         ends = []
-         captures.each do |group, range, name|
-            starts << [range.first, group, name]
-            ends   << [range.last, -group, name]
-         end
-         
 #          STDERR.puts '-' * 100
 #          starts.sort!.reverse!.each{|c| STDERR.puts c.join(', ')}
 #          STDERR.puts 
 #          ends.sort!.reverse!.each{|c| STDERR.puts c.join(', ')}
-         starts.sort!.reverse!
-         ends.sort!.reverse!
-         
-         while ! starts.empty? || ! ends.empty?
-            if starts.empty?
-               pos, key, name = ends.pop
-               processor.close_tag name, pos
-            elsif ends.empty?
-               pos, key, name = starts.pop
-               processor.open_tag name, pos
-            elsif ends.last[1].abs < starts.last[1]
-               pos, key, name = ends.pop
-               processor.close_tag name, pos
-            else
-               pos, key, name = starts.pop
-               processor.open_tag name, pos
-            end
-         end
+      starts.sort!.reverse!
+      ends.sort!.reverse!
+
+      while ! starts.empty? || ! ends.empty?
+        if starts.empty?
+          pos, key, name = ends.pop
+          processor.close_tag name, pos
+        elsif ends.empty?
+          pos, key, name = starts.pop
+          processor.open_tag name, pos
+        elsif ends.last[1].abs < starts.last[1]
+          pos, key, name = ends.pop
+          processor.close_tag name, pos
+        else
+          pos, key, name = starts.pop
+          processor.open_tag name, pos
+        end
       end
-      
-      def match_captures name, match
-         matches = []
-         captures = instance_variable_get "@#{name}"
-         if captures
-            captures.each do |key, value|
-               if key =~ /^\d*$/
-                  matches << [key.to_i, match.offset( key.to_i ), value["name"]] if key.to_i < match.size
-               else
-                  matches << [match.to_index( key.to_sym ), match.offset( key.to_sym), value["name"]] if match.to_index( key.to_sym )
-               end
-            end
-         end
-         matches
+    end
+
+    def match_captures name, match
+      matches = []
+      captures = instance_variable_get "@#{name}"
+      if captures
+        captures.each do |key, value|
+          if key =~ /^\d*$/
+            matches << [key.to_i, match.offset( key.to_i ), value["name"]] if key.to_i < match.size
+          else
+            matches << [match.to_index( key.to_sym ), match.offset( key.to_sym), value["name"]] if match.to_index( key.to_sym )
+          end
+        end
+      end
+      matches
+    end
+
+    def match_first string, position
+      if self.match
+        if match = self.match.match( string, position )
+          return [self, match]
+        end
+      elsif self.begin
+        if match = self.begin.match( string, position )
+          return [self, match]
+        end
+      elsif self.end
+      else
+        return match_first_son( string, position )
       end
-      
-      def match_first string, position
-         if self.match
-            if match = self.match.match( string, position )
-               return [self, match] 
-            end
-         elsif self.begin
-            if match = self.begin.match( string, position )
-               return [self, match] 
-            end
-         elsif self.end
-         else
-            return match_first_son( string, position )
-         end
-         nil
+      nil
+    end
+
+    def match_end string, match, position
+      regstring = self.end.clone
+      regstring.gsub!( /\\([1-9])/ ) { |s| match[$1.to_i] }
+
+      # in spox-textpow this is \\g in 1.9 !?
+      regstring.gsub!( /\\k<(.*?)>/ ) { |s| match[$1.to_sym] }
+      if Textpow::RUBY_19
+        Regexp.new( regstring ).match( string, position )
+      else
+        Oniguruma::ORegexp.new( regstring ).match( string, position )
       end
-      
-      def match_end string, match, position
-         regstring = self.end.clone
-         regstring.gsub!( /\\([1-9])/ ) { |s| match[$1.to_i] }
-         regstring.gsub!( /\\k<(.*?)>/ ) { |s| match[$1.to_sym] }
-         Oniguruma::ORegexp.new( regstring ).match( string, position )
+    end
+
+    # find earliest matching pattern
+    def match_first_son(string, position)
+      return if not patterns
+
+      earliest_match = nil
+      earliest_match_offset = nil
+      patterns.each do |pattern|
+        next unless match = pattern.match_first(string, position)
+
+        match_offset = match_offset(match[1]).first
+        return match if match_offset == 0 # no need to look any further
+
+        if not earliest_match or earliest_match_offset > match_offset
+          earliest_match = match
+          earliest_match_offset = match_offset
+        end
       end
-      
-      def match_first_son string, position
-         match = nil
-         if self.patterns
-            self.patterns.each do |p|
-               tmatch = p.match_first string, position
-               if tmatch
-                  if ! match || match[1].offset.first > tmatch[1].offset.first
-                     match = tmatch
-                  end
-                  #break if tmatch[1].offset.first == position
-               end
-            end
-         end
-         match
+
+      earliest_match
+    end
+
+    def parse_line(stack, line, processor)
+      processor.new_line line
+      top, match = stack.last
+      position = 0
+      #@ln ||= 0
+      #@ln += 1
+      #STDERR.puts @ln
+      loop do
+        if top.patterns
+          pattern, pattern_match = top.match_first_son(line, position)
+        end
+
+        if top.end
+          end_match = top.match_end( line, match, position )
+        end
+
+        if end_match and (not pattern_match or match_offset(pattern_match).first >= match_offset(end_match).first)
+          pattern_match = end_match
+          start_pos = match_offset(pattern_match).first
+          end_pos = match_offset(pattern_match).last
+
+          processor.close_tag top.contentName, start_pos if top.contentName
+          parse_captures "captures", top, pattern_match, processor
+          parse_captures "endCaptures", top, pattern_match, processor
+          processor.close_tag top.name, end_pos if top.name
+          stack.pop
+          top, match = stack.last
+        else
+          break unless pattern
+
+          start_pos = match_offset(pattern_match).first
+          end_pos = match_offset(pattern_match).last
+
+          if pattern.begin
+            processor.open_tag pattern.name, start_pos if pattern.name
+            parse_captures "captures", pattern, pattern_match, processor
+            parse_captures "beginCaptures", pattern, pattern_match, processor
+            processor.open_tag pattern.contentName, end_pos if pattern.contentName
+            top = pattern
+            match = pattern_match
+            stack << [top, match]
+          elsif pattern.match
+            processor.open_tag pattern.name, start_pos if pattern.name
+            parse_captures "captures", pattern, pattern_match, processor
+            processor.close_tag pattern.name, end_pos if pattern.name
+          end
+        end
+
+        position = end_pos
       end
-      
-      def parse_line stack, line, processor
-         processor.new_line line if processor
-         top, match = stack.last
-         position = 0
-         #@ln ||= 0
-         #@ln += 1
-         #STDERR.puts @ln
-         while true
-            if top.patterns
-               pattern, pattern_match = top.match_first_son line, position
-            else
-               pattern, pattern_match = nil
-            end
-            
-            end_match = nil
-            if top.end
-               end_match = top.match_end( line, match, position )
-            end
-            
-            if end_match && ( ! pattern_match || pattern_match.offset.first >= end_match.offset.first )
-               pattern_match = end_match
-               start_pos = pattern_match.offset.first
-               end_pos = pattern_match.offset.last
-               processor.close_tag top.contentName, start_pos if top.contentName && processor
-               parse_captures "captures", top, pattern_match, processor if processor
-               parse_captures "endCaptures", top, pattern_match, processor if processor
-               processor.close_tag top.name, end_pos if top.name && processor
-               stack.pop
-               top, match = stack.last
-            else
-               break unless pattern
-               start_pos = pattern_match.offset.first
-               end_pos = pattern_match.offset.last
-               if pattern.begin
-                  processor.open_tag pattern.name, start_pos if pattern.name && processor
-                  parse_captures "captures", pattern, pattern_match, processor if processor
-                  parse_captures "beginCaptures", pattern, pattern_match, processor if processor
-                  processor.open_tag pattern.contentName, end_pos if pattern.contentName && processor
-                  top = pattern
-                  match = pattern_match
-                  stack << [top, match]
-               elsif pattern.match
-                  processor.open_tag pattern.name, start_pos if pattern.name && processor
-                  parse_captures "captures", pattern, pattern_match, processor if processor
-                  processor.close_tag pattern.name, end_pos if pattern.name && processor
-               end
-            end
-            position = end_pos
-         end
+    end
+
+    def match_offset(match)
+      if Textpow::RUBY_19
+        match.offset(0)
+      else
+        match.offset
       end
-   end
+    end
+  end
 end