Use properties for more members that do not change

gclient.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 """Meta checkout manager supporting both Subversion and GIT.
 
 Files
   .gclient      : Current client configuration, written by 'config' command.
                   Format is a Python script defining 'solutions', a list whose
@@ skipping 193 matching lines @@
     # on the level higher up in an orderly way.
     # This becomes messy for >2 depth as the DEPS file format is a dictionary,
     # thus unsorted, while the .gclient format is a list thus sorted.
     #
     # * _recursion_limit is hard coded 2 and there is no hope to change this
     # value.
     #
     # Interestingly enough, the following condition only works in the case we
     # want: self is a 2nd level node. 3nd level node wouldn't need this since
     # they already have their parent as a requirement.
-    if self.parent in self.root_parent().dependencies:
-      root_deps = self.root_parent().dependencies
+    root_deps = self.root.dependencies
+    if self.parent in root_deps:
       for i in range(0, root_deps.index(self.parent)):
         value = root_deps[i]
         if value.name:
           self._requirements.add(value.name)
 
     if isinstance(self.url, self.FromImpl):
       self._requirements.add(self.url.module_name)
 
     if self.name and self.should_process:
       def yield_full_tree(root):
         """Depth-first recursion."""
         yield root
         for i in root.dependencies:
           for j in yield_full_tree(i):
             if j.should_process:
               yield j
 
-      for obj in yield_full_tree(self.root_parent()):
+      for obj in yield_full_tree(self.root):
         if obj is self or not obj.name:
           continue
         # Step 1: Find any requirements self may need.
         if self.name.startswith(posixpath.join(obj.name, '')):
           self._requirements.add(obj.name)
         # Step 2: Find any requirements self may impose.
         if obj.name.startswith(posixpath.join(self.name, '')):
           try:
             # Access to a protected member _requirements of a client class
             # pylint: disable=W0212
@@ skipping 26 matching lines @@
       ref.ParseDepsFile()
       found_dep = None
       for d in ref.dependencies:
         if d.name == sub_target:
           found_dep = d
           break
       if not found_dep:
         raise gclient_utils.Error(
             'Couldn\'t find %s in %s, referenced by %s (parent: %s)\n%s' % (
                 sub_target, ref.name, self.name, self.parent.name,
-                str(self.root_parent())))
+                str(self.root)))
 
       # Call LateOverride() again.
       parsed_url = found_dep.LateOverride(found_dep.url)
       logging.info('%s, %s to %s' % (self.name, url, parsed_url))
       return parsed_url
     elif isinstance(url, basestring):
       parsed_url = urlparse.urlparse(url)
       if not parsed_url[0]:
         # A relative url. Fetch the real base.
         path = parsed_url[2]
         if not path.startswith('/'):
           raise gclient_utils.Error(
               'relative DEPS entry \'%s\' must begin with a slash' % url)
         # Create a scm just to query the full url.
         parent_url = self.parent.parsed_url
         if isinstance(parent_url, self.FileImpl):
           parent_url = parent_url.file_location
-        scm = gclient_scm.CreateSCM(parent_url, self.root_dir(), None)
+        scm = gclient_scm.CreateSCM(parent_url, self.root.root_dir, None)
         parsed_url = scm.FullUrlForRelativeUrl(url)
       else:
         parsed_url = url
       logging.info('%s, %s -> %s' % (self.name, url, parsed_url))
       return parsed_url
     elif isinstance(url, self.FileImpl):
       parsed_url = url
       logging.info('%s, %s -> %s (File)' % (self.name, url, parsed_url))
       return parsed_url
     elif url is None:
@@ skipping 10 matching lines @@
     self.deps_parsed = True
     # One thing is unintuitive, vars= {} must happen before Var() use.
     local_scope = {}
     var = self.VarImpl(self.custom_vars, local_scope)
     global_scope = {
       'File': self.FileImpl,
       'From': self.FromImpl,
       'Var': var.Lookup,
       'deps_os': {},
     }
-    filepath = os.path.join(self.root_dir(), self.name, self.deps_file)
+    filepath = os.path.join(self.root.root_dir, self.name, self.deps_file)
     if not os.path.isfile(filepath):
       logging.info('%s: No %s file found at %s' % (self.name, self.deps_file,
                                                    filepath))
     else:
       deps_content = gclient_utils.FileRead(filepath)
       logging.debug(deps_content)
       # Eval the content.
       try:
         exec(deps_content, global_scope, local_scope)
       except SyntaxError, e:
         gclient_utils.SyntaxErrorToError(filepath, e)
     deps = local_scope.get('deps', {})
     # load os specific dependencies if defined.  these dependencies may
     # override or extend the values defined by the 'deps' member.
     if 'deps_os' in local_scope:
-      for deps_os_key in self.enforced_os():
+      for deps_os_key in self.root.enforced_os:
         os_deps = local_scope['deps_os'].get(deps_os_key, {})
-        if len(self.enforced_os()) > 1:
+        if len(self.root.enforced_os) > 1:
           # Ignore any conflict when including deps for more than one
           # platform, so we collect the broadest set of dependencies
           # available. We may end up with the wrong revision of something for
           # our platform, but this is the best we can do.
           deps.update([x for x in os_deps.items() if not x[0] in deps])
         else:
           deps.update(os_deps)
 
     self.deps_hooks.extend(local_scope.get('hooks', []))
 
@@ skipping 85 matching lines @@
     # All known hooks are expected to run unconditionally regardless of working
     # copy state, so skip the SCM status check.
     run_scm = command not in ('runhooks', None)
     self.parsed_url = self.LateOverride(self.url)
     if run_scm and self.parsed_url:
       if isinstance(self.parsed_url, self.FileImpl):
         # Special support for single-file checkout.
         if not command in (None, 'cleanup', 'diff', 'pack', 'status'):
           options.revision = self.parsed_url.GetRevision()
           scm = gclient_scm.SVNWrapper(self.parsed_url.GetPath(),
-                                       self.root_dir(),
+                                       self.root.root_dir,
                                        self.name)
           scm.RunCommand('updatesingle', options,
                          args + [self.parsed_url.GetFilename()],
                          self._file_list)
       else:
         # Create a shallow copy to mutate revision.
         options = copy.copy(options)
         options.revision = revision_overrides.get(self.name)
         maybeGetParentRevision(options)
-        scm = gclient_scm.CreateSCM(self.parsed_url, self.root_dir(), self.name)
+        scm = gclient_scm.CreateSCM(
+            self.parsed_url, self.root.root_dir, self.name)
         scm.RunCommand(command, options, args, self._file_list)
         maybeConvertToDateRevision(options)
         self._file_list = [os.path.join(self.name, f.strip())
                            for f in self._file_list]
     self.processed = True
     if self.recursion_limit() > 0:
       # Then we can parse the DEPS file.
       self.ParseDepsFile()
 
       # Parse the dependencies of this dependency.
       for s in self.dependencies:
         work_queue.enqueue(s)
 
   def RunHooksRecursively(self, options):
     """Evaluates all hooks, running actions as needed. run()
     must have been called before to load the DEPS."""
     assert self.hooks_ran == False
     if not self.should_process or self.recursion_limit() <= 0:
       # Don't run the hook when it is above recursion_limit.
       return
     # If "--force" was specified, run all hooks regardless of what files have
     # changed.
     if self.deps_hooks:
       # TODO(maruel): If the user is using git or git-svn, then we don't know
       # what files have changed so we always run all hooks. It'd be nice to fix
       # that.
       if (options.force or
           isinstance(self.parsed_url, self.FileImpl) or
           gclient_scm.GetScmName(self.parsed_url) in ('git', None) or
-          os.path.isdir(os.path.join(self.root_dir(), self.name, '.git'))):
+          os.path.isdir(os.path.join(self.root.root_dir, self.name, '.git'))):
         for hook_dict in self.deps_hooks:
           self._RunHookAction(hook_dict, [])
       else:
         # TODO(phajdan.jr): We should know exactly when the paths are absolute.
         # Convert all absolute paths to relative.
         file_list = self.file_list()
         for i in range(len(file_list)):
           # 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.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:]
 
         # Run hooks on the basis of whether the files from the gclient operation
         # match each hook's pattern.
@@ skipping 19 matching lines @@
       # Python script.  Run it by starting a new copy of the same
       # 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
 
     try:
       gclient_utils.CheckCallAndFilterAndHeader(
-          command, cwd=self.root_dir(), always=True)
+          command, cwd=self.root.root_dir, always=True)
     except (gclient_utils.Error, subprocess2.CalledProcessError), e:
       # 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.
       print >> sys.stderr, 'Error: %s' % str(e)
       sys.exit(2)
 
-  def root_dir(self):
-    return self.parent.root_dir()
-
-  def enforced_os(self):
-    return self.parent.enforced_os()
-
   def recursion_limit(self):
     return self.parent.recursion_limit() - 1
 
   def tree(self, include_all):
     return self.parent.tree(include_all)
 
   def subtree(self, include_all):
     """Breadth first"""
     result = []
     for d in self.dependencies:
@@ skipping 39 matching lines @@
 
   def hierarchy(self):
     """Returns a human-readable hierarchical reference to a Dependency."""
     out = '%s(%s)' % (self.name, self.url)
     i = self.parent
     while i and i.name:
       out = '%s(%s) -> %s' % (i.name, i.url, out)
       i = i.parent
     return out
 
-  def root_parent(self):
-    """Returns the root object, normally a GClient object."""
-    d = self
-    while d.parent:
-      d = d.parent
-    return d
+  @property
+  def root(self):
+    """Returns the root node, a GClient object."""
+    if not self.parent:
+      # This line is to signal pylint that it could be a GClient instance.
+      return self or GClient(None, None)
+    return self.parent.root
 
 
 class GClient(Dependency):
   """Object that represent a gclient checkout. A tree of Dependency(), one per
   solution or DEPS entry."""
 
   DEPS_OS_CHOICES = {
     "win32": "win",
     "win": "win",
     "cygwin": "win",
@@ skipping 39 matching lines @@
     self._recursion_limit = 2
     Dependency.__init__(self, None, None, None, None, None, None, 'unused',
                         True)
     self._options = options
     if options.deps_os:
       enforced_os = options.deps_os.split(',')
     else:
       enforced_os = [self.DEPS_OS_CHOICES.get(sys.platform, 'unix')]
     if 'all' in enforced_os:
       enforced_os = self.DEPS_OS_CHOICES.itervalues()
-    self._enforced_os = list(set(enforced_os))
+    self._enforced_os = tuple(set(enforced_os))
     self._root_dir = root_dir
     self.config_content = None
 
   def SetConfig(self, content):
     assert self.dependencies == []
     config_dict = {}
     self.config_content = content
     try:
       exec(content, config_dict)
     except SyntaxError, e:
@@ skipping 12 matching lines @@
             s.get('deps_file', 'DEPS'),
             True))
       except KeyError:
         raise gclient_utils.Error('Invalid .gclient file. Solution is '
                                   'incomplete: %s' % s)
     # .gclient can have hooks.
     self.deps_hooks = config_dict.get('hooks', [])
     self.deps_parsed = True
 
   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)
 
   @staticmethod
   def LoadCurrentConfig(options):
     """Searches for and loads a .gclient file relative to the current working
     dir. Returns a GClient object."""
     path = gclient_utils.FindGclientRoot(os.getcwd(), options.config_filename)
     if not path:
       return None
@@ skipping 18 matching lines @@
     """
     # Sometimes pprint.pformat will use {', sometimes it'll use { ' ... It
     # makes testing a bit too fun.
     result = 'entries = {\n'
     for entry in self.tree(False):
       # Skip over File() dependencies as we can't version them.
       if not isinstance(entry.parsed_url, self.FileImpl):
         result += '  %s: %s,\n' % (pprint.pformat(entry.name),
             pprint.pformat(entry.parsed_url))
     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)
     logging.info(result)
     gclient_utils.FileWrite(file_path, result)
 
   def _ReadEntries(self):
     """Read the .gclient_entries file for the given client.
 
     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 {}
     try:
       exec(gclient_utils.FileRead(filename), scope)
     except SyntaxError, e:
       gclient_utils.SyntaxErrorToError(filename, e)
     return scope['entries']
 
   def _EnforceRevisions(self):
     """Checks for revision overrides."""
@@ skipping 57 matching lines @@
       # 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.
       entries = [i.name for i in self.tree(False) if i.url]
       for entry, prev_url in self._ReadEntries().iteritems():
         if not prev_url:
           # entry must have been overridden via .gclient custom_deps
           continue
         # 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):
           file_list = []
-          scm = gclient_scm.CreateSCM(prev_url, self.root_dir(), entry_fixed)
+          scm = gclient_scm.CreateSCM(prev_url, 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 and not self._options.force)):
             # 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()))
+                entry_fixed, self.root_dir))
             gclient_utils.RemoveDirectory(e_dir)
       # record the current list of entries for next time
       self._SaveEntries()
     return 0
 
   def PrintRevInfo(self):
     if not self.dependencies:
       raise gclient_utils.Error('No solution specified')
     # Load all the settings.
     work_queue = gclient_utils.ExecutionQueue(self._options.jobs, None)
     for s in self.dependencies:
       work_queue.enqueue(s)
     work_queue.flush({}, None, [], options=self._options)
 
     def GetURLAndRev(dep):
       """Returns the revision-qualified SCM url for a Dependency."""
       if dep.parsed_url is None:
         return None
       if isinstance(dep.parsed_url, self.FileImpl):
         original_url = dep.parsed_url.file_location
       else:
         original_url = dep.parsed_url
       url, _ = gclient_utils.SplitUrlRevision(original_url)
-      scm = gclient_scm.CreateSCM(original_url, self.root_dir(), dep.name)
+      scm = gclient_scm.CreateSCM(original_url, self.root_dir, dep.name)
       if not os.path.isdir(scm.checkout_path):
         return None
       return '%s@%s' % (url, scm.revinfo(self._options, [], None))
 
     if self._options.snapshot:
       new_gclient = ''
       # First level at .gclient
       for d in self.dependencies:
         entries = {}
         def GrabDeps(dep):
@@ skipping 27 matching lines @@
           entries[d.name] = d.parsed_url
       keys = sorted(entries.keys())
       for x in keys:
         print('%s: %s' % (x, entries[x]))
     logging.info(str(self))
 
   def ParseDepsFile(self):
     """No DEPS to parse for a .gclient file."""
     raise gclient_utils.Error('Internal error')
 
+  @property
   def root_dir(self):
     """Root directory of gclient checkout."""
     return self._root_dir
 
+  @property
   def enforced_os(self):
     """What deps_os entries that are to be parsed."""
     return self._enforced_os
 
   def recursion_limit(self):
     """How recursive can each dependencies in DEPS file can load DEPS file."""
     return self._recursion_limit
 
   def tree(self, include_all):
     """Returns a flat list of all the dependencies."""
@@ skipping 417 matching lines @@
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   fix_encoding.fix_encoding()
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: