1668dee8502f6eda99f57eb8664161ba42a63590
[redakcja.git] / apps / dvcs / models.py
1 from datetime import datetime
2
3 from django.core.files.base import ContentFile
4 from django.core.files.storage import FileSystemStorage
5 from django.db import models
6 from django.db.models.base import ModelBase
7 from django.contrib.auth.models import User
8 from django.utils.translation import ugettext_lazy as _
9 from mercurial import mdiff, simplemerge
10
11 from dvcs.fields import GzipFileSystemStorage
12 from dvcs.settings import REPO_PATH
13
14
15 class Tag(models.Model):
16     """
17         a tag (e.g. document stage) which can be applied to a change
18     """
19
20     name = models.CharField(_('name'), max_length=64)
21     slug = models.SlugField(_('slug'), unique=True, max_length=64, 
22             null=True, blank=True)
23     ordering = models.IntegerField(_('ordering'))
24
25     _object_cache = {}
26
27     class Meta:
28         abstract = True
29         ordering = ['ordering']
30
31     def __unicode__(self):
32         return self.name
33
34     @classmethod
35     def get(cls, slug):
36         if slug in cls._object_cache:
37             return cls._object_cache[slug]
38         else:
39             obj = cls.objects.get(slug=slug)
40             cls._object_cache[slug] = obj
41             return obj
42
43     @staticmethod
44     def listener_changed(sender, instance, **kwargs):
45         sender._object_cache = {}
46
47     def next(self):
48         """
49             Returns the next tag - stage to work on.
50             Returns None for the last stage.
51         """
52         try:
53             return Tag.objects.filter(ordering__gt=self.ordering)[0]
54         except IndexError:
55             return None
56
57 models.signals.pre_save.connect(Tag.listener_changed, sender=Tag)
58
59
60 repo = GzipFileSystemStorage(location=REPO_PATH)
61
62 def data_upload_to(instance, filename):
63     return "%d/%d" % (instance.tree.pk, instance.pk)
64
65 class Change(models.Model):
66     """
67         Single document change related to previous change. The "parent"
68         argument points to the version against which this change has been 
69         recorded. Initial text will have a null parent.
70         
71         Data file contains a gzipped text of the document.
72     """
73     author = models.ForeignKey(User, null=True, blank=True)
74     author_name = models.CharField(max_length=128, null=True, blank=True)
75     author_email = models.CharField(max_length=128, null=True, blank=True)
76     data = models.FileField(upload_to=data_upload_to, storage=repo)
77     revision = models.IntegerField(db_index=True)
78
79     parent = models.ForeignKey('self',
80                         null=True, blank=True, default=None,
81                         related_name="children")
82
83     merge_parent = models.ForeignKey('self',
84                         null=True, blank=True, default=None,
85                         related_name="merge_children")
86
87     description = models.TextField(blank=True, default='')
88     created_at = models.DateTimeField(editable=False, db_index=True, 
89                         default=datetime.now)
90     publishable = models.BooleanField(default=False)
91
92     class Meta:
93         abstract = True
94         ordering = ('created_at',)
95         unique_together = ['tree', 'revision']
96
97     def __unicode__(self):
98         return u"Id: %r, Tree %r, Parent %r, Data: %s" % (self.id, self.tree_id, self.parent_id, self.data)
99
100     def author_str(self):
101         if self.author:
102             return "%s %s <%s>" % (
103                 self.author.first_name,
104                 self.author.last_name, 
105                 self.author.email)
106         else:
107             return "%s <%s>" % (
108                 self.author_name,
109                 self.author_email
110                 )
111
112
113     def save(self, *args, **kwargs):
114         """
115             take the next available revision number if none yet
116         """
117         if self.revision is None:
118             tree_rev = self.tree.revision()
119             if tree_rev is None:
120                 self.revision = 0
121             else:
122                 self.revision = tree_rev + 1
123         return super(Change, self).save(*args, **kwargs)
124
125     def materialize(self):
126         f = self.data.storage.open(self.data)
127         text = f.read()
128         f.close()
129         return unicode(text, 'utf-8')
130
131     def merge_with(self, other, author=None, 
132             author_name=None, author_email=None, 
133             description=u"Automatic merge."):
134         """Performs an automatic merge after straying commits."""
135         assert self.tree_id == other.tree_id  # same tree
136         if other.parent_id == self.pk:
137             # immediate child - fast forward
138             return other
139
140         local = self.materialize().encode('utf-8')
141         base = other.parent.materialize().encode('utf-8')
142         remote = other.materialize().encode('utf-8')
143
144         merge = simplemerge.Merge3Text(base, local, remote)
145         result = ''.join(merge.merge_lines())
146         merge_node = self.children.create(
147                     merge_parent=other, tree=self.tree,
148                     author=author,
149                     author_name=author_name,
150                     author_email=author_email,
151                     description=description)
152         merge_node.data.save('', ContentFile(result))
153         return merge_node
154
155     def revert(self, **kwargs):
156         """ commit this version of a doc as new head """
157         self.tree.commit(text=self.materialize(), **kwargs)
158
159
160 def create_tag_model(model):
161     name = model.__name__ + 'Tag'
162     attrs = {
163         '__module__': model.__module__,
164     }
165     return type(name, (Tag,), attrs)
166
167
168 def create_change_model(model):
169     name = model.__name__ + 'Change'
170
171     attrs = {
172         '__module__': model.__module__,
173         'tree': models.ForeignKey(model, related_name='change_set'),
174         'tags': models.ManyToManyField(model.tag_model, related_name='change_set'),
175     }
176     return type(name, (Change,), attrs)
177
178
179
180 class DocumentMeta(ModelBase):
181     "Metaclass for Document models."
182     def __new__(cls, name, bases, attrs):
183         model = super(DocumentMeta, cls).__new__(cls, name, bases, attrs)
184         if not model._meta.abstract:
185             # create a real Tag object and `stage' fk
186             model.tag_model = create_tag_model(model)
187             models.ForeignKey(model.tag_model, 
188                 null=True, blank=True).contribute_to_class(model, 'stage')
189
190             # create real Change model and `head' fk
191             model.change_model = create_change_model(model)
192             models.ForeignKey(model.change_model,
193                     null=True, blank=True, default=None,
194                     help_text=_("This document's current head."),
195                     editable=False).contribute_to_class(model, 'head')
196
197         return model
198
199
200
201 class Document(models.Model):
202     """
203         File in repository.        
204     """
205     __metaclass__ = DocumentMeta
206
207     creator = models.ForeignKey(User, null=True, blank=True, editable=False,
208                 related_name="created_documents")
209
210     user = models.ForeignKey(User, null=True, blank=True)
211
212     class Meta:
213         abstract = True
214
215     def __unicode__(self):
216         return u"{0}, HEAD: {1}".format(self.id, self.head_id)
217
218     @models.permalink
219     def get_absolute_url(self):
220         return ('dvcs.views.document_data', (), {
221                         'document_id': self.id,
222                         'version': self.head_id,
223         })
224
225     def materialize(self, change=None):
226         if self.head is None:
227             return u''
228         if change is None:
229             change = self.head
230         elif not isinstance(change, Change):
231             change = self.change_set.get(pk=change)
232         return change.materialize()
233
234     def commit(self, text, **kwargs):
235         if 'parent' not in kwargs:
236             parent = self.head
237         else:
238             parent = kwargs['parent']
239             if parent is not None and not isinstance(parent, Change):
240                 parent = self.change_set.objects.get(pk=kwargs['parent'])
241
242         author = kwargs.get('author', None)
243         author_name = kwargs.get('author_name', None)
244         author_email = kwargs.get('author_email', None)
245         tags = kwargs.get('tags', [])
246         if tags:
247             # set stage to next tag after the commited one
248             self.stage = max(tags, key=lambda t: t.ordering).next()
249
250         change = self.change_set.create(author=author,
251                     author_name=author_name,
252                     author_email=author_email,
253                     description=kwargs.get('description', ''),
254                     parent=parent)
255
256         change.tags = tags
257         change.data.save('', ContentFile(text.encode('utf-8')))
258         change.save()
259
260         if self.head:
261             # merge new change as new head
262             self.head = self.head.merge_with(change, author=author,
263                     author_name=author_name,
264                     author_email=author_email)
265         else:
266             self.head = change
267         self.save()
268         return self.head
269
270     def history(self):
271         return self.change_set.filter(revision__gt=-1)
272
273     def revision(self):
274         rev = self.change_set.aggregate(
275                 models.Max('revision'))['revision__max']
276         return rev
277
278     def at_revision(self, rev):
279         """Returns a Change with given revision number."""
280         return self.change_set.get(revision=rev)
281
282     def publishable(self):
283         changes = self.change_set.filter(publishable=True).order_by('-created_at')[:1]
284         if changes.count():
285             return changes[0]
286         else:
287             return None