Changeset 140511 in webkit

Timestamp:

Jan 22, 2013 11:22:31 PM (11 years ago)

Author:

commit-queue@webkit.org

Message:

prepare-Changelog should support updating the list of changed files
​https://bugs.webkit.org/show_bug.cgi?id=74358

Patch by Timothy Loh <​timloh@chromium.com> on 2013-01-22
Reviewed by Eric Seidel.

Needing to re-make ChangeLog entries when the list of files/functions
changes is a bit annoying, it'd be nice to have this more automated.
This patch makes `webkit-patch update' update the date line and bug
description if needed, and if the list of changed files/functions has
changed, either updates the list (if there are no annotations), or
otherwise appends the new list below.

• Scripts/webkitpy/tool/steps/preparechangelog.py:

(PrepareChangeLog._resolve_existing_entry):
(PrepareChangeLog):
(PrepareChangeLog._merge_entries):
(PrepareChangeLog.run):

• Scripts/webkitpy/tool/steps/preparechangelog_unittest.py:

(PrepareChangeLogTest.test_resolve_existing_entry):
(make_entry):
(test_ensure_bug_url):

Location:

trunk/Tools

Files:

• ChangeLog (modified) (1 diff)
• Scripts/webkitpy/tool/steps/preparechangelog.py (modified) (3 diffs)
• Scripts/webkitpy/tool/steps/preparechangelog_unittest.py (modified) (2 diffs)

trunk/Tools/ChangeLog

@@ +1 @@
+2013-01-22  Timothy Loh  <timloh@chromium.com>
+
+        prepare-Changelog should support updating the list of changed files
+        https://bugs.webkit.org/show_bug.cgi?id=74358
+
+        Reviewed by Eric Seidel.
+
+        Needing to re-make ChangeLog entries when the list of files/functions
+        changes is a bit annoying, it'd be nice to have this more automated.
+        This patch makes `webkit-patch update' update the date line and bug
+        description if needed, and if the list of changed files/functions has
+        changed, either updates the list (if there are no annotations), or
+        otherwise appends the new list below.
+
+        * Scripts/webkitpy/tool/steps/preparechangelog.py:
+        (PrepareChangeLog._resolve_existing_entry):
+        (PrepareChangeLog):
+        (PrepareChangeLog._merge_entries):
+        (PrepareChangeLog.run):
+        * Scripts/webkitpy/tool/steps/preparechangelog_unittest.py:
+        (PrepareChangeLogTest.test_resolve_existing_entry):
+        (make_entry):
+        (test_ensure_bug_url):
+
 2013-01-22  Tim 'mithro' Ansell  <mithro@mithis.com>
 

trunk/Tools/Scripts/webkitpy/tool/steps/preparechangelog.py

@@ -27 +27 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+import codecs
 import logging
+import os
+import re
 import sys
 
@@ -59 +62 @@
                     self._tool.bugs.bug_url_for_bug_id(bug_id))
 
+    def _resolve_existing_entry(self, changelog_path):
+        # When this is called, the top entry in the ChangeLog was just created
+        # by prepare-ChangeLog, as an clean updated version of the one below it.
+        with codecs.open(changelog_path, "r", "utf-8") as changelog_file:
+            entries_gen = ChangeLog.parse_entries_from_file(changelog_file)
+            entries = zip(entries_gen, range(2))
+
+        if not len(entries):
+            raise Exception("Expected to find at least two ChangeLog entries in %s but found none." % changelog_path)
+        if len(entries) == 1:
+            # If we get here, it probably means we've just rolled over to a
+            # new CL file, so we don't have anything to resolve.
+            return
+
+        (new_entry, _), (old_entry, _) = entries
+        final_entry = self._merge_entries(old_entry, new_entry)
+
+        changelog = ChangeLog(changelog_path)
+        changelog.delete_entries(2)
+        changelog.prepend_text(final_entry)
+
+    def _merge_entries(self, old_entry, new_entry):
+        final_entry = old_entry.contents()
+
+        new_date_line = new_entry.date_line()
+        old_date_line = old_entry.date_line()
+        if new_date_line != old_date_line:
+            final_entry = final_entry.replace(old_date_line, new_date_line)
+
+        new_bug_desc = new_entry.bug_description()
+        old_bug_desc = old_entry.bug_description()
+        if new_bug_desc and old_bug_desc and new_bug_desc != old_bug_desc:
+            final_entry = final_entry.replace(old_bug_desc, new_bug_desc)
+
+        new_touched = new_entry.touched_functions()
+        old_touched = old_entry.touched_functions()
+        if new_touched != old_touched:
+            if old_entry.is_touched_files_text_clean():
+                final_entry = final_entry.replace(old_entry.touched_files_text(), new_entry.touched_files_text())
+            else:
+                final_entry += "\n" + new_entry.touched_files_text()
+
+        return final_entry + "\n"
+
     def run(self, state):
         if self.cached_lookup(state, "changelogs"):
             self._ensure_bug_url(state)
-            return
+
         args = self._tool.deprecated_port().prepare_changelog_command()
         if state.get("bug_id"):
@@ -76 +123 @@
 
         try:
-            self._tool.executive.run_and_throw_if_fail(args, self._options.quiet, cwd=self._tool.scm().checkout_root)
+            output = self._tool.executive.run_and_throw_if_fail(args, self._options.quiet, cwd=self._tool.scm().checkout_root)
         except ScriptError, e:
             _log.error("Unable to prepare ChangeLogs.")
             sys.exit(1)
+
+        # These are the ChangeLog entries added by prepare-Changelog
+        changelogs = re.findall(r'Editing the (\S*/ChangeLog) file.', output)
+        changelogs = set(os.path.join(self._tool.scm().checkout_root, f) for f in changelogs)
+        for changelog in changelogs & set(self.cached_lookup(state, "changelogs")):
+            self._resolve_existing_entry(changelog)
+
         self.did_modify_checkout(state)

trunk/Tools/Scripts/webkitpy/tool/steps/preparechangelog_unittest.py

@@ -37 +37 @@
 from webkitpy.tool.steps.preparechangelog import PrepareChangeLog
 
+# FIXME: These tests should use a MockFileSystem instead of a real file system,
+# once changelog.py and preparechangelog.py are FileSystem compatible.
 
 class PrepareChangeLogTest(changelog_unittest.ChangeLogTest):
+    def test_resolve_existing_entry(self):
+        step = PrepareChangeLog(MockTool(), MockOptions())
+
+        roll_over = "== Rolled over to ChangeLog-2012-10-02 =="
+
+        headers = ["2013-01-18  Timothy Loh  <timloh@chromium.com>\n\n",
+                   "2013-01-20  Timothy Loh  <timloh@chromium.com>\n\n",
+                  u"2009-08-17  Tor Arne Vestb\xf8  <vestbo@webkit.org>\n\n",
+                  u"2009-08-18  Tor Arne Vestb\xf8  <vestbo@webkit.org>\n\n",
+                  ]
+
+        bug_descs = ["        prepare-Changelog should support updating the list of changed files\n",
+                     "        webkit-patch upload should support updating the list of changed files\n"]
+
+        bug_url = "        https://bugs.webkit.org/show_bug.cgi?id=74358\n\n"
+
+        descriptions = ["", "        A description of the changes.\n\n",
+                "        A description.\n\n        With some\n        line breaks\n\n"]
+
+        changes = [
+"""        * Scripts/webkitpy/tool/steps/preparechangelog.py:
+        (PrepareChangeLog):
+        (PrepareChangeLog.run):\n\n""",
+"""        * Scripts/webkitpy/tool/steps/preparechangelog.py:
+        (PrepareChangeLog._resolve_existing_entry):
+        (PrepareChangeLog):
+        (PrepareChangeLog.run):\n\n""",
+"""        * Scripts/webkitpy/tool/steps/preparechangelog.py:
+        (PrepareChangeLog): Some annotations
+        (PrepareChangeLog.run):
+            More annotations\n\n""",
+"""        * Scripts/webkitpy/tool/steps/preparechangelog.py:
+        (PrepareChangeLog): Some annotations
+        (PrepareChangeLog.run):
+            More annotations
+
+        * Scripts/webkitpy/tool/steps/preparechangelog.py:
+        (PrepareChangeLog._resolve_existing_entry):
+        (PrepareChangeLog):
+        (PrepareChangeLog.run):\n\n""",
+            ]
+
+        def make_entry(indices):
+            a, b, c, d = indices
+            return headers[a] + bug_descs[b] + bug_url + descriptions[c] + changes[d]
+
+        test_cases = [((0, 0, 0, 0), (0, 0, 0, 0), (0, 0, 0, 0)),
+                      ((0, 0, 0, 0), (0, 0, 1, 0), (0, 0, 1, 0)),
+                      ((1, 0, 0, 0), (0, 0, 2, 0), (1, 0, 2, 0)),
+                      ((0, 1, 0, 0), (0, 0, 1, 0), (0, 1, 1, 0)),
+                      ((0, 0, 0, 1), (0, 0, 0, 0), (0, 0, 0, 1)),
+                      ((0, 0, 0, 0), (0, 0, 1, 1), (0, 0, 1, 0)),
+                      ((0, 0, 0, 0), (0, 0, 2, 2), (0, 0, 2, 2)),
+                      ((0, 0, 0, 1), (0, 0, 1, 2), (0, 0, 1, 3)),
+                      ((1, 1, 0, 1), (0, 0, 0, 2), (1, 1, 0, 3)),
+                      ((3, 0, 0, 0), (2, 0, 1, 0), (3, 0, 1, 0)),
+        ]
+
+        for new, old, final in test_cases:
+            new_entry = make_entry(new)
+            old_entry = make_entry(old)
+            start_file = new_entry + old_entry + roll_over
+
+            final_entry = make_entry(final)
+            end_file = final_entry + roll_over
+
+            path = self._write_tmp_file_with_contents(start_file.encode("utf-8"))
+            step._resolve_existing_entry(path)
+            actual_output = self._read_file_contents(path, "utf-8")
+            self.assertEquals(actual_output, end_file)
+
     def test_ensure_bug_url(self):
-        # FIXME: This should use a MockFileSystem instead of a real FileSystem.
         capture = OutputCapture()
         step = PrepareChangeLog(MockTool(), MockOptions())
@@ -50 +122 @@
             "changelogs": [changelog_path],
         }
-        capture.assert_outputs(self, step.run, [state])
+        capture.assert_outputs(self, step._ensure_bug_url, [state])
         actual_contents = self._read_file_contents(changelog_path, "utf-8")
         expected_message = "Example title\n        http://example.com/1234"