rubysl-rexml 1.0.0

data/lib/rexml/parsers/lightparser.rb

@@ -0,0 +1,60 @@
+require 'rexml/parsers/streamparser'
+require 'rexml/parsers/baseparser'
+require 'rexml/light/node'
+
+module REXML
+	module Parsers
+		class LightParser
+			def initialize stream
+				@stream = stream
+				@parser = REXML::Parsers::BaseParser.new( stream )
+			end
+
+      def add_listener( listener )
+        @parser.add_listener( listener )
+      end
+
+      def rewind
+        @stream.rewind
+        @parser.stream = @stream
+      end
+
+			def parse
+				root = context = [ :document ]
+				while true
+					event = @parser.pull
+					case event[0]
+					when :end_document
+						break
+					when :end_doctype
+						context = context[1]
+					when :start_element, :start_doctype
+						new_node = event
+						context << new_node
+						new_node[1,0] = [context]
+						context = new_node
+					when :end_element, :end_doctype
+						context = context[1]
+					else
+						new_node = event
+						context << new_node
+						new_node[1,0] = [context]
+					end
+				end
+				root
+			end
+		end
+
+		# An element is an array.  The array contains:
+		#  0			The parent element
+		#  1			The tag name
+		#  2			A hash of attributes
+		#  3..-1	The child elements
+		# An element is an array of size > 3
+		# Text is a String
+		# PIs are [ :processing_instruction, target, data ]
+		# Comments are [ :comment, data ]
+		# DocTypes are DocType structs
+		# The root is an array with XMLDecls, Text, DocType, Array, Text
+	end
+end

data/lib/rexml/parsers/pullparser.rb

@@ -0,0 +1,196 @@
+require 'forwardable'
+
+require 'rexml/parseexception'
+require 'rexml/parsers/baseparser'
+require 'rexml/xmltokens'
+
+module REXML
+  module Parsers
+    # = Using the Pull Parser
+    # <em>This API is experimental, and subject to change.</em>
+    #  parser = PullParser.new( "<a>text<b att='val'/>txet</a>" )
+    #  while parser.has_next?
+    #    res = parser.next
+    #    puts res[1]['att'] if res.start_tag? and res[0] == 'b'
+    #  end
+    # See the PullEvent class for information on the content of the results.
+    # The data is identical to the arguments passed for the various events to
+    # the StreamListener API.
+    #
+    # Notice that:
+    #  parser = PullParser.new( "<a>BAD DOCUMENT" )
+    #  while parser.has_next?
+    #    res = parser.next
+    #    raise res[1] if res.error?
+    #  end
+    #
+    # Nat Price gave me some good ideas for the API.
+    class PullParser
+      include XMLTokens
+      extend Forwardable
+
+      def_delegators( :@parser, :has_next? )
+      def_delegators( :@parser, :entity )
+      def_delegators( :@parser, :empty? )
+      def_delegators( :@parser, :source )
+
+      def initialize stream
+        @entities = {}
+        @listeners = nil
+        @parser = BaseParser.new( stream )
+        @my_stack = []
+      end
+
+      def add_listener( listener )
+        @listeners = [] unless @listeners
+        @listeners << listener
+      end
+
+      def each
+        while has_next?
+          yield self.pull
+        end
+      end
+
+      def peek depth=0
+        if @my_stack.length <= depth
+          (depth - @my_stack.length + 1).times {
+            e = PullEvent.new(@parser.pull)
+            @my_stack.push(e)
+          }
+        end
+        @my_stack[depth]
+      end
+
+      def pull
+        return @my_stack.shift if @my_stack.length > 0
+
+        event = @parser.pull
+        case event[0]
+        when :entitydecl
+          @entities[ event[1] ] = 
+            event[2] unless event[2] =~ /PUBLIC|SYSTEM/
+        when :text
+          unnormalized = @parser.unnormalize( event[1], @entities )
+          event << unnormalized
+        end
+        PullEvent.new( event )
+      end
+
+      def unshift token
+        @my_stack.unshift token
+      end
+    end
+
+    # A parsing event.  The contents of the event are accessed as an +Array?,
+    # and the type is given either by the ...? methods, or by accessing the
+    # +type+ accessor.  The contents of this object vary from event to event,
+    # but are identical to the arguments passed to +StreamListener+s for each
+    # event.
+    class PullEvent
+      # The type of this event.  Will be one of :tag_start, :tag_end, :text,
+      # :processing_instruction, :comment, :doctype, :attlistdecl, :entitydecl,
+      # :notationdecl, :entity, :cdata, :xmldecl, or :error.
+      def initialize(arg)
+        @contents = arg
+      end
+
+      def []( start, endd=nil)
+        if start.kind_of? Range
+          @contents.slice( start.begin+1 .. start.end )
+        elsif start.kind_of? Numeric
+          if endd.nil?
+            @contents.slice( start+1 )
+          else
+            @contents.slice( start+1, endd )
+          end
+        else
+          raise "Illegal argument #{start.inspect} (#{start.class})"
+        end
+      end
+
+      def event_type
+        @contents[0]
+      end
+
+      # Content: [ String tag_name, Hash attributes ]
+      def start_element?
+        @contents[0] == :start_element
+      end
+
+      # Content: [ String tag_name ]
+      def end_element?
+        @contents[0] == :end_element
+      end
+
+      # Content: [ String raw_text, String unnormalized_text ]
+      def text?
+        @contents[0] == :text
+      end
+
+      # Content: [ String text ]
+      def instruction?
+        @contents[0] == :processing_instruction
+      end
+
+      # Content: [ String text ]
+      def comment?
+        @contents[0] == :comment
+      end
+
+      # Content: [ String name, String pub_sys, String long_name, String uri ]
+      def doctype?
+        @contents[0] == :start_doctype
+      end
+
+      # Content: [ String text ]
+      def attlistdecl?
+        @contents[0] == :attlistdecl
+      end
+
+      # Content: [ String text ]
+      def elementdecl?
+        @contents[0] == :elementdecl
+      end
+
+      # Due to the wonders of DTDs, an entity declaration can be just about
+      # anything.  There's no way to normalize it; you'll have to interpret the
+      # content yourself.  However, the following is true:
+      #
+      # * If the entity declaration is an internal entity:
+      #   [ String name, String value ]
+      # Content: [ String text ]
+      def entitydecl?
+        @contents[0] == :entitydecl
+      end
+
+      # Content: [ String text ]
+      def notationdecl?
+        @contents[0] == :notationdecl
+      end
+
+      # Content: [ String text ]
+      def entity?
+        @contents[0] == :entity
+      end
+
+      # Content: [ String text ]
+      def cdata?
+        @contents[0] == :cdata
+      end
+
+      # Content: [ String version, String encoding, String standalone ]
+      def xmldecl?
+        @contents[0] == :xmldecl
+      end
+
+      def error?
+        @contents[0] == :error
+      end
+
+      def inspect
+        @contents[0].to_s + ": " + @contents[1..-1].inspect
+      end
+    end
+  end
+end

data/lib/rexml/parsers/sax2parser.rb

@@ -0,0 +1,238 @@
+require 'rexml/parsers/baseparser'
+require 'rexml/parseexception'
+require 'rexml/namespace'
+require 'rexml/text'
+
+module REXML
+	module Parsers
+    # SAX2Parser
+		class SAX2Parser
+			def initialize source
+				@parser = BaseParser.new(source)
+				@listeners = []
+				@procs = []
+				@namespace_stack = []
+				@has_listeners = false
+				@tag_stack = []
+        @entities = {}
+			end
+
+      def source
+        @parser.source
+      end
+			
+      def add_listener( listener )
+        @parser.add_listener( listener )
+      end
+
+			# Listen arguments:
+			#
+			# Symbol, Array, Block
+			# 	Listen to Symbol events on Array elements
+			# Symbol, Block
+			#   Listen to Symbol events
+			# Array, Listener
+			# 	Listen to all events on Array elements
+			# Array, Block
+			# 	Listen to :start_element events on Array elements
+			# Listener
+			# 	Listen to All events
+			#
+			# Symbol can be one of: :start_element, :end_element,
+			# :start_prefix_mapping, :end_prefix_mapping, :characters,
+			# :processing_instruction, :doctype, :attlistdecl, :elementdecl,
+			# :entitydecl, :notationdecl, :cdata, :xmldecl, :comment
+      #
+      # There is an additional symbol that can be listened for: :progress.
+      # This will be called for every event generated, passing in the current 
+      # stream position.
+			#
+			# Array contains regular expressions or strings which will be matched
+			# against fully qualified element names.
+			#
+			# Listener must implement the methods in SAX2Listener
+			#
+			# Block will be passed the same arguments as a SAX2Listener method would
+			# be, where the method name is the same as the matched Symbol.
+			# See the SAX2Listener for more information.
+			def listen( *args, &blok )
+				if args[0].kind_of? Symbol
+					if args.size == 2
+						args[1].each { |match| @procs << [args[0], match, blok] }
+					else
+						add( [args[0], nil, blok] )
+					end
+				elsif args[0].kind_of? Array
+					if args.size == 2
+						args[0].each { |match| add( [nil, match, args[1]] ) }
+					else
+						args[0].each { |match| add( [ :start_element, match, blok ] ) }
+					end
+				else
+					add([nil, nil, args[0]])
+				end
+			end
+			
+			def deafen( listener=nil, &blok )
+				if listener
+					@listeners.delete_if {|item| item[-1] == listener }
+					@has_listeners = false if @listeners.size == 0
+				else
+					@procs.delete_if {|item| item[-1] == blok }
+				end
+			end
+			
+			def parse
+				@procs.each { |sym,match,block| block.call if sym == :start_document }
+				@listeners.each { |sym,match,block| 
+					block.start_document if sym == :start_document or sym.nil?
+				}
+				root = context = []
+				while true
+					event = @parser.pull
+					case event[0]
+					when :end_document
+						handle( :end_document )
+						break
+          when :start_doctype
+            handle( :doctype, *event[1..-1])
+					when :end_doctype
+						context = context[1]
+					when :start_element
+						@tag_stack.push(event[1])
+						# find the observers for namespaces
+						procs = get_procs( :start_prefix_mapping, event[1] )
+						listeners = get_listeners( :start_prefix_mapping, event[1] )
+						if procs or listeners
+							# break out the namespace declarations
+							# The attributes live in event[2]
+							event[2].each {|n, v| event[2][n] = @parser.normalize(v)}
+							nsdecl = event[2].find_all { |n, value| n =~ /^xmlns(:|$)/ }
+							nsdecl.collect! { |n, value| [ n[6..-1], value ] }
+							@namespace_stack.push({})
+							nsdecl.each do |n,v|
+								@namespace_stack[-1][n] = v
+								# notify observers of namespaces
+								procs.each { |ob| ob.call( n, v ) } if procs
+								listeners.each { |ob| ob.start_prefix_mapping(n, v) } if listeners
+							end
+						end
+						event[1] =~ Namespace::NAMESPLIT
+						prefix = $1
+						local = $2
+						uri = get_namespace(prefix)
+						# find the observers for start_element
+						procs = get_procs( :start_element, event[1] )
+						listeners = get_listeners( :start_element, event[1] )
+						# notify observers
+						procs.each { |ob| ob.call( uri, local, event[1], event[2] ) } if procs
+						listeners.each { |ob| 
+							ob.start_element( uri, local, event[1], event[2] ) 
+						} if listeners
+					when :end_element
+						@tag_stack.pop
+						event[1] =~ Namespace::NAMESPLIT
+						prefix = $1
+						local = $2
+						uri = get_namespace(prefix)
+						# find the observers for start_element
+						procs = get_procs( :end_element, event[1] )
+						listeners = get_listeners( :end_element, event[1] )
+						# notify observers
+						procs.each { |ob| ob.call( uri, local, event[1] ) } if procs
+						listeners.each { |ob| 
+							ob.end_element( uri, local, event[1] ) 
+						} if listeners
+
+						namespace_mapping = @namespace_stack.pop
+						# find the observers for namespaces
+						procs = get_procs( :end_prefix_mapping, event[1] )
+						listeners = get_listeners( :end_prefix_mapping, event[1] )
+						if procs or listeners
+							namespace_mapping.each do |prefix, uri|
+								# notify observers of namespaces
+								procs.each { |ob| ob.call( prefix ) } if procs
+								listeners.each { |ob| ob.end_prefix_mapping(prefix) } if listeners
+							end
+						end
+					when :text
+            #normalized = @parser.normalize( event[1] )
+            #handle( :characters, normalized )
+            copy = event[1].clone
+            @entities.each { |key, value| copy = copy.gsub("&#{key};", value) }
+            copy.gsub!( Text::NUMERICENTITY ) {|m|
+              m=$1
+              m = "0#{m}" if m[0] == ?x
+              [Integer(m)].pack('U*')
+            }
+            handle( :characters, copy )
+          when :entitydecl
+            @entities[ event[1] ] = event[2] if event.size == 3
+						handle( *event )
+					when :processing_instruction, :comment, :attlistdecl, 
+						:elementdecl, :cdata, :notationdecl, :xmldecl
+						handle( *event )
+					end
+          handle( :progress, @parser.position )
+				end
+			end
+
+			private
+			def handle( symbol, *arguments )
+				tag = @tag_stack[-1]
+				procs = get_procs( symbol, tag )
+				listeners = get_listeners( symbol, tag )
+				# notify observers
+				procs.each { |ob| ob.call( *arguments ) } if procs
+				listeners.each { |l| 
+					l.send( symbol.to_s, *arguments ) 
+				} if listeners
+			end
+
+			# The following methods are duplicates, but it is faster than using
+			# a helper
+			def get_procs( symbol, name )
+				return nil if @procs.size == 0
+				@procs.find_all do |sym, match, block|
+          #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
+					(
+						(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)
+							)
+						)
+					)
+				end.collect{|x| x[-1]}
+			end
+			def get_listeners( symbol, name )
+				return nil if @listeners.size == 0
+				@listeners.find_all do |sym, match, block|
+					(
+						(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)
+							)
+						)
+					)
+				end.collect{|x| x[-1]}
+			end
+
+			def add( pair )
+				if pair[-1].respond_to? :call
+					@procs << pair unless @procs.include? pair
+				else
+					@listeners << pair unless @listeners.include? pair
+					@has_listeners = true
+				end
+			end
+
+			def get_namespace( prefix ) 
+        uris = (@namespace_stack.find_all { |ns| not ns[prefix].nil? }) ||
+					(@namespace_stack.find { |ns| not ns[nil].nil? })
+				uris[-1][prefix] unless uris.nil? or 0 == uris.size
+			end
+		end
+	end
+end