uml/uml.py

from fileinput import input as finput
import re

class UntitledError(BaseException): pass
class InternalError(UntitledError): pass
class ParsingError(UntitledError): pass
class MiscError(UntitledError): pass

class Element:
    def __init__(self, element, data=None):
        if not data: self.data = ""
        else: self.data = data
        self.element = element
    def append(self, string, space=False):
        if type(data) == str:
            if space: self.data += " "
            self.data += string
        else: raise InternalError("Appending to object!")
    def set(self, data):
        self.data = data
    def __str__(self):
        return str((str(self.element), str(self.data)))
    def __repl__(self): return self.__str__()

class Table:
    def __init__(self, data=None):
        if data == None: self.data = []
        else:
            self.data = []
            self.addrow(data)
    def addrow(self, data):
        if type(data) == str:
            buf = [i.rstrip().lstrip() for i in data.split("|")]
            if len(self.data) > 0:
                if len(self.data[-1]) == len(buf):
                    self.data.append(buf)
                else:
                    raise ParsingError("tables must have uniform dimensions throughout")
            else:
                self.data.append(buf)
        elif type(data) == list:
            if len(self.data) > 0:
                if len(self.data[-1]) == len(data):
                    self.data.append(data)
                else:
                    raise ParsingError("tables must have uniform dimensions throughout")
            else:
                self.data.append(data)
    def __str__(self):
        return str(self.data)
    def __repl__(self): return self.__str__()

def printchain(chain):
    for i in chain:
        if not i.data == None: print(i.data, i.element)
        else: print(i.element)

def renderer(chain):
    for i in chain:
        rendered = False
        if i.element == "h1":
            rendered = True
            print("+" + (len(i.data) + 2) * "-" + "+")
            print("| " + i.data + " |")
            print("+" + (len(i.data) + 2) * "-" + "+")
        elif i.element == "h2":
            rendered = True
            print(" " + i.data + " ")
            print("=" * (len(i.data) + 2))
        elif i.element == "h3":
            rendered = True
            print(" " + i.data + " ")
            print("-" * (len(i.data) + 2))
        elif "h" in i.element:
            raise ParsingError("you cannot have more than three levels of headers")
        elif i.element == "p":
            rendered = True
            isplit = i.data.split(' ')
            buf = ""

            for i in isplit:
                if (len(i) + len(buf) + 1) <= 63:
                    if not len(buf) == 0: buf += " "
                    buf += i
                else:
                    print(buf)
                    buf = ""
                    buf += i
            print(buf)
        elif i.element == "t":
            buf = [0] * len(i.data.data[0])
            for j in i.data.data:
                c = 0
                for k in j:
                    if len(k) > buf[c]: buf[c] = len(k)
                    c += 1
            width = 0
            for j in buf:
                width += j
            width += 2 * len(i.data.data[0]) + 1
            print("+" + "-" * width + "+")
            # don't ask
            for j in range(len(i.data.data)):
                c = 0
                for k in range(len(i.data.data[j])):
                    if len(i.data.data[j][k]) < buf[c]:
                        i.data.data[j][k] = i.data.data[j][k].ljust(buf[c], " ")
            cbuf = ""
            for j in i.data.data:
                cbuf = "| " + ' | '.join(j) + " |"
                print(cbuf)
            print("+" + "-" * width + "+")
        if rendered: print()

chain = []
flags = {
    "TABLE_PREV": False,
}
def main():
    for i in finput():
        i = i.rstrip()

        # ignore blank lines
        if len(i) == 0: continue

        # lines with text
        if i[0].isalpha(): chain.append(Element("p", i))

        # we have a processing command
        if not i[0].isalpha():
            command = ""
            params = ""
            counter = 0
            for j in i:
                if not j.isalpha() \
                    and not j == ' ':
                    command += j
                else:
                    if j == ' ':
                        params = i[counter + 1:]
                    else:
                        params = i[counter:]
                    break
                counter += 1
            if command[0] == "#": chain.append(Element("h" + str(len(command)), params))
            elif command == "%": chain.append(Element("c", params))
            elif command == "*": chain.append(Element("l", params))
            elif command == "-": chain.append(Element("l", params))
            elif command == ">": chain.append(Element("q", params))
            elif command == "=": chain.append(Element("r", params))
            elif command == "|":
                if flags["TABLE_PREV"]:
                    chain[-1].data.addrow(params)
                    continue
                else:
                    chain.append(Element("t", Table(params)))
                    flags["TABLE_PREV"] = True
                    continue
            flags["TABLE_PREV"] = False
            continue
#    printchain(chain)
    renderer(chain)

if __name__ == "__main__": main()