Remove semicolons from revinfo.

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.
 
 """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 31 matching lines @@
                it will be removed from the list and the list will be extended
                by the list of matching files.
 
   Example:
     hooks = [
       { "pattern": "\\.(gif|jpe?g|pr0n|png)$",
         "action":  ["python", "image_indexer.py", "--all"]},
     ]
 """
 
-__version__ = "0.5.1"
+__version__ = "0.5.2"
 
 import logging
 import optparse
 import os
 import posixpath
 import pprint
 import re
 import subprocess
 import sys
 import threading
@@ skipping 174 matching lines @@
       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 Dependency(GClientKeywords, WorkItem):
   """Object that represents a dependency checkout."""
   DEPS_FILE = 'DEPS'
 
   def __init__(self, parent, name, url, safesync_url, custom_deps,
-               custom_vars, deps_file):
+               custom_vars, deps_file, should_process):
     GClientKeywords.__init__(self)
     self.parent = parent
     self.name = name
     self.url = url
     self.parsed_url = None
     # These 2 are only set in .gclient and not in DEPS files.
     self.safesync_url = safesync_url
     self.custom_vars = custom_vars or {}
     self.custom_deps = custom_deps or {}
     self.deps_hooks = []
     self.dependencies = []
     self.deps_file = deps_file or self.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
-    # A direct reference is dependency that is referenced by a deps, deps_os or
-    # solution. A indirect one is one that was loaded with From() or that
-    # exceeded recursion limit.
-    self.direct_reference = 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
     # Required dependencies to run before running this one:
     self.requirements = []
     if self.parent and self.parent.name:
       self.requirements.append(self.parent.name)
     if isinstance(self.url, self.FromImpl):
       self.requirements.append(self.url.module_name)
 
     # 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__)
     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)
 
   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))
       return overriden_url
     elif isinstance(url, self.FromImpl):
       ref = [dep for dep in self.tree(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(False)
+      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\n%s' % (
                 sub_target, ref.name, self.name, str(self.root_parent())))
       # Call LateOverride() again.
@@ skipping 20 matching lines @@
       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:
       return None
     else:
       raise gclient_utils.Error('Unkown url type')
 
-  def ParseDepsFile(self, direct_reference):
+  def ParseDepsFile(self):
     """Parses the DEPS file for this dependency."""
-    if direct_reference:
-      # Maybe it was referenced earlier by a From() keyword but it's now
-      # directly referenced.
-      self.direct_reference = direct_reference
+    assert self.processed == True
     if self.deps_parsed:
       logging.debug('%s was already parsed' % self.name)
       return
     self.deps_parsed = True
     filepath = os.path.join(self.root_dir(), self.name, self.deps_file)
     if not os.path.isfile(filepath):
       logging.info('%s: No DEPS file found at %s' % (self.name, filepath))
       return
     deps_content = gclient_utils.FileRead(filepath)
     logging.debug(deps_content)
@@ skipping 46 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() and self.should_process
+      if should_process:
+        tree = dict((d.name, d) for d in self.tree(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' %
+                (name, tree[name].hierarchy(), self.hierarchy()))
       self.dependencies.append(Dependency(self, name, url, None, None, None,
-          None))
+          None, should_process))
     logging.debug('Loaded: %s' % str(self))
 
   def run(self, options, revision_overrides, command, args, work_queue):
     """Runs 'command' before parsing the DEPS in case it's a initial checkout
     or a revert."""
     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)
     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.name)
           scm.RunCommand('updatesingle', options,
                          args + [self.parsed_url.GetFilename()],
                          self._file_list)
       else:
         options.revision = revision_overrides.get(self.name)
         scm = gclient_scm.CreateSCM(self.parsed_url, self.root_dir(), self.name)
         scm.RunCommand(command, options, args, self._file_list)
         self._file_list = [os.path.join(self.name, f.strip())
                            for f in self._file_list]
       options.revision = None
     self.processed = True
     if self.recursion_limit():
       # Then we can parse the DEPS file.
