Make each solution dictionary an object.

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 137 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 GClient(GClientKeywords):
-  """Object that represent a gclient checkout."""
+class Dependency(GClientKeywords):
+  """Object that represents a dependency checkout."""
   DEPS_FILE = 'DEPS'
+  def __init__(self, parent, name, url, safesync_url=None, custom_deps=None,
+      custom_vars=None, deps_file=None):
+    GClientKeywords.__init__(self)
+    self.parent = parent
+    self.name = name
+    self.url = url
+    # 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.dependencies = []
+    self.deps_file = deps_file or self.DEPS_FILE
+    self._deps_hooks = []
 
+    # 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)
+
+
+class GClient(Dependency):
+  """Main gclient checkout root where .gclient resides."""
   SUPPORTED_COMMANDS = [
     'cleanup', 'diff', 'export', 'pack', 'revert', 'status', 'update',
     'runhooks'
   ]
 
   DEPS_OS_CHOICES = {
     "win32": "win",
     "win": "win",
     "cygwin": "win",
     "darwin": "mac",
@@ skipping 25 matching lines @@
 """)
 
   DEFAULT_SNAPSHOT_FILE_TEXT = ("""\
 # Snapshot generated with gclient revinfo --snapshot
 solutions = [
 %(solution_list)s
 ]
 """)
 
   def __init__(self, root_dir, options):
+    Dependency.__init__(self, None, None, None)
     self._root_dir = root_dir
     self._options = options
     self.config_content = None
-    self._config_dict = {}
-    self._deps_hooks = []
 
   def SetConfig(self, content):
-    self._config_dict = {}
+    config_dict = {}
     self.config_content = content
     try:
-      exec(content, self._config_dict)
+      exec(content, config_dict)
     except SyntaxError, e:
       try:
         # 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))
+    for s in config_dict.get('solutions', []):
+      self.dependencies.append(Dependency(
+          self, s['name'], s['url'],
+          s.get('safesync_url', None),
+          s.get('custom_deps', {}),
+          s.get('custom_vars', {})))
+    # .gclient can have hooks.
+    self._deps_hooks = config_dict.get('hooks', [])
 
   def SaveConfig(self):
     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))
     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.
 
     Returns:
       A dict representing the contents of the .gclient file or an empty dict if
       the .gclient file doesn't exist.
     """
     if not from_dir:
@@ skipping 93 matching lines @@
         if len(deps_to_include) > 1:
           # Ignore any overrides 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)
 
     if 'hooks' in local_scope and parse_hooks:
-      self._deps_hooks.extend(local_scope['hooks'])
+      # TODO(maruel): Temporary Hack. Since this function is misplaced, find the
+      # right 'self' to add the hooks.
+      for d in self.dependencies:
+        if d.name == solution_name:
+          d._deps_hooks.extend(local_scope['hooks'])
+          break
 
     # If use_relative_paths is set in the DEPS file, regenerate
     # the dictionary using paths relative to the directory containing
     # the DEPS file.
     if local_scope.get('use_relative_paths'):
       rel_deps = {}
       for d, url in deps.items():
         # normpath is required to allow DEPS to use .. in their
         # dependency local path.
         rel_deps[os.path.normpath(os.path.join(solution_name, d))] = url
@@ skipping 12 matching lines @@
         of their DEPS files
 
     Returns:
       A dict mapping module names (as relative paths) to URLs corresponding
       to the entire set of dependencies to checkout for the given client.
 
     Raises:
       Error: If a dependency conflicts with another dependency or of a solution.
     """
     deps = {}
-    for solution in self.GetVar("solutions"):
-      custom_vars = solution.get("custom_vars", {})
+    for solution in self.dependencies:
       solution_deps = self._ParseSolutionDeps(
-                              solution["name"],
-                              solution_deps_content[solution["name"]],
-                              custom_vars,
+                              solution.name,
+                              solution_deps_content[solution.name],
+                              solution.custom_vars,
                               True)
 
       # If a line is in custom_deps, but not in the solution, we want to append
       # this line to the solution.
-      if "custom_deps" in solution:
-        for d in solution["custom_deps"]:
-          if d not in solution_deps:
-            solution_deps[d] = solution["custom_deps"][d]
+      for d in solution.custom_deps:
+        if d not in solution_deps:
+          solution_deps[d] = solution.custom_deps[d]
 
       for d in solution_deps:
-        if "custom_deps" in solution and d in solution["custom_deps"]:
+        if d in solution.custom_deps:
           # Dependency is overriden.
-          url = solution["custom_deps"][d]
+          url = solution.custom_deps[d]
           if url is None:
             continue
         else:
           url = solution_deps[d]
           # if we have a From reference dependent on another solution, then
           # just skip the From reference. When we pull deps for the solution,
           # we will take care of this dependency.
           #
           # If multiple solutions all have the same From reference, then we
           # should only add one to our list of dependencies.
           if isinstance(url, self.FromImpl):
             if url.module_name in solution_urls:
               # Already parsed.
               continue
             if d in deps and type(deps[d]) != str:
               if url.module_name == deps[d].module_name:
                 continue
           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(),
-                                           None)
+              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
     return deps
@@ skipping 24 matching lines @@
     """
     # 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:
       return
 
     # Get any hooks from the .gclient file.
-    hooks = self.GetVar("hooks", [])
+    hooks = self._deps_hooks[:]
     # Add any hooks found in DEPS files.
-    hooks.extend(self._deps_hooks)
+    for d in self.dependencies:
+      hooks.extend(d._deps_hooks)
 
     # If "--force" was specified, run all hooks regardless of what files have
     # changed.  If the user is using git, then we don't know what files have
     # changed so we always run all hooks.
     if self._options.force or is_using_git:
       for hook_dict in hooks:
         self._RunHookAction(hook_dict, [])
       return
 
     # Run hooks on the basis of whether the files from the gclient operation
     # match each hook's pattern.
     for hook_dict in 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)
 
-  def _EnforceRevisions(self, solutions):
+  def _EnforceRevisions(self):
     """Checks for revision overrides."""
     revision_overrides = {}
     if self._options.head:
       return revision_overrides
-    for s in solutions:
-      if not s.get('safesync_url', None):
+    for s in self.dependencies:
+      if not s.safesync_url:
         continue
-      handle = urllib.urlopen(s['safesync_url'])
+      handle = urllib.urlopen(s.safesync_url)
       rev = handle.read().strip()
       handle.close()
       if len(rev):
-        self._options.revisions.append('%s@%s' % (s['name'], rev))
+        self._options.revisions.append('%s@%s' % (s.name, rev))
     if not self._options.revisions:
       return revision_overrides
     # --revision will take over safesync_url.
-    solutions_names = [s['name'] for s in solutions]
+    solutions_names = [s.name for s in self.dependencies]
     index = 0
     for revision in self._options.revisions:
       if not '@' in revision:
         # Support for --revision 123
         revision = '%s@%s' % (solutions_names[index], revision)
-      sol, rev = revision.split("@", 1)
+      sol, rev = revision.split('@', 1)
       if not sol in solutions_names:
         #raise gclient_utils.Error('%s is not a valid solution.' % sol)
         print >> sys.stderr, ('Please fix your script, having invalid '
                               '--revision flags will soon considered an error.')
       else:
         revision_overrides[sol] = rev
       index += 1
     return revision_overrides
 
   def RunOnDeps(self, command, args):
     """Runs a command on each dependency in a client and its dependencies.
 
     The module's dependencies are specified in its top-level DEPS files.
 
     Args:
       command: The command to use (e.g., 'status' or 'diff')
       args: list of str - extra arguments to add to the command line.
 
     Raises:
       Error: If the client has conflicting entries.
     """
     if not command in self.SUPPORTED_COMMANDS:
       raise gclient_utils.Error("'%s' is an unsupported command" % command)
 
-    solutions = self.GetVar("solutions")
-    if not solutions:
+    if not self.dependencies:
       raise gclient_utils.Error("No solution specified")
-    revision_overrides = self._EnforceRevisions(solutions)
+    revision_overrides = self._EnforceRevisions()
 
     # When running runhooks --force, 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 = not (command == 'runhooks' and self._options.force)
 
     entries = {}
     entries_deps_content = {}
     file_list = []
     # Run on the base solutions first.
-    for solution in solutions:
-      name = solution["name"]
-      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.')
+    for solution in self.dependencies:
+      name = solution.name
       if name in entries:
         raise gclient_utils.Error("solution %s specified more than once" % name)
-      url = solution["url"]
+      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.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, solution.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()
@@ skipping 103 matching lines @@
     """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:
+    if not self.dependencies:
       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)
       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:
+    for solution in self.dependencies:
       # Dictionary of { path : SCM url } to describe the gclient checkout
-      name = solution["name"]
+      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"])
+      (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)
+      deps_file = solution.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))
       except IOError, e:
         if e.errno != errno.ENOENT:
           raise
         deps_content = ""
@@ skipping 399 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: