Add AffectedFile.IsTextFile() and deprecate AffectedTextFiles().

presubmit_support.py

 #!/usr/bin/python
 # Copyright (c) 2006-2009 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.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 cPickle  # Exposed through the API.
 import cStringIO  # Exposed through the API.
 import exceptions
 import fnmatch
 import glob
 import marshal  # Exposed through the API.
 import optparse
 import os  # Somewhat exposed through the API.
 import pickle  # Exposed through the API.
 import re  # Exposed through the API.
 import subprocess  # Exposed through the API.
 import sys  # Parts exposed through API.
 import tempfile  # Exposed through the API.
 import types
 import urllib2  # Exposed through the API.
+import warnings
 
 # Local imports.
 # TODO(joi) Would be cleaner to factor out utils in gcl to separate module, but
 # for now it would only be a couple of functions so hardly worth it.
 import gcl
 import gclient
 import presubmit_canned_checks
 
 
 class NotImplementedException(Exception):
   """We're leaving placeholders in a bunch of places to remind us of the
   design of the API, but we have not implemented all of it yet. Implement as
   the need arises.
   """
   pass
 
 
 def normpath(path):
   '''Version of os.path.normpath that also changes backward slashes to
   forward slashes when not running on Windows.
   '''
   # This is safe to always do because the Windows version of os.path.normpath
   # will replace forward slashes with backward slashes.
   path = path.replace(os.sep, '/')
   return os.path.normpath(path)
 
 
+def deprecated(func):
+  """This is a decorator which can be used to mark functions as deprecated.
+
+  It will result in a warning being emmitted when the function is used."""
+  def newFunc(*args, **kwargs):
+    warnings.warn("Call to deprecated function %s." % func.__name__,
+                  category=DeprecationWarning,
+                  stacklevel=2)
+    return func(*args, **kwargs)
+  newFunc.__name__ = func.__name__
+  newFunc.__doc__ = func.__doc__
+  newFunc.__dict__.update(func.__dict__)
+  return newFunc
+
+
 class OutputApi(object):
   """This class (more like a module) gets passed to presubmit scripts so that
   they can specify various types of results.
   """
 
   class PresubmitResult(object):
     """Base class for result objects."""
 
     def __init__(self, message, items=None, long_text=''):
       """
@@ skipping 103 matching lines @@
   def PresubmitLocalPath(self):
     """Returns the local path of the presubmit script currently being run.
 
     This is useful if you don't want to hard-code absolute paths in the
     presubmit script.  For example, It can be used to find another file
     relative to the PRESUBMIT.py script, so the whole tree can be branched and
     the presubmit script still works, without editing its content.
     """
     return self._current_presubmit_path
 
-  @staticmethod
-  def DepotToLocalPath(depot_path):
+  def DepotToLocalPath(self, depot_path):

[Jói Sigurðsson, 2009/05/28 16:49:36]

why make non-static when it doesn't use self?

     """Translate a depot path to a local path (relative to client root).
 
     Args:
       Depot path as a string.
 
     Returns:
       The local path of the depot path under the user's current client, or None
       if the file is not mapped.
 
       Remember to check for the None case and show an appropriate error!
     """
     local_path = gclient.CaptureSVNInfo(depot_path).get('Path')
-    if not local_path:
-      return None
-    else:
+    if local_path:
       return local_path
 
-  @staticmethod
-  def LocalToDepotPath(local_path):
+  def LocalToDepotPath(self, local_path):
     """Translate a local path to a depot path.
 
     Args:
       Local path (relative to current directory, or absolute) as a string.
 
     Returns:
       The depot path (SVN URL) of the file if mapped, otherwise None.
     """
     depot_path = gclient.CaptureSVNInfo(local_path).get('URL')
-    if not depot_path:
-      return None
-    else:
+    if depot_path:
       return depot_path
 
   @staticmethod
   def FilterTextFiles(affected_files, include_deletes=True):
     """Filters out all except text files and optionally also filters out
     deleted files.
 
     Args:
       affected_files: List of AffectedFiles objects.
       include_deletes: If false, deleted files will be filtered out.
@@ skipping 30 matching lines @@
     return [af.LocalPath() for af in self.AffectedFiles(include_dirs)]
 
   def AbsoluteLocalPaths(self, include_dirs=False):
     """Returns absolute local paths of input_api.AffectedFiles()."""
     return [af.AbsoluteLocalPath() for af in self.AffectedFiles(include_dirs)]
 
   def ServerPaths(self, include_dirs=False):
     """Returns server paths of input_api.AffectedFiles()."""
     return [af.ServerPath() for af in self.AffectedFiles(include_dirs)]
 
+  @deprecated
   def AffectedTextFiles(self, include_deletes=True):
     """Same as input_api.change.AffectedTextFiles() except only lists files
     in the same directory as the current presubmit script, or subdirectories
     thereof.
 
     Warning: This function retrieves the svn property on each file so it can be
     slow for large change lists.
     """
     return InputApi.FilterTextFiles(self.AffectedFiles(include_dirs=False),
                                     include_deletes)
 
   def RightHandSideLines(self):
     """An iterator over all text lines in "new" version of changed files.
 
     Only lists lines from new or modified text files in the change that are
     contained by the directory of the currently executing presubmit script.
 
     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.
     """
     return InputApi._RightHandSideLinesImpl(
-        self.AffectedTextFiles(include_deletes=False))
+        filter(lambda x: x.IsTextFile(),
+               self.AffectedFiles(include_deletes=False)))
 
   @staticmethod
   def _RightHandSideLinesImpl(affected_files):
     """Implements RightHandSideLines for InputApi and GclChange."""
     for af in affected_files:
       lines = af.NewContents()
       line_number = 0
       for line in lines:
         line_number += 1
         yield (af, line_number, line)
@@ skipping 40 matching lines @@
     # TODO(maruel): Somewhat crappy, Could be "A" or "A  +" for svn but
     # different for other SCM.
     return self.action
 
   def Property(self, property_name):
     """Returns the specified SCM property of this file, or None if no such
     property.
     """
     return self.properties.get(property_name, None)
 
+  def IsTextFile(self):
+    """Returns True if the file is a text file and not a binary 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.
     """
     if self.IsDirectory():
       return []
@@ skipping 37 matching lines @@
         self.is_directory = gclient.CaptureSVNInfo(
             path).get('Node Kind') in ('dir', 'directory')
     return self.is_directory
 
   def Property(self, property_name):
     if not property_name in self.properties:
       self.properties[property_name] = gcl.GetSVNFileProperty(
           self.AbsoluteLocalPath(), property_name)
     return self.properties[property_name]
 
+  def IsTextFile(self):
+    if self.Action() == 'D':
+      return False
+    mime_type = gcl.GetSVNFileProperty(self.AbsoluteLocalPath(),
+                                       'svn:mime-type')
+    if not mime_type or mime_type.startswith('text/'):
+      return True
+    return False
+
 
 class GclChange(object):
   """Describe a change.
 
   Used directly by the presubmit scripts to query the current change being
   tested.
   
   Instance members:
     tags: Dictionnary of KEY=VALUE pairs found in the change description.
     self.KEY: equivalent to tags['KEY']
@@ skipping 71 matching lines @@
     if include_dirs:
       affected = self._affected_files
     else:
       affected = filter(lambda x: not x.IsDirectory(), self._affected_files)
 
     if include_deletes:
       return affected
     else:
       return filter(lambda x: x.Action() != 'D', affected)
 
+  @deprecated
   def AffectedTextFiles(self, include_deletes=True):
     """Return a list of the text files in a change.
 
     It's common to want to iterate over only the text files.
 
     Args:
       include_deletes: Controls whether to return files with "delete" actions,
       which commonly aren't relevant to presubmit scripts.
     """
     return InputApi.FilterTextFiles(self.AffectedFiles(include_dirs=False),
@@ skipping 19 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.
     """
     return InputApi._RightHandSideLinesImpl(
-        self.AffectedTextFiles(include_deletes=False))
+        filter(lambda x: x.IsTextFile(),
+               self.AffectedFiles(include_deletes=False)))
 
 
 def ListRelevantPresubmitFiles(files):
   """Finds all presubmit files that apply to a given set of source files.
 
   Args:
     files: An iterable container containing file paths.
 
   Return:
     ['foo/blat/PRESUBMIT.py', 'mat/gat/PRESUBMIT.py']
@@ skipping 18 matching lines @@
   return presubmit_files
 
 
 class PresubmitExecuter(object):
   def __init__(self, change_info, committing):
     """
     Args:
       change_info: The ChangeInfo object for the change.
       committing: True if 'gcl commit' is running, False if 'gcl upload' is.
     """
+    # TODO(maruel): Determine the SCM.
     self.change = GclChange(change_info, gcl.GetRepositoryRoot())
     self.committing = committing
 
   def ExecPresubmitScript(self, script_text, presubmit_path):
     """Executes a single presubmit script.
 
     Args:
       script_text: The text of the presubmit script.
       presubmit_path: The path to the presubmit file (this will be reported via
         input_api.PresubmitLocalPath()).
@@ skipping 140 matching lines @@
   return not DoPresubmitChecks(gcl.ChangeInfo(name='temp', files=files),
                                options.commit,
                                options.verbose,
                                sys.stdout,
                                sys.stdin,
                                default_presubmit=None)
 
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv))