kitabu 0.4.7 → 1.0.0.rc1

data/lib/kitabu/vendor/ruby1.8/plist/plist/parser.rb

@@ -1,224 +0,0 @@
-#--###########################################################
-# Copyright 2006, Ben Bleything <ben@bleything.net> and      #
-# Patrick May <patrick@hexane.org>                           #
-#                                                            #
-# Distributed under the MIT license.                         #
-##############################################################
-#++
-# Plist parses Mac OS X xml property list files into ruby data structures.
-#
-# === Load a plist file
-# This is the main point of the library:
-#
-#   r = Plist::parse_xml( filename_or_xml )
-module Plist
-# Note that I don't use these two elements much:
-#
-#  + Date elements are returned as DateTime objects.
-#  + Data elements are implemented as Tempfiles
-#
-# Plist::parse_xml will blow up if it encounters a data element.
-# If you encounter such an error, or if you have a Date element which
-# can't be parsed into a Time object, please send your plist file to
-# plist@hexane.org so that I can implement the proper support.
-  def Plist::parse_xml( filename_or_xml )
-    listener = Listener.new
-    #parser = REXML::Parsers::StreamParser.new(File.new(filename), listener)
-    parser = StreamParser.new(filename_or_xml, listener)
-    parser.parse
-    listener.result
-  end
-
-  class Listener
-    #include REXML::StreamListener
-
-    attr_accessor :result, :open
-
-    def initialize
-      @result = nil
-      @open   = Array.new
-    end
-
-
-    def tag_start(name, attributes)
-      @open.push PTag::mappings[name].new
-    end
-
-    def text( contents )
-      @open.last.text = contents if @open.last
-    end
-
-    def tag_end(name)
-      last = @open.pop
-      if @open.empty?
-        @result = last.to_ruby
-      else
-        @open.last.children.push last
-      end
-    end
-  end
-
-  class StreamParser
-    def initialize( plist_data_or_file, listener )
-      if plist_data_or_file.respond_to? :read
-        @xml = plist_data_or_file.read
-      elsif File.exists? plist_data_or_file
-        @xml = File.read( plist_data_or_file )
-      else
-        @xml = plist_data_or_file
-      end
-
-      @listener = listener
-    end
-
-    TEXT       = /([^<]+)/
-    XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>*/um
-    DOCTYPE_PATTERN = /\s*<!DOCTYPE\s+(.*?)(\[|>)/um
-    COMMENT_START = /\A<!--/u
-    COMMENT_END = /.*?-->/um
-
-
-    def parse
-      plist_tags = PTag::mappings.keys.join('|')
-      start_tag  = /<(#{plist_tags})([^>]*)>/i
-      end_tag    = /<\/(#{plist_tags})[^>]*>/i
-
-      require 'strscan'
-
-      @scanner = StringScanner.new( @xml )
-      until @scanner.eos?
-        if @scanner.scan(COMMENT_START)
-          @scanner.scan(COMMENT_END)
-        elsif @scanner.scan(XMLDECL_PATTERN)
-        elsif @scanner.scan(DOCTYPE_PATTERN)
-        elsif @scanner.scan(start_tag)
-          @listener.tag_start(@scanner[1], nil)
-          if (@scanner[2] =~ /\/$/)
-            @listener.tag_end(@scanner[1])
-          end
-        elsif @scanner.scan(TEXT)
-          @listener.text(@scanner[1])
-        elsif @scanner.scan(end_tag)
-          @listener.tag_end(@scanner[1])
-        else
-          raise "Unimplemented element"
-        end
-      end
-    end
-  end
-
-  class PTag
-    @@mappings = { }
-    def PTag::mappings
-      @@mappings
-    end
-
-    def PTag::inherited( sub_class )
-      key = sub_class.to_s.downcase
-      key.gsub!(/^plist::/, '' )
-      key.gsub!(/^p/, '')  unless key == "plist"
-
-      @@mappings[key] = sub_class
-    end
-
-    attr_accessor :text, :children
-    def initialize
-      @children = Array.new
-    end
-
-    def to_ruby
-      raise "Unimplemented: " + self.class.to_s + "#to_ruby on #{self.inspect}"
-    end
-  end
-
-  class PList < PTag
-    def to_ruby
-      children.first.to_ruby if children.first
-    end
-  end
-
-  class PDict < PTag
-    def to_ruby
-      dict = Hash.new
-      key = nil
-
-      children.each do |c|
-        if key.nil?
-          key = c.to_ruby
-        else
-          dict[key] = c.to_ruby
-          key = nil
-        end
-      end
-
-      dict
-    end
-  end
-
-  class PKey < PTag
-    def to_ruby
-      CGI::unescapeHTML(text || '')
-    end
-  end
-
-  class PString < PTag
-    def to_ruby
-      CGI::unescapeHTML(text || '')
-    end
-  end
-
-  class PArray < PTag
-    def to_ruby
-      children.collect do |c|
-        c.to_ruby
-      end
-    end
-  end
-
-  class PInteger < PTag
-    def to_ruby
-      text.to_i
-    end
-  end
-
-  class PTrue < PTag
-    def to_ruby
-      true
-    end
-  end
-
-  class PFalse < PTag
-    def to_ruby
-      false
-    end
-  end
-
-  class PReal < PTag
-    def to_ruby
-      text.to_f
-    end
-  end
-
-  require 'date'
-  class PDate < PTag
-    def to_ruby
-      DateTime.parse(text)
-    end
-  end
-
-  require 'base64'
-  class PData < PTag
-    def to_ruby
-      data = Base64.decode64(text.gsub(/\s+/, ''))
-
-      begin
-        return Marshal.load(data)
-      rescue Exception => e
-        io = StringIO.new
-        io.write data
-        io.rewind
-        return io
-      end
-    end
-  end
-end

data/lib/kitabu/vendor/ruby1.8/textpow/textpow.rb

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

data/lib/kitabu/vendor/ruby1.8/textpow/textpow/debug_processor.rb

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

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

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