Move patch management functions into their own file, patch.py.

checkout.py

 # coding=utf8
 # 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.
 """Manages a project checkout.
+
+Includes support for svn, git-svn and git.
 """
 
 import logging
 import os
 import re
 import subprocess
 import tempfile
 
+import patch
 import subprocess2
 import svn_utils
 
 
 def get_code_review_setting(path, key,
     codereview_settings_file='codereview.settings'):
   """Parses codereview.settings and return the value for the key if present.
 
   Don't cache the values in case the file is changed."""
   settings = {}
@@ skipping 31 matching lines @@
   Commit is not fully implemented yet. Reimplementing all the commands is
   slightly complex, svn add with history needs to be done with svn
   copy/rename/move and the situation quickly becomes harder when directories are
   moved.
   """
   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 bool(self.svn_url)
 
   def prepare(self):
     """Creates the initial checkouts for the repo."""
     # Will checkout if the directory is not present.
     logging.info('Checking out %s in %s' %
         (self.project_name, self.project_path))
     return svn_utils.revert(
         self.svn_url,
         self.project_path,
         self.commit_user,
         self.commit_pwd)
 
-  def apply_patch(self, patch):
+  def apply_patch(self, patch_data):
     """Applies a patch."""
     try:
-      svn_utils.apply_patch(self.project_path, patch)
+      patch.apply_patch(self.project_path, patch_data)
       return True
     except subprocess.CalledProcessError, e:
       if e.returncode == 1:
         return False
       raise
 
   def commit(self, commit_message, user):
     """Commits a patch."""
     logging.info('Committing patch for %s' % user)
     assert self.commit_user
@@ skipping 29 matching lines @@
     self.remote_branch = remote_branch
     self.working_branch = 'working_branch'
 
   def prepare(self):
     """Resets the git repository in a clean state."""
     assert os.path.isdir(self.project_path)
     self.check_call(['checkout', 'master', '--force'])
     self.check_call(['pull', self.remote, self.remote_branch])
     self.call(['branch', '-D', self.working_branch])
 
-  def apply_patch(self, patch):
+  def apply_patch(self, patch_data):
     """Applies a patch on 'working_branch'."""
     self.check_call(
         ['checkout', '-b', self.working_branch,
          '%s/%s' % (self.remote, self.remote_branch)])
-    self.check_call(['apply', '--index', '-p0'], stdin=patch)
+    self.check_call(['apply', '--index', '-p0'], stdin=patch_data)
     self.check_call(['commit', '-m', 'Committed patch'])
 
   def commit(self, commit_message, user):
     self.check_call(['commit', '--amend', '-m', commit_message])
 
   def check_call(self, args, **kwargs):
     kwargs.setdefault('cwd', self.project_path)
     return subprocess2.check_call(['git'] + args, **kwargs)
 
   def call(self, args, **kwargs):
@@ skipping 133 matching lines @@
   """Converts a checkout into a read-only one."""
   def __init__(self, checkout):
     self.checkout = checkout
 
   def prepare(self):
     return self.checkout.prepare()
 
   def get_settings(self, key):
     return self.checkout.get_settings(key)
 
-  def apply_patch(self, patch):
-    return self.checkout.apply_patch(patch)
+  def apply_patch(self, patch_data):
+    return self.checkout.apply_patch(patch_data)
 
   def commit(self, message, user):
     logging.info('Would have committed for %s with message: %s' % (
         user, message))
     return 'FAKE'
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path