#!/usr/bin/python

import os

import logging

import StringIO

name_characters = "0123456789abcdefghijklmnopqrstuvwxyz_-."

# printable ASCII:

data_characters = "!#$%&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~"

data_characters += "\""

escaped_characters = "<>\\"

whitespace_characters = " \t\n"

data_characters += escaped_characters + whitespace_characters

# future: numerical values for different contexts

# e.g. EMPTY = 10

def main():

	help_message = """

Edgecase Markup Language (EML) Parser Library:

This library supplies a class that can parse a file object or a string into an EML element tree.

Use:

1)

from eml_parser import Element

with open(file_path, 'r') as f:

	root_element = Element.from_file_object(f)

2)

from eml_parser import Element

s = "<content>hello <bold>world</bold></content>"

root_element = Element.from_string(s)

Both class methods accept an optional Python logger object, using the keyword argument "logger".

Example:

import logging

from eml_parser import Element, create_console_logger

logger = create_console_logger(logging.INFO)

with open(file_path, 'r') as f:

	root_element = Element.from_file_object(f, logger)

To display the EML element tree:

print(root_element.tree())

"""

	print help_message

def run_test():

	# how to run this function from the command line:

	# $ python -c "import eml_parser; eml_parser.run_test()"

	#logger = create_console_logger(logging.DEBUG)

	logger = create_file_logger(logging.INFO)

	data = "<content>hello world this is dog</content>"

	#data = "<foo>x<bar>y</bar>b</foo>"

	#data = "<e1>foo<e2></e2>xxx<e3>bar</e3>hello</e1>"

	#data = "<e1>foo</e1>asdf"

	try:

		root_element = Element.from_string(data, logger=logger)

		logger.info("Built Element from string.")

		logger.info("\n" + root_element.tree() + "\n")

	except Exception as e:

		logger.exception("Error occurred when building an Element from file object")

def create_console_logger(level):

	logger_name = __name__ + ':console'

	# create logger

	logger = logging.getLogger(logger_name)

	logger.setLevel(level)

	# create console handler

	ch = logging.StreamHandler()

	ch.setLevel(level)

	# create formatter

	formatter = logging.Formatter('[%(name)s] [%(levelname)s] [%(message)s]')

	# add formatter to ch

	ch.setFormatter(formatter)

	# add ch to logger

	logger.addHandler(ch)

	return logger

def create_file_logger(level, filepath=None):

	if not filepath:

		filepath = __name__ + ".log"

	logger_name = filepath

	logger = logging.getLogger(logger_name)

	logger.setLevel(level)

	handler = logging.FileHandler(filepath, mode='w', delay=True)

	handler.setLevel(level)

	formatter = logging.Formatter('[%(asctime)s] [%(name)s] [%(levelname)s] [%(message)s]')

	handler.setFormatter(formatter)

	logger.addHandler(handler)

	return logger

def create_null_logger():

	logger = logging.getLogger(__name__)

	handler = logging.NullHandler()

	logger.addHandler(handler)

	return logger

class Element:

	def __init__(self):

		self.name = ""

		self.end_name = ""

		self.complete = False

		self.children = []

		self.parent = None

		self.logger = None

	def __str__(self):

		return "Element: [{}]".format(self.name)

	def tree(self):

		return "\n".join(self.tree_lines())

	def tree_lines(self):

		if self.parent == None:

			tree_lines = ["Tree for " + str(self)]

		else:

			tree_lines = [" " + str(self)]

		for child in self.children:

			child_lines = child.tree_lines()

			child_lines = [("-" + x) for x in child_lines]

			tree_lines.extend(child_lines)

		return tree_lines

	@classmethod

	def from_string(cls, string, parent=None, logger=None):

		f = StringIO.StringIO(string)

		element = cls.from_file_object(f, parent=parent, logger=logger)

		return element

	@classmethod

	def from_file_object(cls, f, parent=None, logger=None):

		if not logger:

			logger = create_null_logger()

		e = cls()

		e.parent = parent

		e.logger = logger

		e.process_file_object(f)

		if not e.parent:

			# this is the root Element.	

			# did we reach the end of the file object?

			remaining_data = f.read()

			if len(remaining_data) > 0:

				message = "Finished building root element, but found this data at end of file: {}".format(repr(remaining_data))

				raise Exception(message)

		return e

	def process_file_object(self, f):

		c = "empty" # c = context

		handled = False # have we handled this combination of context and byte? 

		message = "Element: context [{}], byte [{}]."

		while True:

			b = f.read(1) # b = byte

			if not b:

				if not self.complete:

					message = message.format(c, b)

					message += " No more data left, but Element is not complete."

					raise Exception(message)

				break

			self.logger.debug(message.format(c, b))

			if b == "<":

				if c == "empty":

					c = "start_tag_open"

					handled = True

				elif c == "start_tag_close":

					c = "tag_open"

					handled = True

				elif c == "data":

					c = "tag_open"

					handled = True

			elif b == ">":

				if c == "start_tag_name":

					c = "start_tag_close"

					handled = True

				elif c == "end_tag_name":

					c = "end_tag_close"

					# we're at the end. move 1 level back up in the decision hierarchy.

					if self.name != self.end_name:

						message = message.format(c, b)

						message += " Finished building Element, but end tag name ({}) is not the same as start tag name ({}).".format(self.end_name, self.name)

						raise Exception(message)

					# mark element as complete

					self.complete = True

					self.logger.debug("End Element. Move up 1 level.")

					break

			elif b == "/":

				if c == "tag_open":

					c = "end_tag_open"

					handled = True

			elif b in name_characters:

				if c == "start_tag_open":

					c = "start_tag_name"

					self.name += b

					handled = True

				elif c == "start_tag_name":

					self.name += b

					handled = True

				elif c == "start_tag_close":

					c = "data"

					self.logger.debug("switch to Datum.")

					# rewind file by 1 byte

					f.seek(-1, os.SEEK_CUR)

					# pass file object to Datum class

					datum = Datum.from_file_object(f, logger=self.logger)

					self.children.append(datum)

					handled = True

				elif c == "end_tag_open":

					c = "end_tag_name"

					self.end_name += b

					handled = True

				elif c == "end_tag_name":

					self.end_name += b

					handled = True

				elif c == "tag_open":

					# child Element

					c = "data"

					self.logger.debug("switch to Element.")

					# rewind file by 2 bytes

					f.seek(-2, os.SEEK_CUR)

					# pass file object to Element class

					child = Element.from_file_object(f, parent=self, logger=self.logger)

					self.children.append(child)

					handled = True

				elif c == "data":

					self.logger.debug("switch to Datum.")

					# rewind file by 1 byte

					f.seek(-1, os.SEEK_CUR)

					# pass file object to Datum class

					datum = Datum.from_file_object(f, logger=self.logger)

					self.children.append(datum)

					handled = True

			elif b in data_characters:

				if c == "start_tag_close":

					c = "data"

					self.logger.debug("switch to Datum.")

					# rewind file by 1 byte

					f.seek(-1, os.SEEK_CUR)

					# pass file object to Datum class

					datum = Datum.from_file_object(f, logger=self.logger)

					self.children.append(datum)

					handled = True

			if not handled:

				raise Exception(message.format(c, b))

			handled = False	

