diff --git a/checkout.py b/checkout.py index 2260ab348..6f82383db 100644 --- a/checkout.py +++ b/checkout.py @@ -566,183 +566,6 @@ class GitCheckoutBase(CheckoutBase): return branches, active -class GitSvnCheckoutBase(GitCheckoutBase, SvnMixIn): - """Base class for git-svn checkout. Not to be used as-is.""" - def __init__(self, - root_dir, project_name, remote_branch, - commit_user, commit_pwd, - svn_url, trunk, post_processors=None): - """trunk is optional.""" - GitCheckoutBase.__init__( - self, root_dir, project_name + '.git', remote_branch, post_processors) - SvnMixIn.__init__(self) - self.commit_user = commit_user - self.commit_pwd = commit_pwd - # svn_url in this case is the root of the svn repository. - self.svn_url = svn_url - self.trunk = trunk - assert bool(self.commit_user) >= bool(self.commit_pwd) - assert self.svn_url - assert self.trunk - self._cache_svn_auth() - - def prepare(self, revision): - """Resets the git repository in a clean state.""" - self._check_call_git(['reset', '--hard', '--quiet']) - if revision: - try: - revision = self._check_output_git( - ['svn', 'find-rev', 'r%d' % revision]) - except subprocess.CalledProcessError: - self._check_call_git( - ['fetch', self.remote, self.remote_branch, '--quiet']) - revision = self._check_output_git( - ['svn', 'find-rev', 'r%d' % revision]) - super(GitSvnCheckoutBase, self).prepare(revision) - else: - branches, active = self._branches() - if active != 'master': - if not 'master' in branches: - self._check_call_git( - ['checkout', '--quiet', '-b', 'master', - '%s/%s' % (self.remote, self.remote_branch)]) - else: - self._check_call_git(['checkout', 'master', '--force', '--quiet']) - # git svn rebase --quiet --quiet doesn't work, use two steps to silence - # it. - self._check_call_git_svn(['fetch', '--quiet', '--quiet']) - self._check_call_git( - ['rebase', '--quiet', '--quiet', - '%s/%s' % (self.remote, self.remote_branch)]) - if self.working_branch in branches: - self._call_git(['branch', '-D', self.working_branch]) - return self._get_revision() - - def _git_svn_info(self, key): - """Calls git svn info. This doesn't support nor need --config-dir.""" - return self._parse_svn_info(self._check_output_git(['svn', 'info']), key) - - def commit(self, commit_message, user): - """Commits a patch.""" - logging.info('Committing patch for %s' % user) - # Fix the commit message and author. It returns the git hash, which we - # ignore unless it's None. - if not super(GitSvnCheckoutBase, self).commit(commit_message, user): - return None - # TODO(maruel): git-svn ignores --config-dir as of git-svn version 1.7.4 and - # doesn't support --with-revprop. - # Either learn perl and upstream or suck it. - kwargs = {} - if self.commit_pwd: - kwargs['stdin'] = self.commit_pwd + '\n' - kwargs['stderr'] = subprocess2.STDOUT - self._check_call_git_svn( - ['dcommit', '--rmdir', '--find-copies-harder', - '--username', self.commit_user], - **kwargs) - revision = int(self._git_svn_info('revision')) - return revision - - def _cache_svn_auth(self): - """Caches the svn credentials. It is necessary since git-svn doesn't prompt - for it.""" - if not self.commit_user or not self.commit_pwd: - return - # Use capture to lower noise in logs. - self._check_output_svn(['ls', self.svn_url], cwd=None) - - def _check_call_git_svn(self, args, **kwargs): - """Handles svn authentication while calling git svn.""" - args = ['svn'] + args - if not self.svn_config.default: - args.extend(['--config-dir', self.svn_config.svn_config_dir]) - return self._check_call_git(args, **kwargs) - - def _get_revision(self): - revision = int(self._git_svn_info('revision')) - if revision != self._last_seen_revision: - logging.info('Updated to revision %d' % revision) - self._last_seen_revision = revision - return revision - - -class GitSvnPremadeCheckout(GitSvnCheckoutBase): - """Manages a git-svn clone made out from an initial git-svn seed. - - This class is very similar to GitSvnCheckout but is faster to bootstrap - because it starts right off with an existing git-svn clone. - """ - def __init__(self, - root_dir, project_name, remote_branch, - commit_user, commit_pwd, - svn_url, trunk, git_url, post_processors=None): - super(GitSvnPremadeCheckout, self).__init__( - root_dir, project_name, remote_branch, - commit_user, commit_pwd, - svn_url, trunk, post_processors) - self.git_url = git_url - assert self.git_url - - def prepare(self, revision): - """Creates the initial checkout for the repo.""" - if not os.path.isdir(self.project_path): - logging.info('Checking out %s in %s' % - (self.project_name, self.project_path)) - assert self.remote == 'origin' - # self.project_path doesn't exist yet. - self._check_call_git( - ['clone', self.git_url, self.project_name, '--quiet'], - cwd=self.root_dir, - stderr=subprocess2.STDOUT) - try: - configured_svn_url = self._check_output_git( - ['config', 'svn-remote.svn.url']).strip() - except subprocess.CalledProcessError: - configured_svn_url = '' - - if configured_svn_url.strip() != self.svn_url: - self._check_call_git_svn( - ['init', - '--prefix', self.remote + '/', - '-T', self.trunk, - self.svn_url]) - self._check_call_git_svn(['fetch']) - return super(GitSvnPremadeCheckout, self).prepare(revision) - - -class GitSvnCheckout(GitSvnCheckoutBase): - """Manages a git-svn clone. - - Using git-svn hides some of the complexity of using a svn checkout. - """ - def __init__(self, - root_dir, project_name, - commit_user, commit_pwd, - svn_url, trunk, post_processors=None): - super(GitSvnCheckout, self).__init__( - root_dir, project_name, 'trunk', - commit_user, commit_pwd, - svn_url, trunk, post_processors) - - def prepare(self, revision): - """Creates the initial checkout for the repo.""" - assert not revision, 'Implement revision if necessary' - if not os.path.isdir(self.project_path): - logging.info('Checking out %s in %s' % - (self.project_name, self.project_path)) - # TODO: Create a shallow clone. - # self.project_path doesn't exist yet. - self._check_call_git_svn( - ['clone', - '--prefix', self.remote + '/', - '-T', self.trunk, - self.svn_url, self.project_path, - '--quiet'], - cwd=self.root_dir, - stderr=subprocess2.STDOUT) - return super(GitSvnCheckout, self).prepare(revision) - - class ReadOnlyCheckout(object): """Converts a checkout into a read-only one.""" def __init__(self, checkout, post_processors=None): diff --git a/tests/checkout_test.py b/tests/checkout_test.py index 26cb4453d..31e1f4f1f 100755 --- a/tests/checkout_test.py +++ b/tests/checkout_test.py @@ -429,79 +429,6 @@ class SvnCheckout(SvnBaseTest): self.assertEquals(expected, values) -class GitSvnCheckout(SvnBaseTest): - name = 'foo.git' - - def _get_co(self, post_processors): - self.assertNotEqual(False, post_processors) - return checkout.GitSvnCheckout( - self.root_dir, self.name[:-4], - self.usr, self.pwd, - self.svn_base, self.svn_trunk, post_processors) - - def testAll(self): - expected = { - 'author': self.FAKE_REPOS.USERS[0][0], - } - root = os.path.join(self.root_dir, self.name) - self._check_base(self._get_co(None), root, True, expected) - - def testGitSvnPremade(self): - # Test premade git-svn clone. First make a git-svn clone. - git_svn_co = self._get_co(None) - revision = git_svn_co.prepare(None) - self.assertEquals(self.previous_log['revision'], revision) - # Then use GitSvnClone to clone it to lose the git-svn connection and verify - # git svn init / git svn fetch works. - git_svn_clone = checkout.GitSvnPremadeCheckout( - self.root_dir, self.name[:-4] + '2', 'trunk', - self.usr, self.pwd, - self.svn_base, self.svn_trunk, git_svn_co.project_path) - self.assertEquals( - self.previous_log['revision'], git_svn_clone.prepare(None)) - - def testException(self): - self._check_exception( - self._get_co(None), 'fatal: corrupt patch at line 12\n') - - def testSvnProps(self): - co = self._get_co(None) - co.prepare(None) - try: - svn_props = [('foo', 'bar')] - co.apply_patch( - [patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, svn_props)]) - self.fail() - except patch.UnsupportedPatchFormat, e: - self.assertEquals(e.filename, 'chrome/file.cc') - self.assertEquals( - e.status, - 'Cannot apply svn property foo to file chrome/file.cc.') - co.prepare(None) - # svn:eol-style is ignored. - svn_props = [('svn:eol-style', 'LF')] - co.apply_patch( - [patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, svn_props)]) - - def testProcess(self): - self._test_process(self._get_co) - - def testPrepare(self): - co = self._get_co(None) - # TODO(maruel): Cheat here until prepare(revision != None) implemented. - co.old_prepare = co.prepare - def prepare(rev): - # Basically, test that it is broken. - self.assertEquals(1, rev) - self.assertEquals(2, co.old_prepare(None)) - return 1 - co.prepare = prepare - self._test_prepare(co) - - def testMove(self): - self._check_move(self._get_co(None)) - - class RawCheckout(SvnBaseTest): def setUp(self): super(RawCheckout, self).setUp()