Remove SVN-specific function InputApi.FilterTextFiles().

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'
 
@@ skipping 204 matching lines @@
     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 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.
-
-    Returns:
-      Filtered list of AffectedFiles objects.
-    """
-    output_files = []
-    for af in affected_files:
-      if include_deletes or af.Action() != 'D':
-        path = af.AbsoluteLocalPath()
-        mime_type = gcl.GetSVNFileProperty(path, 'svn:mime-type')
-        if not mime_type or mime_type.startswith('text/'):
-          output_files.append(af)
-    return output_files
-
   def AffectedFiles(self, include_dirs=False, include_deletes=True):
     """Same as input_api.change.AffectedFiles() except only lists files
     (and optionally directories) in the same directory as the current presubmit
     script, or subdirectories thereof.
     """
-    output_files = []
     dir_with_slash = normpath("%s/" % self.PresubmitLocalPath())
     if len(dir_with_slash) == 1:
       dir_with_slash = ''
-    for af in self.change.AffectedFiles(include_dirs, include_deletes):
-      af_path = normpath(af.LocalPath())
-      if af_path.startswith(dir_with_slash):
-        output_files.append(af)
-    return output_files
+    return filter(lambda x: normpath(x.LocalPath()).startswith(dir_with_slash),
+                  self.change.AffectedFiles(include_dirs, include_deletes))
 
   def LocalPaths(self, include_dirs=False):
     """Returns local paths of input_api.AffectedFiles()."""
     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):
+  def AffectedTextFiles(self, include_deletes=None):
     """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)
+    if include_deletes is not None:
+      warnings.warn("AffectedTextFiles(include_deletes=%s)"
+                        " is deprecated and ignored" % str(include_deletes),
+                    category=DeprecationWarning,
+                    stacklevel=2)
+    return filter(lambda x: x.IsTextFile(),
+                  self.AffectedFiles(include_dirs=False, include_deletes=False))
 
   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.
 
@@ skipping 59 matching lines @@
     # 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."""
+    """Returns True if the file is a text file and not a binary file.
+    
+    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.
     """
@@ skipping 148 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),
-                                    include_deletes)
+  def AffectedTextFiles(self, include_deletes=None):
+    """Return a list of the existing text files in a change."""
+    if include_deletes is not None:
+      warnings.warn("AffectedTextFiles(include_deletes=%s)"
+                        " is deprecated and ignored" % str(include_deletes),
+                    category=DeprecationWarning,
+                    stacklevel=2)
+    return filter(lambda x: x.IsTextFile(),
+                  self.AffectedFiles(include_dirs=False, include_deletes=False))
 
   def LocalPaths(self, include_dirs=False):
     """Convenience function."""
     return [af.LocalPath() for af in self.AffectedFiles(include_dirs)]
 
   def AbsoluteLocalPaths(self, include_dirs=False):
     """Convenience function."""
     return [af.AbsoluteLocalPath() for af in self.AffectedFiles(include_dirs)]
 
   def ServerPaths(self, include_dirs=False):
@@ skipping 209 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))