Remove gcl.ChangeInfo dependency in presubmit_support.py.

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.3.2'
 
@@ skipping 155 matching lines @@
       r".*\b[A-Z0-9_]+$",
       # SCM (can happen in dual SCM configuration). (Slightly over aggressive)
       r".*\.git[\\\/].*",
       r".*\.svn[\\\/].*",
   )
 
   def __init__(self, change, presubmit_path, is_committing):
     """Builds an InputApi object.
 
     Args:
-      change: A presubmit.GclChange object.
+      change: A presubmit.Change object.
       presubmit_path: The path to the presubmit script being processed.
       is_committing: True if the change is about to be committed.
     """
     # Version number of the presubmit_support script.
     self.version = [int(x) for x in __version__.split('.')]
     self.change = change
     self.is_committing = is_committing
 
     # We expose various modules and functions as attributes of the input_api
     # so that presubmit scripts don't have to import them.
@@ skipping 166 matching lines @@
         line_number += 1
         yield (af, line_number, line)
 
 
 class AffectedFile(object):
   """Representation of a file in a change."""
 
   def __init__(self, path, action, repository_root=''):
     self._path = path
     self._action = action
-    self._repository_root = repository_root
+    self._local_root = repository_root
     self._is_directory = None
     self._properties = {}
     self.scm = ''
 
   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):
     """Returns the path of this file on the local disk relative to client root.
     """
     return normpath(self._path)
 
   def AbsoluteLocalPath(self):
     """Returns the absolute path of this file on the local disk.
     """
-    return normpath(os.path.join(self._repository_root, self.LocalPath()))
+    return normpath(os.path.join(self._local_root, self.LocalPath()))
 
   def IsDirectory(self):
     """Returns true if this object is a directory."""
     if self._is_directory is None:
       path = self.AbsoluteLocalPath()
       self._is_directory = (os.path.exists(path) and
                             os.path.isdir(path))
     return self._is_directory
 
   def Action(self):
@@ skipping 88 matching lines @@
         self._is_text_file = False
       elif self.IsDirectory():
         self._is_text_file = False
       else:
         mime_type = gcl.GetSVNFileProperty(self.AbsoluteLocalPath(),
                                            'svn:mime-type')
         self._is_text_file = (not mime_type or mime_type.startswith('text/'))
     return self._is_text_file
 
 
