Refactor code so that a namespace lookup object is passed to all methods that need to qualify XML tags / attributes.

This change allows valid serialization of objects in isolation of the main framework in a manner that will produce fully valid XML.

Author: Jamie Kirkpatrick

TODO.txt

@@ -0,0 +1,7 @@
+Code to sort out after namespace map addition:
+
+Message.to_xml()
+ClassSerializerMeta.namespace
+
+create_xml_element - pass nsmap
+_add_messages_for_methods / _add_bindings_for_methods : create_xml_element (no nsmap)

soaplib/serializers/binary.py

@@ -1,6 +1,6 @@
 import base64
 import cStringIO
-from soaplib.xml import *
+from soaplib.xml import ns, create_xml_element
 
 class Attachment(object):
 
@@ -36,7 +36,7 @@ def load_from_file(self):
         f.close()
 
     @classmethod
-    def to_xml(cls,value,name='retval'):
+    def to_xml(cls,value,name='retval',nsmap=ns):
         '''This class method takes the data from the attachment and 
         base64 encodes it as the text of an Element.  An attachment can
         specify a filename and if no data is given, it will read the data 
@@ -45,7 +45,7 @@ def to_xml(cls,value,name='retval'):
         if value.__class__ is not Attachment:
             raise Exception("Do not know how to serialize class %s"%type(value))
 
-        element = create_xml_element(name)
+        element = create_xml_element(name, nsmap)
         if value.data:
             # the data has already been loaded, just encode
             # and return the element
@@ -79,14 +79,18 @@ def from_xml(cls,element):
         return a
 
     @classmethod
-    def get_datatype(cls,withNamespace=False):
+    def get_datatype(cls,nsmap=None):
         '''Returns the datatype base64Binary'''
-        if withNamespace:
-            return 'xs:base64Binary'
+        if nsmap is not None:
+            return nsmap.get(cls.get_namespace_id()) + 'base64Binary'
         return 'base64Binary'
+        
+    @classmethod
+    def get_namespace_id(cls):
+        return 'xs'
 
     @classmethod
-    def add_to_schema(cls,added_params):
+    def add_to_schema(cls,added_params,nsmap):
         ''' 
         Nothing needs to happen here as base64Binary is a standard
         schema element

soaplib/serializers/clazz.py

@@ -1,5 +1,5 @@
 import inspect
-from soaplib.xml import *
+from soaplib.xml import ns, create_xml_element, create_xml_subelement, qualify
 
 from primitive import Null
 
@@ -43,8 +43,9 @@ def __init__(self):
             setattr(self,k,None)
 
     @classmethod
-    def to_xml(cls,value,name='retval'):
-        element = create_xml_element(qualify(name, cls.namespace))
+    def to_xml(cls,value,name='retval', nsmap=ns):
+        element = create_xml_element(
+            nsmap.get(cls.get_namespace_id()) + name, nsmap)
 
         for k,v in cls.soap_members.items():
             member_value = getattr(value,k,None)    
@@ -53,7 +54,7 @@ def to_xml(cls,value,name='retval'):
             if subvalue is None:
                 v = Null
 
-            subelements = v.to_xml(subvalue,name=k)
+            subelements = v.to_xml(subvalue,name=k,nsmap=nsmap)
             if type(subelements) != list:
                 subelements = [subelements]
             for s in subelements:
@@ -79,38 +80,40 @@ def from_xml(cls, element):
         return obj
 
     @classmethod
-    def get_datatype(cls,withNamespace=False):
-        if withNamespace:
-            return 'tns:%s'%(cls.__name__)
+    def get_datatype(cls,nsmap=None):
+        if nsmap is not None:
+            return nsmap.get(cls.get_namespace_id()) + cls.__name__
         return cls.__name__
- 
+        
+    @classmethod
+    def get_namespace_id(cls):
+        return 'tns'
+
     @classmethod
-    def add_to_schema(cls, schemaDict):
+    def add_to_schema(cls, schemaDict, nsmap):
 
-        if not schemaDict.has_key(cls.get_datatype(True)):
+        if not schemaDict.has_key(cls.get_datatype(nsmap)):
             for k,v in cls.soap_members.items():
-                v.add_to_schema(schemaDict)
+                v.add_to_schema(schemaDict, nsmap)
 
-            tag = qualify("complexType", ns["xs"])
-            schema_node = create_xml_element(tag)
+            schema_node = create_xml_element(
+                nsmap.get("xs") + "complexType", nsmap)
             schema_node.set('name',cls.__name__)
 
             sequence_node = create_xml_subelement(
-                schema_node, 
-                qualify('sequence', ns["xs"])
-            )
+                schema_node, nsmap.get('xs') + 'sequence')
             for k,v in cls.soap_members.items():
                 member_node = create_xml_subelement(
-                    sequence_node,
-                    qualify('element', ns["xs"])
-                )
+                    sequence_node, nsmap.get('xs') + 'element')
                 member_node.set('name',k)
                 member_node.set('minOccurs','0')
-                member_node.set('type',v.get_datatype(True))
+                member_node.set('type',
+                    "%s:%s" % (v.get_namespace_id(), v.get_datatype()))
 
-            tag = qualify("element", ns["xs"])
-            typeElement = create_xml_element(tag)
+            typeElement = create_xml_element(
+                nsmap.get('xs') + 'element', nsmap)
             typeElement.set('name',cls.__name__)
-            typeElement.set('type','tns:'+cls.__name__)
-            schemaDict[cls.get_datatype(True)+'Complex'] = schema_node
-            schemaDict[cls.get_datatype(True)] = typeElement
+            typeElement.set('type',
+                "%s:%s" % (cls.get_namespace_id(),cls.__name__))
+            schemaDict[cls.get_datatype(nsmap)+'Complex'] = schema_node
+            schemaDict[cls.get_datatype(nsmap)] = typeElement