-      self.ParseDepsFile(True)
+      self.ParseDepsFile()
       # Adjust the implicit dependency requirement; e.g. if a DEPS file contains
       # both src/foo and src/foo/bar, src/foo/bar is implicitly dependent of
       # src/foo. Yes, it's O(n^2)... It's important to do that before
       # enqueueing them.
       for s in self.dependencies:
         for s2 in self.dependencies:
           if s is s2:
             continue
           if s.name.startswith(posixpath.join(s2.name, '')):
             s.requirements.append(s2.name)
 
       # 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:
+      return
     # If "--force" was specified, run all hooks regardless of what files have
     # changed.
-    if self.deps_hooks and self.direct_reference:
+    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'))):
         for hook_dict in self.deps_hooks:
           self._RunHookAction(hook_dict, [])
       else:
@@ skipping 14 matching lines @@
                  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)]
           if matching_file_list:
             self._RunHookAction(hook_dict, matching_file_list)
-    if self.recursion_limit():
-      for s in self.dependencies:
-        s.RunHooksRecursively(options)
+    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
     logging.debug(hook_dict)
     logging.debug(matching_file_list)
     command = hook_dict['action'][:]
@@ skipping 18 matching lines @@
   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 = []
-    # Add breadth-first.
-    if self.direct_reference or include_all:
-      for d in self.dependencies:
+    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))
+    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)
 
   def file_list(self):
     result = self._file_list[:]
     for d in self.dependencies:
       result.extend(d.file_list())
     return result
 
   def __str__(self):
     out = []
     for i in ('name', 'url', 'parsed_url', 'safesync_url', 'custom_deps',
-              'custom_vars', 'deps_hooks', '_file_list', 'processed',
-              'hooks_ran', 'deps_parsed', 'requirements', 'direct_reference'):
+              'custom_vars', 'deps_hooks', '_file_list', 'should_process',
+              'processed', 'hooks_ran', 'deps_parsed', 'requirements'):
       # 'deps_file'
       if self.__dict__[i]:
         out.append('%s: %s' % (i, self.__dict__[i]))
 
     for d in self.dependencies:
       out.extend(['  ' + x for x in str(d).splitlines()])
       out.append('')
     return '\n'.join(out)
 
   def __repr__(self):
@@ skipping 54 matching lines @@
   DEFAULT_SNAPSHOT_FILE_TEXT = ("""\
 # Snapshot generated with gclient revinfo --snapshot
 solutions = [
 %(solution_list)s]
 """)
 
   def __init__(self, root_dir, options):
     # Do not change previous behavior. Only solution level and immediate DEPS
     # are processed.
     self._recursion_limit = 2
-    Dependency.__init__(self, None, None, None, None, None, None, None)
+    Dependency.__init__(self, None, None, None, None, None, None, None, 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._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:
       gclient_utils.SyntaxErrorToError('.gclient', e)
     for s in config_dict.get('solutions', []):
       try:
+        tree = dict((d.name, d) for d in self.tree(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', {}),
-            None))
+            None,
+            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.direct_reference = True
     self.deps_parsed = True
 
   def SaveConfig(self):
     gclient_utils.FileWrite(os.path.join(self.root_dir(),
@@ skipping 191 matching lines @@
       print(self.DEFAULT_SNAPSHOT_FILE_TEXT % {'solution_list': new_gclient})
     else:
       entries = {}
       for d in self.tree(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:
-        line = '%s: %s' % (x, entries[x])
-        if x is not keys[-1]:
-          line += ';'
-        print line
+        print('%s: %s' % (x, entries[x]))
     logging.info(str(self))
 
-  def ParseDepsFile(self, direct_reference):
+  def ParseDepsFile(self):
     """No DEPS to parse for a .gclient file."""
     raise gclient_utils.Error('Internal error')
 
   def root_dir(self):
     """Root directory of gclient checkout."""
     return self._root_dir
 
   def enforced_os(self):
     """What deps_os entries that are to be parsed."""
     return self._enforced_os
@@ skipping 390 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: