spox-textpow 0.10.2

data/History.txt

@@ -0,0 +1,14 @@
+== 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/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/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,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!( /\\g<(.*?)>/ ) { |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.rb

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

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: spox-textpow
+version: !ruby/object:Gem::Version 
+  version: 0.10.2
+platform: ruby
+authors: 
+- spox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: plist
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Textpow is a library to parse and process Textmate bundles.
+email: spox@modspox.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- bin/plist2yaml
+- bin/plist2syntax
+- README.txt
+- History.txt
+- lib/textpow.rb
+- lib/textpow/score_manager.rb
+- lib/textpow/syntax.rb
+- lib/textpow/debug_processor.rb
+- Manifest.txt
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --title
+- TextPow
+- --main
+- README.txt
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: textpow
+test_files: []
+