Continue conversion to more properties.

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 128 matching lines @@
 class Dependency(GClientKeywords, gclient_utils.WorkItem):
   """Object that represents a dependency checkout."""
 
   def __init__(self, parent, name, url, safesync_url, custom_deps,
                custom_vars, deps_file, should_process):
     # Warning: this function can be called from any thread. Both
     # self.dependencies and self.requirements are read and modified from
     # multiple threads at the same time. Sad.
     GClientKeywords.__init__(self)
     gclient_utils.WorkItem.__init__(self, name)
-    self.parent = parent
+
+    # These are not mutable:
+    self._parent = parent
+    self._safesync_url = safesync_url
+    self._deps_file = deps_file
+    self._should_process = should_process
+
+    # This is in both .gclient and DEPS files:
     self.url = url
-    self.parsed_url = None
-    # These 2 are only set in .gclient and not in DEPS files.
-    self.safesync_url = safesync_url
+
+    # These are only set in .gclient and not in DEPS files.
     self.custom_vars = custom_vars or {}
     self.custom_deps = custom_deps or {}
     self.deps_hooks = []
+
+    # Calculates properties:
+    self.parsed_url = None
     self.dependencies = []
-    self.deps_file = deps_file
     # A cache of the files affected by the current operation, necessary for
     # hooks.
     self._file_list = []
     # If it is not set to True, the dependency wasn't processed for its child
     # dependency, i.e. its DEPS wasn't read.
     self.deps_parsed = False
-    # This dependency should be processed, i.e. checked out
-    self.should_process = should_process
     # This dependency has been processed, i.e. checked out
     self.processed = False
     # This dependency had its hook run
     self.hooks_ran = False
 
     # Post process the url to remove trailing slashes.
     if isinstance(self.url, basestring):
       # urls are sometime incorrectly written as proto://host/path/@rev. Replace
       # it to proto://host/path@rev.
       if self.url.count('@') > 1:
@@ skipping 74 matching lines @@
 
     Manages From() keyword accordingly. Do not touch self.parsed_url nor
     self.url because it may called with other urls due to From()."""
     assert self.parsed_url == None or not self.should_process, self.parsed_url
     overriden_url = self.get_custom_deps(self.name, url)
     if overriden_url != url:
       logging.info('%s, %s was overriden to %s' % (self.name, url,
           overriden_url))
       return overriden_url
     elif isinstance(url, self.FromImpl):
-      ref = [dep for dep in self.tree(True) if url.module_name == dep.name]
+      ref = [
+          dep for dep in self.root.subtree(True) if url.module_name == dep.name
+      ]
       if not ref:
         raise gclient_utils.Error('Failed to find one reference to %s. %s' % (
             url.module_name, ref))
       # It may happen that len(ref) > 1 but it's no big deal.
       ref = ref[0]
       sub_target = url.sub_target_name or self.name
       # Make sure the referenced dependency DEPS file is loaded and file the
       # inner referenced dependency.
       ref.ParseDepsFile()
       found_dep = None
@@ skipping 100 matching lines @@
         # dependency local path.
         rel_deps[os.path.normpath(os.path.join(self.name, d))] = url
       deps = rel_deps
 
     # Convert the deps into real Dependency.
     for name, url in deps.iteritems():
       if name in [s.name for s in self.dependencies]:
         raise gclient_utils.Error(
             'The same name "%s" appears multiple times in the deps section' %
                 name)
-      should_process = self.recursion_limit() > 0 and self.should_process
+      should_process = self.recursion_limit and self.should_process
       if should_process:
-        tree = dict((d.name, d) for d in self.tree(False))
+        tree = dict((d.name, d) for d in self.root.subtree(False))
         if name in tree:
           if url == tree[name].url:
             logging.info('Won\'t process duplicate dependency %s' % tree[name])
             # In theory we could keep it as a shadow of the other one. In
             # practice, simply ignore it.
             #should_process = False
             continue
           else:
             raise gclient_utils.Error(
                 'Dependency %s specified more than once:\n  %s\nvs\n  %s' %
@@ skipping 64 matching lines @@
         # 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.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]
+
+      # TODO(phajdan.jr): We should know exactly when the paths are absolute.
+      # Convert all absolute paths to relative.
+      for i in range(len(self._file_list)):
+        # It depends on the command being executed (like runhooks vs sync).
+        if not os.path.isabs(self._file_list[i]):
+          continue
+        prefix = os.path.commonprefix(
+            [self.root.root_dir.lower(), self._file_list[i].lower()])
+        self._file_list[i] = self._file_list[i][len(prefix):]
+        # Strip any leading path separators.
+        while (self._file_list[i].startswith('\\') or
+                self._file_list[i].startswith('/')):
+          self._file_list[i] = self._file_list[i][1:]
     self.processed = True
-    if self.recursion_limit() > 0:
+    if self.recursion_limit:
       # 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:
+    if not self.should_process or not self.recursion_limit:
       # 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.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.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.
         for hook_dict in self.deps_hooks:
           pattern = re.compile(hook_dict['pattern'])
-          matching_file_list = [f for f in file_list if pattern.search(f)]
+          matching_file_list = [f for f in self.file_list if pattern.search(f)]
           if matching_file_list:
             self._RunHookAction(hook_dict, matching_file_list)
     for s in self.dependencies:
       s.RunHooksRecursively(options)
 
   def _RunHookAction(self, hook_dict, matching_file_list):
     """Runs the action from a single hook."""
     # A single DEPS file can specify multiple hooks so this function can be
     # called multiple times on a single Dependency.
     #assert self.hooks_ran == False
@@ skipping 14 matching lines @@
     try:
       gclient_utils.CheckCallAndFilterAndHeader(
           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 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:
       if d.should_process or include_all:
         result.append(d)
     for d in self.dependencies:
       result.extend(d.subtree(include_all))
     return result
 
   def get_custom_deps(self, name, url):
     """Returns a custom deps if applicable."""
     if self.parent:
       url = self.parent.get_custom_deps(name, url)
     # None is a valid return value to disable a dependency.
     return self.custom_deps.get(name, url)
 
+  @property
+  def recursion_limit(self):
+    """Returns > 0 if this dependency is not too recursed to be processed."""
+    return max(self.parent.recursion_limit - 1, 0)
+
+  @property
+  def deps_file(self):
+    return self._deps_file
+
+  @property
+  def safesync_url(self):
+    return self._safesync_url
+
+  @property
+  def should_process(self):
+    """True if this dependency should be processed, i.e. checked out."""
+    return self._should_process
+
+  @property
+  def parent(self):
+    return self._parent
+
+  @property
   def file_list(self):
     result = self._file_list[:]
     for d in self.dependencies:
-      result.extend(d.file_list())
-    return result
+      result.extend(d.file_list)
+    return tuple(result)
 
   def __str__(self):
     out = []
     for i in ('name', 'url', 'parsed_url', 'safesync_url', 'custom_deps',
               'custom_vars', 'deps_hooks', 'file_list', 'should_process',
               'processed', 'hooks_ran', 'deps_parsed', 'requirements'):
       # First try the native property if it exists.
       if hasattr(self, '_' + i):
         value = getattr(self, '_' + i, False)
       else:
@@ skipping 91 matching lines @@
   def SetConfig(self, content):
     assert self.dependencies == []
     config_dict = {}
     self.config_content = content
     try:
       exec(content, config_dict)
     except SyntaxError, e:
       gclient_utils.SyntaxErrorToError('.gclient', e)
     for s in config_dict.get('solutions', []):
       try:
-        tree = dict((d.name, d) for d in self.tree(False))
+        tree = dict((d.name, d) for d in self.root.subtree(False))
         if s['name'] in tree:
           raise gclient_utils.Error(
               'Dependency %s specified more than once in .gclient' % s['name'])
         self.dependencies.append(Dependency(
             self, s['name'], s['url'],
             s.get('safesync_url', None),
             s.get('custom_deps', {}),
             s.get('custom_vars', {}),
             s.get('deps_file', 'DEPS'),
             True))
@@ skipping 31 matching lines @@
     })
 
   def _SaveEntries(self):
     """Creates a .gclient_entries file to record the list of unique checkouts.
 
     The .gclient_entries file lives in the same directory as .gclient.
     """
     # 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):
+    for entry in self.root.subtree(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)
     logging.info(result)
     gclient_utils.FileWrite(file_path, result)
 
   def _ReadEntries(self):
@@ skipping 68 matching lines @@
 
     # Once all the dependencies have been processed, it's now safe to run the
     # hooks.
     if not self._options.nohooks:
       self.RunHooksRecursively(self._options)
 
     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.
-      entries = [i.name for i in self.tree(False) if i.url]
+      entries = [i.name for i in self.root.subtree(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)
         # Use entry and not entry_fixed there.
         if entry not in entries and os.path.exists(e_dir):
           file_list = []
@@ skipping 61 matching lines @@
             'solution_name': d.name,
             'solution_url': d.url,
             'deps_file': d.deps_file,
             'safesync_url' : d.safesync_url or '',
             'solution_deps': ''.join(custom_deps),
         }
       # Print the snapshot configuration file
       print(self.DEFAULT_SNAPSHOT_FILE_TEXT % {'solution_list': new_gclient})
     else:
       entries = {}
-      for d in self.tree(False):
+      for d in self.root.subtree(False):
         if self._options.actual:
           entries[d.name] = GetURLAndRev(d)
         else:
           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
 
+  @property
   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."""
-    return self.subtree(include_all)
-
 
 #### 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 405 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: