/brz/remove-bazaar : revision 0.200.506

1

2

3

#

4

# This program is free software; you can redistribute it and/or modify

5

# it under the terms of the GNU General Public License as published by

24

25

from bzrlib import (

26

branch,

27

bzrdir,

28

27

config,

29

28

errors,

29

foreign,

30

repository,

31

revision,

32

tag,

35

from bzrlib.decorators import (

36

needs_read_lock,

37

)

38

from bzrlib.revision import (

39

NULL_REVISION,

40

)

41

38

from bzrlib.trace import (

42

39

is_quiet,

43

40

mutter,

50

47

NoPushSupport,

51

48

NoSuchRef,

52

49

)

53

from bzrlib.plugins.git.refs import (

54

ref_to_branch_name,

55

extract_tags,

56

tag_name_to_ref,

57

)

58

59

from bzrlib.foreign import ForeignBranch

50

51

try:

52

from bzrlib.foreign import ForeignBranch

53

except ImportError:

54

class ForeignBranch(branch.Branch):

55

def __init__(self, mapping):

56

self.mapping = mapping

57

super(ForeignBranch, self).__init__()

58

59

60

def extract_tags(refs, mapping):

61

ret = {}

62

for k,v in refs.iteritems():

63

if k.startswith("refs/tags/") and not k.endswith("^{}"):

64

v = refs.get(k+"^{}", v)

65

ret[k[len("refs/tags/"):]] = mapping.revision_id_foreign_to_bzr(v)

66

return ret

60

67

61

68

62

69

class GitPullResult(branch.PullResult):

63

"""Result of a pull from a Git branch."""

64

70

65

71

def _lookup_revno(self, revid):

66

72

assert isinstance(revid, str), "was %r" % revid

85

91

86

92

def get_tag_dict(self):

87

93

ret = {}

88

for k,v in extract_tags(self.repository._git.get_refs()).iteritems():

89

try:

90

obj = self.repository._git[v]

91

except KeyError:

92

mutter("Tag %s points at unknown object %s, ignoring", v, obj)

93

continue

94

for k,v in self.repository._git.refs.as_dict("refs/tags").iteritems():

95

obj = self.repository._git.get_object(v)

94

96

while isinstance(obj, Tag):

95

97

v = obj.object[1]

96

obj = self.repository._git[v]

98

obj = self.repository._git.get_object(v)

97

99

if not isinstance(obj, Commit):

98

100

mutter("Tag %s points at object %r that is not a commit, "

99

101

"ignoring", k, obj)

100

102

continue

101

ret[k] = self.branch.lookup_foreign_revision_id(v)

103

ret[k] = self.branch.mapping.revision_id_foreign_to_bzr(v)

102

104

return ret

103

105

104

def _set_tag_dict(self, to_dict):

105

extra = set(self.repository._git.get_refs().keys())

106

for k, revid in to_dict.iteritems():

107

name = tag_name_to_ref(k)

108

if name in extra:

109

extra.remove(name)

110

self.set_tag(k, revid)

111

for name in extra:

112

if name.startswith("refs/tags/"):

113

del self.repository._git[name]

114

115

106

def set_tag(self, name, revid):

116

self.repository._git.refs[tag_name_to_ref(name)], _ = \

117

self.branch.lookup_bzr_revision_id(revid)

118

119

120

class DictTagDict(LocalGitTagDict):

121

122

def __init__(self, branch, tags):

123

super(DictTagDict, self).__init__(branch)

124

self._tags = tags

125

126

def get_tag_dict(self):

127

return self._tags

107

self.repository._git.refs["refs/tags/%s" % name], _ = \

108

self.branch.mapping.revision_id_bzr_to_foreign(revid)

128

109

129

110

130

111

class GitBranchFormat(branch.BranchFormat):

132

113

def get_format_description(self):

133

114

return 'Git Branch'

134

115

135

def network_name(self):

136

return "git"

137

138

116

def supports_tags(self):

139

117

return True

140

118

141

def get_foreign_tests_branch_factory(self):

142

from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory

143

return ForeignTestsBranchFactory()

144

145

119

def make_tags(self, branch):

146

120

if getattr(branch.repository, "get_refs", None) is not None:

147

121

from bzrlib.plugins.git.remote import RemoteGitTagDict

150

124

return LocalGitTagDict(branch)

151

125

152

126

153

class GitReadLock(object):

154

155

def __init__(self, unlock):

156

self.unlock = unlock

157

158

159

class GitWriteLock(object):

160

161

def __init__(self, unlock):

162

self.unlock = unlock

163

164

165

127

class GitBranch(ForeignBranch):

166

128

"""An adapter to git repositories for bzr Branch objects."""

167

129

168

def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):

130

def __init__(self, bzrdir, repository, name, lockfiles):

169

131

self.repository = repository

170

132

self._format = GitBranchFormat()

171

133

self.control_files = lockfiles

172

134

self.bzrdir = bzrdir

173

135

super(GitBranch, self).__init__(repository.get_mapping())

174

if tagsdict is not None:

175

self.tags = DictTagDict(self, tagsdict)

176

self.ref = ref

177

self.name = ref_to_branch_name(ref)

136

self.name = name

178

137

self._head = None

179

self.base = bzrdir.root_transport.base

180

181

def _get_checkout_format(self):

182

"""Return the most suitable metadir for a checkout of this branch.

183

Weaves are used if this branch's repository uses weaves.

184

"""

185

return bzrdir.format_registry.make_bzrdir("default")

186

187

def get_child_submit_format(self):

188

"""Return the preferred format of submissions to this branch."""

189

ret = self.get_config().get_user_option("child_submit_format")

190

if ret is not None:

191

return ret

192

return "git"

138

self.base = bzrdir.transport.base

193

139

194

140

def _get_nick(self, local=False, possible_master_transports=None):

195

141

"""Find the nick name for this branch.

196

142

197

143

:return: Branch nick

198

144

"""

199

return self.name or "HEAD"

145

return self.name

200

146

201

147

def _set_nick(self, nick):

202

148

raise NotImplementedError

204

150

nick = property(_get_nick, _set_nick)

205

151

206

152

def __repr__(self):

207

return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,

208

self.ref or "HEAD")

153

return "%s(%r, %r)" % (self.__class__.__name__, self.repository.base, self.name)

209

154

210

155

def generate_revision_history(self, revid, old_revid=None):

211

156

# FIXME: Check that old_revid is in the ancestry of revid

214

159

215

160

def lock_write(self):

216

161

self.control_files.lock_write()

217

return GitWriteLock(self.unlock)

218

162

219

163

def get_stacked_on_url(self):

220

164

# Git doesn't do stacking (yet...)

221

raise errors.UnstackableBranchFormat(self._format, self.base)

165

return None

222

166

223

167

def get_parent(self):

224

168

"""See Branch.get_parent()."""

231

175

232

176

def lock_read(self):

233

177

self.control_files.lock_read()

234

return GitReadLock(self.unlock)

235

178

236

179

def is_locked(self):

237

180

return self.control_files.is_locked()

247

190

# perhaps should escape this ?

248

191

if self.head is None:

249

192

return revision.NULL_REVISION

250

return self.lookup_foreign_revision_id(self.head)

193

return self.mapping.revision_id_foreign_to_bzr(self.head)

251

194

252

195

def _basic_push(self, target, overwrite=False, stop_revision=None):

253

196

return branch.InterBranch.get(self, target)._basic_push(

254

197

overwrite, stop_revision)

255

198

256

def lookup_foreign_revision_id(self, foreign_revid):

257

return self.repository.lookup_foreign_revision_id(foreign_revid,

258

self.mapping)

259

260

def lookup_bzr_revision_id(self, revid):

261

return self.repository.lookup_bzr_revision_id(

262

revid, mapping=self.mapping)

263

264

199

265

200

class LocalGitBranch(GitBranch):

266

201

"""A local Git branch."""

267

202

268

def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):

269

super(LocalGitBranch, self).__init__(bzrdir, repository, name,

270

lockfiles, tagsdict)

271

refs = repository._git.get_refs()

272

if not (name in refs.keys() or "HEAD" in refs.keys()):

273

raise errors.NotBranchError(self.base)

203

def _get_checkout_format(self):

204

"""Return the most suitable metadir for a checkout of this branch.

205

Weaves are used if this branch's repository uses weaves.

206

"""

207

format = self.repository.bzrdir.checkout_metadir()

208

format.set_branch_format(self._format)

209

return format

274

210

275

211

def create_checkout(self, to_location, revision_id=None, lightweight=False,

276

212

accelerator_tree=None, hardlink=False):

279

215

t.ensure_base()

280

216

format = self._get_checkout_format()

281

217

checkout = format.initialize_on_transport(t)

282

from_branch = branch.BranchReferenceFormat().initialize(checkout,

218

from_branch = branch.BranchReferenceFormat().initialize(checkout,

283

219

self)

284

220

tree = checkout.create_workingtree(revision_id,

285

221

from_branch=from_branch, hardlink=hardlink)

286

222

return tree

287

223

else:

288

224

return self._create_heavyweight_checkout(to_location, revision_id,

289

hardlink)

225

hardlink)

290

226

291

def _create_heavyweight_checkout(self, to_location, revision_id=None,

227

def _create_heavyweight_checkout(self, to_location, revision_id=None,

292

228

hardlink=False):

293

229

"""Create a new heavyweight checkout of this branch.

294

230

297

233

:param hardlink: Whether to hardlink

298

234

:return: WorkingTree object of checkout.

299

235

"""

300

checkout_branch = bzrdir.BzrDir.create_branch_convenience(

301

to_location, force_new_tree=False)

236

checkout_branch = BzrDir.create_branch_convenience(

237

to_location, force_new_tree=False, format=get_rich_root_format())

302

238

checkout = checkout_branch.bzrdir

303

239

checkout_branch.bind(self)

304

# pull up to the specified revision_id to set the initial

240

# pull up to the specified revision_id to set the initial

305

241

# branch tip correctly, and seed it with history.

306

242

checkout_branch.pull(self, stop_revision=revision_id)

307

243

return checkout.create_workingtree(revision_id, hardlink=hardlink)

316

252

317

253

def _get_head(self):

318

254

try:

319

return self.repository._git.ref(self.ref or "HEAD")

255

return self.repository._git.ref(self.name)

320

256

except KeyError:

321

257

return None

322

258

323

def set_last_revision_info(self, revno, revid):

324

self.set_last_revision(revid)

325

326

def set_last_revision(self, revid):

327

(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)

328

self.head = newhead

329

330

259

def _set_head(self, value):

331

260

self._head = value

332

self.repository._git.refs[self.ref or "HEAD"] = self._head

261

self.repository._git.refs[self.name] = self._head

333

262

self._clear_cached_state()

334

263

335

264

head = property(_get_head, _set_head)

353

282

354

283

class GitBranchPullResult(branch.PullResult):

355

284

356

def __init__(self):

357

super(GitBranchPullResult, self).__init__()

358

self.new_git_head = None

359

self._old_revno = None

360

self._new_revno = None

361

362

285

def report(self, to_file):

363

286

if not is_quiet():

364

287

if self.old_revid == self.new_revid:

365

288

to_file.write('No revisions to pull.\n')

366

elif self.new_git_head is not None:

367

to_file.write('Now on revision %d (git sha: %s).\n' %

289

else:

290

to_file.write('Now on revision %d (git sha: %s).\n' %

368

291

(self.new_revno, self.new_git_head))

369

else:

370

to_file.write('Now on revision %d.\n' % (self.new_revno,))

371

292

self._show_tag_conficts(to_file)

372

293

373

def _lookup_revno(self, revid):

374

assert isinstance(revid, str), "was %r" % revid

375

# Try in source branch first, it'll be faster

376

try:

377

return self.source_branch.revision_id_to_revno(revid)

378

except errors.NoSuchRevision:

379

# FIXME: Check using graph.find_distance_to_null() ?

380

return self.target_branch.revision_id_to_revno(revid)

381

382

def _get_old_revno(self):

383

if self._old_revno is not None:

384

return self._old_revno

385

return self._lookup_revno(self.old_revid)

386

387

def _set_old_revno(self, revno):

388

self._old_revno = revno

389

390

old_revno = property(_get_old_revno, _set_old_revno)

391

392

def _get_new_revno(self):

393

if self._new_revno is not None:

394

return self._new_revno

395

return self._lookup_revno(self.new_revid)

396

397

def _set_new_revno(self, revno):

398

self._new_revno = revno

399

400

new_revno = property(_get_new_revno, _set_new_revno)

401

402

294

403

295

class GitBranchPushResult(branch.BranchPushResult):

404

296

407

299

# Try in source branch first, it'll be faster

408

300

try:

409

301

return self.source_branch.revision_id_to_revno(revid)

410

except errors.NoSuchRevision:

302

except NoSuchRevision:

411

303

# FIXME: Check using graph.find_distance_to_null() ?

412

304

return self.target_branch.revision_id_to_revno(revid)

413

305

423

315

class InterFromGitBranch(branch.GenericInterBranch):

424

316

"""InterBranch implementation that pulls from Git into bzr."""

425

317

426

@staticmethod

427

def _get_branch_formats_to_test():

428

return []

429

430

@classmethod

431

def _get_interrepo(self, source, target):

432

return repository.InterRepository.get(source.repository,

433

target.repository)

434

435

@classmethod

436

def is_compatible(cls, source, target):

437

return (isinstance(source, GitBranch) and

438

not isinstance(target, GitBranch) and

439

(getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))

440

441

def _update_revisions(self, stop_revision=None, overwrite=False,

442

graph=None, limit=None):

443

"""Like InterBranch.update_revisions(), but with additions.

444

445

Compared to the `update_revisions()` below, this function takes a

446

`limit` argument that limits how many git commits will be converted

447

and returns the new git head.

448

"""

449

interrepo = self._get_interrepo(self.source, self.target)

318

@classmethod

319

def is_compatible(self, source, target):

320

return (isinstance(source, GitBranch) and

321

not isinstance(target, GitBranch))

322

323

def update_revisions(self, stop_revision=None, overwrite=False,

324

graph=None):

325

"""See InterBranch.update_revisions()."""

326

interrepo = repository.InterRepository.get(self.source.repository,

327

self.target.repository)

328

self._head = None

329

self._last_revid = None

450

330

def determine_wants(heads):

451

if self.source.ref is not None and not self.source.ref in heads:

452

raise NoSuchRef(self.source.ref, heads.keys())

331

if not self.source.name in heads:

332

raise NoSuchRef(self.source.name, heads.keys())

453

333

if stop_revision is not None:

454

334

self._last_revid = stop_revision

455

head, mapping = self.source.repository.lookup_bzr_revision_id(

335

self._head, mapping = self.source.repository.lookup_git_revid(

456

336

stop_revision)

457

337

else:

458

if self.source.ref is not None:

459

head = heads[self.source.ref]

460

else:

461

head = heads["HEAD"]

462

self._last_revid = self.source.lookup_foreign_revision_id(head)

338

self._head = heads[self.source.name]

339

self._last_revid = \

340

self.source.mapping.revision_id_foreign_to_bzr(self._head)

463

341

if self.target.repository.has_revision(self._last_revid):

464

342

return []

465

return [head]

466

pack_hint, head, refs = interrepo.fetch_objects(

467

determine_wants, self.source.mapping, limit=limit)

468

if (pack_hint is not None and

469

self.target.repository._format.pack_compresses):

470

self.target.repository.pack(hint=pack_hint)

471

if head is not None:

472

self._last_revid = self.source.lookup_foreign_revision_id(head)

343

return [self._head]

344

interrepo.fetch_objects(determine_wants, self.source.mapping)

473

345

if overwrite:

474

346

prev_last_revid = None

475

347

else:

476

348

prev_last_revid = self.target.last_revision()

477

self.target.generate_revision_history(self._last_revid,

478

prev_last_revid)

479

return head

480

481

def update_revisions(self, stop_revision=None, overwrite=False,

482

graph=None):

483

"""See InterBranch.update_revisions()."""

484

self._update_revisions(stop_revision, overwrite, graph)

349

self.target.generate_revision_history(self._last_revid, prev_last_revid)

485

350

486

351

def pull(self, overwrite=False, stop_revision=None,

487

352

possible_transports=None, _hook_master=None, run_hooks=True,

488

_override_hook_target=None, local=False, limit=None):

353

_override_hook_target=None, local=False):

489

354

"""See Branch.pull.

490

355

491

356

:param _hook_master: Private parameter - set the branch to

495

360

so it should not run its hooks.

496

361

:param _override_hook_target: Private parameter - set the branch to be

497

362

supplied as the target_branch to pull hooks.

498

:param limit: Only import this many revisons. `None`, the default,

499

means import all revisions.

500

363

"""

501

364

# This type of branch can't be bound.

502

365

if local:

512

375

# We assume that during 'pull' the target repository is closer than

513

376

# the source one.

514

377

graph = self.target.repository.get_graph(self.source.repository)

515

(result.old_revno, result.old_revid) = \

378

result.old_revno, result.old_revid = \

516

379

self.target.last_revision_info()

517

result.new_git_head = self._update_revisions(

518

stop_revision, overwrite=overwrite, graph=graph, limit=limit)

380

self.update_revisions(stop_revision, overwrite=overwrite,

381

graph=graph)

382

result.new_git_head = self._head

519

383

result.tag_conflicts = self.source.tags.merge_to(self.target.tags,

520

384

overwrite)

521

(result.new_revno, result.new_revid) = \

522

self.target.last_revision_info()

385

result.new_revno, result.new_revid = self.target.last_revision_info()

523

386

if _hook_master:

524

387

result.master_branch = _hook_master

525

388

result.local_branch = result.target_branch

539

402

result.target_branch = self.target

540

403

graph = self.target.repository.get_graph(self.source.repository)

541

404

result.old_revno, result.old_revid = self.target.last_revision_info()

542

result.new_git_head = self._update_revisions(

543

stop_revision, overwrite=overwrite, graph=graph)

405

self.update_revisions(stop_revision, overwrite=overwrite,

406

graph=graph)

407

result.new_git_head = self._head

544

408

result.tag_conflicts = self.source.tags.merge_to(self.target.tags,

545

409

overwrite)

546

410

result.new_revno, result.new_revid = self.target.last_revision_info()

547

411

return result

548

412

549

413

550

class InterGitBranch(branch.GenericInterBranch):

414

class InterGitRemoteLocalBranch(branch.InterBranch):

551

415

"""InterBranch implementation that pulls between Git branches."""

552

416

553

554

class InterGitLocalRemoteBranch(InterGitBranch):

555

"""InterBranch that copies from a local to a remote git branch."""

556

557

@staticmethod

558

def _get_branch_formats_to_test():

559

return []

560

561

@classmethod

562

def is_compatible(self, source, target):

563

from bzrlib.plugins.git.remote import RemoteGitBranch

564

return (isinstance(source, LocalGitBranch) and

565

isinstance(target, RemoteGitBranch))

566

567

def _basic_push(self, overwrite=False, stop_revision=None):

568

from dulwich.protocol import ZERO_SHA

569

result = GitBranchPushResult()

570

result.source_branch = self.source

571

result.target_branch = self.target

572

if stop_revision is None:

573

stop_revision = self.source.last_revision()

574

# FIXME: Check for diverged branches

575

def get_changed_refs(old_refs):

576

result.old_revid = self.target.lookup_foreign_revision_id(old_refs.get(self.target.ref, ZERO_SHA))

577

refs = { self.target.ref: self.source.repository.lookup_bzr_revision_id(stop_revision)[0] }

578

result.new_revid = stop_revision

579

for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():

580

refs[tag_name_to_ref(name)] = sha

581

return refs

582

self.target.repository.send_pack(get_changed_refs,

583

self.source.repository._git.object_store.generate_pack_contents)

584

return result

585

586

587

class InterGitRemoteLocalBranch(InterGitBranch):

588

"""InterBranch that copies from a remote to a local git branch."""

589

590

@staticmethod

591

def _get_branch_formats_to_test():

592

return []

593

594

@classmethod

595

def is_compatible(self, source, target):

596

from bzrlib.plugins.git.remote import RemoteGitBranch

597

return (isinstance(source, RemoteGitBranch) and

417

@classmethod

418

def is_compatible(self, source, target):

419

from bzrlib.plugins.git.remote import RemoteGitBranch

420

return (isinstance(source, RemoteGitBranch) and

598

421

isinstance(target, LocalGitBranch))

599

422

600

423

def _basic_push(self, overwrite=False, stop_revision=None):

609

432

return result

610

433

611

434

def update_tags(self, refs):

612

for name, v in extract_tags(refs).iteritems():

613

revid = self.target.lookup_foreign_revision_id(v)

435

for name, revid in extract_tags(refs, self.target.mapping).iteritems():

614

436

self.target.tags.set_tag(name, revid)

615

437

616

438

def update_refs(self, stop_revision=None):

617

interrepo = repository.InterRepository.get(self.source.repository,

439

interrepo = repository.InterRepository.get(self.source.repository,

618

440

self.target.repository)

619

441

if stop_revision is None:

620

refs = interrepo.fetch(branches=["HEAD"])

621

stop_revision = self.target.lookup_foreign_revision_id(refs["HEAD"])

442

refs = interrepo.fetch_refs(branches=["HEAD"])

443

stop_revision = self.target.mapping.revision_id_foreign_to_bzr(refs["HEAD"])

622

444

else:

623

refs = interrepo.fetch(revision_id=stop_revision)

445

refs = interrepo.fetch_refs(revision_id=stop_revision)

624

446

return refs, stop_revision

625

447

626

def pull(self, stop_revision=None, overwrite=False,

627

possible_transports=None, run_hooks=True,local=False):

448

def pull(self, stop_revision=None, overwrite=False,

449

possible_transports=None, local=False):

628

450

# This type of branch can't be bound.

629

451

if local:

630

452

raise errors.LocalRequiresBoundBranch()

638

460

result.new_revid = self.target.last_revision()

639

461

return result

640

462

641

642

class InterToGitBranch(branch.GenericInterBranch):

463

464

class InterToGitBranch(branch.InterBranch):

643

465

"""InterBranch implementation that pulls from Git into bzr."""

644

466

645

def __init__(self, source, target):

646

super(InterToGitBranch, self).__init__(source, target)

647

self.interrepo = repository.InterRepository.get(source.repository,

648

target.repository)

649

650

@staticmethod

651

def _get_branch_formats_to_test():

652

return []

653

654

467

@classmethod

655

468

def is_compatible(self, source, target):

656

return (not isinstance(source, GitBranch) and

469

return (not isinstance(source, GitBranch) and

657

470

isinstance(target, GitBranch))

658

471

659

def update_revisions(self, *args, **kwargs):

472

def push(self, overwrite=True, stop_revision=None,

473

_override_hook_source_branch=None):

660

474

raise NoPushSupport()

661

475

662

def _get_new_refs(self, stop_revision=None):

476

def lossy_push(self, stop_revision=None):

477

result = GitBranchPushResult()

478

result.source_branch = self.source

479

result.target_branch = self.target

480

result.old_revid = self.target.last_revision()

663

481

if stop_revision is None:

664

482

stop_revision = self.source.last_revision()

665

assert type(stop_revision) is str

666

main_ref = self.target.ref or "refs/heads/master"

667

refs = { main_ref: (None, stop_revision) }

483

# FIXME: Check for diverged branches

484

refs = { "refs/heads/master": stop_revision }

668

485

for name, revid in self.source.tags.get_tag_dict().iteritems():

669

486

if self.source.repository.has_revision(revid):

670

refs[tag_name_to_ref(name)] = (None, revid)

671

return refs, main_ref

672

673

def pull(self, overwrite=False, stop_revision=None, local=False,

674

possible_transports=None):

675

from dulwich.protocol import ZERO_SHA

676

result = GitBranchPullResult()

677

result.source_branch = self.source

678

result.target_branch = self.target

679

new_refs, main_ref = self._get_new_refs(stop_revision)

680

def update_refs(old_refs):

681

refs = dict(old_refs)

682

# FIXME: Check for diverged branches

683

refs.update(new_refs)

684

return refs

685

old_refs, new_refs = self.interrepo.fetch_refs(update_refs)

686

result.old_revid = self.target.lookup_foreign_revision_id(

687

old_refs.get(main_ref, ZERO_SHA))

688

result.new_revid = new_refs[main_ref]

689

return result

690

691

def push(self, overwrite=False, stop_revision=None,

692

_override_hook_source_branch=None):

693

from dulwich.protocol import ZERO_SHA

694

result = GitBranchPushResult()

695

result.source_branch = self.source

696

result.target_branch = self.target

697

new_refs, main_ref = self._get_new_refs(stop_revision)

698

def update_refs(old_refs):

699

refs = dict(old_refs)

700

# FIXME: Check for diverged branches

701

refs.update(new_refs)

702

return refs

703

old_refs, new_refs = self.interrepo.fetch_refs(update_refs)

704

(result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))

705

if result.old_revid is None:

706

result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)

707

result.new_revid = new_refs[main_ref]

708

return result

709

710

def lossy_push(self, stop_revision=None):

711

result = GitBranchPushResult()

712

result.source_branch = self.source

713

result.target_branch = self.target

714

new_refs, main_ref = self._get_new_refs(stop_revision)

715

def update_refs(old_refs):

716

refs = dict(old_refs)

717

# FIXME: Check for diverged branches

718

refs.update(new_refs)

719

return refs

720

result.revidmap, old_refs, new_refs = self.interrepo.dfetch_refs(

721

update_refs)

722

result.old_revid = old_refs.get(self.target.ref, (None, NULL_REVISION))[1]

723

result.new_revid = new_refs[main_ref][1]

487

refs["refs/tags/%s" % name] = revid

488

revidmap, new_refs = self.target.repository.dfetch_refs(

489

self.source.repository, refs)

490

if revidmap != {}:

491

self.target.generate_revision_history(revidmap[stop_revision])

492

result.new_revid = self.target.last_revision()

493

result.revidmap = revidmap

724

494

return result

725

495

726

496

727

497

branch.InterBranch.register_optimiser(InterGitRemoteLocalBranch)

728

498

branch.InterBranch.register_optimiser(InterFromGitBranch)

729

499

branch.InterBranch.register_optimiser(InterToGitBranch)

730

branch.InterBranch.register_optimiser(InterGitLocalRemoteBranch)