git.zarb.org Git - booh/blob - lib/booh/rexml/parsers/sax2parser.rb

   1 require 'booh/rexml/parsers/baseparser'
   2 require 'booh/rexml/parseexception'
   3 require 'booh/rexml/namespace'
   4 require 'booh/rexml/text'
   5
   6 module REXML
   7         module Parsers
   8     # SAX2Parser
   9                 class SAX2Parser
  10                         def initialize source
  11                                 @parser = BaseParser.new(source)
  12                                 @listeners = []
  13                                 @procs = []
  14                                 @namespace_stack = []
  15                                 @has_listeners = false
  16                                 @tag_stack = []
  17         @entities = {}
  18                         end
  19
  20       def source
  21         @parser.source
  22       end
  23
  24       def add_listener( listener )
  25         @parser.add_listener( listener )
  26       end
  27
  28                         # Listen arguments:
  29                         #
  30                         # Symbol, Array, Block
  31                         #       Listen to Symbol events on Array elements
  32                         # Symbol, Block
  33                         #   Listen to Symbol events
  34                         # Array, Listener
  35                         #       Listen to all events on Array elements
  36                         # Array, Block
  37                         #       Listen to :start_element events on Array elements
  38                         # Listener
  39                         #       Listen to All events
  40                         #
  41                         # Symbol can be one of: :start_element, :end_element,
  42                         # :start_prefix_mapping, :end_prefix_mapping, :characters,
  43                         # :processing_instruction, :doctype, :attlistdecl, :elementdecl,
  44                         # :entitydecl, :notationdecl, :cdata, :xmldecl, :comment
  45       #
  46       # There is an additional symbol that can be listened for: :progress.
  47       # This will be called for every event generated, passing in the current
  48       # stream position.
  49                         #
  50                         # Array contains regular expressions or strings which will be matched
  51                         # against fully qualified element names.
  52                         #
  53                         # Listener must implement the methods in SAX2Listener
  54                         #
  55                         # Block will be passed the same arguments as a SAX2Listener method would
  56                         # be, where the method name is the same as the matched Symbol.
  57                         # See the SAX2Listener for more information.
  58                         def listen( *args, &blok )
  59                                 if args[0].kind_of? Symbol
  60                                         if args.size == 2
  61                                                 args[1].each { |match| @procs << [args[0], match, blok] }
  62                                         else
  63                                                 add( [args[0], nil, blok] )
  64                                         end
  65                                 elsif args[0].kind_of? Array
  66                                         if args.size == 2
  67                                                 args[0].each { |match| add( [nil, match, args[1]] ) }
  68                                         else
  69                                                 args[0].each { |match| add( [ :start_element, match, blok ] ) }
  70                                         end
  71                                 else
  72                                         add([nil, nil, args[0]])
  73                                 end
  74                         end
  75
  76                         def deafen( listener=nil, &blok )
  77                                 if listener
  78                                         @listeners.delete_if {|item| item[-1] == listener }
  79                                         @has_listeners = false if @listeners.size == 0
  80                                 else
  81                                         @procs.delete_if {|item| item[-1] == blok }
  82                                 end
  83                         end
  84
  85                         def parse
  86                                 @procs.each { |sym,match,block| block.call if sym == :start_document }
  87                                 @listeners.each { |sym,match,block|
  88                                         block.start_document if sym == :start_document or sym.nil?
  89                                 }
  90                                 root = context = []
  91                                 while true
  92                                         event = @parser.pull
  93                                         case event[0]
  94                                         when :end_document
  95                                                 handle( :end_document )
  96                                                 break
  97                                         when :end_doctype
  98                                                 context = context[1]
  99                                         when :start_element
 100                                                 @tag_stack.push(event[1])
 101                                                 # find the observers for namespaces
 102                                                 procs = get_procs( :start_prefix_mapping, event[1] )
 103                                                 listeners = get_listeners( :start_prefix_mapping, event[1] )
 104                                                 if procs or listeners
 105                                                         # break out the namespace declarations
 106                                                         # The attributes live in event[2]
 107                                                         event[2].each {|n, v| event[2][n] = @parser.normalize(v)}
 108                                                         nsdecl = event[2].find_all { |n, value| n =~ /^xmlns(:|$)/ }
 109                                                         nsdecl.collect! { |n, value| [ n[6..-1], value ] }
 110                                                         @namespace_stack.push({})
 111                                                         nsdecl.each do |n,v|
 112                                                                 @namespace_stack[-1][n] = v
 113                                                                 # notify observers of namespaces
 114                                                                 procs.each { |ob| ob.call( n, v ) } if procs
 115                                                                 listeners.each { |ob| ob.start_prefix_mapping(n, v) } if listeners
 116                                                         end
 117                                                 end
 118                                                 event[1] =~ Namespace::NAMESPLIT
 119                                                 prefix = $1
 120                                                 local = $2
 121                                                 uri = get_namespace(prefix)
 122                                                 # find the observers for start_element
 123                                                 procs = get_procs( :start_element, event[1] )
 124                                                 listeners = get_listeners( :start_element, event[1] )
 125                                                 # notify observers
 126                                                 procs.each { |ob| ob.call( uri, local, event[1], event[2] ) } if procs
 127                                                 listeners.each { |ob|
 128                                                         ob.start_element( uri, local, event[1], event[2] )
 129                                                 } if listeners
 130                                         when :end_element
 131                                                 @tag_stack.pop
 132                                                 event[1] =~ Namespace::NAMESPLIT
 133                                                 prefix = $1
 134                                                 local = $2
 135                                                 uri = get_namespace(prefix)
 136                                                 # find the observers for start_element
 137                                                 procs = get_procs( :end_element, event[1] )
 138                                                 listeners = get_listeners( :end_element, event[1] )
 139                                                 # notify observers
 140                                                 procs.each { |ob| ob.call( uri, local, event[1] ) } if procs
 141                                                 listeners.each { |ob|
 142                                                         ob.end_element( uri, local, event[1] )
 143                                                 } if listeners
 144
 145                                                 namespace_mapping = @namespace_stack.pop
 146                                                 # find the observers for namespaces
 147                                                 procs = get_procs( :end_prefix_mapping, event[1] )
 148                                                 listeners = get_listeners( :end_prefix_mapping, event[1] )
 149                                                 if procs or listeners
 150                                                         namespace_mapping.each do |prefix, uri|
 151                                                                 # notify observers of namespaces
 152                                                                 procs.each { |ob| ob.call( prefix ) } if procs
 153                                                                 listeners.each { |ob| ob.end_prefix_mapping(prefix) } if listeners
 154                                                         end
 155                                                 end
 156                                         when :text
 157             #normalized = @parser.normalize( event[1] )
 158             #handle( :characters, normalized )
 159             copy = event[1].clone
 160             @entities.each { |key, value| copy = copy.gsub("&#{key};", value) }
 161             copy.gsub!( Text::NUMERICENTITY ) {|m|
 162               m=$1
 163               m = "0#{m}" if m[0] == ?x
 164               [Integer(m)].pack('U*')
 165             }
 166             handle( :characters, copy )
 167           when :entitydecl
 168             @entities[ event[1] ] = event[2] if event.size == 3
 169                                                 handle( *event )
 170                                         when :processing_instruction, :comment, :doctype, :attlistdecl,
 171                                                 :elementdecl, :cdata, :notationdecl, :xmldecl
 172                                                 handle( *event )
 173                                         end
 174           handle( :progress, @parser.position )
 175                                 end
 176                         end
 177
 178                         private
 179                         def handle( symbol, *arguments )
 180                                 tag = @tag_stack[-1]
 181                                 procs = get_procs( symbol, tag )
 182                                 listeners = get_listeners( symbol, tag )
 183                                 # notify observers
 184                                 procs.each { |ob| ob.call( *arguments ) } if procs
 185                                 listeners.each { |l|
 186                                         l.send( symbol.to_s, *arguments )
 187                                 } if listeners
 188                         end
 189
 190                         # The following methods are duplicates, but it is faster than using
 191                         # a helper
 192                         def get_procs( symbol, name )
 193                                 return nil if @procs.size == 0
 194                                 @procs.find_all do |sym, match, block|
 195           #puts sym.inspect+"=="+symbol.inspect+ "\t"+match.inspect+"=="+name.inspect+ "\t"+( (sym.nil? or symbol == sym) and ((name.nil? and match.nil?) or match.nil? or ( (name == match) or (match.kind_of? Regexp and name =~ match)))).to_s
 196                                         (
 197                                                 (sym.nil? or symbol == sym) and
 198                                                 ((name.nil? and match.nil?) or match.nil? or (
 199                                                         (name == match) or
 200                                                         (match.kind_of? Regexp and name =~ match)
 201                                                         )
 202                                                 )
 203                                         )
 204                                 end.collect{|x| x[-1]}
 205                         end
 206                         def get_listeners( symbol, name )
 207                                 return nil if @listeners.size == 0
 208                                 @listeners.find_all do |sym, match, block|
 209                                         (
 210                                                 (sym.nil? or symbol == sym) and
 211                                                 ((name.nil? and match.nil?) or match.nil? or (
 212                                                         (name == match) or
 213                                                         (match.kind_of? Regexp and name =~ match)
 214                                                         )
 215                                                 )
 216                                         )
 217                                 end.collect{|x| x[-1]}
 218                         end
 219
 220                         def add( pair )
 221                                 if pair[-1].respond_to? :call
 222                                         @procs << pair unless @procs.include? pair
 223                                 else
 224                                         @listeners << pair unless @listeners.include? pair
 225                                         @has_listeners = true
 226                                 end
 227                         end
 228
 229                         def get_namespace( prefix )
 230         uris = (@namespace_stack.find_all { |ns| not ns[prefix].nil? }) ||
 231                                         (@namespace_stack.find { |ns| not ns[nil].nil? })
 232                                 uris[-1][prefix] unless uris.nil? or 0 == uris.size
 233                         end
 234                 end
 235         end
 236 end