Dependency.url is also immutable. Convert more member as 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 118 matching lines @@
 
     def Lookup(self, var_name):
       """Implements the Var syntax."""
       if var_name in self._custom_vars:
         return self._custom_vars[var_name]
       elif var_name in self._local_scope.get("vars", {}):
         return self._local_scope["vars"][var_name]
       raise gclient_utils.Error("Var is not defined: %s" % var_name)
 
 
-class DependencySettings(object):
+class DependencySettings(GClientKeywords):
   """Immutable configuration settings."""
   def __init__(
-      self, parent, safesync_url, managed, custom_deps, custom_vars,
+      self, parent, url, safesync_url, managed, custom_deps, custom_vars,
       deps_file, should_process):
+    GClientKeywords.__init__(self)
+
     # These are not mutable:
     self._parent = parent
     self._safesync_url = safesync_url
     self._deps_file = deps_file
+    self._url = url
     # 'managed' determines whether or not this dependency is synced/updated by
     # gclient after gclient checks it out initially.  The difference between
     # 'managed' and 'should_process' is that the user specifies 'managed' via
     # the --unmanaged command-line flag or a .gclient config, where
     # 'should_process' is dynamically set by gclient if it goes over its
     # recursion limit and controls gclient's behavior so it does not misbehave.
     self._managed = managed
     self._should_process = should_process
 
     # These are only set in .gclient and not in DEPS files.
     self._custom_vars = custom_vars or {}
     self._custom_deps = custom_deps or {}
 
+    # 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:
+        raise gclient_utils.Error('Invalid url "%s"' % self._url)
+      self._url = self._url.replace('/@', '@')
+    elif not isinstance(self._url,
+        (self.FromImpl, self.FileImpl, None.__class__)):
+      raise gclient_utils.Error(
+          ('dependency url must be either a string, None, '
+           'File() or From() instead of %s') % self._url.__class__.__name__)
     if '/' in self._deps_file or '\\' in self._deps_file:
       raise gclient_utils.Error('deps_file name must not be a path, just a '
                                 'filename. %s' % self._deps_file)
 
   @property
   def deps_file(self):
     """Immutable so no need to lock."""
     return self._deps_file
 
   @property
@@ skipping 19 matching lines @@
   @property
   def custom_vars(self):
     """Immutable so no need to lock."""
     return self._custom_vars.copy()
 
   @property
   def custom_deps(self):
     """Immutable so no need to lock."""
     return self._custom_deps.copy()
 
+  @property
+  def url(self):
+    return self._url
 
-class Dependency(GClientKeywords, gclient_utils.WorkItem, DependencySettings):
+
+class Dependency(gclient_utils.WorkItem, DependencySettings):
   """Object that represents a dependency checkout."""
 
   def __init__(self, parent, name, url, safesync_url, managed, custom_deps,
                custom_vars, deps_file, should_process):
-    GClientKeywords.__init__(self)
     gclient_utils.WorkItem.__init__(self, name)
     DependencySettings.__init__(
-        self, parent, safesync_url, managed, custom_deps, custom_vars,
+        self, parent, url, safesync_url, managed, custom_deps, custom_vars,
         deps_file, should_process)
 
     # This is in both .gclient and DEPS files:
-    self.url = url
-
-    self.deps_hooks = []
+    self._deps_hooks = []
 
     # Calculates properties:
-    self.parsed_url = None
+    self._parsed_url = None
     self._dependencies = []
     # 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
+    self._deps_parsed = False
     # This dependency has been processed, i.e. checked out
-    self.processed = False
+    self._processed = False
     # This dependency had its hook run
-    self.hooks_ran = False
+    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:
-        raise gclient_utils.Error('Invalid url "%s"' % self.url)
-      self.url = self.url.replace('/@', '@')
+    # Setup self.requirements and find any other dependency who would have self
+    # as a requirement.
 
-    self._FindDependencies()
-
-    # Sanity checks
-    if not self.name and self.parent:
-      raise gclient_utils.Error('Dependency without name')
-    if not isinstance(self.url,
-        (basestring, self.FromImpl, self.FileImpl, None.__class__)):
-      raise gclient_utils.Error('dependency url must be either a string, None, '
-                                'File() or From() instead of %s' %
-                                self.url.__class__.__name__)
-
-  def _FindDependencies(self):
-    """Setup self.requirements and find any other dependency who would have self
-    as a requirement.
-    """
     # self.parent is implicitly a requirement. This will be recursive by
     # definition.
     if self.parent and self.parent.name:
       self._requirements.add(self.parent.name)
 
     # For a tree with at least 2 levels*, the leaf node needs to depend
     # 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.
     #
@@ skipping 32 matching lines @@
         # 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
             obj.lock.acquire()
             obj._requirements.add(self.name)
           finally:
             obj.lock.release()
 
+    if not self.name and self.parent:
+      raise gclient_utils.Error('Dependency without name')
+
   def LateOverride(self, url):
     """Resolves the parsed url from url.
 
     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))
@@ skipping 52 matching lines @@
       return None
     else:
       raise gclient_utils.Error('Unkown url type')
 
   def ParseDepsFile(self):
     """Parses the DEPS file for this dependency."""
     assert self.processed == True
     if self.deps_parsed:
       logging.debug('%s was already parsed' % self.name)
       return
-    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.root_dir, self.name, self.deps_file)
@@ skipping 17 matching lines @@
         os_deps = local_scope['deps_os'].get(deps_os_key, {})
         if len(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', []))
+    self._deps_hooks.extend(local_scope.get('hooks', []))
 
     # If a line is in custom_deps, but not in the solution, we want to append
     # this line to the solution.
     for d in self.custom_deps:
       if d not in deps:
         deps[d] = self.custom_deps[d]
 
     # If use_relative_paths is set in the DEPS file, regenerate
     # the dictionary using paths relative to the directory containing
     # the DEPS file.
@@ skipping 23 matching lines @@
             #should_process = False
             continue
           else:
             raise gclient_utils.Error(
                 'Dependency %s specified more than once:\n  %s\nvs\n  %s' %
                 (name, tree[name].hierarchy(), self.hierarchy()))
       self._dependencies.append(
           Dependency(
             self, name, url, None, None, None, None,
             self.deps_file, should_process))
+    self._deps_parsed = True
     logging.debug('Loaded: %s' % str(self))
 
   # Arguments number differs from overridden method
   # pylint: disable=W0221
   def run(self, revision_overrides, command, args, work_queue, options):
     """Runs 'command' before parsing the DEPS in case it's a initial checkout
     or a revert."""
 
     def maybeGetParentRevision(options):
       """If we are performing an update and --transitive is set, set the
@@ skipping 28 matching lines @@
                 (options.revision, revision))
         revision_overrides[self.name] = revision
 
     assert self._file_list == []
     if not self.should_process:
       return
     # When running runhooks, there's no need to consult the SCM.
     # 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)
+    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.root_dir,
                                        self.name)
           scm.RunCommand('updatesingle', options,
                          args + [self.parsed_url.GetFilename()],
@@ skipping 16 matching lines @@
         # 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
+    self._processed = True
     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()
@@ skipping 23 matching lines @@
           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
-    self.hooks_ran = True
+    self._hooks_ran = True
     logging.debug(hook_dict)
     logging.debug(matching_file_list)
     command = hook_dict['action'][:]
     if command[0] == 'python':
       # If the hook specified "python" as the first item, the action is a
       # Python script.  Run it by starting a new copy of the same
       # interpreter.
       command[0] = sys.executable
 
     if '$matching_files' in command:
@@ skipping 34 matching lines @@
 
     Immutable so no need to lock.
     """
     return max(self.parent.recursion_limit - 1, 0)
 
   @property
   def dependencies(self):
     return tuple(self._dependencies)
 
   @property
+  def deps_hooks(self):
+    return tuple(self._deps_hooks)
+
+  @property
+  def parsed_url(self):
+    return self._parsed_url
+
+  @property
+  def deps_parsed(self):
+    return self._deps_parsed
+
+  @property
+  def processed(self):
+    return self._processed
+
+  @property
+  def hooks_ran(self):
+    return self._hooks_ran
+
+  @property
   def file_list(self):
     result = self._file_list[:]
     for d in self.dependencies:
       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',
@@ skipping 114 matching lines @@
             s.get('safesync_url', None),
             s.get('managed', True),
             s.get('custom_deps', {}),
             s.get('custom_vars', {}),
             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
+    self._deps_hooks = config_dict.get('hooks', [])
+    self._deps_parsed = True
 
   def SaveConfig(self):
     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."""
@@ skipping 649 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: