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

15

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

16

17

18

from sets import Set

19

20

18

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

21

19

import traceback, socket, fnmatch, difflib, time

22

20

from binascii import hexlify

24

22

import bzrlib

25

23

from inventory import Inventory

26

24

from trace import mutter, note

27

from tree import Tree, EmptyTree, RevisionTree, WorkingTree

25

from tree import Tree, EmptyTree, RevisionTree

28

26

from inventory import InventoryEntry, Inventory

29

27

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

30

28

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

31

29

joinpath, sha_string, file_kind, local_time_offset, appendpath

32

30

from store import ImmutableStore

33

31

from revision import Revision

34

from errors import bailout, BzrError

32

from errors import BzrError

35

33

from textui import show_status

36

from diff import diff_trees

37

34

38

35

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

39

36

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

40

37

41

38

42

39

40

def find_branch(f, **args):

41

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

42

import remotebranch

43

return remotebranch.RemoteBranch(f, **args)

44

else:

45

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

70

43

71

def find_branch_root(f=None):

44

72

"""Find the branch root enclosing f, or pwd.

45

73

74

f may be a filename or a URL.

75

46

76

It is not necessary that f exists.

47

77

48

78

Basically we keep looking up until we find the control directory or

53

83

f = os.path.realpath(f)

54

84

else:

55

85

f = os.path.abspath(f)

86

if not os.path.exists(f):

87

raise BzrError('%r does not exist' % f)

88

56

89

57

90

orig_f = f

58

91

70

103

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

71

104

# branch objects

72

105

73

class Branch:

106

class Branch(object):

74

107

"""Branch holding a history of revisions.

75

108

76

TODO: Perhaps use different stores for different classes of object,

77

so that we can keep track of how much space each one uses,

78

or garbage-collect them.

79

80

TODO: Add a RemoteBranch subclass. For the basic case of read-only

81

HTTP access this should be very easy by,

82

just redirecting controlfile access into HTTP requests.

83

We would need a RemoteStore working similarly.

84

85

TODO: Keep the on-disk branch locked while the object exists.

86

87

TODO: mkdir() method.

109

base

110

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.

88

121

"""

122

base = None

123

_lock_mode = None

124

_lock_count = None

125

89

126

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

90

127

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

91

128

109

146

else:

110

147

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

111

148

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

112

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

113

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

114

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

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'])

115

153

self._check_format()

154

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

116

155

117

156

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

118

157

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

126

165

__repr__ = __str__

127

166

128

167

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")

179

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

207

208

129

209

def abspath(self, name):

130

210

"""Return absolute filename for something in the branch"""

131

211

return os.path.join(self.base, name)

138

218

rp = os.path.realpath(path)

139

219

# FIXME: windows

140

220

if not rp.startswith(self.base):

141

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

221

from errors import NotBranchError

222

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

142

223

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

143

224

rp = rp.lstrip(os.sep)

144

225

return rp

158

239

and binary. binary files are untranslated byte streams. Text

159

240

control files are stored with Unix newlines and in UTF-8, even

160

241

if the platform or locale defaults are different.

242

243

Controlfiles should almost never be opened in write mode but

244

rather should be atomically copied and replaced using atomicfile.

161

245

"""

162

246

163

247

fn = self.controlfilename(file_or_path)

184

268

for d in ('text-store', 'inventory-store', 'revision-store'):

185

269

os.mkdir(self.controlfilename(d))

186

270

for f in ('revision-history', 'merged-patches',

187

'pending-merged-patches', 'branch-name'):

271

'pending-merged-patches', 'branch-name',

272

'branch-lock'):

188

273

self.controlfile(f, 'w').write('')

189

274

mutter('created control directory in ' + self.base)

190

275

Inventory().write_xml(self.controlfile('inventory','w'))

204

289

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

205

290

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

206

291

if fmt != BZR_BRANCH_FORMAT:

207

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

208

