textpow19 0.11.0

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,210 @@
+= Textpow
+
+* http://github.com/cehoffman/textpow
+* http://github.com/spox/textpow
+* http://textpow.rubyforge.org
+
+== DESCRIPTION:
+
+A library for parsing {TextMate}[http://macromates.com/] bundles.
+
+== SYNOPSIS:
+
+
+Parsing a file using Textpow is as easy as 1-2-3!
+
+1. Load the Syntax File:
+
+  require 'textpow'
+  syntax = Textpow::SyntaxNode.load("ruby.tmSyntax")
+
+2. Initialize a processor:
+
+  processor = Textpow::DebugProcessor.new
+
+3. 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.
+
+== REQUIREMENTS:
+
+* Ruby 1.9
+* plist > 3.0
+
+== INSTALL:
+
+  gem install textpow19
+
+== CREDITS:
+
+* {Chris Hoffman}[http://github.com/cehoffman]
+* {Spox}[http://github.com/spox]
+* Dizan Vasque
+
+== LICENSE:
+
+(The MIT License)
+
+* 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,30 @@
+require 'rubygems'
+
+begin
+   require 'hoe'
+   require File.expand_path("../lib/textpow/version", __FILE__)
+
+   Hoe.plugin :gemcutter
+
+   Hoe.spec 'textpow19' do
+      developer("Chris Hoffman", "cehoffman@gmail.com")
+      developer("Spox", "spox@modspox.com")
+      developer("Dizan Vasquez", "dichodaemon@gmail.com")
+      
+      self.version = Textpow::Version
+      self.extra_deps << ['plist', '>= 3.0.1']
+      self.readme_file  = "README.rdoc"
+      self.history_file = "History.rdoc"
+      spec_extras[:required_ruby_version] = ">= 1.9.0"
+   end
+   
+   task :gemspec do
+     sh %{rake debug_gem | grep -v "(in " > `basename \\\`pwd\\\``.gemspec}
+   end
+
+rescue LoadError => e
+   desc 'Run the test suite.'
+   task :test do
+      system "ruby -Ibin:lib:test test_#{rubyforge_name}.rb"
+   end
+end

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.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/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,287 @@
+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
+      #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
+      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
+                    value.force_encoding("ASCII-8BIT")
+                  instance_variable_set( "@#{key}", Regexp.new( value ) )
+               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] }
+         regstring.gsub!( /\\k<(.*?)>/ ) { |s| match[$1.to_sym] }
+         Regexp.new( regstring ).match( string, position )
+      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(0).first > tmatch[1].offset(0).first
+                     match = tmatch
+                  end
+                  #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
+            
+            if end_match && ( ! pattern_match || pattern_match.offset(0).first >= end_match.offset(0).first )
+               pattern_match = end_match
+               start_pos = pattern_match.offset(0).first
+               end_pos = pattern_match.offset(0).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(0).first
+               end_pos = pattern_match.offset(0).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
+   end
+end

data/lib/textpow/version.rb

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

data/test/test_textpow.rb

@@ -0,0 +1,25 @@
+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,128 @@
+--- !ruby/object:Gem::Specification 
+name: textpow19
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 11
+  - 0
+  version: 0.11.0
+platform: ruby
+authors: 
+- Chris Hoffman
+- Spox
+- Dizan Vasquez
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-21 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: plist
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 1
+        version: 3.0.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id003
+description: A library for parsing {TextMate}[http://macromates.com/] bundles.
+email: 
+- cehoffman@gmail.com
+- spox@modspox.com
+- dichodaemon@gmail.com
+executables: 
+- plist2yaml
+- plist2syntax
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+files: 
+- bin/plist2yaml
+- bin/plist2syntax
+- lib/textpow.rb
+- 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
+has_rdoc: true
+homepage: http://github.com/cehoffman/textpow
+licenses: []
+
+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 
+      segments: 
+      - 1
+      - 9
+      - 0
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: textpow19
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A library for parsing {TextMate}[http://macromates.com/] bundles.
+test_files: 
+- test/test_textpow.rb