Add the ability to check out a single file from a repo....

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 411 matching lines @@
 
   class FromImpl:
     """Used to implement the From syntax."""
 
     def __init__(self, module_name):
       self.module_name = module_name
 
     def __str__(self):
       return 'From("%s")' % self.module_name
 
+  class FileImpl:
+    """Used to implement the File('') syntax which lets you sync a single file
+    from an SVN repo."""
+
+    def __init__(self, file_location):
+      self.file_location = file_location
+
+    def __str__(self):
+      return 'File("%s")' % self.file_location
+
+    def GetPath(self):
+      return os.path.split(self.file_location)[0]
+
+    def GetFilename(self):
+      rev_tokens = self.file_location.split('@')
+      return os.path.split(rev_tokens[0])[1]
+
+    def GetRevision(self):
+      rev_tokens = self.file_location.split('@')
+      if len(rev_tokens) > 1:
+        return rev_tokens[1]
+      return None
+
   class _VarImpl:
     def __init__(self, custom_vars, local_scope):
       self._custom_vars = custom_vars
       self._local_scope = local_scope
 
     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", {}):
@@ skipping 12 matching lines @@
     Returns:
       A dict mapping module names (as relative paths) to URLs or an empty
       dict if the solution does not have a DEPS file.
     """
     # Skip empty
     if not solution_deps_content:
       return {}
     # Eval the content
     local_scope = {}
     var = self._VarImpl(custom_vars, local_scope)
-    global_scope = {"From": self.FromImpl, "Var": var.Lookup, "deps_os": {}}
+    global_scope = {
+      "File": self.FileImpl,
+      "From": self.FromImpl,
+      "Var": var.Lookup,
+      "deps_os": {},
+    }
     exec(solution_deps_content, global_scope, local_scope)
     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:
       deps_os_choices = {
           "win32": "win",
           "win": "win",
           "cygwin": "win",
@@ skipping 78 matching lines @@
           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 type(url) != str:
+          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
-          else:
+          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,
@@ skipping 140 matching lines @@
       if command == 'update' and not self._options.verbose:
         pm.update()
       if type(deps[d]) == str:
         url = deps[d]
         entries[d] = url
         if run_scm:
           self._options.revision = revision_overrides.get(d)
           scm = gclient_scm.CreateSCM(url, self._root_dir, d)
           scm.RunCommand(command, self._options, args, file_list)
           self._options.revision = None
+      elif isinstance(deps[d], self.FileImpl):
+        file = deps[d]
+        self._options.revision = file.GetRevision()
+        if run_scm:
+          scm = gclient_scm.CreateSCM(file.GetPath(), self._root_dir, d)
+          scm.RunCommand("updatesingle", self._options,
+                         args + [file.GetFilename()], file_list)
+          
     if command == 'update' and not self._options.verbose:
       pm.end()
 
     # Second pass for inherited deps (via the From keyword)
     for d in deps_to_process:
-      if type(deps[d]) != str:
+      if isinstance(deps[d], self.FromImpl):
         filename = os.path.join(self._root_dir,
                                 deps[d].module_name,
                                 self._options.deps_file)
         content =  gclient_utils.FileRead(filename)
         sub_deps = self._ParseSolutionDeps(deps[d].module_name, content, {})
         url = sub_deps[d]
         entries[d] = url
         if run_scm:
           self._options.revision = revision_overrides.get(d)
           scm = gclient_scm.CreateSCM(url, self._root_dir, d)
@@ skipping 131 matching lines @@
     deps_to_process.sort()
 
     # First pass for direct dependencies.
     for d in deps_to_process:
       if type(deps[d]) == str:
         (url, rev) = GetURLAndRev(d, deps[d])
         entries[d] = "%s@%s" % (url, rev)
 
     # Second pass for inherited deps (via the From keyword)
     for d in deps_to_process:
-      if type(deps[d]) != str:
+      if isinstance(deps[d], self.FromImpl):
         deps_parent_url = entries[deps[d].module_name]
         if deps_parent_url.find("@") < 0:
           raise gclient_utils.Error("From %s missing revisioned url" %
                                         deps[d].module_name)
         content =  gclient_utils.FileRead(os.path.join(
                                             self._root_dir,
                                             deps[d].module_name,
                                             self._options.deps_file))
         sub_deps = self._ParseSolutionDeps(deps[d].module_name, content, {})
         (url, rev) = GetURLAndRev(d, sub_deps[d])
@@ skipping 352 matching lines @@
 
 if "__main__" == __name__:
   try:
     result = Main(sys.argv)
   except gclient_utils.Error, e:
     print >> sys.stderr, "Error: %s" % str(e)
     result = 1
   sys.exit(result)
 
 # vim: ts=2:sw=2:tw=80:et: