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

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

22

24

import bzrlib

23

25

from inventory import Inventory

24

26

from trace import mutter, note

25

from tree import Tree, EmptyTree, RevisionTree

27

from tree import Tree, EmptyTree, RevisionTree, WorkingTree

26

28

from inventory import InventoryEntry, Inventory

27

29

from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \

28

30

format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \

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

36

from diff import diff_trees

34

37

35

38

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

36

39

## TODO: Maybe include checks for common corruption of newlines, etc?

38

41

39

42

40

43

def find_branch(f, **args):

41

if f and (f.startswith('http://') or f.startswith('https://')):

44

if f.startswith('http://') or f.startswith('https://'):

42

45

import remotebranch

43

46

return remotebranch.RemoteBranch(f, **args)

44

47

else:

45

48

return Branch(f, **args)

46

47

48

49

def with_writelock(method):

50

"""Method decorator for functions run with the branch locked."""

51

def d(self, *a, **k):

52

# called with self set to the branch

53

self.lock('w')

54

try:

55

return method(self, *a, **k)

56

finally:

57

self.unlock()

58

return d

59

60

61

def with_readlock(method):

62

def d(self, *a, **k):

63

self.lock('r')

64

try:

65

return method(self, *a, **k)

66

finally:

67

self.unlock()

68

return d

69

49

70

50

71

51

def find_branch_root(f=None):

103

83

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

104

84

# branch objects

105

85

106

class Branch(object):

86

class Branch:

107

87

"""Branch holding a history of revisions.

108

88

109

89

base

110

90

Base directory of the branch.

111

112

_lock_mode

113

None, or 'r' or 'w'

114

115

_lock_count

116

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

117

lock has been taken.

118

119

_lockfile

120

Open file used for locking.

121

91

"""

122

base = None

123

_lock_mode = None

124

_lock_count = None

92

_lockmode = None

125

93

126

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

94

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

127

95

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

128

96

129

97

base -- Base directory for the branch.

146

114

else:

147

115

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

148

116

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

149

from errors import NotBranchError

150

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

151

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

152

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

117

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

118

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

119

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

153

120

self._check_format()

154

self._lockfile = self.controlfile('branch-lock', 'wb')

121

self.lock(lock_mode)

155

122

156

123

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

157

124

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

165

132

__repr__ = __str__

166

133

167

134

168

def __del__(self):

169

if self._lock_mode:

170

from warnings import warn

171

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

172

self.unlock()

173

174

175

def lock(self, mode):

176

if self._lock_mode:

177

if mode == 'w' and cur_lm == 'r':

178

raise BzrError("can't upgrade to a write lock")

135

136

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

137

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

138

try:

139

import fcntl, errno

140

141

if mode == 'w':

142

lm = fcntl.LOCK_EX

143

om = os.O_WRONLY | os.O_CREAT

144

elif mode == 'r':

145

lm = fcntl.LOCK_SH

146

om = os.O_RDONLY

147

else:

148

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

149

150

try:

151

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

152

except OSError, e:

153

if e.errno == errno.ENOENT:

154

# might not exist on branches from <0.0.4

155

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

156

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

157

else:

158

raise e

179

159

180

assert self._lock_count >= 1

181

self._lock_count += 1

182

else:

183

from bzrlib.lock import lock, LOCK_SH, LOCK_EX

184

if mode == 'r':

185

m = LOCK_SH

186

elif mode == 'w':

187

m = LOCK_EX

188

else:

189

raise ValueError('invalid lock mode %r' % mode)

190

191

lock(self._lockfile, m)

192

self._lock_mode = mode

193

self._lock_count = 1

194

195

196

def unlock(self):

197

if not self._lock_mode:

198

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

199

200

if self._lock_count > 1:

201

self._lock_count -= 1

202

else:

203

assert self._lock_count == 1

204

from bzrlib.lock import unlock

205

unlock(self._lockfile)

206

self._lock_mode = self._lock_count = None

160

fcntl.lockf(lockfile, lm)

161

def unlock():

162

fcntl.lockf(lockfile, fcntl.LOCK_UN)

163

os.close(lockfile)

164

self._lockmode = None

165

self.unlock = unlock

166

self._lockmode = mode

