textpow 0.9.0

data/History.txt

@@ -0,0 +1,5 @@
+== 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/score_manager.rb
+lib/textpow/debug_processor.rb
+mm/manual.mm
+test/test_textpow.rb
+History.txt
+Rakefile
+Manifest.txt
+README.txt

data/README.txt

@@ -0,0 +1,48 @@
+== Textpow
+
+A library for parsing TextMate[http://macromates.com/] bundles.
+
+== SYNTAX
+
+
+== REQUIREMENTS:
+
+* Oniguruma for Ruby[http://oniguruma.rubyforge.org] v1.1.0 or higher.
+
+== INSTALL:
+
+sudo gem install -r mama
+
+== BUGS/PROBLEMS/INCOMPATIBILITIES:
+
+
+== TODO:
+
+
+== CREDITS:
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 FIX
+
+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,52 @@
+require 'rubygems'
+require 'fileutils'
+
+rubyforge_name = "textpow"
+
+begin
+   require 'hoe'
+   
+   class Hoe 
+      # Dirty hack to eliminate Hoe from gem dependencies
+      def extra_deps 
+         @extra_deps.delete_if{ |x| x.first == 'hoe' }
+      end
+   end
+   
+   version = /^== *(\d+\.\d+\.\d+)/.match( File.read( 'History.txt' ) )[1]
+   
+   h = Hoe.new('textpow', version) do |p|
+      p.rubyforge_name = rubyforge_name
+      p.author = ['Dizan Vasquez']
+      p.email  = ['dichodaemon@gmail.com']
+      p.email = 'dichodaemon@gmail.com'
+      p.summary = 'An engine for parsing Textmate bundles'
+      p.description = p.paragraphs_of('README.txt', 1 ).join('\n\n')
+      p.url = 'http://textpow.rubyforge.org'
+      p.rdoc_pattern = /^(lib|bin|ext)|txt$/
+      p.changes = p.paragraphs_of('History.txt', 0).join("\n\n")
+      p.clean_globs = ["manual/*"]
+      p.extra_deps << ['oniguruma', '>= 1.1.0']
+      p.extra_deps << ['plist', '>= 3.0.0']
+   end
+   
+   desc 'Create MaMa documentation'
+   task :mama => :clean do
+      system "mm -c -t refresh -o manual mm/manual.mm"
+   end
+   
+   desc 'Publish MaMa documentation to RubyForge'
+      task :mama_publish => [:clean, :mama] do
+      config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
+      host = "#{config["username"]}@rubyforge.org"
+      remote_dir = "/var/www/gforge-projects/#{h.rubyforge_name}"
+      local_dir = 'manual'
+      system "rsync -av --delete #{local_dir}/ #{host}:#{remote_dir}"
+   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/debug_processor.rb

@@ -0,0 +1,34 @@
+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
+      end
+      
+      def end_parsing
+      end
+   end
+end

data/lib/textpow/score_manager.rb

@@ -0,0 +1,60 @@
+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-\B/)
+            if arrays.size == 1
+               max = [max, score_term( arrays[0], reference_scope )].max
+            elsif arrays.size == 2
+               unless score_term( arrays[1], reference_scope ) > 0
+                  max = [max, score_term( arrays[0], reference_scope )].max
+               end
+            else
+               raise ParsingError, "Error in scope string: '#{search_scope}'" if arrays.size < 1 || arrays.size > 2
+            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,286 @@
+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}.#{m}(#{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
+                  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 syntaxes
+         @@syntaxes[@name_space]
+      end
+      
+      def parse( string, processor = nil )
+         processor.start_parsing if processor
+         stack = [[self, nil]]
+         string.each_line do |line|
+            parse_line stack, line, processor
+         end
+         processor.end_parsing 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] }
+         Oniguruma::ORegexp.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.first > tmatch[1].offset.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.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
+   end
+end

data/lib/textpow.rb

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

data/mm/manual.mm

@@ -0,0 +1,263 @@
+~ Textpow ~
+~~ A Library for Processing TextMate Bundles ~~
+
+#Introduction# | index
+
+= What is Textpow? =
+Textpow is a library to parse and process 
+[Textmate http://macromates.com] bundles. Although created created for their
+use in a word processor, these bundles have many other uses. For example, we
+have used them to create a syntax highligting 
+[utility http://ultraviolet.rubyforge.org] and also the markup rendering 
+[engine http://mama.rubyforge.org] used to render this
+documentation.
+
+= Requirements =
+
+* [Oniguruma http://www.geocities.jp/kosako3/oniguruma/] regular expression library (/>= 4.x.x/)
+* [Oniguruma for Ruby http://www.geocities.jp/kosako3/oniguruma/] ruby bindings for oniguruma (/>= 1.1.x/)
+
+= Installation =
+
+If you have [rubygems http://docs.rubygems.org/] installation is straightforward by typing 
+(as root if needed):
+
+--------hl shell-unix-generic,,false------
+gem install -r textpow --include-dependencies
+------------------------------------------
+
+If you prefer to get the sources, the last stable version may be
+downloaded [here http://rubyforge.org/frs/?group_id=3513].
+
+= Status =
+
+The current version of Textpow (0.9.0) is able to parse syntax (/tmLanguage/, /tmSyntax/)
+and theme (/tmTheme/) files.
+
+#Use#
+
+= Syntax files and text parsing =
+
+The idea of parsing is to process some /input text/ using the rules defined in 
+a /syntax [file > syntax_files]/ (which are discussed in detail in Textmate 
+[documentation http://macromates.com/textmate/manual/language_grammars#language_grammars]).
+The text is parsed line by line, and, events are sent to a /[processor > processors]/
+according to how the text matches the syntax file.
+
+-------dot parsing_overview, Overview of the parsing process.----------
+digraph G {
+   node [fontname=Helvetica, fontsize=10];
+   edge [fontname=Helvetica, style=dashed, fontsize=10, decorate=true, fontcolor="#0066aa"];
+   center=true; 
+   {
+      rank=same;
+      node [shape=invhouse, style="filled", color="#333399", fillcolor="#6666cc", fontcolor="white"];
+      syntax_file[label="Syntax file"];
+      text[label="Input text"];
+   }
+   {     
+      node [shape=box, style="filled", color="#993333", fillcolor="#cc6666", fontcolor="white"]
+      syntax_object[label="SyntaxNode"];
+      processor[label="Processor", shape=box];
+   }
+   parse [label="", style=invis, fontsize=0,height=0,width=0,shape=none];
+   rank=same{syntax_object; parse};
+   
+   syntax_file -> syntax_object [label="  SyntaxNode#load"];
+   syntax_object -> parse [arrowhead=none];
+   text -> parse [arrowhead=none];
+   parse -> processor [label="  SyntaxNode#parse"];
+
+}
+-----------------------------------------------------------------------
+
+= For the impatient =
+
+Parsing a file using Textpow is as easy as 1-2-3!
+
+1.  Load the Syntax File:
+
+    ---hl ruby,,false---
+    require 'textpow'
+    syntax = Textpow::SyntaxNode.load("ruby.tmSyntax")
+    -------------
+
+2. Initialize a processor:
+    ---hl ruby,,false---
+    processor = Textpow::DebugProcessor.new
+    -------------
+
+3. Parse some text:
+    ---hl ruby,,false---
+    syntax.parse( text,  processor )
+    -------------
+
+= The gory details =
+
+
+== Syntax files == | syntax_files
+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]:
+
+
+---------hl property_list---------
+ {  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:
+
+---------hl xml---------
+<?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:
+
+-------------hl yaml---------------
+--- 
+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 == | 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 > syntax_files].
+
+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:
+
+------------hl ruby--------------
+class Processor
+   def open_tag name, position
+   end
+      
+   def close_tag name, position
+   end
+      
+   def new_line line
+   end
+      
+   def start_parsing
+   end
+   
+   def end_parsing
+   end
+end
+---------------------------------
+
+* `open_tag`. Is called when a new tag is opened, it receives the tag's name and
+    its position (relative to the current line).
+* `close_tag`. The same that `open_tag`, but it is called when a tag is closed.
+* `new_line`. Is called every time that a new line is processed, it receives the
+    line's contents.
+* `start_parsing`. Is called once at the beginning of the parsing process.
+* `end_parsing`. Is called once after all the input text has been parsed.
+
+Textpow ensures that the methods are called in parsing order, thus, 
+for example, if there are two subsequent calls to `open_tag`, the first
+having `name="text.string", position=10` and the second having 
+`name="markup.string", position=10`, it should be understood that the
+`"markup.string"` tag is /inside/ the `"text.string"` tag.
+
+# Links #
+
+
+= Rubyforge project page =
+
+* [Textpow http://rubyforge.org/projects/textpow].
+
+= Documentation =
+
+* [Textmate documentation http://macromates.com/textmate/manual/].
+* [YAML cookbook http://yaml4r.sourceforge.net/cookbook/].
+
+= Requirements =
+
+* [Oniguruma http://www.geocities.jp/kosako3/oniguruma/].
+* [Oniguruma for ruby http://rubyforge.org/projects/oniguruma/].
+
+= Projects using Textpow =
+
+* [Ultraviolet Syntax Highlighting Engine http://ultraviolet.rubyforge.org/].
+* [Macaronic markup engine http://mama.rubyforge.org/].

data/test/test_textpow.rb

@@ -0,0 +1,24 @@
+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,76 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: textpow
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+date: 2007-05-12 00:00:00 +02:00
+summary: An engine for parsing Textmate bundles
+require_paths: 
+- lib
+email: dichodaemon@gmail.com
+homepage: http://textpow.rubyforge.org
+rubyforge_project: textpow
+description: A library for parsing TextMate[http://macromates.com/] bundles.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Dizan Vasquez
+files: 
+- bin/plist2yaml
+- bin/plist2syntax
+- lib/textpow.rb
+- lib/textpow
+- lib/textpow/syntax.rb
+- lib/textpow/score_manager.rb
+- lib/textpow/debug_processor.rb
+- mm/manual.mm
+- test/test_textpow.rb
+- History.txt
+- Rakefile
+- Manifest.txt
+- README.txt
+test_files: 
+- test/test_textpow.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- plist2yaml
+- plist2syntax
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: oniguruma
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: plist
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+    version: