Switch usage of self._root_dir to self.root_dir()

gclient.py

 #!/usr/bin/python
 # Copyright (c) 2010 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.
 
 """A wrapper script to manage a set of client modules in different SCM.
 
 This script is intended to be used to help basic management of client
 program sources residing in one or more Subversion modules and Git
 repositories, along with other modules it depends on, also in Subversion or Git,
@@ skipping 199 matching lines @@
     self._config_dict = {}
     self._deps_hooks = []
 
   def SetConfig(self, content):
     self._config_dict = {}
     self.config_content = content
     try:
       exec(content, self._config_dict)
     except SyntaxError, e:
       try:
-        __pychecker__ = 'no-objattrs'
         # Try to construct a human readable error message
         error_message = [
             'There is a syntax error in your configuration file.',
             'Line #%s, character %s:' % (e.lineno, e.offset),
             '"%s"' % re.sub(r'[\r\n]*$', '', e.text) ]
       except:
         # Something went wrong, re-raise the original exception
         raise e
       else:
         # Raise a new exception with the human readable message:
         raise gclient_utils.Error('\n'.join(error_message))
 
   def SaveConfig(self):
-    gclient_utils.FileWrite(os.path.join(self._root_dir,
+    gclient_utils.FileWrite(os.path.join(self.root_dir(),
                                          self._options.config_filename),
                             self.config_content)
 
   def _LoadConfig(self):
     client_source = gclient_utils.FileRead(
-        os.path.join(self._root_dir, self._options.config_filename))
+        os.path.join(self.root_dir(), self._options.config_filename))
     self.SetConfig(client_source)
 
   def GetVar(self, key, default=None):
     return self._config_dict.get(key, default)
 
   @staticmethod
   def LoadCurrentConfig(options, from_dir=None):
     """Searches for and loads a .gclient file relative to the current working
     dir.
 
@@ skipping 27 matching lines @@
 
     Args:
       entries: A sequence of solution names.
     """
     # Sometimes pprint.pformat will use {', sometimes it'll use { ' ... It
     # makes testing a bit too fun.
     result = pprint.pformat(entries, 2)
     if result.startswith('{\''):
       result = '{ \'' + result[2:]
     text = "entries = \\\n" + result + '\n'
-    file_path = os.path.join(self._root_dir, self._options.entries_filename)
+    file_path = os.path.join(self.root_dir(), self._options.entries_filename)
     gclient_utils.FileWrite(file_path, text)
 
   def _ReadEntries(self):
     """Read the .gclient_entries file for the given client.
 
     Args:
       client: The client for which the entries file should be read.
 
     Returns:
       A sequence of solution names, which will be empty if there is the
       entries file hasn't been created yet.
     """
     scope = {}
-    filename = os.path.join(self._root_dir, self._options.entries_filename)
+    filename = os.path.join(self.root_dir(), self._options.entries_filename)
     if not os.path.exists(filename):
       return []
     exec(gclient_utils.FileRead(filename), scope)
     return scope["entries"]
 
   def _ParseSolutionDeps(self, solution_name, solution_deps_content,
                          custom_vars, parse_hooks):
     """Parses the DEPS file for the specified solution.
 
     Args:
@@ skipping 115 matching lines @@
           elif isinstance(url, str):
             parsed_url = urlparse.urlparse(url)
             scheme = parsed_url[0]
             if not scheme:
               # A relative url. Fetch the real base.
               path = parsed_url[2]
               if path[0] != "/":
                 raise gclient_utils.Error(
                     "relative DEPS entry \"%s\" must begin with a slash" % d)
               # Create a scm just to query the full url.
-              scm = gclient_scm.CreateSCM(solution["url"], self._root_dir,
+              scm = gclient_scm.CreateSCM(solution["url"], self.root_dir(),
                                            None)
               url = scm.FullUrlForRelativeUrl(url)
         if d in deps and deps[d] != url:
           raise gclient_utils.Error(
               "Solutions have conflicting versions of dependency \"%s\"" % d)
         if d in solution_urls and solution_urls[d] != url:
           raise gclient_utils.Error(
               "Dependency \"%s\" conflicts with specified solution" % d)
         # Grab the dependency.
         deps[d] = url
@@ skipping 11 matching lines @@
       # interpreter.
       command[0] = sys.executable
 
     if '$matching_files' in command:
       splice_index = command.index('$matching_files')
       command[splice_index:splice_index + 1] = matching_file_list
 
     # Use a discrete exit status code of 2 to indicate that a hook action
     # failed.  Users of this script may wish to treat hook action failures
     # differently from VC failures.
-    gclient_utils.SubprocessCall(command, self._root_dir, fail_status=2)
+    gclient_utils.SubprocessCall(command, self.root_dir(), fail_status=2)
 
   def _RunHooks(self, command, file_list, is_using_git):
     """Evaluates all hooks, running actions as needed.
     """
     # Hooks only run for these command types.
     if not command in ('update', 'revert', 'runhooks'):
       return
 
     # Hooks only run when --nohooks is not specified
     if self._options.nohooks:
@@ skipping 86 matching lines @@
       deps_file = solution.get("deps_file", self.DEPS_FILE)
       if '/' in deps_file or '\\' in deps_file:
         raise gclient_utils.Error('deps_file name must not be a path, just a '
                                   'filename.')
       if name in entries:
         raise gclient_utils.Error("solution %s specified more than once" % name)
       url = solution["url"]
       entries[name] = url
       if run_scm and url:
         self._options.revision = revision_overrides.get(name)
-        scm = gclient_scm.CreateSCM(url, self._root_dir, name)
+        scm = gclient_scm.CreateSCM(url, self.root_dir(), name)
         scm.RunCommand(command, self._options, args, file_list)
         file_list = [os.path.join(name, f.strip()) for f in file_list]
         self._options.revision = None
       try:
         deps_content = gclient_utils.FileRead(
-            os.path.join(self._root_dir, name, deps_file))
+            os.path.join(self.root_dir(), name, deps_file))
       except IOError, e:
         if e.errno != errno.ENOENT:
           raise
         deps_content = ""
       entries_deps_content[name] = deps_content
 
     # Process the dependencies next (sort alphanumerically to ensure that
     # containing directories get populated first and for readability)
     deps = self._ParseAllDeps(entries, entries_deps_content)
     deps_to_process = deps.keys()
     deps_to_process.sort()
 
     # First pass for direct dependencies.
     if command == 'update' and not self._options.verbose:
       pm = Progress('Syncing projects', len(deps_to_process))
     for d in deps_to_process:
       if command == 'update' and not self._options.verbose:
         pm.update()
       if type(deps[d]) == str:
         url = deps[d]
         entries[d] = url
         if run_scm:
           self._options.revision = revision_overrides.get(d)
-          scm = gclient_scm.CreateSCM(url, self._root_dir, d)
+          scm = gclient_scm.CreateSCM(url, self.root_dir(), d)
           scm.RunCommand(command, self._options, args, file_list)
           self._options.revision = None
       elif isinstance(deps[d], self.FileImpl):
         file_dep = deps[d]
         self._options.revision = file_dep.GetRevision()
         if run_scm:
-          scm = gclient_scm.CreateSCM(file_dep.GetPath(), self._root_dir, d)
+          scm = gclient_scm.CreateSCM(file_dep.GetPath(), self.root_dir(), d)
           scm.RunCommand("updatesingle", self._options,
                          args + [file_dep.GetFilename()], file_list)
 
     if command == 'update' and not self._options.verbose:
       pm.end()
 
     # Second pass for inherited deps (via the From keyword)
     for d in deps_to_process:
       if isinstance(deps[d], self.FromImpl):
-        filename = os.path.join(self._root_dir,
+        filename = os.path.join(self.root_dir(),
                                 deps[d].module_name,
                                 self.DEPS_FILE)
         content =  gclient_utils.FileRead(filename)
         sub_deps = self._ParseSolutionDeps(deps[d].module_name, content, {},
                                            False)
         # Getting the URL from the sub_deps file can involve having to resolve
         # a File() or having to resolve a relative URL.  To resolve relative
         # URLs, we need to pass in the orignal sub deps URL.
         sub_deps_base_url = deps[deps[d].module_name]
-        url = deps[d].GetUrl(d, sub_deps_base_url, self._root_dir, sub_deps)
+        url = deps[d].GetUrl(d, sub_deps_base_url, self.root_dir(), sub_deps)
         entries[d] = url
         if run_scm:
           self._options.revision = revision_overrides.get(d)
-          scm = gclient_scm.CreateSCM(url, self._root_dir, d)
+          scm = gclient_scm.CreateSCM(url, self.root_dir(), d)
           scm.RunCommand(command, self._options, args, file_list)
           self._options.revision = None
 
     # Convert all absolute paths to relative.
     for i in range(len(file_list)):
       # TODO(phajdan.jr): We should know exactly when the paths are absolute.
       # It depends on the command being executed (like runhooks vs sync).
       if not os.path.isabs(file_list[i]):
         continue
 
-      prefix = os.path.commonprefix([self._root_dir.lower(),
+      prefix = os.path.commonprefix([self.root_dir().lower(),
                                      file_list[i].lower()])
       file_list[i] = file_list[i][len(prefix):]
 
       # Strip any leading path separators.
       while file_list[i].startswith('\\') or file_list[i].startswith('/'):
         file_list[i] = file_list[i][1:]
 
-    is_using_git = gclient_utils.IsUsingGit(self._root_dir, entries.keys())
+    is_using_git = gclient_utils.IsUsingGit(self.root_dir(), entries.keys())
     self._RunHooks(command, file_list, is_using_git)
 
     if command == 'update':
       # Notify the user if there is an orphaned entry in their working copy.
       # Only delete the directory if there are no changes in it, and
       # delete_unversioned_trees is set to true.
       prev_entries = self._ReadEntries()
       for entry in prev_entries:
         # Fix path separator on Windows.
         entry_fixed = entry.replace('/', os.path.sep)
-        e_dir = os.path.join(self._root_dir, entry_fixed)
+        e_dir = os.path.join(self.root_dir(), entry_fixed)
         # Use entry and not entry_fixed there.
         if entry not in entries and os.path.exists(e_dir):
           modified_files = False
           if isinstance(prev_entries, list):
             # old .gclient_entries format was list, now dict
             modified_files = gclient_scm.scm.SVN.CaptureStatus(e_dir)
           else:
             file_list = []
-            scm = gclient_scm.CreateSCM(prev_entries[entry], self._root_dir,
+            scm = gclient_scm.CreateSCM(prev_entries[entry], self.root_dir(),
                                         entry_fixed)
             scm.status(self._options, [], file_list)
             modified_files = file_list != []
           if not self._options.delete_unversioned_trees or modified_files:
             # There are modified files in this entry. Keep warning until
             # removed.
             print(("\nWARNING: \"%s\" is no longer part of this client.  "
                    "It is recommended that you manually remove it.\n") %
                       entry_fixed)
           else:
             # Delete the entry
             print("\n________ deleting \'%s\' " +
-                  "in \'%s\'") % (entry_fixed, self._root_dir)
+                  "in \'%s\'") % (entry_fixed, self.root_dir())
             gclient_utils.RemoveDirectory(e_dir)
       # record the current list of entries for next time
       self._SaveEntries(entries)
     return 0
 
   def PrintRevInfo(self):
     """Output revision info mapping for the client and its dependencies.
 
     This allows the capture of an overall "revision" for the source tree that
     can be used to reproduce the same tree in the future. It is only useful for
     "unpinned dependencies", i.e. DEPS/deps references without a svn revision
     number or a git hash. A git branch name isn't "pinned" since the actual
     commit can change.
 
     The --snapshot option allows creating a .gclient file to reproduce the tree.
     """
     solutions = self.GetVar("solutions")
     if not solutions:
       raise gclient_utils.Error("No solution specified")
 
     # Inner helper to generate base url and rev tuple
     def GetURLAndRev(name, original_url):
       url, _ = gclient_utils.SplitUrlRevision(original_url)
-      scm = gclient_scm.CreateSCM(original_url, self._root_dir, name)
+      scm = gclient_scm.CreateSCM(original_url, self.root_dir(), name)
       return (url, scm.revinfo(self._options, [], None))
 
     # text of the snapshot gclient file
     new_gclient = ""
     # Dictionary of { path : SCM url } to ensure no duplicate solutions
     solution_names = {}
     entries = {}
     entries_deps_content = {}
     # Run on the base solutions first.
     for solution in solutions:
       # Dictionary of { path : SCM url } to describe the gclient checkout
       name = solution["name"]
       if name in solution_names:
         raise gclient_utils.Error("solution %s specified more than once" % name)
       (url, rev) = GetURLAndRev(name, solution["url"])
       entries[name] = "%s@%s" % (url, rev)
       solution_names[name] = "%s@%s" % (url, rev)
       deps_file = solution.get("deps_file", self.DEPS_FILE)
       if '/' in deps_file or '\\' in deps_file:
         raise gclient_utils.Error('deps_file name must not be a path, just a '
                                   'filename.')
       try:
         deps_content = gclient_utils.FileRead(
-            os.path.join(self._root_dir, name, deps_file))
+            os.path.join(self.root_dir(), name, deps_file))
       except IOError, e:
         if e.errno != errno.ENOENT:
           raise
         deps_content = ""
       entries_deps_content[name] = deps_content
 
     # Process the dependencies next (sort alphanumerically to ensure that
     # containing directories get populated first and for readability)
     deps = self._ParseAllDeps(entries, entries_deps_content)
     deps_to_process = deps.keys()
     deps_to_process.sort()
 
     # First pass for direct dependencies.
     for d in deps_to_process:
       if type(deps[d]) == str:
         (url, rev) = GetURLAndRev(d, deps[d])
         entries[d] = "%s@%s" % (url, rev)
 
     # Second pass for inherited deps (via the From keyword)
     for d in deps_to_process:
       if isinstance(deps[d], self.FromImpl):
         deps_parent_url = entries[deps[d].module_name]
         if deps_parent_url.find("@") < 0:
           raise gclient_utils.Error("From %s missing revisioned url" %
                                         deps[d].module_name)
         content =  gclient_utils.FileRead(os.path.join(
-                                            self._root_dir,
+                                            self.root_dir(),
                                             deps[d].module_name,
                                             self.DEPS_FILE))
         sub_deps = self._ParseSolutionDeps(deps[d].module_name, content, {},
                                            False)
         (url, rev) = GetURLAndRev(d, sub_deps[d])
         entries[d] = "%s@%s" % (url, rev)
 
     # Build the snapshot configuration string
     if self._options.snapshot:
       url = entries.pop(name)
       custom_deps = ",\n      ".join(["\"%s\": \"%s\"" % (x, entries[x])
                                       for x in sorted(entries.keys())])
 
       new_gclient += self.DEFAULT_SNAPSHOT_SOLUTION_TEXT % {
                      'solution_name': name,
                      'solution_url': url,
                      'safesync_url' : "",
                      'solution_deps': custom_deps,
                      }
     else:
       print(";\n".join(["%s: %s" % (x, entries[x])
                        for x in sorted(entries.keys())]))
 
     # Print the snapshot configuration file
     if self._options.snapshot:
       config = self.DEFAULT_SNAPSHOT_FILE_TEXT % {'solution_list': new_gclient}
-      snapclient = GClient(self._root_dir, self._options)
+      snapclient = GClient(self.root_dir(), self._options)
       snapclient.SetConfig(config)
       print(snapclient.config_content)
 
+  def root_dir(self):
+    return self._root_dir
+
 
 #### gclient commands.
 
 
 def CMDcleanup(parser, args):
   """Cleans up all working copies.
 
 Mostly svn-specific. Simply runs 'svn cleanup' for each module.
 """
   parser.add_option("--deps", dest="deps_os", metavar="OS_LIST",
@@ skipping 333 matching lines @@
     return CMDhelp(parser, argv)
   except gclient_utils.Error, e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: