|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import types |
|
|
import xml.sax |
|
|
import xml.sax.saxutils |
|
|
import re |
|
|
import os |
|
|
import sys |
|
|
import random |
|
|
import copy |
|
|
import htmlentitydefs |
|
|
|
|
|
from xml.sax.handler import ContentHandler |
|
|
from xml.sax import parse |
|
|
from urlparse import urlparse |
|
|
from urlparse import urlunparse |
|
|
from optparse import OptionParser |
|
|
|
|
|
usage = """webdoc [OPTIONS...] <DOC.XML> |
|
|
|
|
|
--outdir Set output directory |
|
|
--verbose Be verbose |
|
|
""" |
|
|
|
|
|
parser = OptionParser(usage=usage) |
|
|
|
|
|
parser.add_option( |
|
|
"-v", "--verbose", |
|
|
dest = "verb", |
|
|
default = False, |
|
|
action = "store_true", |
|
|
help = "print debug informations") |
|
|
|
|
|
parser.add_option( |
|
|
"-o", "--outdir", |
|
|
dest = "outdir", |
|
|
default = "html", |
|
|
action = "store", |
|
|
help = "write output to this directory") |
|
|
|
|
|
DOCTYPE_XHTML_TRANSITIONAL = \ |
|
|
'<!DOCTYPE html PUBLIC ' \ |
|
|
'"-//W3C//DTD XHTML 1.0 Transitional//EN" ' \ |
|
|
'"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">' |
|
|
|
|
|
|
|
|
mapUnicodeToHtmlEntity = { } |
|
|
for k, v in htmlentitydefs.name2codepoint.items(): |
|
|
c = unichr(v) |
|
|
if c == u'&' or c == u'<' or c == u'>': continue |
|
|
mapUnicodeToHtmlEntity [c] = "&%s;" % k |
|
|
|
|
|
|
|
|
nodeIndex = { } |
|
|
|
|
|
def getUniqueNodeID(id = None): |
|
|
""" |
|
|
getUniqueNodeID() generates an unique ID for a document node. |
|
|
getUniqueNodeID(id) generates an unique ID adding a suffix to id. |
|
|
""" |
|
|
if id is None: id = "id" |
|
|
uniqueId = id |
|
|
count = 0 |
|
|
while 1: |
|
|
if uniqueId not in nodeIndex: break |
|
|
count += 1 |
|
|
uniqueId = "%s-%d" % (id, count) |
|
|
return uniqueId |
|
|
|
|
|
def dumpIndex(): |
|
|
""" |
|
|
Dump the node index, for debugging purposes. |
|
|
""" |
|
|
for x in nodeIndex.itervalues(): |
|
|
print x |
|
|
|
|
|
def ensureDir(dirName): |
|
|
""" |
|
|
Create the directory DIRNAME if it does not exsits. |
|
|
""" |
|
|
if os.path.isdir(dirName): |
|
|
pass |
|
|
elif os.path.isfile(dirName): |
|
|
raise OSError("cannot create the direcory '%s'" |
|
|
"because there exists already " |
|
|
"a file with that name" % newdir) |
|
|
else: |
|
|
head, tail = os.path.split(dirName) |
|
|
if head and not os.path.isdir(head): |
|
|
ensureDir(head) |
|
|
if tail: |
|
|
os.mkdir(dirName) |
|
|
|
|
|
def calcRelURL(toURL, fromURL): |
|
|
""" |
|
|
Calculates a relative URL. |
|
|
""" |
|
|
fromURL = urlparse(fromURL) |
|
|
toURL = urlparse(toURL) |
|
|
if not fromURL.scheme == toURL.scheme: return urlunparse(toURL) |
|
|
if not fromURL.netloc == toURL.netloc: return urlunparse(toURL) |
|
|
|
|
|
fromPath = fromURL.path.split("/") |
|
|
toPath = toURL.path.split("/") |
|
|
for j in xrange(len(fromPath) - 1): fromPath[j] += u"/" |
|
|
for j in xrange(len(toPath) - 1): toPath[j] += u"/" |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
i = 0 |
|
|
while True: |
|
|
if i >= len(fromPath) - 1: break |
|
|
if i >= len(toPath) - 1: break |
|
|
if not fromPath[i] == toPath[i]: break |
|
|
i = i + 1 |
|
|
|
|
|
|
|
|
|
|
|
for j in xrange(len(fromPath) - 1): |
|
|
if len(fromPath[j]) > 1: fromPath[j] = u"../" |
|
|
else: fromPath[j] = u"" |
|
|
|
|
|
fromPath = fromPath[i:-1] |
|
|
toPath = toPath[i:] |
|
|
relPath = u"".join(fromPath) + "".join(toPath) |
|
|
|
|
|
return urlunparse(("", "", relPath, "", "", toURL.fragment)) |
|
|
|
|
|
def walkNodes(rootNode, nodeType = None): |
|
|
for n in rootNode.getChildren(): |
|
|
for m in walkNodes(n, nodeType): |
|
|
yield m |
|
|
if not nodeType or rootNode.isA(nodeType): |
|
|
yield rootNode |
|
|
|
|
|
def walkAncestors(leafNode, nodeType = None): |
|
|
if not nodeType or leafNode.isA(nodeType): |
|
|
yield leafNode |
|
|
p = leafNode.getParent() |
|
|
if p: |
|
|
for m in walkAncestors(p, nodeType): |
|
|
yield m |
|
|
|
|
|
|
|
|
class DocBareParsingError(Exception): |
|
|
|
|
|
def __init__(self, message): |
|
|
self.message = message |
|
|
|
|
|
def __str__(self): |
|
|
return self.message |
|
|
|
|
|
|
|
|
class DocParsingError(Exception): |
|
|
|
|
|
def __init__(self, URL, row, column, message): |
|
|
self.URL = URL |
|
|
self.rowNumber = row |
|
|
self.columnNumber = column |
|
|
self.message = message |
|
|
|
|
|
def __str__(self): |
|
|
return "%s:%d:%d:%s" % (self.URL, |
|
|
self.rowNumber, |
|
|
self.columnNumber, |
|
|
self.message) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class makeBareGuard(object): |
|
|
def __init__(self, func): |
|
|
self.func = func |
|
|
|
|
|
def __call__(self, obj, *args, **keys): |
|
|
try: |
|
|
self.func(obj, *args, **keys) |
|
|
except DocParsingError: |
|
|
raise |
|
|
except DocBareParsingError: |
|
|
raise |
|
|
except Exception, e: |
|
|
raise obj.makeBareParsingError(e.__str__()) |
|
|
|
|
|
def __get__(self, obj, type=None): |
|
|
return types.MethodType(self, obj, type) |
|
|
|
|
|
class makeGuard(object): |
|
|
def __init__(self, func): |
|
|
self.func = func |
|
|
|
|
|
def __call__(self, obj, *args, **keys): |
|
|
try: |
|
|
self.func(obj, *args, **keys) |
|
|
except DocParsingError: |
|
|
raise |
|
|
except DocBareParsingError, e: |
|
|
raise obj.makeParsingError(e.message) |
|
|
except Exception, e: |
|
|
raise obj.makeParsingError(e.__str__()) |
|
|
|
|
|
def __get__(self, obj, type=None): |
|
|
return types.MethodType(self, obj, type) |
|
|
|
|
|
|
|
|
class DocBareNode: |
|
|
|
|
|
""" |
|
|
A node of the document tree without parent, childnren, or any |
|
|
other attribute. It is used to implement frequent leaf nodes such |
|
|
as text chunks. |
|
|
""" |
|
|
def __init__(self): pass |
|
|
|
|
|
def isA(self, classInfo): |
|
|
""" |
|
|
Returns TRUE if the node is of class CLASSINFO. |
|
|
""" |
|
|
return isinstance(self, classInfo) |
|
|
|
|
|
def getChildren(self): |
|
|
""" |
|
|
Returs an empty list |
|
|
""" |
|
|
return [] |
|
|
|
|
|
def setParent(self, parent): pass |
|
|
def getPublishDirName(self): pass |
|
|
def getPublishFileName(self): pass |
|
|
def getPublishURL(self): pass |
|
|
def publish(self, generator, pageNode = None): pass |
|
|
def publishIndex(self, gen, pageNode, openNodeStack): return False |
|
|
|
|
|
def makeBareParsingError(self, message): |
|
|
""" |
|
|
Creates a DocParsingError with the specified message. The |
|
|
source code URL, row, and column are set to the node |
|
|
corresponding values. |
|
|
""" |
|
|
return DocBareParsingError(message) |
|
|
|
|
|
|
|
|
class DocNode(DocBareNode): |
|
|
|
|
|
def __init__(self, attrs, URL, locator): |
|
|
self.parent = None |
|
|
self.children = [] |
|
|
self.attrs = attrs |
|
|
self.sourceURL = None |
|
|
self.sourceRow = None |
|
|
self.sourceColumn = None |
|
|
if attrs.has_key('id'): |
|
|
self.id = attrs['id'] |
|
|
else: |
|
|
self.id = getUniqueNodeID() |
|
|
if URL: |
|
|
if not URL is self.getSourceURL(): |
|
|
self.sourceURL = URL |
|
|
if locator: |
|
|
self.sourceRow = locator.getLineNumber() |
|
|
self.sourceColumn = locator.getColumnNumber() |
|
|
nodeIndex[self.id] = self |
|
|
|
|
|
def __str__(self): |
|
|
return "%s:%d:%d:%s" % (self.getSourceURL(), |
|
|
self.getSourceRow(), |
|
|
self.getSourceColumn(), |
|
|
self.getID()) |
|
|
|
|
|
def dump(self): |
|
|
""" |
|
|
Recusively dump the tree, for debugging purposes. |
|
|
""" |
|
|
depth = self.getDepth() |
|
|
print " " * depth, self |
|
|
for x in self.children: x.dump() |
|
|
|
|
|
|
|
|
|
|
|
def getID(self): |
|
|
""" |
|
|
Returns the node ID |
|
|
""" |
|
|
return self.id |
|
|
|
|
|
def getParent(self): |
|
|
""" |
|
|
Return the node parent. |
|
|
""" |
|
|
return self.parent |
|
|
|
|
|
def getChildren(self): |
|
|
""" |
|
|
Return the list of node children. |
|
|
""" |
|
|
return self.children |
|
|
|
|
|
def getAttributes(self): |
|
|
""" |
|
|
Return the dictionary of node attributes. |
|
|
""" |
|
|
return self.attrs |
|
|
|
|
|
def getDepth(self): |
|
|
""" |
|
|
Return the depth of the node in the tree. |
|
|
""" |
|
|
if self.parent: |
|
|
return self.parent.getDepth() + 1 |
|
|
else: |
|
|
return 0 |
|
|
|
|
|
def setParent(self, parent): |
|
|
""" |
|
|
Set the parent of the node. |
|
|
""" |
|
|
self.parent = parent |
|
|
|
|
|
def adopt(self, orfan): |
|
|
""" |
|
|
Adds ORFAN to the node children and make the node the parent |
|
|
of ORFAN. ORFAN can also be a sequence of orfans. |
|
|
""" |
|
|
self.children.append(orfan) |
|
|
orfan.setParent(self) |
|
|
|
|
|
def findAncestors(self, nodeType = None): |
|
|
""" |
|
|
Return the node ancestors of type NODETYPE. If NODETYPE is |
|
|
None, returns all ancestors. |
|
|
""" |
|
|
if nodeType is None: |
|
|
nodeType = DocNode |
|
|
if self.parent: |
|
|
if self.parent.isA(nodeType): |
|
|
found = [self.parent] |
|
|
else: |
|
|
found = [] |
|
|
found = found + self.parent.findAncestors(nodeType) |
|
|
return found |
|
|
return [] |
|
|
|
|
|
def findChildren(self, nodeType = None): |
|
|
""" |
|
|
Returns the node chldren of type NODTYPE. If NODETYPE is None, |
|
|
returns all children. |
|
|
""" |
|
|
if nodeType is None: |
|
|
nodeType = DocNode |
|
|
return [x for x in self.children if x.isA(nodeType)] |
|
|
|
|
|
def getSourceURL(self): |
|
|
""" |
|
|
Get the URL of the source code file where the node was |
|
|
instantiated. |
|
|
""" |
|
|
if self.sourceURL: |
|
|
return self.sourceURL |
|
|
elif self.parent: |
|
|
return self.parent.getSourceURL() |
|
|
else: |
|
|
return "" |
|
|
|
|
|
def getSourceColumn(self): |
|
|
""" |
|
|
Gets the column of the source code file where the node was |
|
|
instantiated. |
|
|
""" |
|
|
if not self.sourceColumn is None: |
|
|
return self.sourceColumn |
|
|
elif self.parent: |
|
|
return self.parent.getSourceColumn() |
|
|
else: |
|
|
return -1 |
|
|
|
|
|
def getSourceRow(self): |
|
|
""" |
|
|
Gets the row (line) of the source code file where the node was |
|
|
instantiated. |
|
|
""" |
|
|
if not self.sourceRow is None: |
|
|
return self.sourceRow |
|
|
elif self.parent: |
|
|
return self.parent.getSourceRow() |
|
|
else: |
|
|
return -1 |
|
|
|
|
|
def makeParsingError(self, message): |
|
|
""" |
|
|
Creates a DocParsingError with the specified message. The |
|
|
source code URL, row, and column are set to the node |
|
|
corresponding values. |
|
|
""" |
|
|
return DocParsingError( |
|
|
self.getSourceURL(), |
|
|
self.getSourceRow(), |
|
|
self.getSourceColumn(), |
|
|
message) |
|
|
|
|
|
def getPublishDirName(self): |
|
|
""" |
|
|
Returns the publish dir name of the parent. |
|
|
""" |
|
|
if self.parent: |
|
|
return self.parent.getPublishDirName() |
|
|
return None |
|
|
|
|
|
def getPublishFileName(self): |
|
|
""" |
|
|
Returns NONE. |
|
|
""" |
|
|
return None |
|
|
|
|
|
def getPublishURL(self): |
|
|
""" |
|
|
Returns NONE. |
|
|
""" |
|
|
return None |
|
|
|
|
|
def publish(self, generator, pageNode = None): |
|
|
""" |
|
|
Recursively calls PUBLISH() on its children. |
|
|
""" |
|
|
for c in self.getChildren(): |
|
|
c.publish(generator, pageNode) |
|
|
return None |
|
|
|
|
|
def publishIndex(self, gen, pageNode, openNodeStack): |
|
|
""" |
|
|
Recursively calls PUBLISHINDEX() on its children. |
|
|
""" |
|
|
hasIndexedChildren = False |
|
|
for c in self.getChildren(): |
|
|
hasIndexedChildren = c.publishIndex(gen, pageNode, openNodeStack) \ |
|
|
or hasIndexedChildren |
|
|
return hasIndexedChildren |
|
|
|
|
|
|
|
|
def expandAttr(value, pageNode): |
|
|
|
|
|
xvalue = "" |
|
|
next = 0 |
|
|
for m in re.finditer("%[-\w._#:]+;", value): |
|
|
if next < m.start(): |
|
|
xvalue += value[next : m.start()] |
|
|
next = m.end() |
|
|
directive = value[m.start()+1 : m.end()-1] |
|
|
mo = re.match('pathto:(.*)', directive) |
|
|
if mo: |
|
|
toNodeID = mo.group(1) |
|
|
toNodeURL = None |
|
|
if nodeIndex.has_key(toNodeID): |
|
|
toNodeURL = nodeIndex[toNodeID].getPublishURL() |
|
|
if toNodeURL is None: |
|
|
print "warning: could not cross-reference '%s'" % toNodeID |
|
|
toNodeURL = toNodeID |
|
|
fromPageURL = pageNode.getPublishURL() |
|
|
xvalue += calcRelURL(toNodeURL, fromPageURL) |
|
|
else: |
|
|
raise DocBareParsingError( |
|
|
"Unknown directive '%s' while expanding attribute" % directive) |
|
|
if next < len(value): xvalue += value[next:] |
|
|
|
|
|
return xvalue |
|
|
|
|
|
|
|
|
class Generator: |
|
|
|
|
|
def __init__(self, rootDir): |
|
|
ensureDir(rootDir) |
|
|
self.fileStack = [] |
|
|
self.dirStack = [rootDir] |
|
|
ensureDir(rootDir) |
|
|
|
|
|
|
|
|
def open(self, filePath): |
|
|
filePath = os.path.join(self.dirStack[-1], filePath) |
|
|
fid = open(filePath, "w") |
|
|
self.fileStack.append(fid) |
|
|
fid.write(DOCTYPE_XHTML_TRANSITIONAL) |
|
|
|
|
|
|
|
|
def putString(self, str): |
|
|
fid = self.fileStack[-1] |
|
|
fid.write(str.encode('latin-1')) |
|
|
|
|
|
def putXMLString(self, str): |
|
|
fid = self.fileStack[-1] |
|
|
xstr = xml.sax.saxutils.escape(str, mapUnicodeToHtmlEntity) |
|
|
try: |
|
|
fid.write(xstr.encode('latin-1')) |
|
|
except: |
|
|
print "OFFENDING", str, xstr |
|
|
print mapUnicodeToHtmlEntity[str] |
|
|
raise |
|
|
|
|
|
def putXMLAttr(self, str): |
|
|
fid = self.fileStack[-1] |
|
|
xstr = xml.sax.saxutils.quoteattr(str) |
|
|
fid.write(xstr.encode('latin-1')) |
|
|
|
|
|
def close(self): |
|
|
self.fileStack.pop().close() |
|
|
|
|
|
|
|
|
def changeDir(self, dirName): |
|
|
currentDir = self.dirStack[-1] |
|
|
newDir = os.path.join(currentDir, dirName) |
|
|
ensureDir(newDir) |
|
|
self.dirStack.append(newDir) |
|
|
|
|
|
|
|
|
def parentDir(self): |
|
|
self.dirStack.pop() |
|
|
|
|
|
|
|
|
def tell(self): |
|
|
fid = self.fileStack[-1] |
|
|
return fid.tell() |
|
|
|
|
|
def seek(self, pos): |
|
|
fid = self.fileStack[-1] |
|
|
fid.seek(pos) |
|
|
|
|
|
|
|
|
class DocInclude(DocNode): |
|
|
|
|
|
def __init__(self, attrs, URL, locator): |
|
|
DocNode.__init__(self, attrs, URL, locator) |
|
|
if not attrs.has_key("src"): |
|
|
raise self.makeParsingError("include missing 'src' attribute") |
|
|
self.filePath = attrs["src"] |
|
|
|
|
|
def __str__(self): |
|
|
return DocNode.__str__(self) + ":<web:include src=%s>" \ |
|
|
% xml.sax.saxutils.quoteattr(self.filePath) |
|
|
|
|
|
|
|
|
class DocDir(DocNode): |
|
|
|
|
|
def __init__(self, attrs, URL, locator): |
|
|
DocNode.__init__(self, attrs, URL, locator) |
|
|
if not attrs.has_key("name"): |
|
|
raise self.makeParsingError("dir tag missing 'name' attribute") |
|
|
self.dirName = attrs["name"] |
|
|
|
|
|
def __str__(self): |
|
|
return DocNode.__str__(self) + ":<web:dir name=%s>" \ |
|
|
% xml.sax.saxutils.quoteattr(self.dirName) |
|
|
|
|
|
def getPublishDirName(self): |
|
|
return self.parent.getPublishDirName() + self.dirName + os.sep |
|
|
|
|
|
def publish(self, generator, pageNode = None): |
|
|
generator.changeDir(self.dirName) |
|
|
DocNode.publish(self, generator, pageNode) |
|
|
generator.parentDir() |
|
|
|
|
|
publish = makeGuard(publish) |
|
|
|
|
|
|
|
|
class DocGroup(DocNode): |
|
|
|
|
|
def __init__(self, attrs, URL, locator): |
|
|
DocNode.__init__(self, attrs, URL, locator) |
|
|
|
|
|
def __str__(self): |
|
|
return DocNode.__str__(self) + ":<web:group>" |
|
|
|
|
|
|
|
|
class DocCDATAText(DocBareNode): |
|
|
|
|
|
def __init__(self, text): |
|
|
DocBareNode.__init__(self) |
|
|
self.text = text |
|
|
|
|
|
def __str__(self): |
|
|
return DocNode.__str__(self) + ":CDATA text:" + self.text |
|
|
|
|
|
def publish(self, gen, pageNode = None): |
|
|
if pageNode is None: return |
|
|
if not pageNode: return |
|
|
gen.putString(self.text) |
|
|
|
|
|
publish = makeBareGuard(publish) |
|
|
|
|
|
|
|
|
class DocCDATA(DocNode): |
|
|
|
|
|
def __init__(self): |
|
|
DocNode.__init__(self, {}, None, None) |
|
|
|
|
|
def __str__(self): |
|
|
return DocNode.__str__(self) + ":CDATA" |
|
|
|
|
|
def publish(self, gen, pageNode = None): |
|
|
if pageNode is None: return |
|
|
gen.putString("<![CDATA[") |
|
|
DocNode.publish(self, gen, pageNode) |
|
|
gen.putString("]]>") ; |
|
|
|
|
|
publish = makeGuard(publish) |
|
|
|
|
|
|
|
|
class DocHtmlText(DocBareNode): |
|
|
|
|
|
def __init__(self, text): |
|
|
DocBareNode.__init__(self) |
|
|
self.text = text |
|
|
|
|
|
def __str__(self): |
|
|
return DocNode.__str__(self) + ":text:'" + \ |
|
|
self.text.encode('utf-8').encode('string_escape') + "'" |
|
|
|
|
|
def publish(self, gen, pageNode = None): |
|
|
if pageNode is None: return |
|
|
|
|
|
|
|
|
next = 0 |
|
|
for m in re.finditer("%\w+;", self.text): |
|
|
if next < m.start(): |
|
|
gen.putXMLString(self.text[next : m.start()]) |
|
|
next = m.end() |
|
|
directive = self.text[m.start()+1 : m.end()-1] |
|
|
|
|
|
if directive == "content": |
|
|
pageNode.publish(gen, pageNode) |
|
|
|
|
|
elif directive == "pagestyle": |
|
|
for s in pageNode.findChildren(DocPageStyle): |
|
|
s.publish(gen, pageNode) |
|
|
|
|
|
elif directive == "pagescript": |
|
|
for s in pageNode.findChildren(DocPageScript): |
|
|
s.publish(gen, pageNode) |
|
|
|
|
|
elif directive == "pagetitle": |
|
|
gen.putString(pageNode.title) |
|
|
|
|
|
elif directive == "path": |
|
|
ancPages = [x for x in walkAncestors(pageNode, DocPage)] |
|
|
ancPages.reverse() |
|
|
gen.putString(" - ".join([x.title for x in ancPages])) |
|
|
|
|
|
elif directive == "navigation": |
|
|
gen.putString("<ul>\n") |
|
|
openNodeStack = [x for x in walkAncestors(pageNode, DocPage)] |
|
|
siteNode = walkAncestors(pageNode, DocSite).next() |
|
|
siteNode.publishIndex(gen, pageNode, openNodeStack) |
|
|
gen.putString("</ul>\n") |
|
|
|
|
|
else: |
|
|
print "warning: ignoring directive " + label |
|
|
if next < len(self.text): |
|
|
gen.putXMLString(self.text[next:]) |
|
|
|
|
|
publish = makeBareGuard(publish) |
|
|
|
|
|
|
|
|
class DocHtmlElement(DocNode): |
|
|
|
|
|
def __init__(self, tag, attrs, URL = None, locator = None): |
|
|
DocNode.__init__(self, attrs, URL, locator) |
|
|
self.tag = tag |
|
|
|
|
|
def __str__(self): |
|
|
str = "<html:" + self.tag |
|
|
for k, v in self.attrs.items(): |
|
|
str = str + " " + k + "='" + xml.sax.saxutils.escape(v) + "'" |
|
|
str = str + ">" |
|
|
return DocNode.__str__(self) + ":" + str |
|
|
|
|
|
def getPublishURL(self): |
|
|
anc = self.findAncestors(DocPage) |
|
|
if len(anc) == 0: return None |
|
|
return anc[0].getPublishURL() + "#" + self.id |
|
|
|
|
|
def publish(self, gen, pageNode = None): |
|
|
if pageNode is None: return |
|
|
gen.putString("<") |
|
|
gen.putString(self.tag) |
|
|
for name, value in self.attrs.items(): |
|
|
gen.putString(" ") |
|
|
gen.putString(name) |
|
|
gen.putString("=") |
|
|
gen.putXMLAttr(expandAttr(value, pageNode)) |
|
|
gen.putString(">") |
|
|
DocNode.publish(self, gen, pageNode) |
|
|
gen.putString("</") |
|
|
gen.putString(self.tag) |
|
|
gen.putString(">") |
|
|
|
|
|
publish = makeGuard(publish) |
|
|
|
|
|
|
|
|
class DocTemplate(DocNode): |
|
|
|
|
|
def __init__(self, attrs, URL, locator): |
|
|
DocNode.__init__(self, attrs, URL, locator) |
|
|
|
|
|
def publish(self, generator, pageNode = None): |
|
|
if pageNode is None: return |
|
|
DocNode.publish(self, generator, pageNode) |
|
|
|
|
|
publish = makeGuard(publish) |
|
|
|
|
|
|
|
|
class DocPageStyle(DocNode): |
|
|
|
|
|
def __init__(self, attrs, URL, locator): |
|
|
DocNode.__init__(self, attrs, URL, locator) |
|
|
|
|
|
def publish(self, gen, pageNode = None): |
|
|
if pageNode is None: return |
|
|
sa = self.getAttributes() |
|
|
gen.putString("<style rel=\"stylesheet\" type=") |
|
|
if sa.has_key("type"): |
|
|
gen.putXMLAttr(expandAttr(sa["type"], pageNode)) |
|
|
else: |
|
|
gen.putString("\"text/css\" ") |
|
|
if sa.has_key("href"): |
|
|
gen.putString("href=") |
|
|
gen.putXMLAttr(expandAttr(sa["href"], pageNode)) |
|
|
gen.putString(">") |
|
|
DocNode.publish(self, gen, pageNode) |
|
|
gen.putString("</style>") |
|
|
|
|
|
publish = makeGuard(publish) |
|
|
|
|
|
|
|
|
class DocPageScript(DocNode): |
|
|
|
|
|
def __init__(self, attrs, URL, locator): |
|
|
DocNode.__init__(self, attrs, URL, locator) |
|
|
|
|
|
def publish(self, gen, pageNode = None): |
|
|
if pageNode is None: return |
|
|
sa = self.getAttributes() |
|
|
gen.putString("<script type=") |
|
|
if sa.has_key("type"): |
|
|
gen.putXMLAttr(expandAttr(sa["type"], pageNode)) |
|
|
else: |
|
|
gen.putString("\"text/javascript\" ") |
|
|
if sa.has_key("src"): |
|
|
gen.putString("src=") |
|
|
gen.putXMLAttr(expandAttr(sa["src"], pageNode)) |
|
|
gen.putString(">") |
|
|
DocNode.publish(self, gen, pageNode) |
|
|
gen.putString("</script>") |
|
|
|
|
|
publish = makeGuard(publish) |
|
|
|
|
|
|
|
|
class DocPage(DocNode): |
|
|
|
|
|
counter = 0 |
|
|
|
|
|
def __init__(self, attrs, URL, locator): |
|
|
DocNode.__init__(self, attrs, URL, locator) |
|
|
DocPage.counter = 1 + DocPage.counter |
|
|
self.templateID = "template.default" |
|
|
self.name = "page%d" % DocPage.counter |
|
|
self.title = "untitled" |
|
|
self.hide = False |
|
|
|
|
|
for k, v in self.attrs.items(): |
|
|
if k == 'src': |
|
|
self.title = v |
|
|
elif k == 'name': |
|
|
self.name = v |
|
|
elif k == 'id': |
|
|
pass |
|
|
elif k == 'title': |
|
|
self.title = v |
|
|
elif k == 'hide': |
|
|
self.hide = (v.lower() == 'yes') |
|
|
else: |
|
|
raise self.makeParsingError( |
|
|
"web:page cannot have '%s' attribute" % k) |
|
|
|
|
|
def __str__(self): |
|
|
return DocNode.__str__(self) + ":<web:page name='%s' title='%s'>" \ |
|
|
% (xml.sax.saxutils.escape(self.name), |
|
|
xml.sax.saxutils.escape(self.title)) |
|
|
|
|
|
def getPublishFileName(self): |
|
|
return self.name + ".html" |
|
|
|
|
|
def getPublishURL(self): |
|
|
siteNode = self.findAncestors(DocSite)[0] |
|
|
return siteNode.getPublishURL() + \ |
|
|
self.getPublishDirName() + \ |
|
|
self.getPublishFileName() |
|
|
|
|
|
def publish(self, generator, pageNode = None): |
|
|
if not pageNode: |
|
|
generator.open(self.getPublishFileName()) |
|
|
templateNode = nodeIndex[self.templateID] |
|
|
templateNode.publish(generator, self) |
|
|
generator.close() |
|
|
DocNode.publish(self, generator, None) |
|
|
elif pageNode is self: |
|
|
DocNode.publish(self, generator, pageNode) |
|
|
|
|
|
def publishIndex(self, gen, pageNode, openNodeStack): |
|
|
if self.hide: return |
|
|
gen.putString("<li><a href=") |
|
|
gen.putXMLAttr( |
|
|
expandAttr("%%pathto:%s;" % self.getID(), pageNode)) |
|
|
if len(openNodeStack) == 1 and self == openNodeStack[0]: |
|
|
gen.putString(" class='active' ") |
|
|
gen.putString(">") |
|
|
gen.putXMLString(self.title) |
|
|
gen.putString("</a>\n") |
|
|
pos = gen.tell() |
|
|
gen.putString("<ul>\n") |
|
|
hasIndexedChildren = False |
|
|
if len(openNodeStack) > 0 and self == openNodeStack[-1]: |
|
|
openNodeStack.pop() |
|
|
hasIndexedChildren = DocNode.publishIndex(self, gen, pageNode, openNodeStack) |
|
|
if hasIndexedChildren: |
|
|
gen.putString("</ul>") |
|
|
else: |
|
|
gen.seek(pos) |
|
|
gen.putString("</li>\n") |
|
|
return True |
|
|
|
|
|
publish = makeGuard(publish) |
|
|
|
|
|
|
|
|
class DocSite(DocNode): |
|
|
|
|
|
def __init__(self, attrs, URL, locator): |
|
|
DocNode.__init__(self, attrs, URL, locator) |
|
|
self.siteURL = "http://www.foo.org/" |
|
|
self.outDir = "html" |
|
|
|
|
|
def __str__(self): |
|
|
return DocNode.__str__(self) + ":<web:site>" |
|
|
|
|
|
def getPublishURL(self): |
|
|
return self.siteURL |
|
|
|
|
|
def getPublishDirName(self): |
|
|
return "" |
|
|
|
|
|
def getOutDir(self): |
|
|
return self.outDir |
|
|
|
|
|
def setOutDir(self, outDir): |
|
|
self.outDir = outDir |
|
|
|
|
|
def publish(self): |
|
|
generator = Generator(self.outDir) |
|
|
DocNode.publish(self, generator) |
|
|
|
|
|
publish = makeGuard(publish) |
|
|
|
|
|
|
|
|
class DocHandler(ContentHandler): |
|
|
|
|
|
|
|
|
def __init__(self): |
|
|
ContentHandler.__init__(self) |
|
|
self.rootNode = None |
|
|
self.stack = [] |
|
|
self.locatorStack = [] |
|
|
self.filePathStack = [] |
|
|
self.verbosity = 1 |
|
|
self.inDTD = False |
|
|
|
|
|
def resolveEntity(self, publicid, systemid): |
|
|
""" |
|
|
Resolve XML entities by mapping to a local copy of the (X)HTML |
|
|
DTDs. |
|
|
""" |
|
|
return open(os.path.join( |
|
|
os.path.dirname(__file__), |
|
|
'dtd/xhtml1', |
|
|
systemid[systemid.rfind('/')+1:]), "rb") |
|
|
|
|
|
def lookupFile(self, filePath): |
|
|
if os.path.exists(filePath): |
|
|
return filePath |
|
|
if filePath[0] == '/': |
|
|
return None |
|
|
for path in self.filePathStack: |
|
|
dir = os.path.dirname(path) |
|
|
qualFilePath = os.path.join(dir, filePath) |
|
|
if os.path.exists(qualFilePath): |
|
|
return qualFilePath |
|
|
return None |
|
|
|
|
|
def startElement(self, name, attrs): |
|
|
|
|
|
attrs_ = {} |
|
|
for k, v in attrs.items(): |
|
|
attrs_[k] = v |
|
|
attrs = attrs_ |
|
|
|
|
|
URL = self.getCurrentFileName() |
|
|
locator = self.getCurrentLocator() |
|
|
|
|
|
|
|
|
if name == "include": |
|
|
if not attrs.has_key("src"): |
|
|
raise DocParsingError( |
|
|
URL, |
|
|
locator.getLineNumber(), |
|
|
locator.getColumnNumber(), |
|
|
"<web:include> missing 'src' attribute") |
|
|
filePath = attrs["src"] |
|
|
qualFilePath = self.lookupFile(filePath) |
|
|
if qualFilePath is None: |
|
|
raise DocParsingError( |
|
|
URL, |
|
|
locator.getLineNumber(), |
|
|
locator.getColumnNumber(), |
|
|
"<web:include> could not find file '%s'" % filePath) |
|
|
if self.verbosity > 0: |
|
|
print "parsing '%s'" % qualFilePath |
|
|
self.load(qualFilePath) |
|
|
return |
|
|
|
|
|
if len(self.stack) == 0: |
|
|
parent = None |
|
|
else: |
|
|
parent = self.stack[-1] |
|
|
node = None |
|
|
|
|
|
if name == "site": |
|
|
node = DocSite(attrs, URL, locator) |
|
|
elif name == "page": |
|
|
node = DocPage(attrs, URL, locator) |
|
|
elif name == "dir": |
|
|
node = DocDir(attrs, URL, locator) |
|
|
elif name == "template": |
|
|
node = DocTemplate(attrs, URL, locator) |
|
|
elif name == "pagestyle": |
|
|
node = DocPageStyle(attrs, URL, locator) |
|
|
elif name == "pagescript": |
|
|
node = DocPageScript(attrs, URL, locator) |
|
|
elif name == "group": |
|
|
node = DocGroup(attrs, URL, locator) |
|
|
else: |
|
|
node = DocHtmlElement(name, attrs, URL, locator) |
|
|
|
|
|
if parent: parent.adopt(node) |
|
|
self.stack.append(node) |
|
|
|
|
|
def endElement(self, name): |
|
|
if name == "include": |
|
|
return |
|
|
node = self.stack.pop() |
|
|
if len(self.stack) == 0: |
|
|
self.rootNode = node |
|
|
|
|
|
def load(self, qualFilePath): |
|
|
self.filePathStack.append(qualFilePath) |
|
|
parser = xml.sax.make_parser() |
|
|
parser.setContentHandler(self) |
|
|
parser.setEntityResolver(self) |
|
|
parser.setProperty(xml.sax.handler.property_lexical_handler, self) |
|
|
parser.parse(qualFilePath) |
|
|
|
|
|
def setDocumentLocator(self, locator): |
|
|
self.locatorStack.append(locator) |
|
|
|
|
|
def getCurrentLocator(self): |
|
|
if len(self.locatorStack) > 0: |
|
|
return self.locatorStack[-1] |
|
|
else: |
|
|
return None |
|
|
|
|
|
def characters(self, content): |
|
|
parent = self.stack[-1] |
|
|
if parent.isA(DocCDATA): |
|
|
node = DocCDATAText(content) |
|
|
else: |
|
|
node = DocHtmlText(content) |
|
|
parent.adopt(node) |
|
|
|
|
|
def ignorableWhitespace(self, ws): |
|
|
self.characters(ws) |
|
|
|
|
|
def getCurrentFileName(self): |
|
|
return self.filePathStack[-1] |
|
|
|
|
|
def endDocument(self): |
|
|
self.locatorStack.pop() |
|
|
self.filePathStack.pop() |
|
|
|
|
|
def startCDATA(self): |
|
|
node = DocCDATA() |
|
|
self.stack[-1].adopt(node) |
|
|
self.stack.append(node) |
|
|
|
|
|
def endCDATA(self): |
|
|
node = self.stack.pop() |
|
|
if len(self.stack) == 0: |
|
|
self.rootNode = node |
|
|
|
|
|
def comment(self, body): |
|
|
if self.inDTD: return |
|
|
node = DocCDATAText("<!--" + body + "-->") |
|
|
self.stack[-1].adopt(node) |
|
|
|
|
|
def startEntity(self, name): pass |
|
|
def endEntity(self, name): pass |
|
|
|
|
|
def startDTD(self, name, public_id, system_id): |
|
|
self.inDTD = True |
|
|
|
|
|
def endDTD(self): |
|
|
self.inDTD = False |
|
|
|
|
|
|
|
|
if __name__ == '__main__': |
|
|
|
|
|
(opts, args) = parser.parse_args() |
|
|
|
|
|
filePath = args[0] |
|
|
handler = DocHandler() |
|
|
try: |
|
|
handler.load(filePath) |
|
|
except (DocParsingError, xml.sax.SAXParseException), (e): |
|
|
print e |
|
|
sys.exit(-1) |
|
|
|
|
|
|
|
|
handler.rootNode.setOutDir(opts.outdir) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
print "== All pages ==" |
|
|
for x in walkNodes(handler.rootNode, DocPage): |
|
|
print x |
|
|
|
|
|
print "== Publish ==" |
|
|
try: |
|
|
handler.rootNode.publish() |
|
|
except (DocParsingError, xml.sax.SAXParseException), (e): |
|
|
print e |
|
|
sys.exit(-1) |
|
|
sys.exit(0) |
|
|
|
