Add ability to review commit messages.

codereview/views.py

 # Copyright 2008 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 """Views for Rietveld."""
 
 
 import binascii
+import copy
 import datetime
 import email  # see incoming_mail()
 import email.utils
+import difflib
 import itertools
 import json
 import logging
 import md5
 import mimetypes
 import os
 import random
 import re
 import tarfile
 import tempfile
@@ skipping 1704 matching lines @@
 
   ps_key = db.Key.from_path(
     models.PatchSet.kind(),
     db.allocate_ids(db.Key.from_path(models.PatchSet.kind(), 1,
                                      parent=issue.key()), 1)[0],
     parent=issue.key())
 
   patchset = models.PatchSet(issue=issue, data=data, url=url, key=ps_key)
   patchset.put()
 
+  commitPatch = _create_commit_message_patch(patchset,
+                                             patchset.issue.description)
+  commitPatch.put()
+
   if not separate_patches:
     try:
       patches = engine.ParsePatchSet(patchset)
     except:
       # catch all exceptions happening in engine.ParsePatchSet,
       # engine.SplitPatch. With malformed diffs a variety of exceptions could
       # happen there.
       logging.exception('Exception during patch parsing')
       patches = []
     if not patches:
@@ skipping 65 matching lines @@
 @issue_editor_required
 @xsrf_required
 def add(request):
   """/<issue>/add - Add a new PatchSet to an existing Issue."""
   issue = request.issue
   form = AddForm(request.POST, request.FILES)
   if not _add_patchset_from_form(request, issue, form):
     return show(request, issue.key().id(), form)
   return HttpResponseRedirect(reverse(show, args=[issue.key().id()]))
 
+def _create_commit_message_patch(patchset, description):
+  filename = "COMMIT_MSG"

[tfarina1, 2013/07/26 00:55:56]

Can you rename this to "Commit Message"? So it matches how gerrit does. I'll
really like to see this feature in production :)

[Andi, 2013/07/29 08:38:34]

I'd also would like to see a module constant for this string since we refer to
it in several locations in this module.

[jparent1, 2013/08/14 20:16:52]

Done.

[jparent1, 2013/08/14 20:16:52]

Done.

+
+  diff = ""
+  udiff = difflib.unified_diff("",description.splitlines(1),·
+    fromfile="\dev\\null",tofile=filename)
+  for line in udiff:
+    diff += line
+
+  patch_key = db.Key.from_path(
+    models.Patch.kind(),
+    db.allocate_ids(db.Key.from_path(models.Patch.kind(), 1,
+                                     parent=patchset.key()), 1)[0],
+    parent=patchset.key())
+  commitPatch = models.Patch(patchset=patchset, text=utils.to_dbtext(diff),·
+                             filename=filename, key=patch_key,
+                             no_base_file=True)
+  return commitPatch
 
 def _add_patchset_from_form(request, issue, form, message_key='message',
                             emails_add_only=False):
   """Helper for add() and upload()."""
   if form.is_valid():
     data_url = _get_data_url(form)
   if not form.is_valid():
     return None
   account = models.Account.get_account_for_user(request.user)
   if account.blocked:
     return None
   if not issue.edit_allowed:
     # This check is done at each call site but check again as a safety measure.
     return None
   data, url, separate_patches = data_url
   message = form.cleaned_data[message_key]
   ps_key = db.Key.from_path(
     models.PatchSet.kind(),
     db.allocate_ids(db.Key.from_path(models.PatchSet.kind(), 1,
                                      parent=issue.key()), 1)[0],
     parent=issue.key())
   patchset = models.PatchSet(issue=issue, message=message, data=data, url=url,
                              key=ps_key)
   patchset.put()
 
+  commitPatch = _create_commit_message_patch(patchset,
+                                             patchset.issue.description)
+  commitPatch.put()
+
   if not separate_patches:
     try:
       patches = engine.ParsePatchSet(patchset)
     except:
       logging.exception('Exception during patchset parsing')
       patches = []
     if not patches:
       patchset.delete()
       errkey = url and 'url' or 'data'
       form.errors[errkey] = ['Patch set contains no recognizable patches']
@@ skipping 376 matching lines @@
 
   if form.is_valid() and not issue.local_base:
     base = form.get_base()
 
   if not form.is_valid():
     return respond(request, 'edit.html', {'issue': issue, 'form': form})
   cleaned_data = form.cleaned_data
 
   was_closed = issue.closed
   issue.subject = cleaned_data['subject']
+  old_description = issue.description
   issue.description = cleaned_data['description']
+·
+  # If the description was updated, it would get out of sync with the special
+  # COMMIT_MSG file in the last pastchset. So we clone the last patchset,
+  # modulo a new COMMIT_MSG patch.·
+  if issue.description != old_description:
+
+    def clone_without_key(obj, **extra_args):
+      """ Clones an object, without copying the key """
+      klass = obj.__class__
+      props = {}
+      for k, v in klass.properties().iteritems():
+        if not (type(v) == db.DateTimeProperty and
+               (getattr(v, 'auto_now') or getattr(v, 'auto_now_add'))):
+          if type(v) == db.ReferenceProperty:
+            value = getattr(klass, k).get_value_for_datastore(obj)
+          else:
+            value = v.__get__(obj, klass)
+          props[k] = value
+      props.update(extra_args)····
+      return klass(**props)····
+
+    # Create a new patchset from the last one.
+    patchsets = list(issue.patchset_set.order('created'))
+    last_patchset = patchsets[-1]
+    new_patchset_msg = 'Auto-generated patchset by description update.'
+    new_patchset = clone_without_key(last_patchset, parent=issue,
+                                     message=new_patchset_msg)
+    new_patchset.put()
+·
+    # Add the new commit message patch.
+    commitPatch = _create_commit_message_patch(new_patchset, issue.description)
+    commitPatch.put()
+
+    # And copy all the patches over from last patchset.
+    for patch in list(last_patchset.patch_set):
+      # Skip the old commit message, since we just created a new one.
+      if patch.filename == "COMMIT_MSG":
+          continue
+      new_patch = clone_without_key(patch, parent=new_patchset,
+                                    patchset=new_patchset)
+      new_patch.put()
+
   issue.closed = cleaned_data['closed']
   issue.private = cleaned_data.get('private', False)
   base_changed = (issue.base != base)
   issue.base = base
   issue.reviewers = reviewers
   issue.cc = cc
   if base_changed:
     for patchset in issue.patchset_set:
       db.run_in_transaction(_delete_cached_contents, list(patchset.patch_set))
   issue.calculate_updates_for()
@@ skipping 2233 matching lines @@
     if form.is_valid():
       client_id = form.cleaned_data['client_id']
       client_secret = form.cleaned_data['client_secret']
       additional_client_ids = form.cleaned_data['additional_client_ids']
       auth_utils.SecretKey.set_config(client_id, client_secret,
                                       additional_client_ids)
     return HttpResponseRedirect(reverse(set_client_id_and_secret))
   else:
     form = ClientIDAndSecretForm()
     return respond(request, 'set_client_id_and_secret.html', {'form': form})