xamplr-pp 1.0.0

data/lib/xamplr-pp/xppDeluxe.rb

@@ -0,0 +1,49 @@
+
+require "xpp"
+
+class Xpp
+	def startDocument?
+		@type.equal? START_DOCUMENT
+	end
+
+	def endDocument?
+		@type.equal? END_DOCUMENT
+	end
+
+	def startElement?
+		@type.equal? START_ELEMENT
+	end
+
+	def endElement?
+		@type.equal? END_ELEMENT
+	end
+
+	def text?
+		@type.equal? TEXT
+	end
+
+	def cdata?
+		@type.equal? CDATA_SECTION
+	end
+
+	def entityRef?
+		@type.equal? ENTITY_REF
+	end
+
+	def ignorableWhitespace?
+		@type.equal? IGNORABLE_WHITESPACE
+	end
+
+	def processingInstruction?
+		@type.equal? PROCESSING_INSTRUCTION
+	end
+
+	def comment?
+		@type.equal? COMMENT
+	end
+
+	def doctype?
+		@type.equal? DOCTYPE
+	end
+end
+

data/lib/xamplr-pp/xppIter.rb

@@ -0,0 +1,845 @@
+
+class Xpp
+	# XML 'event' types
+	START_DOCUMENT = 'START_DOCUMENT'
+  END_DOCUMENT = 'END_DOCUMENT'
+  START_ELEMENT = 'START_ELEMENT'
+  END_ELEMENT = 'END_ELEMENT'
+  TEXT = 'TEXT'
+  CDATA_SECTION = 'CDATA_SECTION'
+  ENTITY_REF = 'ENTITY_REF'
+  IGNORABLE_WHITESPACE = 'IGNORABLE_WHITESPACE'
+  PROCESSING_INSTRUCTION = 'PROCESSING_INSTRUCTION'
+  COMMENT = 'COMMENT'
+  DOCTYPE = 'DOCTYPE'
+	LOOK_FURTHER = 'LOOK_FURTHER'
+
+	# 'Features', acutally just processing options
+	attr :processNamespace, true
+	attr :reportNamespaceAttributes, true
+
+	# the entities that we will recognise
+	attr :entityMap, true
+	attr :unresolvedEntity
+
+	# some information about where we are
+	attr :line
+	attr :column
+
+  # is the current text whitespace?
+	attr :whitespace
+
+	# element information
+	attr :type
+	attr :emptyElement
+	attr :name
+	attr :qname
+	attr :namespace
+	attr :prefix
+	attr :attributeName
+	attr :attributeQName
+	attr :attributeNamespace
+	attr :attributePrefix
+	attr :attributeValue
+
+	attr :text
+
+	attr :elementNamespacePrefixStack
+	attr :elementNamespaceValueStack
+	attr :elementNamespaceDefaultStack
+
+	# open element information
+	attr :elementName
+	attr :elementQName
+	attr :elementNamespace
+	attr :elementPrefix
+
+	def startDocument?
+		@type.equal? START_DOCUMENT
+	end
+
+	def endDocument?
+		@type.equal? END_DOCUMENT
+	end
+
+	def startElement?
+		@type.equal? START_ELEMENT
+	end
+
+	def endElement?
+		@type.equal? END_ELEMENT
+	end
+
+	def text?
+		@type.equal? TEXT
+	end
+
+	def cdata?
+		@type.equal? CDATA_SECTION
+	end
+
+	def entityRef?
+		@type.equal? ENTITY_REF
+	end
+
+	def ignorableWhitespace?
+		@type.equal? IGNORABLE_WHITESPACE
+	end
+
+	def processingInstruction?
+		@type.equal? PROCESSING_INSTRUCTION
+	end
+
+	def comment?
+		@type.equal? COMMENT
+	end
+
+	def doctype?
+		@type.equal? DOCTYPE
+	end
+
+	def lookFurther?
+		@type.equal? LOOK_FURTHER
+	end
+
+	#def whitespace?
+		#
+		# What is this all about -- FIX
+		#if text? or ignorableWhitespace? or cdata? then
+			#return @whitespace
+		#end
+		#raise "illegal type for whitespace query"
+	#end
+
+	def input=(v)
+		if nil == v then
+			@input = nil
+			@inputBuffer = nil
+			@inputBufferLength = 0
+		elsif v.kind_of? String then
+			@input = nil
+			@inputBuffer = v
+			@inputBufferLength = v.length
+		elsif v.kind_of? IO then
+			@input = v
+			@inputBuffer = nil
+			@inputBufferLength = 0
+		else
+			raise "illegalInput"
+		end
+		@nextInputBuffer = nil
+		@inputBufferPosition = 0
+		@textBuffer = ''
+
+		@line = 1
+		@column = 0
+		@compactNewLine = false
+
+		@elementNamespacePrefixStack = []
+		@elementNamespaceValueStack = []
+		@elementNamespaceDefaultStack = []
+
+		@elementName = []
+		@elementQName = []
+		@elementNamespace = []
+		@elementPrefix = []
+
+		@whitespace = true
+		@type = START_DOCUMENT
+		@unresolvedEntity = false
+
+		@name = nil
+		@namespace = nil
+
+		@attributeName = []
+		@attributeQName = []
+		@attributeNamespace = []
+		@attributePrefix = []
+		@attributeValue = []
+
+		@emptyElement = false
+	end
+
+	def nextEvent
+		begin
+			if (nil == @inputBuffer) and (nil == @input) then
+				raise "no input defined"
+			end
+
+			@whitespace = true
+			@unresolvedEntity = false
+
+			@text = nil
+
+			parseNextEvent
+
+			return @type
+		rescue RuntimeError => message
+			if nil != @inputBuffer then
+		  	message = sprintf("parse error: '%s' -- String input, line %d, column %d", message, @line, @column)
+			elsif nil != @input then
+				if @input.kind_of? File then
+	  			message = sprintf("parse error: '%s' -- file '%s', line %d, column %d", message, @input.path, @line, @column)
+				else
+	  			message = sprintf("parse error: '%s' -- unnamed IO stream, line %d, column %d", message, @line, @column)
+				end
+			else
+	  		message = sprintf("parse error: '%s' -- unknown source, line %d, column %d", message, @line, @column)
+			end
+			raise message
+		end
+	end
+
+private
+	def initialize
+		self.processNamespace = true
+		self.reportNamespaceAttributes = false
+
+		self.input = nil
+
+		self.entityMap = {"amp"=>"&",
+                      "apos"=>"'",
+                      "gt"=>">",
+                      "lt"=>"<",
+                      "quot"=>"\""}
+	end
+
+	def expect(e)
+		c = read
+		if (nil == c) or (c != e) then
+			msg = sprintf("unexpectedChar:: expect '%s' got '%s'\n", (''<<e), (''<<c))
+			raise msg
+		end
+		return c
+	end
+
+	def read
+	  # This is consumes the first thing in the peek buffer.
+
+		result = readFromInput
+
+		if result == ?\n then
+			# counting newlines for line count... not great for the mac
+			@line += 1
+			@column = 1
+		else
+			@column += 1
+		end
+
+		return result
+	end
+
+	def readFromInput
+		if (nil == @inputBuffer) or (@inputBufferLength <= @inputBufferPosition) then
+			getMoreInput
+		end
+
+		if nil != @inputBuffer then
+			c = @inputBuffer[@inputBufferPosition]
+			@inputBufferPosition += 1
+			return c
+		else
+			return nil
+		end
+	end
+
+	def getMoreInput
+		if nil == @input then
+			return nil
+		end
+		@inputBuffer = @nextInputBuffer
+		@inputBufferPosition = 0
+		if nil == @inputBuffer then
+			@inputBuffer = @input.gets
+			@inputBufferPosition = 0
+			if nil == @inputBuffer then
+				@inputBufferLength = 0
+				return nil
+			end
+		end
+		@inputBufferLength = @inputBuffer.length
+		@nextInputBuffer = @input.gets
+	end
+
+	def peekAt0
+		if nil == @inputBuffer then
+			getMoreInput
+		end
+		if @inputBufferPosition < @inputBufferLength then
+			return @inputBuffer[@inputBufferPosition]
+		else
+			if (nil != @nextInputBuffer) and (0 < @nextInputBuffer.length) then
+				return @nextInputBuffer[0]
+			else
+				return nil
+			end
+		end
+	end
+
+	def peekAt1
+		if nil == @inputBuffer then
+			getMoreInput
+		end
+		if (@inputBufferPosition + 1) < @inputBufferLength then
+			return @inputBuffer[@inputBufferPosition + 1]
+		else
+			if @inputBufferPosition < @inputBufferLength then
+				if (nil != @nextInputBuffer) and (0 < @nextInputBuffer.length) then
+					return @nextInputBuffer[0]
+				else
+					return nil
+				end
+			else
+				if (nil != @nextInputBuffer) and (1 < @nextInputBuffer.length) then
+					return @nextInputBuffer[1]
+				else
+					return nil
+				end
+			end
+		end
+	end
+
+	def parseNextEvent
+		@attributeName.clear
+		@attributeQName.clear
+		@attributeNamespace.clear
+		@attributePrefix.clear
+		@attributeValue.clear
+
+		if @emptyElement then
+			# the last event was an empty start element like <start/>
+			@type = END_ELEMENT
+			@emptyElement = false
+			return
+		end
+
+		@prefix = nil
+		@name = nil
+		@qname = nil
+		@namespace = nil
+		@type = peekType
+
+		case @type
+			when END_DOCUMENT
+				# nothing to do
+			when ENTITY_REF
+				parseEntity
+				@text = @textBuffer
+				@textBuffer = ''
+			when START_ELEMENT
+				parseStartElement
+			when END_ELEMENT
+				parseEndElement
+			when TEXT
+				parseText(?<, false)
+				@text = @textBuffer
+				@textBuffer = ''
+				if 0 == @elementName.length then
+					if(@whitespace) then
+						@type = IGNORABLE_WHITESPACE
+					end
+				end
+			when CDATA_SECTION
+printf("\nCDATA... WOW I *am* used\n")
+				# how is this ever called?
+				@type = parseLookFurther
+			else
+				@type = parseLookFurther
+		end
+
+	end
+
+	def parseLookFurther
+		# this could be a comment, processing instruction, or CDATA section
+		expect(?<)
+
+		demand = nil
+		delimiter = nil # **first** (not last) character in delimting string
+
+		@text = @textBuffer
+		@textBuffer = ''
+
+		c = read
+		if ?? == c then
+			result = PROCESSING_INSTRUCTION
+			demand = nil
+			delimiter = ??
+		elsif ?! == c then
+			cc = peekAt0
+			if ?- == cc then
+				result = COMMENT
+				demand = '--'
+				delimiter = ?-
+			elsif ?[ == cc then
+				result = CDATA_SECTION
+				demand = '[CDATA['
+				delimiter = ?]
+			else
+				result = DOCTYPE
+				demand = 'DOCTYPE'
+				delimiter = nil
+			end
+		else
+			# this should never happen because we'll get an illegal name execption
+			# first
+			raise "illegal <{c}"
+		end
+
+		if nil != demand then
+			demand.each_byte do
+				| d |
+				expect d
+			end
+		end
+
+		if DOCTYPE == result then
+			parseDoctype
+		else
+			while true do
+				c = read
+				if nil == c then
+					raise "unexpectedEOF"
+				end
+
+
+				if ((?? == delimiter) or (c == delimiter)) and
+				   (peekAt0 == delimiter) and
+					 (peekAt1 == ?>) then
+					if ?? == delimiter then
+						@text << c
+					end
+					break
+				end
+				@text << c
+			end
+
+			read
+			read
+		end
+
+		return result
+	end
+
+	def parseDoctype
+		depth = 1
+		quoted = false
+
+		@text = ''
+		
+		while true do
+			c = read
+
+			case c
+				when ?', ?" # for the sake of vim '
+					quoted = !quoted
+				when ?<
+					if not quoted then
+						depth += 1
+					end
+				when ?>
+					if not quoted then
+						depth -= 1
+						if 0 == depth then
+							return
+						end
+					end
+				when nil
+					raise "unexpectedEOF"
+			end
+			@text << c
+		end
+	end
+
+	def peekType
+		c = peekAt0
+		case c
+			when nil, 0
+				return END_DOCUMENT
+			when ?&
+				return ENTITY_REF
+			when ?<
+				case peekAt1
+					when ?/
+						return END_ELEMENT
+					when ?[
+						return CDATA_SECTION
+					when ??, ?!
+						return LOOK_FURTHER
+					else
+						return START_ELEMENT
+				end
+			else
+				return TEXT
+		end
+	end
+
+	def parseEntity
+		@compactNewLine = false
+
+		expect(?&)
+
+		@name = ''
+		while true do
+			c = read
+			if ?; == c then
+				break
+			end
+			if nil == c then
+				raise "unexpectedEOF"
+			end
+			@name << c
+		end
+
+		if ?\# == @name[0] then
+			if ?x == @name[1] then
+				c = @name[2..@name.length].hex
+			else
+				c = @name[1..@name.length].to_i
+			end
+			@textBuffer << c
+			@whitespace &= (c <= ?\s)
+		else
+			value = entityMap[@name]
+			if nil != value then
+				@textBuffer << value
+				@whitespace = false
+			else
+				@unresolvedEntity = true
+			end
+		end
+	end
+
+	def parseStartElement
+		#read the "<" that got us here
+		expect(?<)
+
+		@qname = readName
+		@textBuffer = ''
+
+		while true do
+			skipWhitespace
+			c = peekAt0
+			if nil == c then
+				raise "unexpectedEOF"
+			end
+			if ?/ == c then
+				@emptyElement = true
+
+				read
+				skipWhitespace
+				expect(?>)
+
+				break
+			end
+			if ?> == c then
+				@emptyElement = false
+				read
+				break
+			end
+
+			aName = readName
+			@textBuffer = ''
+			if (nil == aName) or (0 == aName.length) then
+				raise "nameExpected"
+			end
+
+			skipWhitespace
+			expect(?=)
+			skipWhitespace
+
+			delimiter = read
+			if (?' != delimiter) and (?" != delimiter) then # for vim: '
+				raise "invalidDelimiter"
+			end
+
+			value = parseText(delimiter, true)
+			@textBuffer = ''
+
+			# skip the end delimiter
+			read
+
+			if processNamespace then
+				@attributeQName.push aName
+			else
+				@attributeName.push aName
+				@attributeQName.push aName
+				@attributeNamespace.push nil
+				@attributePrefix.push nil
+			end
+			@attributeValue.push value
+
+		end
+
+		if processNamespace then
+			handleNamespaces
+		else
+			@name = @qname
+			@namespace = nil
+			@prefix = nil
+		end
+
+		if not @emptyElement then
+			@elementName.push @name
+			@elementQName.push @qname
+			@elementNamespace.push @namespace
+			@elementPrefix.push @prefix
+		end
+
+		#read
+	end
+
+	def parseEndElement
+		if 0 == @elementName.length then
+			raise "elementStackEmpty"
+		end
+
+		# read the "</" that we've only had a peek at
+		expect(?<)
+		expect(?/)
+
+		@qname = readName
+		startQName = @elementQName.pop
+		if @qname != startQName then
+			raise sprintf("unexpectedEndElement wanted '%s' found '%s'", startQName, @qname)
+		end
+		skipWhitespace
+		expect(?>)
+
+		@name = @elementName.pop
+		@prefix = @elementPrefix.pop
+		@namespace = @elementNamespace.pop
+
+		@elementNamespacePrefixStack.pop
+		@elementNamespaceValueStack.pop
+		@elementNamespaceDefaultStack.pop
+	end
+
+	def readName
+		c = peekAt0
+		if !nameStartChar(c) then
+			raise "nameExpected"
+		end
+		while true do
+			appendToTextBuffer(read)
+			c = peekAt0
+			if !nameChar(c) then
+				break
+			end
+		end
+		return @textBuffer
+	end
+
+	# is this method correct?? verify FIX ME
+	def nameStartChar(c)
+		if ((c < ?A) or (?Z < c)) and ((c < ?a) or (?z < c)) then
+			if (c != ?_) and (c != ?:) then
+				return false
+			end
+		end
+		return true
+	end
+
+	# is this method correct?? verify FIX ME
+	def nameChar(c)
+		if nil == c then return false end
+		if ((?A <= c) and (c <= ?Z)) then return true end
+		if ((?a <= c) and (c <= ?z)) then return true end
+		if ((?0 <= c) and (c <= ?9)) then return true end
+		if (?_ == c) then return true end
+		if (?- == c) then return true end
+		if (?. == c) then return true end
+		if (?: == c) then return true end
+
+		return false
+	end
+
+	def handleNamespaces
+		# This is called by parseStartElement to deal with namespaces. Updates knows
+		# name spaces based on the attributes in this start element. Then sets up
+		# the namespaces for this element itself (i.e. process the qname).
+
+		i = 0
+
+		defaultNamespace = @elementNamespaceDefaultStack.last
+
+		qnames = @attributeQName
+		@attributeQName = []
+		values = @attributeValue
+		@attributeValue = []
+
+		prefixList = []
+		valueList = []
+
+		while i < qnames.length do
+			qname = qnames[i]
+			value = values[i]
+			i += 1
+
+			if 'xmlns' == qname then
+				prefix = 'xmlns'
+				name = nil
+				namespace = lookupNamespace prefix
+				defaultNamespace = value
+			else
+				pieces = qname.split(':', 2)
+				if 2 == pieces.length then
+					namespace = value
+					prefix = pieces[0]
+					name = pieces[1]
+
+					if 0 == prefix.length then
+						raise "illegalEmptyAtributePrefix"
+					end
+					if 0 == name.length then
+						raise "illegalEmptyAttributeName"
+					end
+				else
+					# this is a un-prefixed non-xmlns attribute
+					@attributeQName.push qname
+					@attributeName.push qname
+					@attributeNamespace.push nil
+					@attributePrefix.push nil
+					@attributeValue.push value
+
+					next
+				end
+			end
+
+			# only prefixed attributes beyond here
+
+			if nil == namespace then
+				raise "illegalEmptyNamespace"
+			end
+
+			if "xmlns" != prefix then
+				anyQualifiedAttributes = true
+
+				@attributeQName.push qname
+				@attributeName.push name
+				@attributeNamespace.push namespace
+				@attributePrefix.push prefix
+				@attributeValue.push value
+			else
+				if (nil != name) and ((nil == namespace) or (0 == namespace.length)) then
+					raise "illegalNamespace"
+				end
+
+				prefixList.push name
+				valueList.push value
+
+				if @reportNamespaceAttributes then
+					@attributeQName.push qname
+					@attributeName.push name
+					@attributeNamespace.push namespace
+					@attributePrefix.push prefix
+					@attributeValue.push value
+
+#why???
+#					anyQualifiedAttributes = true
+				end
+			end
+
+		end
+
+		@elementNamespacePrefixStack.push prefixList
+		@elementNamespaceValueStack.push valueList
+		@elementNamespaceDefaultStack.push defaultNamespace
+		
+		if anyQualifiedAttributes then
+			# run over the attributes and make sure we have them qualified
+			for i in 0..(@attributeName.length-1) do
+				prefix = @attributePrefix[i]
+
+				if nil != prefix then
+					@attributeNamespace[i] = lookupNamespace prefix
+				end
+			end
+		end
+
+		# handle namespaces for the element name
+		pieces = @qname.split(':', 2)
+		if 2 == pieces.length then
+			@name = pieces[1]
+			@prefix = pieces[0]
+			@namespace = lookupNamespace @prefix
+		else
+			@name = @qname
+			@namespace = defaultNamespace
+			@prefix = nil
+		end
+	end
+
+	def lookupNamespace(prefix)
+		if nil == prefix then
+			raise "illegalPrefix"
+		end
+		if'xml' == prefix then
+			return 'http://www.w3.org/XML/1998/namespace'
+		end
+		if'xmlns' == prefix then
+			return 'http://www.w3.org/2000/xmlns/'
+		end
+
+		i = @elementNamespacePrefixStack.length - 1
+		while 0 <= i do
+			j = @elementNamespacePrefixStack[i].index(prefix)
+			if nil != j then
+				return @elementNamespaceValueStack[i][j]
+			end
+
+			i -= 1
+		end
+		raise "unknownNamespacePrefix"
+	end
+
+	def parseText(delimiter, resolve)
+		c = peekAt0
+		while (nil != c) and (delimiter != c) do
+			if ?& == c then
+				if !resolve then
+					break
+				end
+
+				parseEntity
+
+				if @unresolvedEntity then
+					raise "unresolvedEntity"
+				end
+			else
+				appendToTextBuffer(read)
+			end
+
+			c = peekAt0
+		end
+
+		return @textBuffer
+	end
+
+	def appendToTextBuffer(c)
+		if ((?\r == c) or (?\n == c)) and startElement? then
+			if (?\n == c) and @compactNewLine then
+				@compactNewLine = false
+				return
+			end
+			@compactNewLine = (?\r == c)
+			c = startElement? ? ?\s : ?\n
+		else
+			@compactNewLine = false
+		end
+
+		@textBuffer << c
+		@whitespace &= (c <= ?\s)
+		return @textBuffer
+	end
+
+	def skipWhitespace
+		while true do
+			c = peekAt0
+			if (nil == c) or (?\s < c) then
+				return
+			end
+			read
+		end
+	end
+
+end