gis: Merged revisions 4669-4785 via svnmerge from trunk.

git-svn-id: http://code.djangoproject.com/svn/django/branches/gis@4786 bcc190cf-cafb-0310-a4f2-bffc1f526a37

7 files changed, 107 insertions, 41 deletions

diff --git a/django/core/management.py b/django/core/management.py
index a78c9f91d4..485165613c 100644
--- a/django/core/management.py
+++ b/django/core/management.py
@@ -280,7 +280,7 @@ def get_sql_delete(app):
     from django.db import backend, connection, models, get_introspection_module
     introspection = get_introspection_module()
 
-    # This should work even if a connecton isn't available
+    # This should work even if a connection isn't available
     try:
         cursor = connection.cursor()
     except:
@@ -516,6 +516,7 @@ def syncdb(verbosity=1, interactive=True):
     created_models = set()
     pending_references = {}
 
+    # Create the tables for each model
     for app in models.get_apps():
         app_name = app.__name__.split('.')[-2]
         model_list = models.get_models(app)
@@ -537,6 +538,11 @@ def syncdb(verbosity=1, interactive=True):
                 cursor.execute(statement)
             table_list.append(model._meta.db_table)
 
+    # Create the m2m tables. This must be done after all tables have been created
+    # to ensure that all referred tables will exist.
+    for app in models.get_apps():
+        app_name = app.__name__.split('.')[-2]
+        model_list = models.get_models(app)
         for model in model_list:
             if model in created_models:
                 sql = _get_many_to_many_sql_for_model(model)
@@ -546,7 +552,7 @@ def syncdb(verbosity=1, interactive=True):
                     for statement in sql:
                         cursor.execute(statement)
 
-        transaction.commit_unless_managed()
+    transaction.commit_unless_managed()
 
     # Send the post_syncdb signal, so individual apps can do whatever they need
     # to do at this point.
@@ -1358,13 +1364,14 @@ def load_data(fixture_labels, verbosity=1):
         for fixture_dir in app_fixtures + list(settings.FIXTURE_DIRS) + ['']:
             if verbosity > 1:
                 print "Checking %s for fixtures..." % humanize(fixture_dir)
-            try:
-                fixture_name, format = fixture_label.rsplit('.', 1)
-                formats = [format]
-            except ValueError:
+            parts = fixture_label.split('.')
+            if len(parts) == 1:
                 fixture_name = fixture_label
                 formats = serializers.get_serializer_formats()
-            
+            else:
+                fixture_name, format = '.'.join(parts[:-1]), parts[-1]
+                formats = [format]
+
             label_found = False
             for format in formats:
                 serializer = serializers.get_serializer(format)
@@ -1439,7 +1446,7 @@ def dump_data(app_labels, format='json', indent=None):
         for model in get_models(app):
             objects.extend(model.objects.all())
     try:
-        print serializers.serialize(format, objects, indent=indent)
+        return serializers.serialize(format, objects, indent=indent)
     except Exception, e:
         sys.stderr.write(style.ERROR("Unable to serialize database: %s\n" % e))
 dump_data.help_doc = 'Output the contents of the database as a fixture of the given format'
@@ -1585,7 +1592,7 @@ def execute_from_command_line(action_mapping=DEFAULT_ACTION_MAPPING, argv=None):
             parser.print_usage_and_exit()
     elif action == 'dumpdata':
         try:
-            action_mapping[action](args[1:], options.format, options.indent)
+            print action_mapping[action](args[1:], options.format, options.indent)
         except IndexError:
             parser.print_usage_and_exit()
     elif action in ('startapp', 'startproject'):
diff --git a/django/core/serializers/__init__.py b/django/core/serializers/__init__.py
index f20258c416..494393f3cf 100644
--- a/django/core/serializers/__init__.py
+++ b/django/core/serializers/__init__.py
@@ -25,6 +25,13 @@ BUILTIN_SERIALIZERS = {
     "json"   : "django.core.serializers.json",
 }
 
+# Check for PyYaml and register the serializer if it's available.
+try:
+    import yaml
+    BUILTIN_SERIALIZERS["yaml"] = "django.core.serializers.pyyaml"
+except ImportError:
+    pass    
+
 _serializers = {}
         
 def register_serializer(format, serializer_module):
diff --git a/django/core/serializers/base.py b/django/core/serializers/base.py
index 0ec05d1cf3..8e610ad240 100644
--- a/django/core/serializers/base.py
+++ b/django/core/serializers/base.py
@@ -34,17 +34,17 @@ class Serializer(object):
         for obj in queryset:
             self.start_object(obj)
             for field in obj._meta.fields:
-                if field is obj._meta.pk:
-                    continue
-                elif field.rel is None:
-                    if self.selected_fields is None or field.attname in self.selected_fields:
-                        self.handle_field(obj, field)
-                else:
-                    if self.selected_fields is None or field.attname[:-3] in self.selected_fields:
-                        self.handle_fk_field(obj, field)
+                if field.serialize:
+                    if field.rel is None:
+                        if self.selected_fields is None or field.attname in self.selected_fields:
+                            self.handle_field(obj, field)
+                    else:
+                        if self.selected_fields is None or field.attname[:-3] in self.selected_fields:
+                            self.handle_fk_field(obj, field)
             for field in obj._meta.many_to_many:
-                if self.selected_fields is None or field.attname in self.selected_fields:
-                    self.handle_m2m_field(obj, field)
+                if field.serialize:
+                    if self.selected_fields is None or field.attname in self.selected_fields:
+                        self.handle_m2m_field(obj, field)
             self.end_object(obj)
         self.end_serialization()
         return self.getvalue()
@@ -54,11 +54,7 @@ class Serializer(object):
         Convert a field's value to a string.
         """
         if isinstance(field, models.DateTimeField):
-            value = getattr(obj, field.name)
-            if value is None:
-                value = ''
-            else:
-                value = value.strftime("%Y-%m-%d %H:%M:%S")
+            value = getattr(obj, field.name).strftime("%Y-%m-%d %H:%M:%S")
         elif isinstance(field, models.FileField):
             value = getattr(obj, "get_%s_url" % field.name, lambda: None)()
         else:
diff --git a/django/core/serializers/python.py b/django/core/serializers/python.py
index a9baa01d5a..29ce6bf9bd 100644
--- a/django/core/serializers/python.py
+++ b/django/core/serializers/python.py
@@ -57,7 +57,7 @@ def Deserializer(object_list, **options):
     for d in object_list:
         # Look up the model and starting build a dict of data for it.
         Model = _get_model(d["model"])
-        data = {Model._meta.pk.attname : d["pk"]}
+        data = {Model._meta.pk.attname : Model._meta.pk.to_python(d["pk"])}
         m2m_data = {}
         
         # Handle each field
@@ -70,16 +70,17 @@ def Deserializer(object_list, **options):
             # Handle M2M relations
             if field.rel and isinstance(field.rel, models.ManyToManyRel):
                 pks = []
+                m2m_convert = field.rel.to._meta.pk.to_python
                 for pk in field_value:
                     if isinstance(pk, unicode):
-                        pks.append(pk.encode(options.get("encoding", settings.DEFAULT_CHARSET)))
+                        pks.append(m2m_convert(pk.encode(options.get("encoding", settings.DEFAULT_CHARSET))))
                     else:
-                        pks.append(pk)
+                        pks.append(m2m_convert(pk))
                 m2m_data[field.name] = pks
                 
             # Handle FK fields
             elif field.rel and isinstance(field.rel, models.ManyToOneRel):
-                data[field.attname] = field_value
+                data[field.attname] = field.rel.to._meta.pk.to_python(field_value)
                     
             # Handle all other fields
             else:
diff --git a/django/core/serializers/pyyaml.py b/django/core/serializers/pyyaml.py
new file mode 100644
index 0000000000..fa3dec984e
--- /dev/null
+++ b/django/core/serializers/pyyaml.py
@@ -0,0 +1,36 @@
+"""
+YAML serializer.
+
+Requires PyYaml (http://pyyaml.org/), but that's checked for in __init__.
+"""
+
+import datetime
+from django.core.serializers.python import Serializer as PythonSerializer
+from django.core.serializers.python import Deserializer as PythonDeserializer
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from StringIO import StringIO
+import yaml
+
+class Serializer(PythonSerializer):
+    """
+    Convert a queryset to YAML.
+    """
+    def end_serialization(self):
+        yaml.dump(self.objects, self.stream, **self.options)
+        
+    def getvalue(self):
+        return self.stream.getvalue()
+
+def Deserializer(stream_or_string, **options):
+    """
+    Deserialize a stream or string of YAML data.
+    """
+    if isinstance(stream_or_string, basestring):
+        stream = StringIO(stream_or_string)
+    else:
+        stream = stream_or_string
+    for obj in PythonDeserializer(yaml.load(stream)):
+        yield obj
+        
diff --git a/django/core/serializers/xml_serializer.py b/django/core/serializers/xml_serializer.py
index 8fa7bbfac9..3a0fdb5395 100644
--- a/django/core/serializers/xml_serializer.py
+++ b/django/core/serializers/xml_serializer.py
@@ -13,6 +13,10 @@ class Serializer(base.Serializer):
     Serializes a QuerySet to XML.
     """
     
+    def indent(self, level):
+        if self.options.get('indent', None) is not None:
+            self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent', None) * level)
+
     def start_serialization(self):
         """
         Start serialization -- open the XML document and the root element.
@@ -25,6 +29,7 @@ class Serializer(base.Serializer):
         """
         End serialization -- end the document.
         """
+        self.indent(0)
         self.xml.endElement("django-objects")
         self.xml.endDocument()
         
@@ -35,6 +40,7 @@ class Serializer(base.Serializer):
         if not hasattr(obj, "_meta"):
             raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))
             
+        self.indent(1)
         self.xml.startElement("object", {
             "pk"    : str(obj._get_pk_val()),
             "model" : str(obj._meta),
@@ -44,6 +50,7 @@ class Serializer(base.Serializer):
         """
         Called after handling all fields for an object.
         """
+        self.indent(1)
         self.xml.endElement("object")
         
     def handle_field(self, obj, field):
@@ -51,16 +58,19 @@ class Serializer(base.Serializer):
         Called to handle each field on an object (except for ForeignKeys and
         ManyToManyFields)
         """
+        self.indent(2)
         self.xml.startElement("field", {
             "name" : field.name,
             "type" : field.get_internal_type()
         })
         
         # Get a "string version" of the object's data (this is handled by the
-        # serializer base class).  None is handled specially.
-        value = self.get_string_value(obj, field)
-        if value is not None:
+        # serializer base class). 
+        if getattr(obj, field.name) is not None:
+            value = self.get_string_value(obj, field)
             self.xml.characters(str(value))
+        else:
+            self.xml.addQuickElement("None")
 
         self.xml.endElement("field")
         
@@ -92,6 +102,7 @@ class Serializer(base.Serializer):
         """
         Helper to output the <field> element for relational fields
         """
+        self.indent(2)
         self.xml.startElement("field", {
             "name" : field.name,
             "rel"  : field.rel.__class__.__name__,
@@ -127,7 +138,8 @@ class Deserializer(base.Deserializer):
         pk = node.getAttribute("pk")
         if not pk:
             raise base.DeserializationError("<object> node is missing the 'pk' attribute")
-        data = {Model._meta.pk.name : pk}
+
+        data = {Model._meta.pk.attname : Model._meta.pk.to_python(pk)}
         
         # Also start building a dict of m2m data (this is saved as
         # {m2m_accessor_attribute : [list_of_related_objects]})
@@ -148,17 +160,20 @@ class Deserializer(base.Deserializer):
             
             # As is usually the case, relation fields get the special treatment.
             if field.rel and isinstance(field.rel, models.ManyToManyRel):
-                m2m_data[field.name] = self._handle_m2m_field_node(field_node)
+                m2m_data[field.name] = self._handle_m2m_field_node(field_node, field)
             elif field.rel and isinstance(field.rel, models.ManyToOneRel):
-                data[field.attname] = self._handle_fk_field_node(field_node)
+                data[field.attname] = self._handle_fk_field_node(field_node, field)
             else:
-                value = field.to_python(getInnerText(field_node).strip().encode(self.encoding))
+                if len(field_node.childNodes) == 1 and field_node.childNodes[0].nodeName == 'None':
+                    value = None
+                else:
+                    value = field.to_python(getInnerText(field_node).strip().encode(self.encoding))
                 data[field.name] = value
         
         # Return a DeserializedObject so that the m2m data has a place to live.
         return base.DeserializedObject(Model(**data), m2m_data)
         
-    def _handle_fk_field_node(self, node):
+    def _handle_fk_field_node(self, node, field):
         """
         Handle a <field> node for a ForeignKey
         """
@@ -166,13 +181,16 @@ class Deserializer(base.Deserializer):
         if len(node.childNodes) == 1 and node.childNodes[0].nodeName == 'None':
             return None
         else:
-            return getInnerText(node).strip().encode(self.encoding)
+            return field.rel.to._meta.pk.to_python(
+                       getInnerText(node).strip().encode(self.encoding))
         
-    def _handle_m2m_field_node(self, node):
+    def _handle_m2m_field_node(self, node, field):
         """
         Handle a <field> node for a ManyToManyField
         """
-        return [c.getAttribute("pk").encode(self.encoding) for c in node.getElementsByTagName("object")]
+        return [field.rel.to._meta.pk.to_python(
+                    c.getAttribute("pk").encode(self.encoding)) 
+                    for c in node.getElementsByTagName("object")]
     
     def _get_model_from_node(self, node, attr):
         """
diff --git a/django/core/validators.py b/django/core/validators.py
index ebfbd3961e..bd7d790e04 100644
--- a/django/core/validators.py
+++ b/django/core/validators.py
@@ -140,7 +140,8 @@ def _isValidDate(date_string):
     try:
         date(year, month, day)
     except ValueError, e:
-        raise ValidationError, gettext('Invalid date: %s.' % e)    
+        msg = gettext('Invalid date: %s') % gettext(str(e))
+        raise ValidationError, msg    
 
 def isValidANSIDate(field_data, all_data):
     if not ansi_date_re.search(field_data):
@@ -363,7 +364,7 @@ class NumberIsInRange(object):
         self.lower, self.upper = lower, upper
         if not error_message:
             if lower and upper:
-                self.error_message = gettext("This value must be between %s and %s.") % (lower, upper)
+                 self.error_message = gettext("This value must be between %(lower)s and %(upper)s.") % {'lower': lower, 'upper': upper}
             elif lower:
                 self.error_message = gettext("This value must be at least %s.") % lower
             elif upper: