Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Auto-naming for migrations and some writer fixes

  • Loading branch information...
commit 91c470def50c4de420b0c6ee7debddc5bbd53ec8 1 parent cd80961
@andrewgodwin andrewgodwin authored
View
91 django/db/migrations/autodetector.py
@@ -1,3 +1,4 @@
+import re
from django.db.migrations import operations
from django.db.migrations.migration import Migration
@@ -11,7 +12,7 @@ class MigrationAutodetector(object):
Note that this naturally operates on entire projects at a time,
as it's likely that changes interact (for example, you can't
add a ForeignKey without having a migration to add the table it
- depends on first). A user interface may offer single-app detection
+ depends on first). A user interface may offer single-app usage
if it wishes, with the caveat that it may not always be possible.
"""
@@ -21,8 +22,12 @@ def __init__(self, from_state, to_state):
def changes(self):
"""
- Returns a set of migration plans which will achieve the
- change from from_state to to_state.
+ Returns a dict of migration plans which will achieve the
+ change from from_state to to_state. The dict has app labels
+ as kays and a list of migrations as values.
+
+ The resulting migrations aren't specially named, but the names
+ do matter for dependencies inside the set.
"""
# We'll store migrations as lists by app names for now
self.migrations = {}
@@ -53,17 +58,77 @@ def changes(self):
for app_label, migrations in self.migrations.items():
for m1, m2 in zip(migrations, migrations[1:]):
m2.dependencies.append((app_label, m1.name))
- # Flatten and return
- result = set()
- for app_label, migrations in self.migrations.items():
- for migration in migrations:
- subclass = type("Migration", (Migration,), migration)
- instance = subclass(migration['name'], app_label)
- result.add(instance)
- return result
+ return self.migrations
def add_to_migration(self, app_label, operation):
migrations = self.migrations.setdefault(app_label, [])
if not migrations:
- migrations.append({"name": "auto_%i" % (len(migrations) + 1), "operations": [], "dependencies": []})
- migrations[-1]['operations'].append(operation)
+ subclass = type("Migration", (Migration,), {"operations": [], "dependencies": []})
+ instance = subclass("auto_%i" % (len(migrations) + 1), app_label)
+ migrations.append(instance)
+ migrations[-1].operations.append(operation)
+
+ @classmethod
+ def suggest_name(cls, ops):
+ """
+ Given a set of operations, suggests a name for the migration
+ they might represent. Names not guaranteed to be unique; they
+ must be prefixed by a number or date.
+ """
+ if len(ops) == 1:
+ if isinstance(ops[0], operations.CreateModel):
+ return ops[0].name.lower()
+ elif isinstance(ops[0], operations.DeleteModel):
+ return "delete_%s" % ops[0].name.lower()
+ elif all(isinstance(o, operations.CreateModel) for o in ops):
+ return "_".join(sorted(o.name.lower() for o in ops))
+ return "auto"
+
+ @classmethod
+ def parse_number(cls, name):
+ """
+ Given a migration name, tries to extract a number from the
+ beginning of it. If no number found, returns None.
+ """
+ if re.match(r"^\d+_", name):
+ return int(name.split("_")[0])
+ return None
+
+ @classmethod
+ def arrange_for_graph(cls, changes, graph):
+ """
+ Takes in a result from changes() and a MigrationGraph,
+ and fixes the names and dependencies of the changes so they
+ extend the graph from the leaf nodes for each app.
+ """
+ leaves = graph.leaf_nodes()
+ name_map = {}
+ for app_label, migrations in changes.items():
+ if not migrations:
+ continue
+ # Find the app label's current leaf node
+ app_leaf = None
+ for leaf in leaves:
+ if leaf[0] == app_label:
+ app_leaf = leaf
+ break
+ # Work out the next number in the sequence
+ if app_leaf is None:
+ next_number = 1
+ else:
+ next_number = (cls.parse_number(app_leaf[1]) or 0) + 1
+ # Name each migration
+ for i, migration in enumerate(migrations):
+ if i == 0 and app_leaf:
+ migration.dependencies.append(app_leaf)
+ if i == 0 and not app_leaf:
+ new_name = "0001_initial"
+ else:
+ new_name = "%04i_%s" % (next_number, cls.suggest_name(migration.operations))
+ name_map[(app_label, migration.name)] = (app_label, new_name)
+ migration.name = new_name
+ # Now fix dependencies
+ for app_label, migrations in changes.items():
+ for migration in migrations:
+ migration.dependencies = [name_map.get(d, d) for d in migration.dependencies]
+ return changes
View
16 django/db/migrations/graph.py
@@ -120,14 +120,20 @@ def _dfs(start, get_children, path):
def __str__(self):
return "Graph: %s nodes, %s edges" % (len(self.nodes), sum(len(x) for x in self.dependencies.values()))
- def project_state(self, node, at_end=True):
+ def project_state(self, nodes, at_end=True):
"""
- Given a migration node, returns a complete ProjectState for it.
+ Given a migration node or nodes, returns a complete ProjectState for it.
If at_end is False, returns the state before the migration has run.
"""
- plan = self.forwards_plan(node)
- if not at_end:
- plan = plan[:-1]
+ if not isinstance(nodes[0], tuple):
+ nodes = [nodes]
+ plan = []
+ for node in nodes:
+ for migration in self.forwards_plan(node):
+ if migration not in plan:
+ if not at_end and migration in nodes:
+ continue
+ plan.append(migration)
project_state = ProjectState()
for node in plan:
project_state = self.nodes[node].mutate_state(project_state)
View
12 django/db/migrations/writer.py
@@ -1,5 +1,7 @@
+from __future__ import unicode_literals
import datetime
import types
+from django.utils import six
from django.db import models
@@ -36,11 +38,12 @@ def as_string(self):
operation_strings.append("migrations.%s(%s\n )" % (name, "".join("\n %s," % arg for arg in arg_strings)))
items["operations"] = "[%s\n ]" % "".join("\n %s," % s for s in operation_strings)
# Format imports nicely
+ imports.discard("from django.db import models")
if not imports:
items["imports"] = ""
else:
items["imports"] = "\n".join(imports) + "\n"
- return MIGRATION_TEMPLATE % items
+ return (MIGRATION_TEMPLATE % items).encode("utf8")
@property
def filename(self):
@@ -84,16 +87,17 @@ def serialize(cls, value):
elif isinstance(value, (datetime.datetime, datetime.date)):
return repr(value), set(["import datetime"])
# Simple types
- elif isinstance(value, (int, long, float, str, unicode, bool, types.NoneType)):
+ elif isinstance(value, (int, long, float, six.binary_type, six.text_type, bool, types.NoneType)):
return repr(value), set()
# Django fields
elif isinstance(value, models.Field):
attr_name, path, args, kwargs = value.deconstruct()
module, name = path.rsplit(".", 1)
if module == "django.db.models":
- imports = set()
+ imports = set(["from django.db import models"])
+ name = "models.%s" % name
else:
- imports = set("import %s" % module)
+ imports = set(["import %s" % module])
name = path
arg_strings = []
for arg in args:
View
33 tests/migrations/test_autodetector.py
@@ -2,6 +2,7 @@
from django.test import TransactionTestCase
from django.db.migrations.autodetector import MigrationAutodetector
from django.db.migrations.state import ProjectState, ModelState
+from django.db.migrations.graph import MigrationGraph
from django.db import models
@@ -11,6 +12,8 @@ class AutodetectorTests(TransactionTestCase):
"""
author_empty = ModelState("testapp", "Author", [("id", models.AutoField(primary_key=True))])
+ other_pony = ModelState("otherapp", "Pony", [("id", models.AutoField(primary_key=True))])
+ other_stable = ModelState("otherapp", "Stable", [("id", models.AutoField(primary_key=True))])
def make_project_state(self, model_states):
"Shortcut to make ProjectStates from lists of predefined models"
@@ -19,6 +22,28 @@ def make_project_state(self, model_states):
project_state.add_model_state(model_state)
return project_state
+ def test_arrange_for_graph(self):
+ "Tests auto-naming of migrations for graph matching."
+ # Make a fake graph
+ graph = MigrationGraph()
+ graph.add_node(("testapp", "0001_initial"), None)
+ graph.add_node(("testapp", "0002_foobar"), None)
+ graph.add_node(("otherapp", "0001_initial"), None)
+ graph.add_dependency(("testapp", "0002_foobar"), ("testapp", "0001_initial"))
+ graph.add_dependency(("testapp", "0002_foobar"), ("otherapp", "0001_initial"))
+ # Use project state to make a new migration change set
+ before = self.make_project_state([])
+ after = self.make_project_state([self.author_empty, self.other_pony, self.other_stable])
+ autodetector = MigrationAutodetector(before, after)
+ changes = autodetector.changes()
+ # Run through arrange_for_graph
+ changes = autodetector.arrange_for_graph(changes, graph)
+ # Make sure there's a new name, deps match, etc.
+ self.assertEqual(changes["testapp"][0].name, "0003_author")
+ self.assertEqual(changes["testapp"][0].dependencies, [("testapp", "0002_foobar")])
+ self.assertEqual(changes["otherapp"][0].name, "0002_pony_stable")
+ self.assertEqual(changes["otherapp"][0].dependencies, [("otherapp", "0001_initial")])
+
def test_new_model(self):
"Tests autodetection of new models"
# Make state
@@ -27,9 +52,9 @@ def test_new_model(self):
autodetector = MigrationAutodetector(before, after)
changes = autodetector.changes()
# Right number of migrations?
- self.assertEqual(len(changes), 1)
+ self.assertEqual(len(changes['testapp']), 1)
# Right number of actions?
- migration = changes.pop()
+ migration = changes['testapp'][0]
self.assertEqual(len(migration.operations), 1)
# Right action?
action = migration.operations[0]
@@ -44,9 +69,9 @@ def test_old_model(self):
autodetector = MigrationAutodetector(before, after)
changes = autodetector.changes()
# Right number of migrations?
- self.assertEqual(len(changes), 1)
+ self.assertEqual(len(changes['testapp']), 1)
# Right number of actions?
- migration = changes.pop()
+ migration = changes['testapp'][0]
self.assertEqual(len(migration.operations), 1)
# Right action?
action = migration.operations[0]
View
41 tests/migrations/test_writer.py
@@ -1,5 +1,6 @@
# encoding: utf8
import datetime
+from django.utils import six
from django.test import TransactionTestCase
from django.db.migrations.writer import MigrationWriter
from django.db import models, migrations
@@ -10,23 +11,33 @@ class WriterTests(TransactionTestCase):
Tests the migration writer (makes migration files from Migration instances)
"""
- def safe_exec(self, value, string):
+ def safe_exec(self, string, value=None):
l = {}
try:
- exec(string, {}, l)
- except:
- self.fail("Could not serialize %r: failed to exec %r" % (value, string.strip()))
+ exec(string, globals(), l)
+ except Exception as e:
+ if value:
+ self.fail("Could not exec %r (from value %r): %s" % (string.strip(), value, e))
+ else:
+ self.fail("Could not exec %r: %s" % (string.strip(), e))
return l
- def assertSerializedEqual(self, value):
+ def serialize_round_trip(self, value):
string, imports = MigrationWriter.serialize(value)
- new_value = self.safe_exec(value, "%s\ntest_value_result = %s" % ("\n".join(imports), string))['test_value_result']
- self.assertEqual(new_value, value)
+ return self.safe_exec("%s\ntest_value_result = %s" % ("\n".join(imports), string), value)['test_value_result']
+
+ def assertSerializedEqual(self, value):
+ self.assertEqual(self.serialize_round_trip(value), value)
def assertSerializedIs(self, value):
- string, imports = MigrationWriter.serialize(value)
- new_value = self.safe_exec(value, "%s\ntest_value_result = %s" % ("\n".join(imports), string))['test_value_result']
- self.assertIs(new_value, value)
+ self.assertIs(self.serialize_round_trip(value), value)
+
+ def assertSerializedFieldEqual(self, value):
+ new_value = self.serialize_round_trip(value)
+ self.assertEqual(value.__class__, new_value.__class__)
+ self.assertEqual(value.max_length, new_value.max_length)
+ self.assertEqual(value.null, new_value.null)
+ self.assertEqual(value.unique, new_value.unique)
def test_serialize(self):
"""
@@ -48,6 +59,9 @@ def test_serialize(self):
self.assertSerializedEqual(datetime.datetime.utcnow)
self.assertSerializedEqual(datetime.date.today())
self.assertSerializedEqual(datetime.date.today)
+ # Django fields
+ self.assertSerializedFieldEqual(models.CharField(max_length=255))
+ self.assertSerializedFieldEqual(models.TextField(null=True, blank=True))
def test_simple_migration(self):
"""
@@ -62,4 +76,9 @@ def test_simple_migration(self):
})
writer = MigrationWriter(migration)
output = writer.as_string()
- print output
+ # It should NOT be unicode.
+ self.assertIsInstance(output, six.binary_type, "Migration as_string returned unicode")
+ # We don't test the output formatting - that's too fragile.
+ # Just make sure it runs for now, and that things look alright.
+ result = self.safe_exec(output)
+ self.assertIn("Migration", result)
Please sign in to comment.
Something went wrong with that request. Please try again.