-class GclChange(object):
+class Change(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']
   """
 
+  _AFFECTED_FILES = AffectedFile
+
   # Matches key/value (or "tag") lines in changelist descriptions.
-  _tag_line_re = re.compile(
+  _TAG_LINE_RE = re.compile(
       '^\s*(?P<key>[A-Z][A-Z_0-9]*)\s*=\s*(?P<value>.*?)\s*$')
 
-  def __init__(self, change_info):
-    #  Do not keep a reference to the original change_info.
-    self._name = change_info.name
-    self._full_description = change_info.description
-    self._repository_root = change_info.GetLocalRoot()
-    self.issue = change_info.issue
-    self.patchset = change_info.patchset
+  def __init__(self, name, description, local_root, files, issue, patchset):
+    if files is None:
+      files = []
+    self._name = name
+    self._full_description = description
+    self._local_root = local_root
+    self.issue = issue
+    self.patchset = patchset
 
     # From the description text, build up a dictionary of key/value pairs
     # plus the description minus all key/value or "tag" lines.
     self._description_without_tags = []
     self.tags = {}
     for line in self._full_description.splitlines():
-      m = self._tag_line_re.match(line)
+      m = self._TAG_LINE_RE.match(line)
       if m:
         self.tags[m.group('key')] = m.group('value')
       else:
         self._description_without_tags.append(line)
 
     # Change back to text and remove whitespace at end.
     self._description_without_tags = '\n'.join(self._description_without_tags)
     self._description_without_tags = self._description_without_tags.rstrip()
 
     self._affected_files = [
-        SvnAffectedFile(info[1], info[0].strip(), self._repository_root)
-        for info in change_info.GetFiles()
+        self._AFFECTED_FILES(info[1], info[0].strip(), self._local_root)
+        for info in files
     ]
 
   def Name(self):
     """Returns the change name."""
     return self._name
 
   def DescriptionText(self):
     """Returns the user-entered changelist description, minus tags.
 
     Any line in the user-provided description starting with e.g. "FOO="
     (whitespace permitted before and around) is considered a tag line.  Such
     lines are stripped out of the description this function returns.
     """
     return self._description_without_tags
 
   def FullDescriptionText(self):
     """Returns the complete changelist description including tags."""
     return self._full_description
 
   def RepositoryRoot(self):
     """Returns the repository (checkout) root directory for this change,
     as an absolute path.
     """
-    return self._repository_root
+    return self._local_root
 
   def __getattr__(self, attr):
     """Return tags directly as attributes on the object."""
     if not re.match(r"^[A-Z_]*$", attr):
       raise AttributeError(self, attr)
     return self.tags.get(attr)
 
   def AffectedFiles(self, include_dirs=False, include_deletes=True):
     """Returns a list of AffectedFile instances for all files in the change.
 
@@ skipping 48 matching lines @@
       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(
         filter(lambda x: x.IsTextFile(),
                self.AffectedFiles(include_deletes=False)))
 
 
+class SvnChange(Change):
+  _AFFECTED_FILES = SvnAffectedFile
+
+
 def ListRelevantPresubmitFiles(files, root):
   """Finds all presubmit files that apply to a given set of source files.
 
   Args:
     files: An iterable container containing file paths.
     root: Path where to stop searching.
 
   Return:
     List of absolute paths of the existing PRESUBMIT.py scripts.
   """
   entries = []
   for f in files:
     f = normpath(os.path.join(root, f))
     while f:
       f = os.path.dirname(f)
       if f in entries:
         break
       entries.append(f)
       if f == root:
         break
   entries.sort()
   entries = map(lambda x: os.path.join(x, 'PRESUBMIT.py'), entries)
   return filter(lambda x: os.path.isfile(x), entries)
 
 
 class PresubmitExecuter(object):
-  def __init__(self, change_info, committing):
+  def __init__(self, change, committing):
     """
     Args:
-      change_info: The gcl.ChangeInfo object for the change.
+      change: The Change object.
       committing: True if 'gcl commit' is running, False if 'gcl upload' is.
     """
-    # TODO(maruel): Determine the SCM.
-    self.change = GclChange(change_info)
+    self.change = change
     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 21 matching lines @@
         if not isinstance(item, OutputApi.PresubmitResult):
           raise exceptions.RuntimeError(
             'All presubmit results must be of types derived from '
             'output_api.PresubmitResult')
     else:
       result = ()  # no error since the script doesn't care about current event.
 
     return result
 
 
-def DoPresubmitChecks(change_info,
+def DoPresubmitChecks(change,
                       committing,
                       verbose,
                       output_stream,
                       input_stream,
                       default_presubmit,
                       may_prompt):
   """Runs all presubmit checks that apply to the files in the change.
 
   This finds all PRESUBMIT.py files in directories enclosing the files in the
   change (up to the repository root) and calls the relevant entrypoint function
   depending on whether the change is being committed or uploaded.
 
   Prints errors, warnings and notifications.  Prompts the user for warnings
   when needed.
 
   Args:
-    change_info: The gcl.ChangeInfo object for the change.
+    change: The Change object.
     committing: True if 'gcl commit' is running, False if 'gcl upload' is.
     verbose: Prints debug info.
     output_stream: A stream to write output from presubmit tests to.
     input_stream: A stream to read input from the user.
     default_presubmit: A default presubmit script to execute in any case.
     may_prompt: Enable (y/n) questions on warning or error.
 
   Return:
     True if execution can continue, False if not.
   """
-  presubmit_files = ListRelevantPresubmitFiles(change_info.GetFileNames(),
-                                               change_info.GetLocalRoot())
+  presubmit_files = ListRelevantPresubmitFiles(change.AbsoluteLocalPaths(True),
+                                               change.RepositoryRoot())
   if not presubmit_files and verbose:
     output_stream.write("Warning, no presubmit.py found.\n")
   results = []
-  executer = PresubmitExecuter(change_info, committing)
+  executer = PresubmitExecuter(change, committing)
   if default_presubmit:
     if verbose:
       output_stream.write("Running default presubmit script.\n")
-    fake_path = os.path.join(change_info.GetLocalRoot(), 'PRESUBMIT.py')
+    fake_path = os.path.join(change.RepositoryRoot(), 'PRESUBMIT.py')
     results += executer.ExecPresubmitScript(default_presubmit, fake_path)
   for filename in presubmit_files:
     filename = os.path.abspath(filename)
     if verbose:
       output_stream.write("Running %s\n" % filename)
     # Accept CRLF presubmit script.
     presubmit_script = gcl.ReadFile(filename, 'rU')
     results += executer.ExecPresubmitScript(presubmit_script, filename)
 
   errors = []
@@ skipping 50 matching lines @@
 
 def Main(argv):
   parser = optparse.OptionParser(usage="%prog [options]",
                                  version="%prog " + str(__version__))
   parser.add_option("-c", "--commit", action="store_true",
                    help="Use commit instead of upload checks")
   parser.add_option("-r", "--recursive", action="store_true",
                    help="Act recursively")
   parser.add_option("-v", "--verbose", action="store_true",
                    help="Verbose output")
+  parser.add_option("--files", default='')
+  parser.add_option("--name", default='no name')
+  parser.add_option("--description", default='')
+  parser.add_option("--issue", type='int', default=0)
+  parser.add_option("--patchset", type='int', default=0)
+  parser.add_options("--root", default='')
+  parser.add_options("--default_presubmit", default='')
+  parser.add_options("--may_prompt", action='store_true')
   options, args = parser.parse_args(argv[1:])
-  files = ParseFiles(args, options.recursive)
+  if not options.files:
+    options.files = ParseFiles(args, options.recursive)
+  if not options.root:
+    options.root = gcl.GetRepositoryRoot()
   if options.verbose:
     print "Found %d files." % len(files)
-  return not DoPresubmitChecks(gcl.ChangeInfo('No name', 0, 0, '', files,
-                                              gcl.GetRepositoryRoot()),
+  return not DoPresubmitChecks(SvnChange(options.name,
+                                         options.description,
+                                         options.root,
+                                         options.files,
+                                         options.issue,
+                                         options.patchset),
                                options.commit,
                                options.verbose,
                                sys.stdout,
                                sys.stdin,
-                               None,
-                               False)
+                               options.default_presubmit,
+                               options.may_prompt)
 
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv))