Merge branch 'master' into python2

Conflicts:
	wrw/proto.py

diff --combined wrw/proto.py
index a67fa19,0e3c798..36a9db9
--- 1/wrw/proto.py
--- 2/wrw/proto.py
+++ b/wrw/proto.py
@@@ -98,19 -98,20 +98,19 @@@ def simpleerror(env, startreq, code, ti
  </body>
  </html>
  """ % (title, title, htmlq(msg))
 -    buf = buf.encode("us-ascii")
      startreq("%i %s" % (code, title), [("Content-Type", "text/html"), ("Content-Length", str(len(buf)))])
      return [buf]
  
  def urlq(url):
 -    if isinstance(url, str):
 +    if isinstance(url, unicode):
          url = url.encode("utf-8")
      ret = ""
-     invalid = ";&=#?/\"'"
 -    invalid = b"%;&=#?/\"'"
++    invalid = "%;&=#?/\"'"
      for c in url:
 -        if c in invalid or (c <= 32) or (c >= 128):
 -            ret += "%%%02X" % c
 +        if c in invalid or (ord(c) <= 32) or (ord(c) >= 128):
 +            ret += "%%%02X" % ord(c)
          else:
 -            ret += chr(c)
 +            ret += c
      return ret
  
  class urlerror(ValueError):
@@@ -197,19 -198,34 +197,19 @@@ def parurl(url, pars={}, **augment)
  
  # Wrap these, since binascii is a bit funky. :P
  def enhex(bs):
 -    return base64.b16encode(bs).decode("us-ascii")
 +    return base64.b16encode(bs)
  def unhex(es):
 -    if not isinstance(es, collections.ByteString):
 -        try:
 -            es = es.encode("us-ascii")
 -        except UnicodeError:
 -            raise binascii.Error("non-ascii character in hex-string")
      return base64.b16decode(es)
  def enb32(bs):
 -    return base64.b32encode(bs).decode("us-ascii")
 +    return base64.b32encode(bs)
  def unb32(es):
 -    if not isinstance(es, collections.ByteString):
 -        try:
 -            es = es.encode("us-ascii")
 -        except UnicodeError:
 -            raise binascii.Error("non-ascii character in base32-string")
      if (len(es) % 8) != 0:
          es += b"=" * (8 - (len(es) % 8))
      es = es.upper()             # The whole point of Base32 is that it's case-insensitive :P
      return base64.b32decode(es)
  def enb64(bs):
 -    return base64.b64encode(bs).decode("us-ascii")
 +    return base64.b64encode(bs)
  def unb64(es):
 -    if not isinstance(es, collections.ByteString):
 -        try:
 -            es = es.encode("us-ascii")
 -        except UnicodeError:
 -            raise binascii.Error("non-ascii character in base64-string")
      if (len(es) % 4) != 0:
          es += b"=" * (4 - (len(es) % 4))
      return base64.b64decode(es)

diff --combined wrw/sp/cons.py
index bc9bfa2,d8b30a8..1cc93ea
--- 1/wrw/sp/cons.py
--- 2/wrw/sp/cons.py
+++ b/wrw/sp/cons.py
@@@ -1,21 -1,21 +1,21 @@@
- import sys
+ import sys, collections
  import xml.dom.minidom
  
  class node(object):
      pass
  
 -class text(node, str):
 +class text(node, unicode):
      def __todom__(self, doc):
          return doc.createTextNode(self)
  
 -class raw(node, str):
 +class raw(node, unicode):
      def __todom__(self, doc):
          raise Exception("Cannot convert raw code to DOM objects")
  
  class element(node):
      def __init__(self, ns, name, ctx):
          self.ns = ns
 -        self.name = str(name)
 +        self.name = unicode(name)
          self.ctx = ctx
          self.attrs = {}
          self.children = []
@@@ -23,13 -23,13 +23,13 @@@
      def __call__(self, *children, **attrs):
          for child in children:
              self.ctx.addchild(self, child)
 -        for k, v in attrs.items():
 +        for k, v in attrs.iteritems():
              self.ctx.addattr(self, k, v)
          return self
  
      def __todom__(self, doc):
          el = doc.createElementNS(self.ns, self.name)
 -        for k, v in self.attrs.items():
 +        for k, v in self.attrs.iteritems():
              el.setAttribute(k, v)
          for child in self.children:
              el.appendChild(child.__todom__(doc))
@@@ -44,10 -44,9 +44,10 @@@ class context(object)
  
      def __init__(self):
          self.nodeconv = {}
 -        self.nodeconv[bytes] = lambda ob: text(ob, self.charset)
 -        self.nodeconv[str] = text
 +        self.nodeconv[str] = lambda ob: text(ob, self.charset)
 +        self.nodeconv[unicode] = text
          self.nodeconv[int] = text
 +        self.nodeconv[long] = text
          self.nodeconv[float] = text
  
      def nodefrom(self, ob):
@@@ -57,16 -56,23 +57,23 @@@
              return ob.__tonode__()
          if type(ob) in self.nodeconv:
              return self.nodeconv[type(ob)](ob)
-         raise Exception("No node conversion known for %s objects" % str(type(ob)))
+         return None
  
      def addchild(self, node, child):
          if child is None:
              return
-         node.children.append(self.nodefrom(child))
+         new = self.nodefrom(child)
+         if new is not None:
+             node.children.append(new)
+         elif isinstance(child, collections.Iterable):
+             for ch in child:
+                 self.addchild(node, ch)
+         else:
+             raise Exception("No node conversion known for %s objects" % str(type(child)))
  
      def addattr(self, node, k, v):
          if v is not None:
 -            node.attrs[str(k)] = str(v)
 +            node.attrs[unicode(k)] = unicode(v)
  
  class constructor(object):
      def __init__(self, ns, elcls=element, ctx=None):