Remove two seams options.gclient and options.scm_wrapper in gclient.

gclient.py

 #!/usr/bin/python
 #
 # Copyright 2008 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
@@ skipping 952 matching lines @@
       the .gclient file doesn't exist.
     """
     if not from_dir:
       from_dir = os.curdir
     path = os.path.realpath(from_dir)
     while not os.path.exists(os.path.join(path, options.config_filename)):
       next = os.path.split(path)
       if not next[1]:
         return None
       path = next[0]
-    client = options.gclient(path, options)
+    client = GClient(path, options)
     client._LoadConfig()
     return client
 
   def SetDefaultConfig(self, solution_name, solution_url, safesync_url):
     self.SetConfig(DEFAULT_CLIENT_FILE_TEXT % (
       solution_name, solution_url, safesync_url
     ))
 
   def _SaveEntries(self, entries):
     """Creates a .gclient_entries file to record the list of unique checkouts.
@@ skipping 177 matching lines @@
           else:
             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 Error(
                     "relative DEPS entry \"%s\" must begin with a slash" % d)
               # Create a scm just to query the full url.
-              scm = self._options.scm_wrapper(solution["url"], self._root_dir,
-                                              None)
+              scm = SCMWrapper(solution["url"], self._root_dir, None)
               url = scm.FullUrlForRelativeUrl(url)
         if d in deps and deps[d] != url:
           raise Error(
               "Solutions have conflicting versions of dependency \"%s\"" % d)
         if d in solution_urls and solution_urls[d] != url:
           raise Error(
               "Dependency \"%s\" conflicts with specified solution" % d)
         # Grab the dependency.
         deps[d] = url
     return deps
@@ skipping 90 matching lines @@
     file_list = []
     # Run on the base solutions first.
     for solution in solutions:
       name = solution["name"]
       if name in entries:
         raise Error("solution %s specified more than once" % name)
       url = solution["url"]
       entries[name] = url
       if run_scm:
         self._options.revision = revision_overrides.get(name)
-        scm = self._options.scm_wrapper(url, self._root_dir, name)
+        scm = SCMWrapper(url, self._root_dir, name)
         scm.RunCommand(command, self._options, args, file_list)
         self._options.revision = None
       try:
         deps_content = FileRead(os.path.join(self._root_dir, name,
                                              self._options.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()
     deps_to_process.sort()
 
     # First pass for direct dependencies.
     for d in deps_to_process:
       if type(deps[d]) == str:
         url = deps[d]
         entries[d] = url
         if run_scm:
           self._options.revision = revision_overrides.get(d)
-          scm = self._options.scm_wrapper(url, self._root_dir, d)
+          scm = SCMWrapper(url, self._root_dir, d)
           scm.RunCommand(command, self._options, args, file_list)
           self._options.revision = None
 
     # Second pass for inherited deps (via the From keyword)
     for d in deps_to_process:
       if type(deps[d]) != str:
         sub_deps = self._ParseSolutionDeps(
                            deps[d].module_name,
                            FileRead(os.path.join(self._root_dir,
                                                  deps[d].module_name,
                                                  self._options.deps_file)),
                            {})
         url = sub_deps[d]
         entries[d] = url
         if run_scm:
           self._options.revision = revision_overrides.get(d)
-          scm = self._options.scm_wrapper(url, self._root_dir, d)
+          scm = SCMWrapper(url, self._root_dir, d)
           scm.RunCommand(command, self._options, args, file_list)
           self._options.revision = None
 
     is_using_git = IsUsingGit(self._root_dir, entries.keys())
     self._RunHooks(command, file_list, is_using_git)
 
     if command == 'update':
       # notify the user if there is an orphaned entry in their working copy.
       # TODO(darin): we should delete this directory manually if it doesn't
       # have any changes in it.
@@ skipping 121 matching lines @@
 
 ## gclient commands.
 
 
 def DoCleanup(options, args):
   """Handle the cleanup subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
-  client = options.gclient.LoadCurrentConfig(options)
+  client = GClient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   options.verbose = True
   return client.RunOnDeps('cleanup', args)
 
 
 def DoConfig(options, args):
   """Handle the config subcommand.
 
   Args:
     options: If options.spec set, a string providing contents of config file.
     args: The command line args.  If spec is not set,
           then args[0] is a string URL to get for config file.
 
   Raises:
     Error: on usage error
   """
   if len(args) < 1 and not options.spec:
     raise Error("required argument missing; see 'gclient help config'")
   if os.path.exists(options.config_filename):
     raise Error("%s file already exists in the current directory" %
                 options.config_filename)
-  client = options.gclient('.', options)
+  client = GClient('.', options)
   if options.spec:
     client.SetConfig(options.spec)
   else:
     # TODO(darin): it would be nice to be able to specify an alternate relpath
     # for the given URL.
     base_url = args[0]
     name = args[0].split("/")[-1]
     safesync_url = ""
     if len(args) > 1:
       safesync_url = args[1]
@@ skipping 12 matching lines @@
   else:
     raise Error("unknown subcommand '%s'; see 'gclient help'" % args[0])
 
 
 def DoStatus(options, args):
   """Handle the status subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
-  client = options.gclient.LoadCurrentConfig(options)
+  client = GClient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   options.verbose = True
   return client.RunOnDeps('status', args)
 
 
 def DoUpdate(options, args):
   """Handle the update and sync subcommands.
 
   Raises:
     Error: if client isn't configured properly.
   """
-  client = options.gclient.LoadCurrentConfig(options)
+  client = GClient.LoadCurrentConfig(options)
 
   if not client:
     raise Error("client not configured; see 'gclient config'")
 
   if not options.head:
     solutions = client.GetVar('solutions')
     if solutions:
       for s in solutions:
         if s.get('safesync_url', ''):
           # rip through revisions and make sure we're not over-riding
@@ skipping 17 matching lines @@
     print(client.ConfigContent())
   return client.RunOnDeps('update', args)
 
 
 def DoDiff(options, args):
   """Handle the diff subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
-  client = options.gclient.LoadCurrentConfig(options)
+  client = GClient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   options.verbose = True
   return client.RunOnDeps('diff', args)
 
 
 def DoRevert(options, args):
   """Handle the revert subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
-  client = options.gclient.LoadCurrentConfig(options)
+  client = GClient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   return client.RunOnDeps('revert', args)
 
 
 def DoRunHooks(options, args):
   """Handle the runhooks subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
-  client = options.gclient.LoadCurrentConfig(options)
+  client = GClient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   return client.RunOnDeps('runhooks', args)
 
 
 def DoRevInfo(options, args):
   """Handle the revinfo subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
-  client = options.gclient.LoadCurrentConfig(options)
+  client = GClient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   client.PrintRevInfo()
 
 
 gclient_command_map = {
   "cleanup": DoCleanup,
   "config": DoConfig,
   "diff": DoDiff,
   "help": DoHelp,
@@ skipping 68 matching lines @@
 
   if len(argv) < 3 and command == "help":
     option_parser.print_help()
     return 0
 
   # Files used for configuration and state saving.
   options.config_filename = os.environ.get("GCLIENT_FILE", ".gclient")
   options.entries_filename = ".gclient_entries"
   options.deps_file = "DEPS"
 
-  options.gclient = GClient
-  options.scm_wrapper = SCMWrapper
   options.platform = sys.platform
   return DispatchCommand(command, options, args)
 
 
 if "__main__" == __name__:
   try:
     result = Main(sys.argv)
   except Error, e:
     print >> sys.stderr, "Error: %s" % str(e)
     result = 1
   sys.exit(result)
 
 # vim: ts=2:sw=2:tw=80:et: