#
# Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of the License "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description: 
# Base Class for defining filter classes
# All filter classes that get defined should derive from this base class
#

class Filter(object):
	
	def open(self, params):
		return False
	
	def write(self, text):
		return False

	def summary(self):
		return False
	
	def close(self):
		return False
	
	def formatError(self, message):
		return "sbs: error: " + message + "\n"
		
	def formatWarning(self, message):
		return "sbs: warning: " + message + "\n"	

	def parseNamedParams(self, names, params):
		''' Match named parameters e.g. ['a=b','c=d'] against a list of expected
		names.  Allow for abbreviations.
		'''
		r = {}
		
		# Shorten all the names so they match abbreviations
		shortnames = []

		for name in names:
			shortname = ""
			conflict = True
			while len(shortname)<len(name) and conflict:
				shortname+=name[len(shortname)]
				conflict = False
				othernames = names[:] # Copy
				othernames.remove(name)
				for othername in othernames:
					if othername.startswith(shortname):
						conflict = True
						break
				if conflict == False:
					shortnames.append((shortname,name))
					r[name] = [] # Prime the hash key for this param
			if conflict:
				raise KeyError("Parameter name '{0}' duplicated".format(name))

		# Parse the params
		for param in params:
			if '=' in param:
				(key,value) = param.split('=')
				matched = False
				for (shortname, name) in shortnames:
					if key.strip().startswith(shortname):
						r[name].append(value.strip())
						matched = True
						break
				if not matched:
					raise ValueError("Named parameter '{0}' not valid in filter {1}".format(key,self.__class__.__name__))
			else:
				# Unnamed arg
				if not '' in names:
					raise ValueError("All parameters to the {0} filter must be named".format(self.__class__.__name__))
				else:
					r[''].append(param.strip())
		return r	
			
import sys
import xml.sax

class FilterSAX(Filter, xml.sax.handler.ContentHandler, xml.sax.handler.ErrorHandler):
	"base class for filters using a SAX parser"
	
	# define these methods in your subclass
	
	def startDocument(self):
		"called once before any elements are seen"
		pass
		
	def startElement(self, name, attributes):
		"called on the opening of any element"
		pass
	
	def characters(self, char):
		"called one or more times with body text from an element"
		pass
		
	def endElement(self, name):
		"called on the closing of any element"
		pass
	
	def endDocument(self):
		"called once when all elements are closed"
		pass

	def error(self, exception):
		"the parse found an error which is (possibly) recoverable"
		pass
		
	def fatalError(self, exception):
		"the parser thinks an error occurred which should stop everything"
		pass
		
	def warning(self, exception):
		"the parser found something to complain about that might not matter"
		pass
		
	# these methods are from the Filter base class
	
	def open(self, params):
		"initialise"
		
		self.params = params

		self.parser = xml.sax.make_parser(['xml.sax.expatreader'])
		self.parser.setContentHandler(self)
		self.parser.setErrorHandler(self)
		
		self.ok = True

		return self.ok
			
	def write(self, text):
		"process some log text"
		if self.ok:
			self.parser.feed(text)
		return self.ok

	def close(self):
		"finish off"
		try:
			self.parser.close()
		except Exception, ex:
			sys.stderr.write(self.formatError(str(ex)))
			self.ok = False
			
		return self.ok
	
class RaptorLogNotValid(Exception):
	pass

class PerRecipeFilter(FilterSAX):
	# Define this in your class
	def handleRecipe(self):
		# These variables are available to you:
		# self.name
		# self.target
		# self.host
		# self.layer
		# self.component
		# self.bldinf
		# self.mmp
		# self.config
		# self.platform
		# self.phase
		# self.source
		# self.prereqs
		# self.text
		# self.exit
		# self.attempt (final attempt number)
		# self.flags
		# self.start
		# self.elapsed

		return False
	
	# Helper functions
	def formatData(self, key, hash='self'):
		'''Output prettifier - return the attribute value, or just return 'undef' if the attribute is not set.'''

		if hash=='self':
			hash=self.__dict__
		if hash.has_key(key):
			return hash[key]
		else:
			return 'undef'
	
	# data keys
	recipeData = set(['name','target','host','layer','component','bldinf','mmp','config','platform','phase','source','prereqs'])
	statusData = set(['exit','attempt','flags'])
	timeData = set(['start','elapsed'])

	# methods from the SAX parser
	def startDocument(self):
		self.inRecipe = False
		self.text = ""

	def startElement(self, name, attributes):
		if name == "recipe":
			if self.inRecipe:
				self.error(RaptorLogNotValid("Nested recipes; {0} recipe for {1} inside {2} recipe for {3}".format(self.formatData('name', hash=attributes), self.formatData('target',hash=attributes), self.formatData('name'), self.formatData('target') )))
			else:
				self.inRecipe = True
				self.__setHashElements(attributes, self.__dict__, self.recipeData )		
		elif self.inRecipe:
			if name == "status":
				self.__setHashElements(attributes, self.__dict__, self.statusData)
			elif name == "time":
				self.__setHashElements(attributes, self.__dict__, self.timeData)
			else:
				self.error(RaptorLogNotValid("Unexpected <{0}> tag in {1} recipe for {2}".format(name, self.formatData('name'), self.formatData('target'))))
	
	def endElement(self, name):
		if name == "recipe":
			if not self.inRecipe:
				self.error(RaptorLogNotValid("Extra recipe close tag"))
			else:
				if not self.handleRecipe():
					self.error(RaptorLogNotValid('Handling of {0} recipe for {1} failed'.format(self.formatData('name'), self.formatData('target'))))
				self.inRecipe = False
				
				self.__delData(self.recipeData|self.statusData|self.timeData)
				self.text=""

	def characters(self, char):
		if self.inRecipe:
			self.text += char

	def error(self, exception):
		"the parse found an error which is (possibly) recoverable"
		pass
		
	def fatalError(self, exception):
		"the parser thinks an error occurred which should stop everything"
		pass
		
	def warning(self, exception):
		"the parser found something to complain about that might not matter"
		pass

	# Private methods
	def __setHashElements(self, fro, to, keys):
		for key in keys:
			if fro.has_key(key):
				to[key] = fro[key]

	def __delData(self, keys):
		for key in keys:
			if self.__dict__.has_key(key):
				del self.__dict__[key]

# the end