['use a different bzr version',

209

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

210

211

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

212

299

def read_working_inventory(self):

213

300

"""Read the working inventory."""

214

301

before = time.time()

218

305

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

219

306

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

220

307

return inv

221

308

222

309

223

310

def _write_inventory(self, inv):

224

311

"""Update the working inventory.

237

324

os.remove(inv_fname)

238

325

os.rename(tmpfname, inv_fname)

239

326

mutter('wrote working inventory')

240

327

241

328

242

329

inventory = property(read_working_inventory, _write_inventory, None,

243

330

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

244

331

245

332

246

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

333

@with_writelock

334

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

247

335

"""Make files versioned.

248

336

249

337

Note that the command line normally calls smart_add instead.

262

350

TODO: Adding a directory should optionally recurse down and

263

351

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

264

352

higher-level method.

265

266

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

267

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

268

True

269

>>> b.show_status()

270

? foo

271

>>> b.add('foo')

272

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

273

False

274

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

275

True

276

>>> b.show_status()

277

A foo

278

279

>>> b.add('foo')

280

Traceback (most recent call last):

281

...

282

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

283

284

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

285

Traceback (most recent call last):

286

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

287

353

"""

288

289

354

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

290

355

# should probably put it back with the previous ID.

291

356

if isinstance(files, types.StringTypes):

357

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

292

358

files = [files]

293

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

294

367

inv = self.read_working_inventory()

295

for f in files:

368

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

296

369

if is_control_file(f):

297

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

370

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

298

371

299

372

fp = splitpath(f)

300

373

301

374

if len(fp) == 0:

302

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

303

375

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

376

304

377

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

305

378

306

379

try:

307

380

kind = file_kind(fullpath)

308

381

except OSError:

309

382

# maybe something better?

310

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

311

383

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

384

312

385

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

313

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

386

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

314

387

315

file_id = gen_file_id(f)

388

if file_id is None:

389

file_id = gen_file_id(f)

316

390

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

317

391

318

392

if verbose:

319

393

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

320

394

321

395

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

396

397

self._write_inventory(inv)

322

398

323

self._write_inventory(inv)

324

325

399

326

400

def print_file(self, file, revno):

327

401

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

329

403

# use inventory as it was in that revision

330

404

file_id = tree.inventory.path2id(file)

331

405

if not file_id:

332

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

406

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

333

407

tree.print_file(file_id)

334

335

408

409

410

@with_writelock

336

411

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

337

412

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

338

413

340

415

341

416

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

342

417

343

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

344

>>> b.add('foo')

345

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

346

True

347

>>> b.remove('foo')

348

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

349

True

350

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

351

False

352

353

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

354

>>> b.add('foo')

355

>>> b.commit('one')

356

>>> b.remove('foo')

357

>>> b.commit('two')

358

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

359

False

360

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

361

False

362

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

363

True

364

365

418

TODO: Do something useful with directories.

366

419

367

420

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

371

424

"""

372

425

## TODO: Normalize names

373

426

## TODO: Remove nested loops; better scalability

374

375

427

if isinstance(files, types.StringTypes):

376

428

files = [files]

377

429

378

430

tree = self.working_tree()

379

431

inv = tree.inventory

380

432

382

434

for f in files:

383

435

fid = inv.path2id(f)

384

436

if not fid:

385

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

437

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

386

438

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

387

439

if verbose:

388

440

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

396

448

self._write_inventory(inv)

397

449

398

450

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

399

461

def unknowns(self):

400

462

"""Return all unknown files.

401

463

415

477

return self.working_tree().unknowns()

416

478

417

479

418

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

419

committer=None,

420

verbose=False):

421

"""Commit working copy as a new revision.

422

423

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

424

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

425

to that inventory and store that.

426

427

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

428

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

429

approach is to make a temporary copy of the files before

430

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

431

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

432

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

433

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

434

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

435

whole thing is a bit hard.

436

437

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

438

postdated/predated commit.

439

"""

440

441

## TODO: Show branch names

442

443

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

444

445

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

446

# and also build a new revision inventory. The revision

447

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

448

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

449

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

450

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

451

# working inventory.

452

453

work_inv = self.read_working_inventory()

454

inv = Inventory()

455

basis = self.basis_tree()

456

basis_inv = basis.inventory

457

missing_ids = []

458

for path, entry in work_inv.iter_entries():

459

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

460

461

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

462

## revision of this file (if any).

463

464

entry = entry.copy()

465

466

p = self.abspath(path)

467

file_id = entry.file_id

468

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

469

470

if not os.path.exists(p):

471

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

472

if verbose:

473

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

474

missing_ids.append(file_id)

475

continue

476

477

# TODO: Handle files that have been deleted

478

479

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

480

# waste to store them many times.

481

482

inv.add(entry)

483

484

if basis_inv.has_id(file_id):

485

old_kind = basis_inv[file_id].kind

486

if old_kind != entry.kind:

487

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

488

% (file_id, old_kind, entry.kind))

489

490

if entry.kind == 'directory':

491

if not isdir(p):

492

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

493

elif entry.kind == 'file':

494

if not isfile(p):

495

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

496

497

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

498

499

entry.text_sha1 = sha_string(content)

500

entry.text_size = len(content)

501

502

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

503

if (old_ie

504

and (old_ie.text_size == entry.text_size)

505

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

506

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

507

entry.text_id = basis_inv[file_id].text_id

508

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

509

entry.text_id)

510

511

else:

512

entry.text_id = gen_file_id(entry.name)

513

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

514

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

515

if verbose:

516

if not old_ie:

517

state = 'A'

518

elif (old_ie.name == entry.name

519

and old_ie.parent_id == entry.parent_id):

520

state = 'M'

521

else:

522

state = 'R'

523

524

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

525

526

for file_id in missing_ids:

527

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

528

# since parents may be removed before their children we

529

# have to test.

530

531

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

532

# the workingtree should know how to filter itself.

533

if work_inv.has_id(file_id):

534

del work_inv[file_id]

535

536

537

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

538

539

inv_tmp = tempfile.TemporaryFile()

540

inv.write_xml(inv_tmp)

541

inv_tmp.seek(0)

542

self.inventory_store.add(inv_tmp, inv_id)

543

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

544

545

self._write_inventory(work_inv)

546

547

if timestamp == None:

548

timestamp = time.time()

549

550

if committer == None:

551

committer = username()

552

553

if timezone == None:

554

timezone = local_time_offset()

555

556

mutter("building commit log message")

557

rev = Revision(timestamp=timestamp,

558

timezone=timezone,

559

committer=committer,

560

precursor = self.last_patch(),

561

message = message,

562

inventory_id=inv_id,

563

revision_id=rev_id)

564

565

rev_tmp = tempfile.TemporaryFile()

566

rev.write_xml(rev_tmp)

567

rev_tmp.seek(0)

568

self.revision_store.add(rev_tmp, rev_id)

569

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

570

571

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

572

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

573

## matter.

574

575

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

576

## applies and recreates the right state.

577

578

## TODO: Also calculate and store the inventory SHA1

579

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

580

581

582

self.append_revision(rev_id)

583

584

if verbose:

585

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

586

587

588

480

def append_revision(self, revision_id):

589

481

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

590

482

rev_history = self.revision_history()

629

521

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

630

522

631

523

524

@with_readlock

632

525

def revision_history(self):

633

526

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

634

527

638

531

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

639

532

640

533

534

def enum_history(self, direction):

535

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

536

537

direction

538

'forward' is from earliest to latest

539

'reverse' is from latest to earliest

540

"""

541

rh = self.revision_history()

542

if direction == 'forward':

543

i = 1

544

for rid in rh:

545

yield i, rid

546

i += 1

547

elif direction == 'reverse':

548

i = len(rh)

549

while i > 0:

550

yield i, rh[i-1]

551

i -= 1

552

else:

553

raise ValueError('invalid history direction', direction)

554

555

641

556

def revno(self):

642

557

"""Return current revision number for this branch.

643

558

644

559

That is equivalent to the number of revisions committed to

645

560

this branch.

646

647

>>> b = ScratchBranch()

648

>>> b.revno()

649

0

650

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

651

>>> b.revno()

652

1

653

561

"""

654

562

return len(self.revision_history())

655

563

656

564

657

565

def last_patch(self):

658

566

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

659

660

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

661

True

662

567

"""

663

568

ph = self.revision_history()

664

569

if ph:

665

570

return ph[-1]

666

571

else:

667

572

return None

573

574

575

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

576

"""Deprecated"""

577

from bzrlib.commit import commit

578

commit(self, *args, **kw)

668

579

669

580

670

581

def lookup_revision(self, revno):

684

595

685

596

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

686

597

an `EmptyTree` is returned."""

687

598

# TODO: refactor this to use an existing revision object

599

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

688

600

if revision_id == None:

689

601

return EmptyTree()

690

602

else:

694

606

695

607

def working_tree(self):

696

608

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

609

from workingtree import WorkingTree

697

610

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

698

611

699

612

701

614

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

702

615

703

616

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

704

705

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

706

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

707

False

708

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

709

True

710

>>> b.add('foo')

711

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

712

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

713

True

714

617

"""

715

618

r = self.last_patch()

716

619

if r == None:

720

623

721

624

722

625

723

def write_log(self, show_timezone='original', verbose=False):

724

"""Write out human-readable log of commits to this branch

725

726

utc -- If true, show dates in universal time, not local time."""

727

## TODO: Option to choose either original, utc or local timezone

728

revno = 1

729

precursor = None

730

for p in self.revision_history():

731

print '-' * 40

732

print 'revno:', revno

733

## TODO: Show hash if --id is given.

734

##print 'revision-hash:', p

735

rev = self.get_revision(p)

736

print 'committer:', rev.committer

737

print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,

738

show_timezone))

739

740

## opportunistic consistency check, same as check_patch_chaining

741

if rev.precursor != precursor:

742

bailout("mismatched precursor!")

743

744

print 'message:'

745

if not rev.message:

746

print ' (no message)'

747

else:

748

for l in rev.message.split('\n'):

749

print ' ' + l

750

751

if verbose == True and precursor != None:

752

print 'changed files:'

753

tree = self.revision_tree(p)

754

prevtree = self.revision_tree(precursor)

755

756

for file_state, fid, old_name, new_name, kind in \

757

diff_trees(prevtree, tree, ):

758

if file_state == 'A' or file_state == 'M':

759

show_status(file_state, kind, new_name)

760

elif file_state == 'D':

761

show_status(file_state, kind, old_name)

762

elif file_state == 'R':

763

show_status(file_state, kind,

764

old_name + ' => ' + new_name)

765

766

revno += 1

767

precursor = p

768

769

626

@with_writelock

770

627

def rename_one(self, from_rel, to_rel):

771

628

"""Rename one file.

772

629

773

630

This can change the directory or the filename or both.

774

"""

631

"""

775

632

tree = self.working_tree()

776

633

inv = tree.inventory

777

634

if not tree.has_filename(from_rel):

778

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

635

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

779

636

if tree.has_filename(to_rel):

780

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

781

637

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

638

782

639

file_id = inv.path2id(from_rel)

783

640

if file_id == None:

784

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

641

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

785

642

786

643

if inv.path2id(to_rel):

787

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

644

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

788

645

789

646

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

790

647

to_dir_id = inv.path2id(to_dir)

791

648

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

792

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

649

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

793

650

794

651

mutter("rename_one:")

795

652

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

797

654

mutter(" to_rel %r" % to_rel)

798

655

mutter(" to_dir %r" % to_dir)

799

656

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

800

657

801

658

inv.rename(file_id, to_dir_id, to_tail)

802

659

803

660

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

804

661

805

662

from_abs = self.abspath(from_rel)

806

663

to_abs = self.abspath(to_rel)

807

664

try:

808

665

os.rename(from_abs, to_abs)

809

666

except OSError, e:

810

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

667

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

811

668

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

812

669

["rename rolled back"])

813

670

814

671

self._write_inventory(inv)

815

816

817

672

673

674

675

@with_writelock

818

676

def move(self, from_paths, to_name):

819

677

"""Rename files.

820

678

832

690

inv = tree.inventory

833

691

to_abs = self.abspath(to_name)

834

692

if not isdir(to_abs):

835

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

693

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

836

694

if not tree.has_filename(to_name):

837

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

695

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

838

696

to_dir_id = inv.path2id(to_name)

839

697

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

840

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

698

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

841

699

to_dir_ie = inv[to_dir_id]

842

700

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

843

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

701

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

844

702

845

to_idpath = Set(inv.get_idpath(to_dir_id))

703

to_idpath = inv.get_idpath(to_dir_id)

846

704

847

705

for f in from_paths:

848

706

if not tree.has_filename(f):

849

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

707

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

850

708

f_id = inv.path2id(f)

851

709

if f_id == None:

852

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

710

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

853

711

name_tail = splitpath(f)[-1]

854

712

dest_path = appendpath(to_name, name_tail)

855

713

if tree.has_filename(dest_path):

856

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

714

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

857

715

if f_id in to_idpath:

858

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

716

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

859

717

860

718

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

861

719

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

869

727

try:

870

728

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

871

729

except OSError, e:

872

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

730

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

873

731

["rename rolled back"])

874

732

875

733

self._write_inventory(inv)

876

734

877

735

878

736

879

def show_status(self, show_all=False):

880

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

881

882

The list is show sorted in order by file name.

883

884

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

885

>>> b.show_status()

886

? foo

887

>>> b.add('foo')

888

>>> b.show_status()

889

A foo

890

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

891

>>> b.show_status()

892

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

893

>>> b.show_status()

894

D foo

895

896

TODO: Get state for single files.

897

"""

898

899

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

900

# sorted by name, incorporating all the different sources.

901

902

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

903

# just step through in order.

904

905

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

906

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

907

908

old = self.basis_tree()

909

new = self.working_tree()

910

911

for fs, fid, oldname, newname, kind in diff_trees(old, new):

912

if fs == 'R':

913

show_status(fs, kind,

914

oldname + ' => ' + newname)

915

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

916

show_status(fs, kind, newname)

917

elif fs == 'D':

918

show_status(fs, kind, oldname)

919

elif fs == '.':

920

if show_all:

921

show_status(fs, kind, newname)

922

elif fs == 'I':

923

if show_all:

924

show_status(fs, kind, newname)

925

elif fs == '?':

926

show_status(fs, kind, newname)

927

else:

928

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

929

930

931

737

932

738

class ScratchBranch(Branch):

933

739

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

936

742

>>> isdir(b.base)

937

743

True

938

744

>>> bd = b.base

939

>>> del b

745

>>> b.destroy()

940

746

>>> isdir(bd)

941

747

False

942

748

"""

956

762

957

763

958

764

def __del__(self):

765

self.destroy()

766

767

def destroy(self):

959

768

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

960

769

try:

770

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

961

771

shutil.rmtree(self.base)

962

except OSError:

772

except OSError, e:

963

773

# Work around for shutil.rmtree failing on Windows when

964

774

# readonly files are encountered

775

mutter("hit exception in destroying ScratchBranch: %s" % e)

965

776

for root, dirs, files in os.walk(self.base, topdown=False):

966

777

for name in files:

967

778

os.chmod(os.path.join(root, name), 0700)

968

779

shutil.rmtree(self.base)

780

self.base = None

969

781

970

782

971

783

988

800

989

801

990

802

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

998

803

def gen_file_id(name):

999

804

"""Return new file id.

1000

805

1001

806

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

1002

807

cope with just randomness because running uuidgen every time is

1003

808

slow."""

809

import re

810

811

# get last component

1004

812

idx = name.rfind('/')

1005

813

if idx != -1:

1006

814

name = name[idx+1 : ]

1008

816

if idx != -1:

1009

817

name = name[idx+1 : ]

1010

818

819

# make it not a hidden file

1011

820

name = name.lstrip('.')

1012

821

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

1013

826

s = hexlify(rand_bytes(8))

1014

827

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