~bzr-pqm/bzr/bzr.dev : revision 477

15

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

16

17

18

from sets import Set

19

18

20

import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile

19

21

import traceback, socket, fnmatch, difflib, time

20

22

from binascii import hexlify

29

31

joinpath, sha_string, file_kind, local_time_offset, appendpath

30

32

from store import ImmutableStore

31

33

from revision import Revision

32

from errors import BzrError

34

from errors import bailout, BzrError

33

35

from textui import show_status

34

36

35

37

BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"

43

45

return remotebranch.RemoteBranch(f, **args)

44

46

else:

45

47

return Branch(f, **args)

46

47

48

49

def _relpath(base, path):

50

"""Return path relative to base, or raise exception.

51

52

The path may be either an absolute path or a path relative to the

53

current working directory.

54

55

Lifted out of Branch.relpath for ease of testing.

56

57

os.path.commonprefix (python2.4) has a bad bug that it works just

58

on string prefixes, assuming that '/u' is a prefix of '/u2'. This

59

avoids that problem."""

60

rp = os.path.abspath(path)

61

62

s = []

63

head = rp

64

while len(head) >= len(base):

65

if head == base:

66

break

67

head, tail = os.path.split(head)

68

if tail:

69

s.insert(0, tail)

70

else:

71

from errors import NotBranchError

72

raise NotBranchError("path %r is not within branch %r" % (rp, base))

73

74

return os.sep.join(s)

75

48

76

49

77

50

def find_branch_root(f=None):

104

77

raise BzrError('%r is not in a branch' % orig_f)

105

78

f = head

106

79

107

class DivergedBranches(Exception):

108

def __init__(self, branch1, branch2):

109

self.branch1 = branch1

110

self.branch2 = branch2

111

Exception.__init__(self, "These branches have diverged.")

80

112

81

113

82

######################################################################

114

83

# branch objects

115

84

116

class Branch(object):

85

class Branch:

117

86

"""Branch holding a history of revisions.

118

87

119

88

base

120

89

Base directory of the branch.

121

122

_lock_mode

123

None, or 'r' or 'w'

124

125

_lock_count

126

If _lock_mode is true, a positive count of the number of times the

127

lock has been taken.

128

129

_lock

130

Lock object from bzrlib.lock.

131

90

"""

132

base = None

133

_lock_mode = None

134

_lock_count = None

135

_lock = None

91

_lockmode = None

136

92

137

def __init__(self, base, init=False, find_root=True):

93

def __init__(self, base, init=False, find_root=True, lock_mode='w'):

138

94

"""Create new branch object at a particular location.

139

95

140

96

base -- Base directory for the branch.

157

113

else:

158

114

self.base = os.path.realpath(base)

159

115

if not isdir(self.controlfilename('.')):

160

from errors import NotBranchError

161

raise NotBranchError("not a bzr branch: %s" % quotefn(base),

162

['use "bzr init" to initialize a new working tree',

163

'current bzr can only operate from top-of-tree'])

116

bailout("not a bzr branch: %s" % quotefn(base),

117

['use "bzr init" to initialize a new working tree',

118

'current bzr can only operate from top-of-tree'])

164

119

self._check_format()

120

self.lock(lock_mode)

165

121

166

122

self.text_store = ImmutableStore(self.controlfilename('text-store'))

167

123

self.revision_store = ImmutableStore(self.controlfilename('revision-store'))

175

131

__repr__ = __str__

176

132

177

133

178

def __del__(self):

179

if self._lock_mode or self._lock:

180

from warnings import warn

181

warn("branch %r was not explicitly unlocked" % self)

182

self._lock.unlock()

183

184

185

186

def lock_write(self):

187

if self._lock_mode:

188

if self._lock_mode != 'w':

189

from errors import LockError

190

raise LockError("can't upgrade to a write lock from %r" %

191

self._lock_mode)

192

self._lock_count += 1

193

else:

194

from bzrlib.lock import WriteLock

195

196

self._lock = WriteLock(self.controlfilename('branch-lock'))

197

self._lock_mode = 'w'

198

self._lock_count = 1

199

200

201

202

def lock_read(self):

203

if self._lock_mode:

204

assert self._lock_mode in ('r', 'w'), \

205

"invalid lock mode %r" % self._lock_mode

206

self._lock_count += 1

207

else:

208

from bzrlib.lock import ReadLock

209

210

self._lock = ReadLock(self.controlfilename('branch-lock'))

211

self._lock_mode = 'r'

212

self._lock_count = 1

213

214

134

135

def lock(self, mode='w'):

136

"""Lock the on-disk branch, excluding other processes."""

137

try:

138

import fcntl, errno

139

140

if mode == 'w':

141

lm = fcntl.LOCK_EX

142

om = os.O_WRONLY | os.O_CREAT

143

elif mode == 'r':

144

lm = fcntl.LOCK_SH

145

om = os.O_RDONLY

146

else:

147

raise BzrError("invalid locking mode %r" % mode)

148

149

try:

150

lockfile = os.open(self.controlfilename('branch-lock'), om)

151

except OSError, e:

152

if e.errno == errno.ENOENT:

153

# might not exist on branches from <0.0.4

154

self.controlfile('branch-lock', 'w').close()

155

lockfile = os.open(self.controlfilename('branch-lock'), om)

156

else:

157

raise e

215

158

216

def unlock(self):

217

if not self._lock_mode:

218

from errors import LockError

219

raise LockError('branch %r is not locked' % (self))

220

221

if self._lock_count > 1:

222

self._lock_count -= 1

223

else:

224

self._lock.unlock()

225

self._lock = None

226

self._lock_mode = self._lock_count = None

159

fcntl.lockf(lockfile, lm)

160

def unlock():

161

fcntl.lockf(lockfile, fcntl.LOCK_UN)

162

os.close(lockfile)

163

self._lockmode = None

164

self.unlock = unlock

165

self._lockmode = mode

166

except ImportError:

167

warning("please write a locking method for platform %r" % sys.platform)

168

def unlock():

169

self._lockmode = None

170

self.unlock = unlock

171

self._lockmode = mode

172

173

174

def _need_readlock(self):

175

if self._lockmode not in ['r', 'w']:

176

raise BzrError('need read lock on branch, only have %r' % self._lockmode)

177

178

def _need_writelock(self):

179

if self._lockmode not in ['w']:

180

raise BzrError('need write lock on branch, only have %r' % self._lockmode)

227

181

228

182

229

183

def abspath(self, name):

235

189

"""Return path relative to this branch of something inside it.

