Makes trychange.py search harder for codereview.settings in a gclient checkout.

trychange.py

 #!/usr/bin/python
 # Copyright (c) 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.
 """Client-side script to send a try job to the try server. It communicates to
 the try server by either writting to a svn repository or by directly connecting
 to the server by HTTP.
 """
 
 import datetime
@@ skipping 99 matching lines @@
       self.codereview_settings = {}
       settings_file = self.ReadRootFile(self.codereview_settings_file)
       if settings_file:
         for line in settings_file.splitlines():
           if not line or line.lstrip().startswith('#'):
             continue
           k, v = line.split(":", 1)
           self.codereview_settings[k.strip()] = v.strip()
     return self.codereview_settings.get(key, '')
 
-  def GclStyleSettings(self):
+  def _GclStyleSettings(self):
     """Set default settings based on the gcl-style settings from the
     repository."""
     settings = {
       'port': self.GetCodeReviewSetting('TRYSERVER_HTTP_PORT'),
       'host': self.GetCodeReviewSetting('TRYSERVER_HTTP_HOST'),
       'svn_repo': self.GetCodeReviewSetting('TRYSERVER_SVN_URL'),
       'project': self.GetCodeReviewSetting('TRYSERVER_PROJECT'),
       'root': self.GetCodeReviewSetting('TRYSERVER_ROOT'),
       'patchlevel': self.GetCodeReviewSetting('TRYSERVER_PATCHLEVEL'),
     }
+    logging.info('\n'.join(['%s: %s' % (k, v)
+                            for (k, v) in settings.iteritems() if v]))
     for (k, v) in settings.iteritems():
       if v and getattr(self.options, k) is None:
         setattr(self.options, k, v)
 
-  def GclientStyleSettings(self):
+  def _GclientStyleSettings(self):
     """Find the root, assuming a gclient-style checkout."""
+    self.gclient_root = None
     if not self.options.no_gclient and not self.options.root:
       root = self.checkout_root
-      gclient_root = gclient_utils.FindGclientRoot(root)
-      if gclient_root:
-        self.options.root = gclient_utils.PathDifference(gclient_root, root)
+      self.gclient_root = gclient_utils.FindGclientRoot(root)
+      if self.gclient_root:
+        logging.info('Found .gclient at %s' % self.gclient_root)
+        self.options.root = gclient_utils.PathDifference(self.gclient_root,
+                                                         root)
 
   def AutomagicalSettings(self):
     """Determines settings based on supported code review and checkout tools.
     """
-    self.GclStyleSettings()
-    self.GclientStyleSettings()
+    self._GclientStyleSettings()
+    self._GclStyleSettings()
 
   def ReadRootFile(self, filename):
-    raise NotImplementedError()
+    if not self.options.root:
+      filepath = os.path.join(self.checkout_root, filename)
+      if os.path.isfile(filepath):
+        logging.info('Found %s at %s' % (filename, self.checkout_root))
+        return gclient_util.FileRead(filepath)
+      return None
+    root = os.path.abspath(self.gclient_root)
+    cur = os.path.abspath(self.checkout_root)
+    assert cur.startswith(root), (root, cur)
+    while cur.startswith(root):
+      filepath = os.path.join(cur, filename)
+      if os.path.isfile(filepath):
+        logging.info('Found %s at %s' % (filename, cur))
+        return gclient_utils.FileRead(filepath)
+      cur = os.path.dirname(cur)
+    logging.warning('Didn\'t find %s' % filename)
+    return None
 
 
 class SVN(SCM):
   """Gathers the options and diff for a subversion checkout."""
   def __init__(self, *args, **kwargs):
     SCM.__init__(self, *args, **kwargs)
     self.checkout_root = scm.SVN.GetCheckoutRoot(self.checkout_root)
     if not self.options.email:
       # Assumes the svn credential is an email address.
       self.options.email = scm.SVN.GetEmail(self.checkout_root)
     logging.info("SVN(%s)" % self.checkout_root)
 
   def ReadRootFile(self, filename):
+    data = SCM.ReadRootFile(self, filename)
+    if data:
+      return data
+
+    # Try to search on the subversion repository for the file.
     try:
-      # Try to search on the subversion repository for the file.
-      import gcl
-      data = gcl.GetCachedFile(filename)
-      logging.debug('%s:\n%s' % (filename, data))
-      return data
+      from gcl import GetCachedFile
     except ImportError:
-      try:
-        data = gclient_utils.FileRead(os.path.join(self.checkout_root,
-                                                   filename))
-        logging.debug('%s:\n%s' % (filename, data))
-        return data
-      except (IOError, OSError):
-        logging.debug('%s:\nNone' % filename)
-        return None
+      return None
+    data = GetCachedFile(filename)
+    logging.debug('%s:\n%s' % (filename, data))
+    return data
 
   def GenerateDiff(self):
     """Returns a string containing the diff for the given file list.
 
     The files in the list should either be absolute paths or relative to the
     given root.
     """
     if not self.files:
       previous_cwd = os.getcwd()
       os.chdir(self.checkout_root)
@@ skipping 26 matching lines @@
       self.options.email = scm.GIT.GetEmail(self.checkout_root)
     if not self.diff_against:
       self.diff_against = scm.GIT.GetUpstreamBranch(self.checkout_root)
       if not self.diff_against:
         raise NoTryServerAccess(
             "Unable to determine default branch to diff against. "
             "Verify this branch is set up to track another"
             "(via the --track argument to \"git checkout -b ...\"")
     logging.info("GIT(%s)" % self.checkout_root)
 
-  def ReadRootFile(self, filename):
-    try:
-      # A git checkout is always a full checkout.
-      data = gclient_utils.FileRead(os.path.join(self.checkout_root, filename))
-      logging.debug('%s:\n%s' % (filename, data))
-      return data
-    except (IOError, OSError):
-      logging.debug('%s:\nNone' % filename)
-      return None
-
   def GenerateDiff(self):
     if not self.files:
       self.files = scm.GIT.GetDifferentFiles(self.checkout_root,
                                              branch=self.diff_against)
 
     def NotExcluded(f):
       for r in self.options.exclude:
         if re.search(r, f):
           logging.info('Ignoring "%s"' % f)
           return False
@@ skipping 331 matching lines @@
                    help="SVN url to use to write the changes in; --use_svn is "
                         "implied when using --svn_repo")
   parser.add_option_group(group)
 
   options, args = parser.parse_args(argv)
   if len(args) == 1 and args[0] == 'help':
     parser.print_help()
 
   if not swallow_exception:
     if options.verbose == 0:
-      logging.basicConfig(level=logging.ERROR)
+      logging.basicConfig(level=logging.WARNING)
     elif options.verbose == 1:
-      logging.basicConfig(level=logging.WARNING)
-    elif options.verbose == 2:
       logging.basicConfig(level=logging.INFO)
-    elif options.verbose > 2:
+    elif options.verbose > 1:
       logging.basicConfig(level=logging.DEBUG)
 
   logging.debug(argv)
 
   if options.rietveld_url:
     # Try to extract the review number if possible and fix the protocol.
     if not '://' in options.rietveld_url:
       options.rietveld_url = 'http://' + options.rietveld_url
     match = re.match(r'^(.*)/(\d+)$', options.rietveld_url)
     if match:
@@ skipping 110 matching lines @@
   except (InvalidScript, NoTryServerAccess), e:
     if swallow_exception:
       return 1
     print e
     return 1
   return 0
 
 
 if __name__ == "__main__":
   sys.exit(TryChange(None, [], False))