Complete apply_issue.py.

checkout.py

 # coding=utf8
 # 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.
 """Manages a project checkout.
 
 Includes support for svn, git-svn and git.
 """
 
 from __future__ import with_statement
@@ skipping 44 matching lines @@
     self.status = status
 
 
 class CheckoutBase(object):
   # Set to None to have verbose output.
   VOID = subprocess2.VOID
 
   def __init__(self, root_dir, project_name):
     self.root_dir = root_dir
     self.project_name = project_name
-    self.project_path = os.path.join(self.root_dir, self.project_name)
+    if self.project_name is None:
+      self.project_path = self.root_dir
+    else:
+      self.project_path = os.path.join(self.root_dir, self.project_name)
     # Only used for logging purposes.
     self._last_seen_revision = None
     assert self.root_dir
-    assert self.project_name
     assert self.project_path
 
   def get_settings(self, key):
     return get_code_review_setting(self.project_path, key)
 
   def prepare(self):
     """Checks out a clean copy of the tree and removes any local modification.
 
     This function shouldn't throw unless the remote repository is inaccessible,
     there is no free disk space or hard issues like that.
@@ skipping 142 matching lines @@
 
 
 class SvnCheckout(CheckoutBase, SvnMixIn):
   """Manages a subversion checkout."""
   def __init__(self, root_dir, project_name, commit_user, commit_pwd, svn_url):
     super(SvnCheckout, self).__init__(root_dir, project_name)
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     self.svn_url = svn_url
     assert bool(self.commit_user) >= bool(self.commit_pwd)
-    assert self.svn_url
 
   def prepare(self):
     # Will checkout if the directory is not present.
+    assert self.svn_url
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
     revision = self._revert()
     if revision != self._last_seen_revision:
       logging.info('Updated at revision %d' % revision)
       self._last_seen_revision = revision
     return revision
 
   def apply_patch(self, patches, post_processor=None):
@@ skipping 93 matching lines @@
 
 
 class GitCheckoutBase(CheckoutBase):
   """Base class for git checkout. Not to be used as-is."""
   def __init__(self, root_dir, project_name, remote_branch):
     super(GitCheckoutBase, self).__init__(root_dir, project_name)
     # There is no reason to not hardcode it.
     self.remote = 'origin'
     self.remote_branch = remote_branch
     self.working_branch = 'working_branch'
-    assert self.remote_branch
 
   def prepare(self):
     """Resets the git repository in a clean state.
 
     Checks it out if not present and deletes the working branch.
     """
+    assert self.remote_branch
     assert os.path.isdir(self.project_path)
     self._check_call_git(['reset', '--hard', '--quiet'])
     branches, active = self._branches()
     if active != 'master':
       self._check_call_git(['checkout', 'master', '--force', '--quiet'])
     self._check_call_git(['pull', self.remote, self.remote_branch, '--quiet'])
     if self.working_branch in branches:
       self._call_git(['branch', '-D', self.working_branch])
 
   def apply_patch(self, patches, post_processor=None):
     """Applies a patch on 'working_branch' and switch to it.
 
     Also commits the changes on the local branch.
 
     Ignores svn properties and raise an exception on unexpected ones.
     """
     post_processor = post_processor or []
     # It this throws, the checkout is corrupted. Maybe worth deleting it and
     # trying again?
-    self._check_call_git(
-        ['checkout', '-b', self.working_branch,
-          '%s/%s' % (self.remote, self.remote_branch), '--quiet'])
+    if self.remote_branch:
+      self._check_call_git(
+          ['checkout', '-b', self.working_branch,
+            '%s/%s' % (self.remote, self.remote_branch), '--quiet'])
     for p in patches:
       try:
         stdout = ''
         if p.is_delete:
           stdout += self._check_output_git(['rm', p.filename])
         else:
           dirname = os.path.dirname(p.filename)
           full_dir = os.path.join(self.project_path, dirname)
           if dirname and not os.path.isdir(full_dir):
             os.makedirs(full_dir)
@@ skipping 250 matching lines @@
         user, message))
     return 'FAKE'
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path