236

190

237

191

Raises an error if path is not in this branch."""

238

return _relpath(self.base, path)

192

rp = os.path.realpath(path)

193

# FIXME: windows

194

if not rp.startswith(self.base):

195

bailout("path %r is not within branch %r" % (rp, self.base))

196

rp = rp[len(self.base):]

197

rp = rp.lstrip(os.sep)

198

return rp

239

199

240

200

241

201

def controlfilename(self, file_or_path):

302

262

fmt = self.controlfile('branch-format', 'r').read()

303

263

fmt.replace('\r\n', '')

304

264

if fmt != BZR_BRANCH_FORMAT:

305

raise BzrError('sorry, branch format %r not supported' % fmt,

306

['use a different bzr version',

307

'or remove the .bzr directory and "bzr init" again'])

308

265

bailout('sorry, branch format %r not supported' % fmt,

266

['use a different bzr version',

267

'or remove the .bzr directory and "bzr init" again'])

309

268

310

269

311

270

def read_working_inventory(self):

312

271

"""Read the working inventory."""

272

self._need_readlock()

313

273

before = time.time()

314

274

# ElementTree does its own conversion from UTF-8, so open in

315

275

# binary.

316

self.lock_read()

317

try:

318

inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))

319

mutter("loaded inventory of %d items in %f"

320

% (len(inv), time.time() - before))

321

return inv

322

finally:

323

self.unlock()

324

276

inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))

277

mutter("loaded inventory of %d items in %f"

278

% (len(inv), time.time() - before))

279

return inv

280

325

281

326

282

def _write_inventory(self, inv):

327

283

"""Update the working inventory.

329

285

That is to say, the inventory describing changes underway, that

330

286

will be committed to the next revision.

331

287

"""

288

self._need_writelock()

332

289

## TODO: factor out to atomicfile? is rename safe on windows?

333

290

## TODO: Maybe some kind of clean/dirty marker on inventory?

334

291

tmpfname = self.controlfilename('inventory.tmp')

340

297

os.remove(inv_fname)

341

298

os.rename(tmpfname, inv_fname)

342

299

mutter('wrote working inventory')

343

300

344

301

345

302

inventory = property(read_working_inventory, _write_inventory, None,

346

303

"""Inventory for the working copy.""")

347

304

348

305

349

def add(self, files, verbose=False, ids=None):

306

def add(self, files, verbose=False):

350

307

"""Make files versioned.

351

308

352

309

Note that the command line normally calls smart_add instead.

354

311

This puts the files in the Added state, so that they will be

355

312

recorded by the next commit.

356

313

357

files

358

List of paths to add, relative to the base of the tree.

359

360

ids

361

If set, use these instead of automatically generated ids.

362

Must be the same length as the list of files, but may

363

contain None for ids that are to be autogenerated.

364

365

314

TODO: Perhaps have an option to add the ids even if the files do

366

not (yet) exist.

315

not (yet) exist.

367

316

368

317

TODO: Perhaps return the ids of the files? But then again it

369

is easy to retrieve them if they're needed.

318

is easy to retrieve them if they're needed.

319

320

TODO: Option to specify file id.

370

321

371

322

TODO: Adding a directory should optionally recurse down and

372

add all non-ignored children. Perhaps do that in a

373

higher-level method.

323

add all non-ignored children. Perhaps do that in a

324

higher-level method.

325

326

>>> b = ScratchBranch(files=['foo'])

327

>>> 'foo' in b.unknowns()

328

True

329

>>> b.show_status()

330

? foo

331

>>> b.add('foo')

332

>>> 'foo' in b.unknowns()

333

False

334

>>> bool(b.inventory.path2id('foo'))

335

True

336

>>> b.show_status()

337

A foo

338

339

>>> b.add('foo')

340

Traceback (most recent call last):

341

...

342

BzrError: ('foo is already versioned', [])

343

344

>>> b.add(['nothere'])

345

Traceback (most recent call last):

346

BzrError: ('cannot add: not a regular file or directory: nothere', [])

374

347

"""

348

self._need_writelock()

349

375

350

# TODO: Re-adding a file that is removed in the working copy

376

351

# should probably put it back with the previous ID.

377

352

if isinstance(files, types.StringTypes):

378

assert(ids is None or isinstance(ids, types.StringTypes))

379

353

files = [files]

380

if ids is not None:

381

ids = [ids]

382

383

if ids is None:

384

ids = [None] * len(files)

385

else:

386

assert(len(ids) == len(files))

387

388

self.lock_write()

389

try:

390

inv = self.read_working_inventory()

391

for f,file_id in zip(files, ids):

392

if is_control_file(f):

393

raise BzrError("cannot add control file %s" % quotefn(f))

394

395

fp = splitpath(f)

396

397

if len(fp) == 0:

398

raise BzrError("cannot add top-level %r" % f)

399

400

fullpath = os.path.normpath(self.abspath(f))

401

402

try:

403

kind = file_kind(fullpath)

404

except OSError:

405

# maybe something better?

406

raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))

407

408

if kind != 'file' and kind != 'directory':

409

raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))

410

411

if file_id is None:

412

file_id = gen_file_id(f)

413

inv.add_path(f, kind=kind, file_id=file_id)

414

415

if verbose:

416

show_status('A', kind, quotefn(f))

417

418

mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))

419

420

self._write_inventory(inv)

421

finally:

422

self.unlock()

423

354

355

inv = self.read_working_inventory()

356

for f in files:

357

if is_control_file(f):

358

bailout("cannot add control file %s" % quotefn(f))

359

360

fp = splitpath(f)

361

362

if len(fp) == 0:

363

bailout("cannot add top-level %r" % f)

364

365

fullpath = os.path.normpath(self.abspath(f))

366

367

try:

368

kind = file_kind(fullpath)

369

except OSError:

370

# maybe something better?

371

bailout('cannot add: not a regular file or directory: %s' % quotefn(f))

372

373

if kind != 'file' and kind != 'directory':

374

bailout('cannot add: not a regular file or directory: %s' % quotefn(f))

375

376

file_id = gen_file_id(f)

377

inv.add_path(f, kind=kind, file_id=file_id)

378

379

if verbose:

380

show_status('A', kind, quotefn(f))

381

382

mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))

383

384

self._write_inventory(inv)

385

424

386

425

387

def print_file(self, file, revno):

426

388

"""Print `file` to stdout."""

427

self.lock_read()

428

try:

429

tree = self.revision_tree(self.lookup_revision(revno))

430

# use inventory as it was in that revision

431

file_id = tree.inventory.path2id(file)

432

if not file_id:

433

raise BzrError("%r is not present in revision %d" % (file, revno))

434

tree.print_file(file_id)

435

finally:

436

self.unlock()

437

389

self._need_readlock()

390

tree = self.revision_tree(self.lookup_revision(revno))

391

# use inventory as it was in that revision

392

file_id = tree.inventory.path2id(file)

393

if not file_id:

394

bailout("%r is not present in revision %d" % (file, revno))

395

tree.print_file(file_id)

396

438

397

439

398

def remove(self, files, verbose=False):

440

399

"""Mark nominated files for removal from the inventory.

443

402

444

403

TODO: Refuse to remove modified files unless --force is given?

445

404

405

>>> b = ScratchBranch(files=['foo'])

406

>>> b.add('foo')

407

>>> b.inventory.has_filename('foo')

408

True

409

>>> b.remove('foo')

410

>>> b.working_tree().has_filename('foo')

411

True

412

>>> b.inventory.has_filename('foo')

413

False

414

415

>>> b = ScratchBranch(files=['foo'])

416

>>> b.add('foo')

417

>>> b.commit('one')

418

>>> b.remove('foo')

419

>>> b.commit('two')

420

>>> b.inventory.has_filename('foo')

421

False

422

>>> b.basis_tree().has_filename('foo')

423

False

424

>>> b.working_tree().has_filename('foo')

425

True

426

446

427

TODO: Do something useful with directories.

447

428

448

429

TODO: Should this remove the text or not? Tough call; not

452

433

"""

453

434

## TODO: Normalize names

454

435

## TODO: Remove nested loops; better scalability

436

self._need_writelock()

437

455

438

if isinstance(files, types.StringTypes):

456

439

files = [files]

457

458

self.lock_write()

459

460

try:

461

tree = self.working_tree()

462

inv = tree.inventory

463

464

# do this before any modifications

465

for f in files:

466

fid = inv.path2id(f)

467

if not fid:

468

raise BzrError("cannot remove unversioned file %s" % quotefn(f))

469

mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))

470

if verbose:

471

# having remove it, it must be either ignored or unknown

472

if tree.is_ignored(f):

473

new_status = 'I'

474

else:

475

new_status = '?'

476

show_status(new_status, inv[fid].kind, quotefn(f))

477

del inv[fid]

478

479

self._write_inventory(inv)

480

finally:

481

self.unlock()

482

483

484

# FIXME: this doesn't need to be a branch method

485

def set_inventory(self, new_inventory_list):

486

inv = Inventory()

487

for path, file_id, parent, kind in new_inventory_list:

488

name = os.path.basename(path)

489

if name == "":

490

continue

491

inv.add(InventoryEntry(file_id, name, kind, parent))

440

441

tree = self.working_tree()

442

inv = tree.inventory

443

444

# do this before any modifications

445

for f in files:

446

fid = inv.path2id(f)

447

if not fid:

448

bailout("cannot remove unversioned file %s" % quotefn(f))

449

mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))

450

if verbose:

451

# having remove it, it must be either ignored or unknown

452

if tree.is_ignored(f):

453

new_status = 'I'

454

else:

455

new_status = '?'

456

show_status(new_status, inv[fid].kind, quotefn(f))

457

del inv[fid]

458

492

459

self._write_inventory(inv)

493

460

494

461

511

478

return self.working_tree().unknowns()

512

479

513

480

481

def commit(self, message, timestamp=None, timezone=None,

482

committer=None,

483

verbose=False):

484

"""Commit working copy as a new revision.

485

486

The basic approach is to add all the file texts into the

487

store, then the inventory, then make a new revision pointing

488

to that inventory and store that.

489

490

This is not quite safe if the working copy changes during the

491

commit; for the moment that is simply not allowed. A better

492

approach is to make a temporary copy of the files before

493

computing their hashes, and then add those hashes in turn to

494

the inventory. This should mean at least that there are no

495

broken hash pointers. There is no way we can get a snapshot

496

of the whole directory at an instant. This would also have to

497

be robust against files disappearing, moving, etc. So the

498

whole thing is a bit hard.

499

500

timestamp -- if not None, seconds-since-epoch for a

501

postdated/predated commit.

502

"""

503

self._need_writelock()

504

505

## TODO: Show branch names

506

507

# TODO: Don't commit if there are no changes, unless forced?

508

509

# First walk over the working inventory; and both update that

510

# and also build a new revision inventory. The revision

511

# inventory needs to hold the text-id, sha1 and size of the

512

# actual file versions committed in the revision. (These are

513

# not present in the working inventory.) We also need to

514

# detect missing/deleted files, and remove them from the

515

# working inventory.

516

517

work_inv = self.read_working_inventory()

518

inv = Inventory()

519

basis = self.basis_tree()

520

basis_inv = basis.inventory

521

missing_ids = []

522

for path, entry in work_inv.iter_entries():

523

## TODO: Cope with files that have gone missing.

524

525

## TODO: Check that the file kind has not changed from the previous

526

## revision of this file (if any).

527

528

entry = entry.copy()

529

530

p = self.abspath(path)

531

file_id = entry.file_id

532

mutter('commit prep file %s, id %r ' % (p, file_id))

533

534

if not os.path.exists(p):

535

mutter(" file is missing, removing from inventory")

536

if verbose:

537

show_status('D', entry.kind, quotefn(path))

538

missing_ids.append(file_id)

539

continue

540

541

# TODO: Handle files that have been deleted

542

543

# TODO: Maybe a special case for empty files? Seems a

544

# waste to store them many times.

545

546

inv.add(entry)

547

548

if basis_inv.has_id(file_id):

549

old_kind = basis_inv[file_id].kind

550

if old_kind != entry.kind:

551

bailout("entry %r changed kind from %r to %r"

552

% (file_id, old_kind, entry.kind))

553

554

if entry.kind == 'directory':

555

if not isdir(p):

556

bailout("%s is entered as directory but not a directory" % quotefn(p))

557

elif entry.kind == 'file':

558

if not isfile(p):

559

bailout("%s is entered as file but is not a file" % quotefn(p))

560

561

content = file(p, 'rb').read()

562

563

entry.text_sha1 = sha_string(content)

564

entry.text_size = len(content)

565

566

old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]

567

if (old_ie

568

and (old_ie.text_size == entry.text_size)

569

and (old_ie.text_sha1 == entry.text_sha1)):

570

## assert content == basis.get_file(file_id).read()

571

entry.text_id = basis_inv[file_id].text_id

572

mutter(' unchanged from previous text_id {%s}' %

573

entry.text_id)

574

575

else:

576

entry.text_id = gen_file_id(entry.name)

577

self.text_store.add(content, entry.text_id)

578

mutter(' stored with text_id {%s}' % entry.text_id)

579

if verbose:

580

if not old_ie:

581

state = 'A'

582

elif (old_ie.name == entry.name

583

and old_ie.parent_id == entry.parent_id):

584

state = 'M'

585

else:

586

state = 'R'

587

588

show_status(state, entry.kind, quotefn(path))

589

590

for file_id in missing_ids:

591

# have to do this later so we don't mess up the iterator.

592

# since parents may be removed before their children we

593

# have to test.

594

595

# FIXME: There's probably a better way to do this; perhaps

596

# the workingtree should know how to filter itself.

597

if work_inv.has_id(file_id):

598

del work_inv[file_id]

599

600

601

inv_id = rev_id = _gen_revision_id(time.time())

602

603

inv_tmp = tempfile.TemporaryFile()

604

inv.write_xml(inv_tmp)

605

inv_tmp.seek(0)

606

self.inventory_store.add(inv_tmp, inv_id)

607

mutter('new inventory_id is {%s}' % inv_id)

608

609

self._write_inventory(work_inv)

610

611

if timestamp == None:

612

timestamp = time.time()

613

614

if committer == None:

615

committer = username()

616

617

if timezone == None:

618

timezone = local_time_offset()

619

620

mutter("building commit log message")

621

rev = Revision(timestamp=timestamp,

622

timezone=timezone,

623

committer=committer,

624

precursor = self.last_patch(),

625

message = message,

626

inventory_id=inv_id,

627

revision_id=rev_id)

628

629

rev_tmp = tempfile.TemporaryFile()

630

rev.write_xml(rev_tmp)

631

rev_tmp.seek(0)

632

self.revision_store.add(rev_tmp, rev_id)

633

mutter("new revision_id is {%s}" % rev_id)

634

635

## XXX: Everything up to here can simply be orphaned if we abort

636

## the commit; it will leave junk files behind but that doesn't

637

## matter.

638

639

## TODO: Read back the just-generated changeset, and make sure it

640

## applies and recreates the right state.

641

642

## TODO: Also calculate and store the inventory SHA1

643

mutter("committing patch r%d" % (self.revno() + 1))

644

645

646

self.append_revision(rev_id)

647

648

if verbose:

649

note("commited r%d" % self.revno())

650

651

514

652

def append_revision(self, revision_id):

515

653

mutter("add {%s} to revision-history" % revision_id)

516

654

rev_history = self.revision_history()

532

670

533

671

def get_revision(self, revision_id):

534

672

"""Return the Revision object for a named revision"""

673

self._need_readlock()

535

674

r = Revision.read_xml(self.revision_store[revision_id])

536

675

assert r.revision_id == revision_id

537

676

return r

543

682

TODO: Perhaps for this and similar methods, take a revision

544

683

parameter which can be either an integer revno or a

545

684

string hash."""

685

self._need_readlock()

546

686

i = Inventory.read_xml(self.inventory_store[inventory_id])

547

687

return i

548

688

549

689

550

690

def get_revision_inventory(self, revision_id):

551

691

"""Return inventory of a past revision."""

692

self._need_readlock()

552

693

if revision_id == None:

553

694

return Inventory()

554

695

else:

561

702

>>> ScratchBranch().revision_history()

562

703

[]

563

704

"""

564

self.lock_read()

565

try:

566

return [l.rstrip('\r\n') for l in

567

self.controlfile('revision-history', 'r').readlines()]

568

finally:

569

self.unlock()

570

571

572

def common_ancestor(self, other, self_revno=None, other_revno=None):

573

"""

574

>>> import commit

575

>>> sb = ScratchBranch(files=['foo', 'foo~'])

576

>>> sb.common_ancestor(sb) == (None, None)

577

True

578

>>> commit.commit(sb, "Committing first revision", verbose=False)

579

>>> sb.common_ancestor(sb)[0]

580

1

581

>>> clone = sb.clone()

582

>>> commit.commit(sb, "Committing second revision", verbose=False)

583

>>> sb.common_ancestor(sb)[0]

584

2

585

>>> sb.common_ancestor(clone)[0]

586

1

587

>>> commit.commit(clone, "Committing divergent second revision",

588

... verbose=False)

589

>>> sb.common_ancestor(clone)[0]

590

1

591

>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)

592

True

593

>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)

594

True

595

>>> clone2 = sb.clone()

596

>>> sb.common_ancestor(clone2)[0]

597

2

598

>>> sb.common_ancestor(clone2, self_revno=1)[0]

599

1

600

>>> sb.common_ancestor(clone2, other_revno=1)[0]

601

1

602

"""

603

my_history = self.revision_history()

604

other_history = other.revision_history()

605

if self_revno is None:

606

self_revno = len(my_history)

607

if other_revno is None:

608

other_revno = len(other_history)

609

indices = range(min((self_revno, other_revno)))

610

indices.reverse()

611

for r in indices:

612

if my_history[r] == other_history[r]:

613

return r+1, my_history[r]

614

return None, None

705

self._need_readlock()

706

return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]

707

615

708

616

709

def enum_history(self, direction):

617

710

"""Return (revno, revision_id) for history of branch.

632

725

yield i, rh[i-1]

633

726

i -= 1

634

727

else:

635

raise ValueError('invalid history direction', direction)

728

raise BzrError('invalid history direction %r' % direction)

636

729

637

730

638

731

def revno(self):

640

733

641

734

That is equivalent to the number of revisions committed to

642

735

this branch.

736

737

>>> b = ScratchBranch()

738

>>> b.revno()

739

0

740

>>> b.commit('no foo')

741

>>> b.revno()

742

1

643

743

"""

644

744

return len(self.revision_history())

645

745

646

746

647

747

def last_patch(self):

648

748

"""Return last patch hash, or None if no history.

749

750

>>> ScratchBranch().last_patch() == None

751

True

649

752

"""

650

753

ph = self.revision_history()

651

754

if ph:

652

755

return ph[-1]

653

756

else:

654

757

return None

655

656

657

def missing_revisions(self, other):

658

"""

659

If self and other have not diverged, return a list of the revisions

660

present in other, but missing from self.

661

662

>>> from bzrlib.commit import commit

663

>>> bzrlib.trace.silent = True

664

>>> br1 = ScratchBranch()

665

>>> br2 = ScratchBranch()

666

>>> br1.missing_revisions(br2)

667

[]

668

>>> commit(br2, "lala!", rev_id="REVISION-ID-1")

669

>>> br1.missing_revisions(br2)

670

[u'REVISION-ID-1']

671

>>> br2.missing_revisions(br1)

672

[]

673

>>> commit(br1, "lala!", rev_id="REVISION-ID-1")

674

>>> br1.missing_revisions(br2)

675

[]

676

>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")

677

>>> br1.missing_revisions(br2)

678

[u'REVISION-ID-2A']

679

>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")

680

>>> br1.missing_revisions(br2)

681

Traceback (most recent call last):

682

DivergedBranches: These branches have diverged.

683

"""

684

self_history = self.revision_history()

685

self_len = len(self_history)

686

other_history = other.revision_history()

687

other_len = len(other_history)

688

common_index = min(self_len, other_len) -1

689

if common_index >= 0 and \

690

self_history[common_index] != other_history[common_index]:

691

raise DivergedBranches(self, other)

692

if self_len < other_len:

693

return other_history[self_len:]

694

return []

695

696

697

def update_revisions(self, other):

698

"""If self and other have not diverged, ensure self has all the

699

revisions in other

700

701

>>> from bzrlib.commit import commit

702

>>> bzrlib.trace.silent = True

703

>>> br1 = ScratchBranch(files=['foo', 'bar'])

704

>>> br1.add('foo')

705

>>> br1.add('bar')

706

>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)

707

>>> br2 = ScratchBranch()

708

>>> br2.update_revisions(br1)

709

Added 2 texts.

710

Added 1 inventories.

711

Added 1 revisions.

712

>>> br2.revision_history()

713

[u'REVISION-ID-1']

714

>>> br2.update_revisions(br1)

715

Added 0 texts.

716

Added 0 inventories.

717

Added 0 revisions.

718

>>> br1.text_store.total_size() == br2.text_store.total_size()

719

True

720

"""

721

revision_ids = self.missing_revisions(other)

722

revisions = [other.get_revision(f) for f in revision_ids]

723

needed_texts = sets.Set()

724

for rev in revisions:

725

inv = other.get_inventory(str(rev.inventory_id))

726

for key, entry in inv.iter_entries():

727

if entry.text_id is None:

728

continue

729

if entry.text_id not in self.text_store:

730

needed_texts.add(entry.text_id)

731

count = self.text_store.copy_multi(other.text_store, needed_texts)

732

print "Added %d texts." % count

733

inventory_ids = [ f.inventory_id for f in revisions ]

734

count = self.inventory_store.copy_multi(other.inventory_store,

735

inventory_ids)

736

print "Added %d inventories." % count

737

revision_ids = [ f.revision_id for f in revisions]

738

count = self.revision_store.copy_multi(other.revision_store,

739

revision_ids)

740

for revision_id in revision_ids:

741

self.append_revision(revision_id)

742

print "Added %d revisions." % count

743

744

745

def commit(self, *args, **kw):

746

"""Deprecated"""

747

from bzrlib.commit import commit

748

commit(self, *args, **kw)

749

758

750

759

751

760

def lookup_revision(self, revno):

765

774

766

775

`revision_id` may be None for the null revision, in which case

767

776

an `EmptyTree` is returned."""

768

# TODO: refactor this to use an existing revision object

769

# so we don't need to read it in twice.

777

self._need_readlock()

770

778

if revision_id == None:

771

779

return EmptyTree()

772

780

else:

784

792

"""Return `Tree` object for last revision.

785

793

786

794

If there are no revisions yet, return an `EmptyTree`.

795

796

>>> b = ScratchBranch(files=['foo'])

797

>>> b.basis_tree().has_filename('foo')

798

False

799

>>> b.working_tree().has_filename('foo')

800

True

801

>>> b.add('foo')

802

>>> b.commit('add foo')

803

>>> b.basis_tree().has_filename('foo')

804

True

787

805

"""

788

806

r = self.last_patch()

789

807

if r == None:

798

816

799

817

This can change the directory or the filename or both.

800

818

"""

801

self.lock_write()

819

self._need_writelock()

820

tree = self.working_tree()

821

inv = tree.inventory

822

if not tree.has_filename(from_rel):

823

bailout("can't rename: old working file %r does not exist" % from_rel)

824

if tree.has_filename(to_rel):

825

bailout("can't rename: new working file %r already exists" % to_rel)

826

827

file_id = inv.path2id(from_rel)

828

if file_id == None:

829

bailout("can't rename: old name %r is not versioned" % from_rel)

830

831

if inv.path2id(to_rel):

832

bailout("can't rename: new name %r is already versioned" % to_rel)

833

834

to_dir, to_tail = os.path.split(to_rel)

835

to_dir_id = inv.path2id(to_dir)

836

if to_dir_id == None and to_dir != '':

837

bailout("can't determine destination directory id for %r" % to_dir)

838

839

mutter("rename_one:")

840

mutter(" file_id {%s}" % file_id)

841

mutter(" from_rel %r" % from_rel)

842

mutter(" to_rel %r" % to_rel)

843

mutter(" to_dir %r" % to_dir)

844

mutter(" to_dir_id {%s}" % to_dir_id)

845

846

inv.rename(file_id, to_dir_id, to_tail)

847

848

print "%s => %s" % (from_rel, to_rel)

849

850

from_abs = self.abspath(from_rel)

851

to_abs = self.abspath(to_rel)

802

852

try:

803

tree = self.working_tree()

804

inv = tree.inventory

805

if not tree.has_filename(from_rel):

806

raise BzrError("can't rename: old working file %r does not exist" % from_rel)

807

if tree.has_filename(to_rel):

808

raise BzrError("can't rename: new working file %r already exists" % to_rel)

809

810

file_id = inv.path2id(from_rel)

811

if file_id == None:

812

raise BzrError("can't rename: old name %r is not versioned" % from_rel)

813

814

if inv.path2id(to_rel):

815

raise BzrError("can't rename: new name %r is already versioned" % to_rel)

816

817

to_dir, to_tail = os.path.split(to_rel)

818

to_dir_id = inv.path2id(to_dir)

819

if to_dir_id == None and to_dir != '':

820

raise BzrError("can't determine destination directory id for %r" % to_dir)

821

822

mutter("rename_one:")

823

mutter(" file_id {%s}" % file_id)

824

mutter(" from_rel %r" % from_rel)

825

mutter(" to_rel %r" % to_rel)

826

mutter(" to_dir %r" % to_dir)

827

mutter(" to_dir_id {%s}" % to_dir_id)

828

829

inv.rename(file_id, to_dir_id, to_tail)

830

831

print "%s => %s" % (from_rel, to_rel)

832

833

from_abs = self.abspath(from_rel)

834

to_abs = self.abspath(to_rel)

835

try:

836

os.rename(from_abs, to_abs)

837

except OSError, e:

838

raise BzrError("failed to rename %r to %r: %s"

839

% (from_abs, to_abs, e[1]),

840

["rename rolled back"])

841

842

self._write_inventory(inv)

843

finally:

844

self.unlock()

853

os.rename(from_abs, to_abs)

854

except OSError, e:

855

bailout("failed to rename %r to %r: %s"

856

% (from_abs, to_abs, e[1]),

857

["rename rolled back"])

858

859

self._write_inventory(inv)

860

845

861

846

862

847

863

def move(self, from_paths, to_name):

855

871

Note that to_name is only the last component of the new name;

856

872

this doesn't change the directory.

857

873

"""

858

self.lock_write()

859

try:

860

## TODO: Option to move IDs only

861

assert not isinstance(from_paths, basestring)

862

tree = self.working_tree()

863

inv = tree.inventory

864

to_abs = self.abspath(to_name)

865

if not isdir(to_abs):

866

raise BzrError("destination %r is not a directory" % to_abs)

867

if not tree.has_filename(to_name):

868

raise BzrError("destination %r not in working directory" % to_abs)

869

to_dir_id = inv.path2id(to_name)

870

if to_dir_id == None and to_name != '':

871

raise BzrError("destination %r is not a versioned directory" % to_name)

872

to_dir_ie = inv[to_dir_id]

873

if to_dir_ie.kind not in ('directory', 'root_directory'):

874

raise BzrError("destination %r is not a directory" % to_abs)

875

876

to_idpath = inv.get_idpath(to_dir_id)

877

878

for f in from_paths:

879

if not tree.has_filename(f):

880

raise BzrError("%r does not exist in working tree" % f)

881

f_id = inv.path2id(f)

882

if f_id == None:

883

raise BzrError("%r is not versioned" % f)

884

name_tail = splitpath(f)[-1]

885

dest_path = appendpath(to_name, name_tail)

886

if tree.has_filename(dest_path):

887

raise BzrError("destination %r already exists" % dest_path)

888

if f_id in to_idpath:

889

raise BzrError("can't move %r to a subdirectory of itself" % f)

890

891

# OK, so there's a race here, it's possible that someone will

892

# create a file in this interval and then the rename might be

893

# left half-done. But we should have caught most problems.

894

895

for f in from_paths:

896

name_tail = splitpath(f)[-1]

897

dest_path = appendpath(to_name, name_tail)

898

print "%s => %s" % (f, dest_path)

899

inv.rename(inv.path2id(f), to_dir_id, name_tail)

900

try:

901

os.rename(self.abspath(f), self.abspath(dest_path))

902

except OSError, e:

903

raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),

904

["rename rolled back"])

905

906

self._write_inventory(inv)

907

finally:

908

self.unlock()

874

self._need_writelock()

875

## TODO: Option to move IDs only

876

assert not isinstance(from_paths, basestring)

877

tree = self.working_tree()

878

inv = tree.inventory

879

to_abs = self.abspath(to_name)

880

if not isdir(to_abs):

881

bailout("destination %r is not a directory" % to_abs)

882

if not tree.has_filename(to_name):

883

bailout("destination %r not in working directory" % to_abs)

884

to_dir_id = inv.path2id(to_name)

885

if to_dir_id == None and to_name != '':

886

bailout("destination %r is not a versioned directory" % to_name)

887

to_dir_ie = inv[to_dir_id]

888

if to_dir_ie.kind not in ('directory', 'root_directory'):

889

bailout("destination %r is not a directory" % to_abs)

890

891

to_idpath = Set(inv.get_idpath(to_dir_id))

892

893

for f in from_paths:

894

if not tree.has_filename(f):

895

bailout("%r does not exist in working tree" % f)

896

f_id = inv.path2id(f)

897

if f_id == None:

898

bailout("%r is not versioned" % f)

899

name_tail = splitpath(f)[-1]

900

dest_path = appendpath(to_name, name_tail)

901

if tree.has_filename(dest_path):

902

bailout("destination %r already exists" % dest_path)

903

if f_id in to_idpath:

904

bailout("can't move %r to a subdirectory of itself" % f)

905

906

# OK, so there's a race here, it's possible that someone will

907

# create a file in this interval and then the rename might be

908

# left half-done. But we should have caught most problems.

909

910

for f in from_paths:

911

name_tail = splitpath(f)[-1]

912

dest_path = appendpath(to_name, name_tail)

913

print "%s => %s" % (f, dest_path)

914

inv.rename(inv.path2id(f), to_dir_id, name_tail)

915

try:

916

os.rename(self.abspath(f), self.abspath(dest_path))

917

except OSError, e:

918

bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),

919

["rename rolled back"])

920

921

self._write_inventory(inv)

922

909

923

910

924

911

925

920

934

>>> isdir(bd)

921

935

False

922

936

"""

923

def __init__(self, files=[], dirs=[], base=None):

937

def __init__(self, files=[], dirs=[]):

924

938

"""Make a test branch.

925

939

926

940

This creates a temporary directory and runs init-tree in it.

927

941

928

942

If any files are listed, they are created in the working copy.

929

943

"""

930

init = False

931

if base is None:

932

base = tempfile.mkdtemp()

933

init = True

934

Branch.__init__(self, base, init=init)

944

Branch.__init__(self, tempfile.mkdtemp(), init=True)

935

945

for d in dirs:

936

946

os.mkdir(self.abspath(d))

937

947

939

949

file(os.path.join(self.base, f), 'w').write('content of %s' % f)

940

950

941

951

942

def clone(self):

943

"""

944

>>> orig = ScratchBranch(files=["file1", "file2"])

945

>>> clone = orig.clone()

946

>>> os.path.samefile(orig.base, clone.base)

947

False

948

>>> os.path.isfile(os.path.join(clone.base, "file1"))

949

True

950

"""

951

base = tempfile.mkdtemp()

952

os.rmdir(base)

953

shutil.copytree(self.base, base, symlinks=True)

954

return ScratchBranch(base=base)

955

956

952

def __del__(self):

957

953

self.destroy()

958

954

959

955

def destroy(self):

960

956

"""Destroy the test branch, removing the scratch directory."""

961

957

try:

962

if self.base:

963

mutter("delete ScratchBranch %s" % self.base)

964

shutil.rmtree(self.base)

958

mutter("delete ScratchBranch %s" % self.base)

959

shutil.rmtree(self.base)

965

960

except OSError, e:

966

961

# Work around for shutil.rmtree failing on Windows when

967

962

# readonly files are encountered

993

988

994

989

995

990

991

def _gen_revision_id(when):

992

"""Return new revision-id."""

993

s = '%s-%s-' % (user_email(), compact_date(when))

994

s += hexlify(rand_bytes(8))

995

return s

996

997

996

998

def gen_file_id(name):

997

999

"""Return new file id.

998

1000

999

1001

This should probably generate proper UUIDs, but for the moment we

1000

1002

cope with just randomness because running uuidgen every time is

1001

1003

slow."""

1002

import re

1003

1004

# get last component

1005

1004

idx = name.rfind('/')

1006

1005

if idx != -1:

1007

1006

name = name[idx+1 : ]

1009

1008

if idx != -1:

1010

1009

name = name[idx+1 : ]

1011

1010

1012

# make it not a hidden file

1013

1011

name = name.lstrip('.')

1014

1012

1015

# remove any wierd characters; we don't escape them but rather

1016

# just pull them out

1017

name = re.sub(r'[^\w.]', '', name)

1018

1019

1013

s = hexlify(rand_bytes(8))

1020

1014

return '-'.join((name, compact_date(time.time()), s))