kitabu 0.4.5

data/lib/kitabu/vendor/ruby1.8/textpow/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/kitabu/vendor/ruby1.8/textpow/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/kitabu/vendor/ruby1.8/textpow/textpow/syntax.rb

@@ -0,0 +1,284 @@
+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
+                  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 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] }
+         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/kitabu/vendor/ruby1.8/uv/render/xhtml/active4d.render

@@ -0,0 +1,140 @@
+--- 
+name: Active4D
+line: 
+  begin: ""
+  end: ""
+tags: 
+- begin: <span class="EmbeddedSource">
+  end: </span>
+  selector: text.html source.active4d
+- begin: <span class="PlainXmlText">
+  end: </span>
+  selector: text.xml
+- begin: <span class="LineComment">
+  end: </span>
+  selector: comment.line
+- begin: <span class="BlockComment">
+  end: </span>
+  selector: comment.block
+- begin: <span class="String">
+  end: </span>
+  selector: string
+- begin: <span class="InterpolatedEntity">
+  end: </span>
+  selector: string.interpolated variable
+- begin: <span class="Number">
+  end: </span>
+  selector: constant.numeric
+- begin: <span class="UserDefinedConstant">
+  end: </span>
+  selector: constant.character, constant.other
+- begin: <span class="DateTimeLiteral">
+  end: </span>
+  selector: constant.other.date, constant.other.time
+- begin: <span class="BuiltInConstant">
+  end: </span>
+  selector: constant.language
+- begin: <span class="LocalVariable">
+  end: </span>
+  selector: variable.other.local
+- begin: <span class="Variable">
+  end: </span>
+  selector: variable
+- begin: <span class="TableField">
+  end: </span>
+  selector: variable.other.table-field
+- begin: <span class="Keyword">
+  end: </span>
+  selector: keyword
+- begin: <span class="Operator">
+  end: </span>
+  selector: keyword.operator
+- begin: <span class="Storage">
+  end: </span>
+  selector: storage
+- begin: <span class="TypeName">
+  end: </span>
+  selector: entity.name.type
+- begin: <span class="InheritedClass">
+  end: </span>
+  selector: entity.other.inherited-class
+- begin: <span class="FunctionName">
+  end: </span>
+  selector: entity.name.function
+- begin: <span class="FunctionArgument">
+  end: </span>
+  selector: variable.parameter
+- begin: <span class="TagContainer">
+  end: </span>
+  selector: meta.tag
+- begin: <span class="TagName">
+  end: </span>
+  selector: entity.name.tag
+- begin: <span class="TagAttribute">
+  end: </span>
+  selector: entity.other.attribute-name
+- begin: <span class="CommandMethod">
+  end: </span>
+  selector: support.function
+- begin: <span class="NamedConstant">
+  end: </span>
+  selector: support.constant
+- begin: <span class="LibraryClassType">
+  end: </span>
+  selector: support.type, support.class
+- begin: <span class="LibraryVariable">
+  end: </span>
+  selector: support.variable
+- begin: <span class="Invalid">
+  end: </span>
+  selector: invalid
+- begin: <span class="DiffHeader">
+  end: </span>
+  selector: meta.diff
+- begin: <span class="DiffLineRange">
+  end: </span>
+  selector: meta.diff.range
+- begin: <span class="DiffDeletedLine">
+  end: </span>
+  selector: markup.deleted.diff
+- begin: <span class="DiffInsertedLine">
+  end: </span>
+  selector: markup.inserted.diff
+- begin: <span class="DiffUnchangedLine">
+  end: </span>
+  selector: source.diff
+listing: 
+  begin: <pre class="active4d">
+  end: </pre>
+document: 
+  begin: |
+    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+    <html xmlns="http://www.w3.org/1999/xhtml" lang="en">
+    
+    <head>
+      <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
+      <meta http-equiv="cache-control" content="no-cache" />
+      <meta http-equiv="expires" content="3600" />
+      <meta name="revisit-after" content="2 days" />
+      <meta name="robots" content="index,follow" />
+      <meta name="publisher" content="Dichodaemon" />
+      <meta name="copyright" content="Dichodaemon" />
+    
+      <meta name="author" content="Dichodaemon" />
+      <meta name="distribution" content="global" />
+      <meta name="description" content="Ocatarinetabellachithchix" />
+      <meta name="keywords" content="arzaversperia flexilimosos toves" />
+      <link rel="stylesheet" type="text/css" media="screen,projection,print" href="css/active4d.css" />
+      <title>active4d</title>
+    
+    </head>
+    
+    <body>
+
+  end: "  <p>\n    <a href=\"http://validator.w3.org/check?uri=referer\">\n      <img style=\"border:0\"\n           src=\"http://www.w3.org/Icons/valid-xhtml10\"\n           alt=\"Valid XHTML 1.0 Strict\" height=\"31\" width=\"88\" />\n    </a>\n    <a href=\"http://jigsaw.w3.org/css-validator/check?uri=referer\">\n      <img style=\"border:0;width:88px;height:31px\"\n           src=\"http://jigsaw.w3.org/css-validator/images/vcss\" \n           alt=\"Valid CSS!\" />\n    </a>\n  </p>\n\
+    </body>\n\
+    </html>\n"
+filter: CGI.escapeHTML( @escaped )
+line-numbers: 
+  begin: <span class="line-numbers">
+  end: </span>