class Datum:

	def __init__(self):

		self.bytes = ""

		self.parent = None

		self.logger = None

	@classmethod

	def from_file_object(cls, f, parent=None, logger=None):

		d = cls()

		d.parent = parent

		d.logger = logger

		d.process_file_object(f)

		return d

	def __str__(self):

		return "Datum: [{} bytes]".format(len(self.bytes))

	def tree_lines(self):

		tree_line = " " + str(self)

		n = 5 # display this number of bytes from either end of the Datum.

		m = len(self.bytes) 

		if m <= n*2:

			tree_line += ": [{}]".format(self.bytes)

		else:

			tree_line += ": [{} ... {}]".format(self.bytes[:n], self.bytes[-n:])

		return [tree_line]

	def process_file_object(self, f):

		c = "data" # c = context

		handled = False # have we handled this combination of context and byte? 

		message = "Datum: context [{}], byte [{}]."

		while True:

			b = f.read(1) # b = byte

			if not b:

				break

			self.logger.debug(message.format(c, b))

			if b == "<":

				if c == "data":

					# this is a new Element

					self.logger.debug("End Datum. Move up 1 level.")

					# rewind file by 1 byte

					f.seek(-1, os.SEEK_CUR)

					break

			elif b == ">":

				if c == "data":

					# error

					raise Exception(message.format(c, b))

			elif b == "\\":

				if c == "data":

					c = "escape"

					handled = True

				elif c == "escape":

					self.bytes += b

					c = "data"

					handled = True

			elif b in data_characters:

				if c == "data":

					self.bytes += b

					handled = True

			if not handled:

					raise Exception(message.format(c, b))

			handled = False	

if __name__ == "__main__":

	main()

#!/usr/bin/python

from eml_parser import Element, Datum

import unittest

class TestElement(unittest.TestCase):

	def test_upper(self):

		self.assertEqual('foo'.upper(), 'FOO')

	def test_empty_element(self):

		s = "<content></content>"

		e = Element.from_string(s)

		self.assertEqual(e.name, "content")

		self.assertEqual(len(e.children), 0)

	def test_single_start_tag(self):

		s = "<content>"	

		with self.assertRaises(Exception):

			Element.from_string(s)

	def test_some_garble(self):

		s = "uahslyfasdlhgfas"

		with self.assertRaises(Exception):

			Element.from_string(s)

	def test_single_end_tag(self):

		s = "</foo>"

		with self.assertRaises(Exception):

			Element.from_string(s)

	def test_element_containing_data(self):

		s = "<content>hello world this is dog</content>"

		e = Element.from_string(s)

		self.assertEqual(e.name, "content")

		self.assertEqual(len(e.children), 1)

		child = e.children[0]

		self.assertIsInstance(child, Datum)

	def test_element_containing_element(self):

		s = "<foo>x<bar>y</bar>b</foo>"

		e = Element.from_string(s)

		self.assertEqual(e.name, "foo")

		self.assertEqual(len(e.children), 3)

		child1 = e.children[0]

		self.assertIsInstance(child1, Datum)

		child2 = e.children[1]

		self.assertIsInstance(child2, Element)

		self.assertEqual(len(child2.children), 1)

	def test_element_followed_by_garble(self):

		s = "<e1>foo</e1>asdf"

		with self.assertRaises(Exception):

			Element.from_string(s)

if __name__ == '__main__':

	unittest.main()