167

except ImportError:

168

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

169

def unlock():

170

self._lockmode = None

171

self.unlock = unlock

172

self._lockmode = mode

173

174

175

def _need_readlock(self):

176

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

177

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

178

179

def _need_writelock(self):

180

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

181

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

207

182

208

183

209

184

def abspath(self, name):

218

193

rp = os.path.realpath(path)

219

194

# FIXME: windows

220

195

if not rp.startswith(self.base):

221

from errors import NotBranchError

222

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

196

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

223

197

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

224

198

rp = rp.lstrip(os.sep)

225

199

return rp

289

263

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

290

264

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

291

265

if fmt != BZR_BRANCH_FORMAT:

292

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

293

['use a different bzr version',

294

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

295

296

297

298

@with_readlock

266

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

267

['use a different bzr version',

268

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

269

270

299

271

def read_working_inventory(self):

300

272

"""Read the working inventory."""

273

self._need_readlock()

301

274

before = time.time()

302

275

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

303

276

# binary.

305

278

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

306

279

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

307

280

return inv

308

281

309

282

310

283

def _write_inventory(self, inv):

311

284

"""Update the working inventory.

313

286

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

314

287

will be committed to the next revision.

315

288

"""

289

self._need_writelock()

316

290

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

317

291

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

318

292

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

324

298

os.remove(inv_fname)

325

299

os.rename(tmpfname, inv_fname)

326

300

mutter('wrote working inventory')

327

301

328

302

329

303

inventory = property(read_working_inventory, _write_inventory, None,

330

304

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

331

305

332

306

333

@with_writelock

334

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

307

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

335

308

"""Make files versioned.

336

309

337

310

Note that the command line normally calls smart_add instead.

350

323

TODO: Adding a directory should optionally recurse down and

351

324

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

352

325

higher-level method.

326

327

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

328

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

329

True

330

>>> b.show_status()

331

? foo

332

>>> b.add('foo')

333

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

334

False

335

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

336

True

337

>>> b.show_status()

338

A foo

339

340

>>> b.add('foo')

341

Traceback (most recent call last):

342

...

343

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

344

345

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

346

Traceback (most recent call last):

347

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

353

348

"""

349

self._need_writelock()

350

354

351

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

355

352

# should probably put it back with the previous ID.

356

353

if isinstance(files, types.StringTypes):

357

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

358

354

files = [files]

359

if ids is not None:

360

ids = [ids]

361

362

if ids is None:

363

ids = [None] * len(files)

364

else:

365

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

366

355

367

356

inv = self.read_working_inventory()

368

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

357

for f in files:

369

358

if is_control_file(f):

370

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

359

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

371

360

372

361

fp = splitpath(f)

373

362

374

363

if len(fp) == 0:

375

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

376

364

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

365

377

366

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

378

367

379

368

try:

380

369

kind = file_kind(fullpath)

381

370

except OSError:

382

371

# maybe something better?

383

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

384

372

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

373

385

374

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

386

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

375

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

387

376

388

if file_id is None:

389

file_id = gen_file_id(f)

377

file_id = gen_file_id(f)

390

378

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

391

379

392

380

if verbose:

393

381

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

394

382

395

383

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

396

384

397

385

self._write_inventory(inv)

398

386

399

387

400

388

def print_file(self, file, revno):

401

389

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

390

self._need_readlock()

402

391

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

403

392

# use inventory as it was in that revision

404

393

file_id = tree.inventory.path2id(file)

405

394

if not file_id:

406

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

395

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

407

396

tree.print_file(file_id)

408

409

410

@with_writelock

397

398

411

399

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

412

400

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

413

401

415

403

416

404

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

417

405

406

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

407

>>> b.add('foo')

408

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

409

True

410

>>> b.remove('foo')

411

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

412

True

413

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

414

False

415

416

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

417

>>> b.add('foo')

418

>>> b.commit('one')

419

>>> b.remove('foo')

420

>>> b.commit('two')

421

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

422

False

423

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

424

False

425

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

426

True

427

418

428

TODO: Do something useful with directories.

419

429

420

430

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

424

434

"""

425

435

## TODO: Normalize names

426

436

## TODO: Remove nested loops; better scalability

437

self._need_writelock()

438

427

439

if isinstance(files, types.StringTypes):

428

440

files = [files]

429

441

430

442

tree = self.working_tree()

431

443

inv = tree.inventory

432

444

434

446

for f in files:

435

447

fid = inv.path2id(f)

436

448

if not fid:

437

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

449

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

438

450

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

439

451

if verbose:

440

452

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

448

460

self._write_inventory(inv)

449

461

450

462

451

def set_inventory(self, new_inventory_list):

452

inv = Inventory()

453

for path, file_id, parent, kind in new_inventory_list:

454

name = os.path.basename(path)

455

if name == "":

456

continue

457

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

458

self._write_inventory(inv)

459

460

461

463

def unknowns(self):

462

464

"""Return all unknown files.

463

465

477

479

return self.working_tree().unknowns()

478

480

479

481

482

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

483

committer=None,

484

verbose=False):

485

"""Commit working copy as a new revision.

486

487

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

488

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

489

to that inventory and store that.

490

491

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

492

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

493

approach is to make a temporary copy of the files before

494

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

495

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

496

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

497

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

498

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

499

whole thing is a bit hard.

500

501

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

502

postdated/predated commit.

503

"""

504

self._need_writelock()

505

506

## TODO: Show branch names

507

508

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

509

510

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

511

# and also build a new revision inventory. The revision

512

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

513

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

514

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

515

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

516

# working inventory.

517

518

work_inv = self.read_working_inventory()

519

inv = Inventory()

520

basis = self.basis_tree()

521

basis_inv = basis.inventory

522

missing_ids = []

523

for path, entry in work_inv.iter_entries():

524

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

525

526

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

527

## revision of this file (if any).

528

529

entry = entry.copy()

530

531

p = self.abspath(path)

532

file_id = entry.file_id

533

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

534

535

if not os.path.exists(p):

536

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

537

if verbose:

538

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

539

missing_ids.append(file_id)

540

continue

541

542

# TODO: Handle files that have been deleted

543

544

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

545

# waste to store them many times.

546

547

inv.add(entry)

548

549

if basis_inv.has_id(file_id):

550

old_kind = basis_inv[file_id].kind

551

if old_kind != entry.kind:

552

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

553

% (file_id, old_kind, entry.kind))

554

555

if entry.kind == 'directory':

556

if not isdir(p):

557

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

558

elif entry.kind == 'file':

559

if not isfile(p):

560

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

561

562

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

563

564

entry.text_sha1 = sha_string(content)

565

entry.text_size = len(content)

566

567

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

568

if (old_ie

569

and (old_ie.text_size == entry.text_size)

570

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

571

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

572

entry.text_id = basis_inv[file_id].text_id

573

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

574

entry.text_id)

575

576

else:

577

entry.text_id = gen_file_id(entry.name)

578

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

579

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

580

if verbose:

581

if not old_ie:

582

state = 'A'

583

elif (old_ie.name == entry.name

584

and old_ie.parent_id == entry.parent_id):

585

state = 'M'

586

else:

587

state = 'R'

588

589

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

590

591

for file_id in missing_ids:

592

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

593

# since parents may be removed before their children we

594

# have to test.

595

596

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

597

# the workingtree should know how to filter itself.

598

if work_inv.has_id(file_id):

599

del work_inv[file_id]

600

601

602

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

603

604

inv_tmp = tempfile.TemporaryFile()

605

inv.write_xml(inv_tmp)

606

inv_tmp.seek(0)

607

self.inventory_store.add(inv_tmp, inv_id)

608

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

609

610

self._write_inventory(work_inv)

611

612

if timestamp == None:

613

timestamp = time.time()

614

615

if committer == None:

616

committer = username()

617

618

if timezone == None:

619

timezone = local_time_offset()

620

621

mutter("building commit log message")

622

rev = Revision(timestamp=timestamp,

623

timezone=timezone,

624

committer=committer,

625

precursor = self.last_patch(),

626

message = message,

627

inventory_id=inv_id,

628

revision_id=rev_id)

629

630

rev_tmp = tempfile.TemporaryFile()

631

rev.write_xml(rev_tmp)

632

rev_tmp.seek(0)

633

self.revision_store.add(rev_tmp, rev_id)

634

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

635

636

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

637

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

638

## matter.

639

640

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

641

## applies and recreates the right state.

642

643

## TODO: Also calculate and store the inventory SHA1

644

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

645

646

647

self.append_revision(rev_id)

648

649

if verbose:

650

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

651

652

480

653

def append_revision(self, revision_id):

481

654

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

482

655

rev_history = self.revision_history()

498

671

499

672

def get_revision(self, revision_id):

500

673

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

674

self._need_readlock()

501

675

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

502

676

assert r.revision_id == revision_id

503

677

return r

509

683

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

510

684

parameter which can be either an integer revno or a

511

685

string hash."""

686

self._need_readlock()

512

687

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

513

688

return i

514

689

515

690

516

691

def get_revision_inventory(self, revision_id):

517

692

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

693

self._need_readlock()

518

694

if revision_id == None:

519

695

return Inventory()

520

696

else:

521

697

return self.get_inventory(self.get_revision(revision_id).inventory_id)

522

698

523

699

524

@with_readlock

525

700

def revision_history(self):

526

701

"""Return sequence of revision hashes on to this branch.

527

702

528

703

>>> ScratchBranch().revision_history()

529

704

[]

530

705

"""

706

self._need_readlock()

531

707

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

532

708

533

709

550

726

yield i, rh[i-1]

551

727

i -= 1

552

728

else:

553

raise ValueError('invalid history direction', direction)

729

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

554

730

555

731

556

732

def revno(self):

558

734

559

735

That is equivalent to the number of revisions committed to

560

736

this branch.

737

738

>>> b = ScratchBranch()

739

>>> b.revno()

740

0

741

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

742

>>> b.revno()

743

1

561

744

"""

562

745

return len(self.revision_history())

563

746

564

747

565

748

def last_patch(self):

566

749

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

750

751

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

752

True

567

753

"""

568

754

ph = self.revision_history()

569

755

if ph:

570

756

return ph[-1]

571

757

else:

572

758

return None

573

574

575

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

576

"""Deprecated"""

577

from bzrlib.commit import commit

578

commit(self, *args, **kw)

579

759

580

760

581

761

def lookup_revision(self, revno):

595

775

596

776

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

597

777

an `EmptyTree` is returned."""

598

# TODO: refactor this to use an existing revision object

599

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

778

self._need_readlock()

600

779

if revision_id == None:

601

780

return EmptyTree()

602

781

else:

606

785

607

786

def working_tree(self):

608

787

"""Return a `Tree` for the working copy."""

609

from workingtree import WorkingTree

610

788

return WorkingTree(self.base, self.read_working_inventory())

611

789

612

790

614

792

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

615

793

616

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

617

805

"""

618

806

r = self.last_patch()

619

807

if r == None:

623

811

624

812

625

813

626

@with_writelock

627

814

def rename_one(self, from_rel, to_rel):

628

815

"""Rename one file.

629

816

630

817

This can change the directory or the filename or both.

631

818

"""

819

self._need_writelock()

632

820

tree = self.working_tree()

633

821

inv = tree.inventory

634

822

if not tree.has_filename(from_rel):

635

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

823

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

636

824

if tree.has_filename(to_rel):

637

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

638

825

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

826

639

827

file_id = inv.path2id(from_rel)

640

828

if file_id == None:

641

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

829

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

642

830

643

831

if inv.path2id(to_rel):

644

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

832

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

645

833

646

834

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

647

835

to_dir_id = inv.path2id(to_dir)

648

836

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

649

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

837

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

650

838

651

839

mutter("rename_one:")

652

840

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

654

842

mutter(" to_rel %r" % to_rel)

655

843

mutter(" to_dir %r" % to_dir)

656

844

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

657

845

658

846

inv.rename(file_id, to_dir_id, to_tail)

659

847

660

848

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

661

849

662

850

from_abs = self.abspath(from_rel)

663

851

to_abs = self.abspath(to_rel)

664

852

try:

665

853

os.rename(from_abs, to_abs)

666

854

except OSError, e:

667

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

855

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

668

856

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

669

857

["rename rolled back"])

670

858

671

859

self._write_inventory(inv)

672

673

674

675

@with_writelock

860

861

862

676

863

def move(self, from_paths, to_name):

677

864

"""Rename files.

678

865

684

871

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

685

872

this doesn't change the directory.

686

873

"""

874

self._need_writelock()

687

875

## TODO: Option to move IDs only

688

876

assert not isinstance(from_paths, basestring)

689

877

tree = self.working_tree()

690

878

inv = tree.inventory

691

879

to_abs = self.abspath(to_name)

692

880

if not isdir(to_abs):

693

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

881

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

694

882

if not tree.has_filename(to_name):

695

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

883

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

696

884

to_dir_id = inv.path2id(to_name)

697

885

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

698

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

886

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

699

887

to_dir_ie = inv[to_dir_id]

700

888

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

701

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

889

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

702

890

703

to_idpath = inv.get_idpath(to_dir_id)

891

to_idpath = Set(inv.get_idpath(to_dir_id))

704

892

705

893

for f in from_paths:

706

894

if not tree.has_filename(f):

707

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

895

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

708

896

f_id = inv.path2id(f)

709

897

if f_id == None:

710

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

898

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

711

899

name_tail = splitpath(f)[-1]

712

900

dest_path = appendpath(to_name, name_tail)

713

901

if tree.has_filename(dest_path):

714

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

902

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

715

903

if f_id in to_idpath:

716

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

904

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

717

905

718

906

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

719

907

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

727

915

try:

728

916

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

729

917

except OSError, e:

730

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

918

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

731

919

["rename rolled back"])

732

920

733

921

self._write_inventory(inv)

734

922

735

923

736

924

925

def show_status(self, show_all=False, file_list=None):

926

"""Display single-line status for non-ignored working files.

927

928

The list is show sorted in order by file name.

929

930

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

931

>>> b.show_status()

932

? foo

933

>>> b.add('foo')

934

>>> b.show_status()

935

A foo

936

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

937

>>> b.show_status()

938

>>> os.unlink(b.abspath('foo'))

939

>>> b.show_status()

940

D foo

941

"""

942

self._need_readlock()

943

944

# We have to build everything into a list first so that it can

945

# sorted by name, incorporating all the different sources.

946

947

# FIXME: Rather than getting things in random order and then sorting,

948

# just step through in order.

949

950

# Interesting case: the old ID for a file has been removed,

951

# but a new file has been created under that name.

952

953

old = self.basis_tree()

954

new = self.working_tree()

955

956

items = diff_trees(old, new)

957

# We want to filter out only if any file was provided in the file_list.

958

if isinstance(file_list, list) and len(file_list):

959

items = [item for item in items if item[3] in file_list]

960

961

for fs, fid, oldname, newname, kind in items:

962

if fs == 'R':

963

show_status(fs, kind,

964

oldname + ' => ' + newname)

965

elif fs == 'A' or fs == 'M':

966

show_status(fs, kind, newname)

967

elif fs == 'D':

968

show_status(fs, kind, oldname)

969

elif fs == '.':

970

if show_all:

971

show_status(fs, kind, newname)

972

elif fs == 'I':

973

if show_all:

974

show_status(fs, kind, newname)

975

elif fs == '?':

976

show_status(fs, kind, newname)

977

else:

978

bailout("weird file state %r" % ((fs, fid),))

979

980

737

981

738

982

class ScratchBranch(Branch):

739

983

"""Special test class: a branch that cleans up after itself.

800

1044

801

1045

802

1046

1047

def _gen_revision_id(when):

1048

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

1049

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

1050

s += hexlify(rand_bytes(8))

1051

return s

1052

1053

803

1054

def gen_file_id(name):

804

1055

"""Return new file id.

805

1056

806

1057

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

807

1058

cope with just randomness because running uuidgen every time is

808

1059

slow."""

809

import re

810

811

# get last component

812

1060

idx = name.rfind('/')

813

1061

if idx != -1:

814

1062

name = name[idx+1 : ]

816

1064

if idx != -1:

817

1065

name = name[idx+1 : ]

818

1066

819

# make it not a hidden file

820

1067

name = name.lstrip('.')

821

1068

822

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

823

# just pull them out

824

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

825

826

1069

s = hexlify(rand_bytes(8))

827

1070

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