A step closer to make presubmit SCM independent.

gcl.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.
 #
 # Wrapper script around Rietveld's upload.py that groups files into
 # changelists.
 
 import getpass
 import os
@@ skipping 268 matching lines @@
   # _SEPARATOR\n
   # description
 
   def __init__(self, name, issue, patchset, description, files):
     self.name = name
     self.issue = int(issue)
     self.patchset = int(patchset)
     self.description = description
     if files is None:
       files = []
-    self.files = files
+    self._files = files
     self.patch = None
+    self._local_root = GetRepositoryRoot()
 
-  def FileList(self):
-    """Returns a list of files."""
-    return [file[1] for file in self.files]
+  def GetFileNames(self):
+    """Returns the list of file names included in this change."""
+    return [file[1] for file in self._files]
+
+  def GetFiles(self):
+    """Returns the list of files included in this change with their status."""
+    return self._files
+
+  def GetLocalRoot(self):
+    """Returns the local repository checkout root directory."""
+    return self._local_root
 
   def _NonDeletedFileList(self):
     """Returns a list of files in this change, not including deleted files."""
-    return [file[1] for file in self.files if not file[0].startswith("D")]
+    return [file[1] for file in self.GetFiles()
+            if not file[0].startswith("D")]
 
   def _AddedFileList(self):
     """Returns a list of files added in this change."""
-    return [file[1] for file in self.files if file[0].startswith("A")]
+    return [file[1] for file in self.GetFiles() if file[0].startswith("A")]
 
   def Save(self):
     """Writes the changelist information to disk."""
     data = ChangeInfo._SEPARATOR.join([
         "%d, %d" % (self.issue, self.patchset),
-        "\n".join([f[0] + f[1] for f in self.files]),
+        "\n".join([f[0] + f[1] for f in self.GetFiles()]),
         self.description])
     WriteFile(GetChangelistInfoFile(self.name), data)
 
   def Delete(self):
     """Removes the changelist information from disk."""
     os.remove(GetChangelistInfoFile(self.name))
 
   def CloseIssue(self):
     """Closes the Rietveld issue for this changelist."""
     data = [("description", self.description),]
@@ skipping 51 matching lines @@
 
     Inline methods added to header files won't be detected by this. That's
     acceptable for purposes of determining if a unit test is needed, since
     inline methods should be trivial.
     """
     # To check for methods added to source or header files, we need the diffs.
     # We'll generate them all, since there aren't likely to be many files
     # apart from source and headers; besides, we'll want them all if we're
     # uploading anyway.
     if self.patch is None:
-      self.patch = GenerateDiff(self.FileList())
+      self.patch = GenerateDiff(self.GetFileNames())
 
     definition = ""
     for line in self.patch.splitlines():
       if not line.startswith("+"):
         continue
       line = line.strip("+").rstrip(" \t")
       # Skip empty lines, comments, and preprocessor directives.
       # TODO(pamg): Handle multiline comments if it turns out to be a problem.
       if line == "" or line.startswith("/") or line.startswith("#"):
         continue
@@ skipping 77 matching lines @@
 
 def LoadChangelistInfoForMultiple(changenames, fail_on_not_found=True,
                                   update_status=False):
   """Loads many changes and merge their files list into one pseudo change.
 
   This is mainly usefull to concatenate many changes into one for a 'gcl try'.
   """
   changes = changenames.split(',')
   aggregate_change_info = ChangeInfo(changenames, 0, 0, '', None)
   for change in changes:
-    aggregate_change_info.files += ChangeInfo.Load(change, fail_on_not_found,
-                                                   update_status).files
+    aggregate_change_info._files += ChangeInfo.Load(change, fail_on_not_found,
+                                                    update_status).GetFiles()
   return aggregate_change_info
 
 
 def GetCLs():
   """Returns a list of all the changelists in this repository."""
   cls = os.listdir(GetChangesDir())
   if CODEREVIEW_SETTINGS_FILE in cls:
     cls.remove(CODEREVIEW_SETTINGS_FILE)
   return cls
 
@@ skipping 22 matching lines @@
   files = {}
 
   # Since the files are normalized to the root folder of the repositary, figure
   # out what we need to add to the paths.
   dir_prefix = os.getcwd()[len(GetRepositoryRoot()):].strip(os.sep)
 
   # Get a list of all files in changelists.
   files_in_cl = {}
   for cl in GetCLs():
     change_info = ChangeInfo.Load(cl)
-    for status, filename in change_info.files:
+    for status, filename in change_info.GetFiles():
       files_in_cl[filename] = change_info.name
 
   # Get all the modified files.
   status_result = gclient.CaptureSVNStatus(None)
   for line in status_result:
     status = line[0]
     filename = line[1]
     if status[0] == "?":
       continue
     if dir_prefix:
@@ skipping 47 matching lines @@
 
 
 def Opened():
   """Prints a list of modified files in the current directory down."""
   files = GetModifiedFiles()
   cl_keys = files.keys()
   cl_keys.sort()
   for cl_name in cl_keys:
     if cl_name:
       note = ""
-      if len(ChangeInfo.Load(cl_name).files) != len(files[cl_name]):
+      if len(ChangeInfo.Load(cl_name).GetFiles()) != len(files[cl_name]):
         note = " (Note: this changelist contains files outside this directory)"
       print "\n--- Changelist " + cl_name + note + ":"
     for file in files[cl_name]:
       print "".join(file)
 
 
 def Help(argv=None):
   if argv:
     if argv[0] == 'try':
       TryChange(None, ['--help'], swallow_exception=False)
@@ skipping 125 matching lines @@
 
 
 
 def OptionallyDoPresubmitChecks(change_info, committing, args):
   if FilterFlag(args, "--no_presubmit") or FilterFlag(args, "--force"):
     return True
   return DoPresubmitChecks(change_info, committing, True)
 
 
 def UploadCL(change_info, args):
-  if not change_info.FileList():
+  if not change_info.GetFiles():
     print "Nothing to upload, changelist is empty."
     return
   if not OptionallyDoPresubmitChecks(change_info, False, args):
     return
   no_try = FilterFlag(args, "--no_try") or FilterFlag(args, "--no-try")
   no_watchlists = FilterFlag(args, "--no_watchlists") or \
                   FilterFlag(args, "--no-watchlists")
 
   # Map --send-mail to --send_mail
   if FilterFlag(args, "--send-mail"):
@@ skipping 28 matching lines @@
     upload_arg.append("--issue=%d" % change_info.issue)
   else: # First time we upload.
     handle, desc_file = tempfile.mkstemp(text=True)
     os.write(handle, change_info.description)
     os.close(handle)
 
     # Watchlist processing -- CC people interested in this changeset
     # http://dev.chromium.org/developers/contributing-code/watchlists
     if not no_watchlists:
       import watchlists
-      watchlist = watchlists.Watchlists(GetRepositoryRoot())
+      watchlist = watchlists.Watchlists(change_info.GetLocalRoot())
       watchers = watchlist.GetWatchersForPaths(change_info.FileList())
 
     cc_list = GetCodeReviewSetting("CC_LIST")
     if not no_watchlists and watchers:
         # Filter out all empty elements and join by ','
         cc_list = ','.join(filter(None, [cc_list] + watchers))
     if cc_list:
       upload_arg.append("--cc=" + cc_list)
     upload_arg.append("--description_file=" + desc_file + "")
     if change_info.description:
       subject = change_info.description[:77]
       if subject.find("\r\n") != -1:
         subject = subject[:subject.find("\r\n")]
       if subject.find("\n") != -1:
         subject = subject[:subject.find("\n")]
       if len(change_info.description) > 77:
         subject = subject + "..."
       upload_arg.append("--message=" + subject)
 
   # Change the current working directory before calling upload.py so that it
   # shows the correct base.
   previous_cwd = os.getcwd()
-  os.chdir(GetRepositoryRoot())
+  os.chdir(change_info.GetLocalRoot())
 
   # If we have a lot of files with long paths, then we won't be able to fit
   # the command to "svn diff".  Instead, we generate the diff manually for
   # each file and concatenate them before passing it to upload.py.
   if change_info.patch is None:
-    change_info.patch = GenerateDiff(change_info.FileList())
+    change_info.patch = GenerateDiff(change_info.GetFileNames())
   issue, patchset = upload.RealMain(upload_arg, change_info.patch)
   if issue and patchset:
     change_info.issue = int(issue)
     change_info.patchset = int(patchset)
     change_info.Save()
 
   if desc_file:
     os.remove(desc_file)
 
   # Do background work on Rietveld to lint the file so that the results are
   # ready when the issue is viewed.
   SendToRietveld("/lint/issue%s_%s" % (issue, patchset), timeout=0.5)
 
   # Once uploaded to Rietveld, send it to the try server.
   if not no_try:
     try_on_upload = GetCodeReviewSetting('TRY_ON_UPLOAD')
     if try_on_upload and try_on_upload.lower() == 'true':
       trychange_args = []
       if clobber:
         trychange_args.append('--clobber')
       TryChange(change_info, trychange_args, swallow_exception=True)
 
   os.chdir(previous_cwd)
 
 
 def PresubmitCL(change_info):
   """Reports what presubmit checks on the change would report."""
-  if not change_info.FileList():
+  if not change_info.GetFiles():
     print "Nothing to presubmit check, changelist is empty."
     return
 
   print "*** Presubmit checks for UPLOAD would report: ***"
   DoPresubmitChecks(change_info, False, False)
 
   print "\n*** Presubmit checks for COMMIT would report: ***"
   DoPresubmitChecks(change_info, True, False)
 
 
 def TryChange(change_info, args, swallow_exception):
   """Create a diff file of change_info and send it to the try server."""
   try:
     import trychange
   except ImportError:
     if swallow_exception:
       return
     ErrorExit("You need to install trychange.py to use the try server.")
 
   if change_info:
     trychange_args = ['--name', change_info.name]
     if change_info.issue:
       trychange_args.extend(["--issue", str(change_info.issue)])
     if change_info.patchset:
       trychange_args.extend(["--patchset", str(change_info.patchset)])
     trychange_args.extend(args)
     trychange.TryChange(trychange_args,
-                        file_list=change_info.FileList(),
+                        file_list=change_info.GetFileNames(),
                         swallow_exception=swallow_exception,
                         prog='gcl try')
   else:
     trychange.TryChange(args,
                         file_list=None,
                         swallow_exception=swallow_exception,
                         prog='gcl try')
 
 
 def Commit(change_info, args):
-  if not change_info.FileList():
+  if not change_info.GetFiles():
     print "Nothing to commit, changelist is empty."
     return
   if not OptionallyDoPresubmitChecks(change_info, True, args):
     return
 
   # We face a problem with svn here: Let's say change 'bleh' modifies
   # svn:ignore on dir1\. but another unrelated change 'pouet' modifies
   # dir1\foo.cc. When the user `gcl commit bleh`, foo.cc is *also committed*.
   # The only fix is to use --non-recursive but that has its issues too:
   # Let's say if dir1 is deleted, --non-recursive must *not* be used otherwise
   # you'll get "svn: Cannot non-recursively commit a directory deletion of a
   # directory with child nodes". Yay...
   commit_cmd = ["svn", "commit"]
   filename = ''
   if change_info.issue:
     # Get the latest description from Rietveld.
     change_info.description = GetIssueDescription(change_info.issue)
 
   commit_message = change_info.description.replace('\r\n', '\n')
   if change_info.issue:
     commit_message += ('\nReview URL: http://%s/%d' %
                        (GetCodeReviewSetting("CODE_REVIEW_SERVER"),
                         change_info.issue))
 
   handle, commit_filename = tempfile.mkstemp(text=True)
   os.write(handle, commit_message)
   os.close(handle)
 
   handle, targets_filename = tempfile.mkstemp(text=True)
-  os.write(handle, "\n".join(change_info.FileList()))
+  os.write(handle, "\n".join(change_info.GetFileNames()))
   os.close(handle)
 
   commit_cmd += ['--file=' + commit_filename]
   commit_cmd += ['--targets=' + targets_filename]
   # Change the current working directory before calling commit.
   previous_cwd = os.getcwd()
-  os.chdir(GetRepositoryRoot())
+  os.chdir(change_info.GetLocalRoot())
   output = RunShell(commit_cmd, True)
   os.remove(commit_filename)
   os.remove(targets_filename)
   if output.find("Committed revision") != -1:
     change_info.Delete()
 
     if change_info.issue:
       revision = re.compile(".*?\nCommitted revision (\d+)",
                             re.DOTALL).match(output).group(1)
       viewvc_url = GetCodeReviewSetting("VIEW_VC")
@@ skipping 25 matching lines @@
 
   other_files = GetFilesNotInCL()
   
   #Edited files will have a letter for the first character in a string.
   #This regex looks for the presence of that character.
   file_re = re.compile(r"^[a-z].+\Z", re.IGNORECASE)
   affected_files = filter(lambda x: file_re.match(x[0]), other_files)
   unaffected_files = filter(lambda x: not file_re.match(x[0]), other_files)
 
   separator1 = ("\n---All lines above this line become the description.\n"
-                "---Repository Root: " + GetRepositoryRoot() + "\n"
+                "---Repository Root: " + change_info.GetLocalRoot() + "\n"
                 "---Paths in this changelist (" + change_info.name + "):\n")
   separator2 = "\n\n---Paths modified but not in any changelist:\n\n"
   text = (description + separator1 + '\n' +
-          '\n'.join([f[0] + f[1] for f in change_info.files]) + separator2 +
+          '\n'.join([f[0] + f[1] for f in change_info.GetFiles()]) +
+          separator2 +
           '\n'.join([f[0] + f[1] for f in affected_files]) + '\n' +
           '\n'.join([f[0] + f[1] for f in unaffected_files]) + '\n')
 
   handle, filename = tempfile.mkstemp(text=True)
   os.write(handle, text)
   os.close(handle)
 
   os.system(GetEditor() + " " + filename)
 
   result = ReadFile(filename)
@@ skipping 16 matching lines @@
 
   new_cl_files = []
   for line in cl_files_text.splitlines():
     if not len(line):
       continue
     if line.startswith("---"):
       break
     status = line[:7]
     file = line[7:]
     new_cl_files.append((status, file))
-  change_info.files = new_cl_files
+  change_info._files = new_cl_files
 
   change_info.Save()
   print change_info.name + " changelist saved."
   if change_info.MissingTests():
     Warn("WARNING: " + MISSING_TEST_MSG)
 
 # We don't lint files in these path prefixes.
 IGNORE_PATHS = ("webkit",)
 
 # Valid extensions for files we want to lint.
 CPP_EXTENSIONS = ("cpp", "cc", "h")
 
 def Lint(change_info, args):
   """Runs cpplint.py on all the files in |change_info|"""
   try:
     import cpplint
   except ImportError:
     ErrorExit("You need to install cpplint.py to lint C++ files.")
 
   # Change the current working directory before calling lint so that it
   # shows the correct base.
   previous_cwd = os.getcwd()
-  os.chdir(GetRepositoryRoot())
+  os.chdir(change_info.GetLocalRoot())
 
   # Process cpplints arguments if any.
-  filenames = cpplint.ParseArguments(args + change_info.FileList())
+  filenames = cpplint.ParseArguments(args + change_info.GetFileNames())
 
   for file in filenames:
     if len([file for suffix in CPP_EXTENSIONS if file.endswith(suffix)]):
       if len([file for prefix in IGNORE_PATHS if file.startswith(prefix)]):
         print "Ignoring non-Google styled file %s" % file
       else:
         cpplint.ProcessFile(file, cpplint._cpplint_state.verbose_level)
 
   print "Total errors found: %d\n" % cpplint._cpplint_state.error_count
   os.chdir(previous_cwd)
@@ skipping 14 matching lines @@
   if not result and may_prompt:
     print "\nPresubmit errors, can't continue (use --no_presubmit to bypass)"
   return result
 
 
 def Changes():
   """Print all the changelists and their files."""
   for cl in GetCLs():
     change_info = ChangeInfo.Load(cl, True, True)
     print "\n--- Changelist " + change_info.name + ":"
-    for file in change_info.files:
+    for file in change_info.GetFiles():
       print "".join(file)
 
 
 def main(argv=None):
   if argv is None:
     argv = sys.argv
 
   if len(argv) == 1:
     Help()
     return 0;
@@ skipping 75 matching lines @@
     UploadCL(change_info, argv[3:])
   elif command == "presubmit":
     PresubmitCL(change_info)
   elif command in ("commit", "submit"):
     Commit(change_info, argv[3:])
   elif command == "delete":
     change_info.Delete()
   elif command == "try":
     # When the change contains no file, send the "changename" positional
     # argument to trychange.py.
-    if change_info.files:
+    if change_info.GetFiles():
       args = argv[3:]
     else:
       change_info = None
       args = argv[2:]
     TryChange(change_info, args, swallow_exception=False)
   else:
     # Everything else that is passed into gcl we redirect to svn, after adding
     # the files. This allows commands such as 'gcl diff xxx' to work.
     args =["svn", command]
     root = GetRepositoryRoot()
-    args.extend([os.path.join(root, x) for x in change_info.FileList()])
+    args.extend([os.path.join(root, x) for x in change_info.GetFileNames()])
     RunShell(args, True)
   return 0
 
 
 if __name__ == "__main__":
   sys.exit(main())