xmlWriter.py :  » GUI » TTX-FontTools » fonttools-2.3 » Lib » Python Open Source

"""xmlWriter.py -- Simple XML authoring class"""

import string
import struct
import os

INDENT = "  "


class XMLWriter:
  
  def __init__(self, fileOrPath, indentwhite=INDENT, idlefunc=None, encoding="ISO-8859-1"):
    if not hasattr(fileOrPath, "write"):
      self.file = open(fileOrPath, "w")
      if os.name == "mac":
        import macfs
        macfs.FSSpec(fileOrPath).SetCreatorType('R*ch', 'TEXT')
    else:
      # assume writable file object
      self.file = fileOrPath
    self.indentwhite = indentwhite
    self.indentlevel = 0
    self.stack = []
    self.needindent = 1
    self.idlefunc = idlefunc
    self.idlecounter = 0
    if encoding:
      self.writeraw('<?xml version="1.0" encoding="%s"?>' % encoding)
    else:
      self.writeraw('<?xml version="1.0"?>')
    self.newline()
  
  def close(self):
    self.file.close()
  
  def write(self, data):
    self.writeraw(escape(data))
  
  def write_noindent(self, data):
    self.file.write(escape(data))
  
  def write8bit(self, data):
    self.writeraw(escape8bit(data))
  
  def write16bit(self, data):
    self.writeraw(escape16bit(data))
  
  def writeraw(self, data):
    if self.needindent:
      self.file.write(self.indentlevel * self.indentwhite)
      self.needindent = 0
    self.file.write(data)
  
  def newline(self):
    self.file.write("\n")
    self.needindent = 1
    idlecounter = self.idlecounter
    if not idlecounter % 100 and self.idlefunc is not None:
      self.idlefunc()
    self.idlecounter = idlecounter + 1
  
  def comment(self, data):
    data = escape(data)
    lines = string.split(data, "\n")
    self.writeraw("<!-- " + lines[0])
    for line in lines[1:]:
      self.newline()
      self.writeraw("     " + line)
    self.writeraw(" -->")
  
  def simpletag(self, _TAG_, *args, **kwargs):
    attrdata = apply(self.stringifyattrs, args, kwargs)
    data = "<%s%s/>" % (_TAG_, attrdata)
    self.writeraw(data)
  
  def begintag(self, _TAG_, *args, **kwargs):
    attrdata = apply(self.stringifyattrs, args, kwargs)
    data = "<%s%s>" % (_TAG_, attrdata)
    self.writeraw(data)
    self.stack.append(_TAG_)
    self.indent()
  
  def endtag(self, _TAG_):
    assert self.stack and self.stack[-1] == _TAG_, "nonmatching endtag"
    del self.stack[-1]
    self.dedent()
    data = "</%s>" % _TAG_
    self.writeraw(data)
  
  def dumphex(self, data):
    linelength = 16
    hexlinelength = linelength * 2
    chunksize = 8
    for i in range(0, len(data), linelength):
      hexline = hexStr(data[i:i+linelength])
      line = ""
      white = ""
      for j in range(0, hexlinelength, chunksize):
        line = line + white + hexline[j:j+chunksize]
        white = " "
      self.writeraw(line)
      self.newline()
  
  def indent(self):
    self.indentlevel = self.indentlevel + 1
  
  def dedent(self):
    assert self.indentlevel > 0
    self.indentlevel = self.indentlevel - 1
  
  def stringifyattrs(self, *args, **kwargs):
    if kwargs:
      assert not args
      attributes = kwargs.items()
      attributes.sort()
    elif args:
      assert len(args) == 1
      attributes = args[0]
    else:
      return ""
    data = ""
    for attr, value in attributes:
      data = data + ' %s="%s"' % (attr, escapeattr(str(value)))
    return data
  

def escape(data):
  data = string.replace(data, "&", "&amp;")
  data = string.replace(data, "<", "&lt;")
  return data

def escapeattr(data):
  data = string.replace(data, "&", "&amp;")
  data = string.replace(data, "<", "&lt;")
  data = string.replace(data, '"', "&quot;")
  return data

def escape8bit(data):
  def escapechar(c):
    n = ord(c)
    if c in "<&":
      if c == "&":
        return "&amp;"
      else:
        return "&lt;"
    elif 32 <= n <= 127:
      return c
    else:
      return "&#" + `n` + ";"
  return string.join(map(escapechar, data), "")

needswap = struct.pack("h", 1) == "\001\000"

def escape16bit(data):
  import array
  a = array.array("H")
  a.fromstring(data)
  if needswap:
    a.byteswap()
  def escapenum(n, amp=ord("&"), lt=ord("<")):
    if n == amp:
      return "&amp;"
    elif n == lt:
      return "&lt;"
    elif 32 <= n <= 127:
      return chr(n)
    else:
      return "&#" + `n` + ";"
  return string.join(map(escapenum, a), "")


def hexStr(s):
  h = string.hexdigits
  r = ''
  for c in s:
    i = ord(c)
    r = r + h[(i >> 4) & 0xF] + h[i & 0xF]
  return r