Admin/website/build/pypager.py

         handler.endElement(u"td")
         handler.startElement(u"td", {})
         handler.characters(u"%i%sKB" % (size / 1024, unichr(160)))
         handler.endElement(u"td")
 
+    def mirror(self, handler, **args):
+
+        """<?mirror prefix="..." title="..."?> - generates a mirror switch link,
+           where prefix denotes the base root url of the mirror location
+           and title the visible description"""
+
+        prefix = args[u"prefix"]
+        title = args[u"title"]
+        handler.startElement(u"a", {u"href": posixpath.join(prefix, self._pc.relLocOfThis())})
+        handler.characters(title)
+        handler.endElement(u"a")
+
     def getPc(self):
 
         return self._pc
 
 # a notion of paths
 class PathCalculator:
 
     def __init__(self, srcLoc, srcRoot, dstRoot):
 
         self._src = path.normpath(path.abspath(srcLoc))
-        srcPath, srcName = path.split(self._src)
+        srcPath, self._srcName = path.split(self._src)
         self._srcRoot = path.normpath(path.abspath(srcRoot))
         self._dstRoot = path.normpath(path.abspath(dstRoot))
         self._relRoot = ""
         relLocChain = []
         diffRoot = srcPath

         loc = self.absDstPathOf(loc)
         loc = self.stripCommonPrefix(loc, self._dstRoot)
         loc = self.stripCommonPrefix(loc, self._relLoc)
         return loc
 
+    def relLocOfThis(self):
+
+        return posixpath.join(self._relLoc, self._srcName)
+
     def stripCommonPrefix(self, loc, prefix):
 
         common = self.commonPrefix((loc, prefix))
         if common:
             loc = loc[len(common):]

         return common or ""
 
 # the XML transformer
 class TransformerHandler(ContentHandler, EntityResolver):
 
-    def __init__(self, out, encoding, dtd, func):
+    def __init__(self, out, encoding, dtd, func, spamprotect):
 
         ContentHandler.__init__(self)
         #~ EntityResolver.__init__(self)
         self._out = codecs.getwriter(encoding)(out)
         self._ns_contexts = [{}] # contains uri -> prefix dicts
         self._current_context = self._ns_contexts[-1]
         self._undeclared_ns_maps = []
         self._encoding = encoding
         self._lastStart = False
         self._func = func
+        self._spamprotect = spamprotect
         self._characterBuffer = {}
         self._currentXPath = []
         self._title = None
         self._init = False
         self._dtd = dtd

             self._out.write(u'>')
             self._lastStart = False
 
     def flushCharacterBuffer(self):
 
-        self._out.write(escape(u"".join(self._characterBuffer)))
+        self._out.write(escape(u"".join(self._characterBuffer)).replace(u"@", u"@"))
         self._characterBuffer = []
 
     def transformAbsPath(self, attrs, attrname):
 
         pathval = attrs.get(attrname, None)

         self._out.write(u'<' + name)
         # this list is not exhaustive
         for tagname, attrname in ((u"a", u"href"), (u"img", u"src"), (u"link", u"href")):
             if name == tagname:
                 attrs = self.transformAbsPath(attrs, attrname)
-        for (name, value) in attrs.items():
-            self._out.write(u' %s=%s' % (name, quoteattr(value)))
-        self._currentXPath.append(name)
+        if self.spamprotect and name = u"a":
+            value = attrs.get(u"href")
+            if value and value.startswith(u"mailto:"):
+                attrs = dict(attrs)
+                attrs[u"href"] = "".join([ ("&#%i;" % ord(c)) for c in value ])
+        for (key, value) in attrs.items():
+            self._out.write(u' %s=%s' % (key, quoteattr(value)))
+        self._currentXPath.append(key)
         self._lastStart = True
 
     def endElement(self, name):
 
         if name == u"dummy:wrapper":

         type="string", default=".",
         help="local mirror of XHTML DTDs", metavar='location')
     cmdlineparser.add_option("-m", "--encodinghtml",
         action="store", dest="encodinghtml",
         type="string", default="",
-        help="force value of html content encoding meta ", metavar='encoding')
-
+        help="force value of html content encoding meta tag", metavar='encoding')
+    cmdlineparser.add_option("-s", "--spamprotect",
+        action="store_true", dest="spamprotect",
+        help="rewrite mailto-links using entities")
 
     options, args = cmdlineparser.parse_args(sys.argv[1:])
 
     # check source
     if len(args) < 1:

         ostream = open(dst, 'wb')
     else:
         ostream = sys.stdout
 
     # process file
-    transformer = TransformerHandler(ostream, outputEncoding, options.dtd, func)
+    transformer = TransformerHandler(ostream, outputEncoding, options.dtd, func, options.spamprotect)
     parseWithER(istream, transformer)
 
     # close handles
     ostream.close()
     istream.close()