presubmit_support: cache the result of ChangedContents.

presubmit_support.py

 #!/usr/bin/env python
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Enables directory-specific presubmit checks to run at upload and/or commit.
 """
 
 __version__ = '1.6.1'
 
 # TODO(joi) Add caching where appropriate/needed. The API is designed to allow
 # caching (between all different invocations of presubmit scripts for a given
 # change). We should add it as our presubmit scripts start feeling slow.
 
+import copy

[M-A Ruel, 2011/04/23 01:05:03]

not needed.

[ncarter (slow), 2011/04/26 17:15:19]

Done.

 import cPickle  # Exposed through the API.
 import cStringIO  # Exposed through the API.
 import fnmatch
 import glob
 import logging
 import marshal  # Exposed through the API.
 import optparse
 import os  # Somewhat exposed through the API.
 import pickle  # Exposed through the API.
 import random
@@ skipping 364 matching lines @@
 
     This is useful for doing line-by-line regex checks, like checking for
     trailing whitespace.
 
     Yields:
       a 3 tuple:
         the AffectedFile instance of the current file;
         integer line number (1-based); and
         the contents of the line as a string.
 
-    Note: The cariage return (LF or CR) is stripped off.
+    Note: The carriage return (LF or CR) is stripped off.
     """
     files = self.AffectedSourceFiles(source_file_filter)
     return _RightHandSideLinesImpl(files)
 
   def ReadFile(self, file_item, mode='r'):
     """Reads an arbitrary file.
 
     Deny reading anything outside the repository.
     """
     if isinstance(file_item, AffectedFile):
       file_item = file_item.AbsoluteLocalPath()
     if not file_item.startswith(self.change.RepositoryRoot()):
       raise IOError('Access outside the repository root is denied.')
     return gclient_utils.FileRead(file_item, mode)
 
 
 class AffectedFile(object):
   """Representation of a file in a change."""
   # Method could be a function
   # pylint: disable=R0201
   def __init__(self, path, action, repository_root=''):
     self._path = path
     self._action = action
     self._local_root = repository_root
     self._is_directory = None
     self._properties = {}
+    self._cached_changed_contents = None
+    self._cached_new_contents = None
     logging.debug('%s(%s)' % (self.__class__.__name__, self._path))
 
   def ServerPath(self):
     """Returns a path string that identifies the file in the SCM system.
 
     Returns the empty string if the file does not exist in SCM.
     """
     return ""
 
   def LocalPath(self):
@@ skipping 32 matching lines @@
     Deleted files are not text file."""
     raise NotImplementedError()  # Implement when needed
 
   def NewContents(self):
     """Returns an iterator over the lines in the new version of file.
 
     The new version is the file in the user's workspace, i.e. the "right hand
     side".
 
     Contents will be empty if the file is a directory or does not exist.
-    Note: The cariage returns (LF or CR) are stripped off.
+    Note: The carriage returns (LF or CR) are stripped off.
     """
-    if self.IsDirectory():
-      return []
-    else:
-      return gclient_utils.FileRead(self.AbsoluteLocalPath(),
-                                    'rU').splitlines()
+    if self._cached_new_contents is None:
+      if self.IsDirectory():
+        self._cached_new_contents = []
+      else:
+        self._cached_new_contents = gclient_utils.FileRead(

[M-A Ruel, 2011/04/23 01:05:03]

It should trap IOError and set to []. The file could be deleted.

[ncarter (slow), 2011/04/26 17:15:19]

Done.  Also, added unittest.

+            self.AbsoluteLocalPath(), 'rU').splitlines()
+    return copy.deepcopy(self._cached_new_contents)

[M-A Ruel, 2011/04/23 01:05:03]

return self._cached_new_contents[:]

[ncarter (slow), 2011/04/26 17:15:19]

Of course.  Done.

 
   def OldContents(self):
     """Returns an iterator over the lines in the old version of file.
 
     The old version is the file in depot, i.e. the "left hand side".
     """
     raise NotImplementedError()  # Implement when needed
 
   def OldFileTempPath(self):
     """Returns the path on local disk where the old contents resides.
 
     The old version is the file in depot, i.e. the "left hand side".
     This is a read-only cached copy of the old contents. *DO NOT* try to
     modify this file.
     """
     raise NotImplementedError()  # Implement if/when needed.
 
   def ChangedContents(self):
     """Returns a list of tuples (line number, line text) of all new lines.
 
      This relies on the scm diff output describing each changed code section
      with a line of the form
 
      ^@@ <old line num>,<old size> <new line num>,<new size> @@$
     """
-    new_lines = []
+    if self._cached_changed_contents is not None:
+      return copy.deepcopy(self._cached_changed_contents)
+    self._cached_changed_contents = []
     line_num = 0
 
     if self.IsDirectory():
       return []
 
     for line in self.GenerateScmDiff().splitlines():
       m = re.match(r'^@@ [0-9\,\+\-]+ \+([0-9]+)\,[0-9]+ @@', line)
       if m:
         line_num = int(m.groups(1)[0])
         continue
       if line.startswith('+') and not line.startswith('++'):
-        new_lines.append((line_num, line[1:]))
+        self._cached_changed_contents.append((line_num, line[1:]))
       if not line.startswith('-'):
         line_num += 1
-    return new_lines
+    return copy.deepcopy(self._cached_changed_contents)
 
   def __str__(self):
     return self.LocalPath()
 
   def GenerateScmDiff(self):
     raise NotImplementedError()  # Implemented in derived classes.
 
 
 class SvnAffectedFile(AffectedFile):
   """Representation of a file in a change out of a Subversion checkout."""
@@ skipping 677 matching lines @@
   except PresubmitFailure, e:
     print >> sys.stderr, e
     print >> sys.stderr, 'Maybe your depot_tools is out of date?'
     print >> sys.stderr, 'If all fails, contact maruel@'
     return 2
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   sys.exit(Main(None))