textpow1x 0.11.0

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+pkg/
+*.gemspec

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+gemspec
+
+gem 'oniguruma', :platform => :ruby_18
+
+group :dev do
+  gem 'rake', '0.8.7'
+  gem 'jeweler'
+  gem 'hoe'
+end

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    textpow1x (0.11.0)
+      plist (>= 3.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    hoe (2.12.3)
+      rake (~> 0.8)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    oniguruma (1.1.0)
+    plist (3.1.0)
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  hoe
+  jeweler
+  oniguruma
+  rake (= 0.8.7)
+  textpow1x!

data/History.rdoc

@@ -0,0 +1,17 @@
+== 0.11.0 / 2009-06-12
+* Updated to 1.9 compatibility. Does not use onigumura gem anymore
+
+== 0.10.1 / 2008-02-20
+* FIX: Endless loop in method_missing when @proxy_variable is not present.
+
+== 0.10.0 / 2007-06-15
+* CHANGE: Now the scopeName for the entire syntax is passed to start_parsing and end_parsing. This means that programs using older version should modify their processors accordingly.
+
+== 0.9.1 / 2007-06-14
+* FIX: Score manager now handles multiple subtractions in scope definitions.
+
+== 0.9.0 / 2007-03-19
+
+* 1 major enhancement
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,13 @@
+bin/plist2yaml
+bin/plist2syntax
+lib/textpow.rb
+lib/textpow
+lib/textpow/syntax.rb
+lib/textpow/version.rb
+lib/textpow/score_manager.rb
+lib/textpow/debug_processor.rb
+test/test_textpow.rb
+History.rdoc
+Rakefile
+Manifest.txt
+README.rdoc

data/README.rdoc

@@ -0,0 +1,212 @@
+A library for parsing {TextMate}[http://macromates.com/] bundles.
+
+For Ruby 1.8 and 1.9.
+
+
+== INSTALL:
+
+  gem install textpow1x
+
+=== Ruby 1.8
+Install oniguruma
+
+  # Ubuntu
+  sudo apt-get -y install libonig-dev
+  gem install oniguruma
+  
+  # OsX (no idea if this works...)
+  port install oniguruma4
+
+
+== USAGE:
+
+1. Get a .tmSyntax File
+
+2. Load the Syntax File:
+
+  require 'textpow'
+  syntax = Textpow::SyntaxNode.load("ruby.tmSyntax")
+
+3. Initialize a processor:
+
+  processor = Textpow::DebugProcessor.new
+
+4. Parse some text:
+
+  syntax.parse( text,  processor )
+
+
+=== INDEPTH:
+
+At the heart of syntax parsing are ..., well, syntax files. Lets see for instance
+the example syntax that appears in textmate's
+{documentation}[http://macromates.com/textmate/manual/language_grammars#language_grammars]:
+
+
+  {  scopeName = 'source.untitled';
+     fileTypes = ( txt );
+     foldingStartMarker = '\{\s*$';
+     foldingStopMarker = '^\s*\}';
+     patterns = (
+        {  name = 'keyword.control.untitled';
+           match = '\b(if|while|for|return)\b';
+        },
+        {  name = 'string.quoted.double.untitled';
+           begin = '"';
+           end = '"';
+           patterns = (
+              {  name = 'constant.character.escape.untitled';
+                 match = '\\.';
+              }
+           );
+        },
+     );
+  }
+
+But Textpow is not able to parse text pfiles. However, in practice this is not a problem,
+since it is possible to convert both text and binary pfiles to an XML format. Indeed, all
+the syntaxes in the Textmate syntax {repository}[http://macromates.com/svn/Bundles/trunk/Bundles/]
+are in XML format:
+
+  <?xml version="1.0" encoding="UTF-8"?>
+  <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+  <plist version="1.0">
+  <dict>
+     <key>scopeName</key>
+     <string>source.untitled</string>
+     <key>fileTypes</key>
+     <array>
+        <string>txt</string>
+     </array>
+     <key>foldingStartMarker</key>
+     <string>\{\s*$</string>
+     <key>foldingStopMarker</key>
+     <string>^\s*\}</string>
+     <key>patterns</key>
+     <array>
+        <dict>
+           <key>name</key>
+           <string>keyword.control.untitled</string>
+           <key>match</key>
+           <string>\b(if|while|for|return)\b</string>
+        </dict>
+        <dict>
+           <key>name</key>
+           <string>string.quoted.double.untitled</string>
+           <key>begin</key>
+           <string>"</string>
+           <key>end</key>
+           <string>"</string>
+           <key>patterns</key>
+           <array>
+              <dict>
+                 <key>name</key>
+                 <string>constant.character.escape.untitled</string>
+                 <key>match</key>
+                 <string>\\.</string>
+              </dict>
+           </array>
+        </dict>
+     </array>
+  </dict>
+
+Of course, most people find XML both ugly and cumbersome. Fortunately, it is
+also possible to store syntax files in YAML format, which is much easier to
+read:
+
+  ---
+  fileTypes:
+  - txt
+  scopeName: source.untitled
+  foldingStartMarker: \{\s*$
+  foldingStopMarker: ^\s*\}
+  patterns:
+  - name: keyword.control.untitled
+    match: \b(if|while|for|return)\b
+  - name: string.quoted.double.untitled
+    begin: '"'
+    end: '"'
+    patterns:
+    - name: constant.character.escape.untitled
+      match: \\.
+
+==== Processors
+
+Until now we have talked about the parsing process without explaining what
+it is exactly. Basically, parsing consists in reading text from a string or
+file and applying tags to parts of the text according to what has been
+specified in the syntax file.
+
+In textpow, the process takes place line by line, from the beginning to the
+end and from left to right for every line. As the text is parsed, events are
+sent to a processor object when a tag is open or closed and so on.
+A processor is any object which implements one or more of the following
+methods:
+
+  class Processor
+     def open_tag name, position
+     end
+
+     def close_tag name, position
+     end
+
+     def new_line line
+     end
+
+     def start_parsing name
+     end
+
+     def end_parsing name
+     end
+  end
+
+* <tt>open_tag</tt>. Is called when a new tag is opened, it receives the tag's name and
+  its position (relative to the current line).
+* <tt>close_tag</tt>. The same that <tt>open_tag</tt>, but it is called when a tag is closed.
+* <tt>new_line</tt>. Is called every time that a new line is processed, it receives the
+  line's contents.
+* <tt>start_parsing</tt>. Is called once at the beginning of the parsing process. It
+  receives the scope name for the syntax being used.
+* <tt>end_parsing</tt>. Is called once after all the input text has been parsed. It
+  receives the scope name for the syntax being used.
+
+Textpow ensures that the methods are called in parsing order, thus,
+for example, if there are two subsequent calls to <tt>open_tag</tt>, the first
+having <tt>name="text.string", position=10</tt> and the second having
+<tt>name="markup.string", position=10</tt>, it should be understood that the
+<tt>"markup.string"</tt> tag is inside the <tt>"text.string"</tt> tag.
+
+== CREDITS:
+
+* {Michael Grosser}[http://github.com/grosser]
+* {Chris Hoffman}[http://github.com/cehoffman]
+* {Spox}[http://github.com/spox]
+* Dizan Vasque
+
+== LICENSE:
+
+(The MIT License)
+
+* Copyright (c) 2011 Michael Grosser
+* Copyright (c) 2010 Chris Hoffman
+* Copyright (c) 2009 Spox
+* Copyright (c) 2007-2008 Dizan Vasquez
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new do |test|
+  test.libs << 'lib'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/bin/plist2syntax

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'plist'
+require 'yaml'
+
+result = Plist::parse_xml( ARGV[0] )
+standard_name = File.basename( ARGV[0] ).downcase.gsub(/\s+/, '_').gsub(/\.(plist|tm[Ll]anguage)/, '').gsub(/\(|\)|:/, '').gsub(/_+/, '_')
+puts standard_name
+
+File.open( "#{standard_name}.yaml", "w" ) {|f| YAML.dump( result, f ) }

data/bin/plist2yaml

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'plist'
+require 'yaml'
+
+result = Plist::parse_xml( ARGV[0] )
+YAML.dump( result, STDOUT )

data/lib/textpow/debug_processor.rb

@@ -0,0 +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
+end

data/lib/textpow/score_manager.rb

@@ -0,0 +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
+        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
+
+    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
+    end
+  end
+end

data/lib/textpow/syntax.rb

@@ -0,0 +1,323 @@
+module Textpow
+  RUBY_19 = (RUBY_VERSION > "1.9.0")
+end
+require 'oniguruma' unless Textpow::RUBY_19
+
+require 'plist'
+
+module Textpow
+  class SyntaxProxy
+    def initialize hash, syntax
+      @syntax = syntax
+      @proxy = hash["include"]
+    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
+
+    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
+    unless Textpow::RUBY_19
+      OPTIONS = {:options => Oniguruma::OPTION_CAPTURE_GROUP}
+    end
+
+    @@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
+    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
+            if Textpow::RUBY_19
+              value.force_encoding("ASCII-8BIT")
+              instance_variable_set( "@#{key}", Regexp.new( value ) )
+            else
+              instance_variable_set( "@#{key}", Oniguruma::ORegexp.new( value, OPTIONS ) )
+            end
+          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 syntaxes
+      @@syntaxes[@name_space]
+    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
+
+    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 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 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
+    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
+      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
+    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
+            ok = if Textpow::RUBY_19
+              ! match || match[1].offset(0).first > tmatch[1].offset(0).first
+            else
+              ! match || match[1].offset.first > tmatch[1].offset.first
+            end
+            match = tmatch if ok
+            #break if tmatch[1].offset.first == position
+          end
+        end
+      end
+      match
+    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
+
+        ok = if Textpow::RUBY_19
+          end_match && ( ! pattern_match || pattern_match.offset(0).first >= end_match.offset(0).first )
+        else
+          end_match && ( ! pattern_match || pattern_match.offset.first >= end_match.offset.first )
+        end
+
+        if ok
+          pattern_match = end_match
+          if Textpow::RUBY_19
+            start_pos = pattern_match.offset(0).first
+            end_pos = pattern_match.offset(0).last
+          else
+            start_pos = pattern_match.offset.first
+            end_pos = pattern_match.offset.last
+          end
+          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
+          if Textpow::RUBY_19
+            start_pos = pattern_match.offset(0).first
+            end_pos = pattern_match.offset(0).last
+          else
+            start_pos = pattern_match.offset.first
+            end_pos = pattern_match.offset.last
+          end
+
+          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
+  end
+end

data/lib/textpow/version.rb

@@ -0,0 +1,3 @@
+module Textpow
+  Version = "0.11.0"
+end

data/lib/textpow.rb

@@ -0,0 +1,10 @@
+require 'yaml'
+require 'textpow/syntax'
+require 'textpow/debug_processor'
+require 'textpow/score_manager'
+require 'textpow/version'
+
+module Textpow
+  class ParsingError < Exception; end
+end
+

data/test/textpow_test.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'textpow'
+require 'test/unit'
+
+class ScoreManagerTest < Test::Unit::TestCase
+  include Textpow
+
+  def test_score
+    sp = ScoreManager.new
+    reference_scope = 'text.html.basic source.php.embedded.html string.quoted.double.php'
+
+    assert_not_equal( 0, sp.score( 'source.php string', reference_scope ) )
+    assert_not_equal( 0, sp.score( 'text.html source.php', reference_scope ) )
+    assert_equal( 0, sp.score( 'string source.php', reference_scope ) )
+    assert_equal( 0, sp.score( 'source.php text.html', reference_scope ) )
+
+    assert_equal( 0, sp.score( 'text.html source.php - string', reference_scope ) )
+    assert_not_equal( 0, sp.score( 'text.html source.php - ruby', reference_scope ) )
+
+    assert( sp.score( 'string', reference_scope ) > sp.score( 'source.php', reference_scope ) )
+    assert( sp.score( 'string.quoted', reference_scope ) > sp.score( 'source.php', reference_scope ) )
+    assert( sp.score( 'text source string', reference_scope ) > sp.score( 'source string', reference_scope ) )
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: textpow1x
+version: !ruby/object:Gem::Version 
+  hash: 51
+  prerelease: 
+  segments: 
+  - 0
+  - 11
+  - 0
+  version: 0.11.0
+platform: ruby
+authors: 
+- Dizan Vasquez
+- Spox
+- Chris Hoffman
+- Michael Grosser
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-12 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 0
+        - 1
+        version: 3.0.1
+  type: :runtime
+  name: plist
+  version_requirements: *id001
+  prerelease: false
+description: A library for parsing TextMate bundles on ruby 1.x
+email: 
+- michael@grosser.it
+executables: 
+- plist2yaml
+- plist2syntax
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- History.rdoc
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- bin/plist2syntax
+- bin/plist2yaml
+- lib/textpow.rb
+- lib/textpow/debug_processor.rb
+- lib/textpow/score_manager.rb
+- lib/textpow/syntax.rb
+- lib/textpow/version.rb
+- test/textpow_test.rb
+has_rdoc: true
+homepage: http://github.com/grosser/textpow
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A library for parsing TextMate bundles on ruby 1.x
+test_files: []
+