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

24

import bzrlib

25

from inventory import Inventory

26

from trace import mutter, note

27

from tree import Tree, EmptyTree, RevisionTree, WorkingTree

27

from tree import Tree, EmptyTree, RevisionTree

28

from inventory import InventoryEntry, Inventory

29

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

29

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

30

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

31

joinpath, sha_string, file_kind, local_time_offset

31

joinpath, sha_string, file_kind, local_time_offset, appendpath

32

from store import ImmutableStore

33

from revision import Revision

34

from errors import bailout

34

from errors import bailout, BzrError

35

from textui import show_status

36

from diff import diff_trees

37

36

38

37

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

39

38

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

40

39

41

40

42

41

42

def find_branch(f, **args):

43

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

44

import remotebranch

45

return remotebranch.RemoteBranch(f, **args)

46

else:

47

return Branch(f, **args)

48

49

43

50

def find_branch_root(f=None):

44

51

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

45

52

53

f may be a filename or a URL.

54

46

55

It is not necessary that f exists.

47

56

48

57

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

49

58

run into the root."""

50

if f is None:

59

if f == None:

51

60

f = os.getcwd()

52

61

elif hasattr(os.path, 'realpath'):

53

62

f = os.path.realpath(f)

54

63

else:

55

64

f = os.path.abspath(f)

65

if not os.path.exists(f):

66

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

67

56

68

57

69

orig_f = f

58

70

59

last_f = f

60

71

while True:

61

72

if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):

62

73

return f

63

74

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

64

75

if head == f:

65

76

# reached the root, whatever that may be

66

bailout('%r is not in a branch' % orig_f)

77

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

67

78

f = head

68

79

69

80

74

85

class Branch:

75

86

"""Branch holding a history of revisions.

76

87

77

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

78

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

79

or garbage-collect them.

80

81

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

82

HTTP access this should be very easy by,

83

just redirecting controlfile access into HTTP requests.

84

We would need a RemoteStore working similarly.

85

86

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

87

88

:todo: mkdir() method.

88

base

89

Base directory of the branch.

89

90

"""

90

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

91

_lockmode = None

92

93

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

91

94

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

92

95

93

:param base: Base directory for the branch.

96

base -- Base directory for the branch.

94

97

95

:param init: If True, create new control files in a previously

98

init -- If True, create new control files in a previously

96

99

unversioned directory. If False, the branch must already

97

100

be versioned.

98

101

99

:param find_root: If true and init is false, find the root of the

102

find_root -- If true and init is false, find the root of the

100

103

existing branch containing base.

101

104

102

105

In the test suite, creation of new trees is tested using the

114

117

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

115

118

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

116

119

self._check_format()

120

self.lock(lock_mode)

117

121

118

122

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

119

123

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

127

131

__repr__ = __str__

128

132

129

133

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

158

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)

181

182

130

183

def abspath(self, name):

131

184

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

132

185

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

153

206

154

207

155

208

def controlfile(self, file_or_path, mode='r'):

156

"""Open a control file for this branch"""

157

return file(self.controlfilename(file_or_path), mode)

209

"""Open a control file for this branch.

210

211

There are two classes of file in the control directory: text

212

and binary. binary files are untranslated byte streams. Text

213

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

214

if the platform or locale defaults are different.

215

216

Controlfiles should almost never be opened in write mode but

217

rather should be atomically copied and replaced using atomicfile.

218

"""

219

220

fn = self.controlfilename(file_or_path)

221

222

if mode == 'rb' or mode == 'wb':

223

return file(fn, mode)

224

elif mode == 'r' or mode == 'w':

225

# open in binary mode anyhow so there's no newline translation;

226

# codecs uses line buffering by default; don't want that.

227

import codecs

228

return codecs.open(fn, mode + 'b', 'utf-8',

229

buffering=60000)

230

else:

231

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

232

158

233

159

234

160

235

def _make_control(self):

166

241

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

167

242

os.mkdir(self.controlfilename(d))

168

243

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

169

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

244

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

245

'branch-lock'):

170

246

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

171

247

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

172

248

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

179

255

180

256

In the future, we might need different in-memory Branch

181

257

classes to support downlevel branches. But not yet.

182

"""

183

# read in binary mode to detect newline wierdness.

184

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

258

"""

259

# This ignores newlines so that we can open branches created

260

# on Windows from Linux and so on. I think it might be better

261

# to always make all internal files in unix format.

262

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

263

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

185

264

if fmt != BZR_BRANCH_FORMAT:

186

265

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

187

266

['use a different bzr version',

190

269

191

270

def read_working_inventory(self):

192

271

"""Read the working inventory."""

272

self._need_readlock()

193

273

before = time.time()

194

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

274

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

275

# binary.

276

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

195

277

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

196

278

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

197

279

return inv

203

285

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

204

286

will be committed to the next revision.

205

287

"""

288

self._need_writelock()

206

289

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

207

290

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

208

291

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

209

tmpf = file(tmpfname, 'w')

292

tmpf = file(tmpfname, 'wb')

210

293

inv.write_xml(tmpf)

211

294

tmpf.close()

212

os.rename(tmpfname, self.controlfilename('inventory'))

295

inv_fname = self.controlfilename('inventory')

296

if sys.platform == 'win32':

297

os.remove(inv_fname)

298

os.rename(tmpfname, inv_fname)

213

299

mutter('wrote working inventory')

214

300

215

301

217

303

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

218

304

219

305

220

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

306

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

221

307

"""Make files versioned.

222

308

309

Note that the command line normally calls smart_add instead.

310

223

311

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

224

312

recorded by the next commit.

225

313

226

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

314

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

227

315

not (yet) exist.

228

316

229

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

317

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

230

318

is easy to retrieve them if they're needed.

231

319

232

:todo: Option to specify file id.

320

TODO: Option to specify file id.

233

321

234

:todo: Adding a directory should optionally recurse down and

322

TODO: Adding a directory should optionally recurse down and

235

323

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

236

324

higher-level method.

237

238

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

239

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

240

True

241

>>> b.show_status()

242

? foo

243

>>> b.add('foo')

244

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

245

False

246

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

247

True

248

>>> b.show_status()

249

A foo

250

251

>>> b.add('foo')

252

Traceback (most recent call last):

253

...

254

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

255

256

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

257

Traceback (most recent call last):

258

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

259

325

"""

326

self._need_writelock()

260

327

261

328

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

262

329

# should probably put it back with the previous ID.

263

330

if isinstance(files, types.StringTypes):

331

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

264

332

files = [files]

333

if ids is not None:

334

ids = [ids]

335

336

if ids is None:

337

ids = [None] * len(files)

338

else:

339

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

265

340

266

341

inv = self.read_working_inventory()

267

for f in files:

342

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

268

343

if is_control_file(f):

269

344

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

270

345

284

359

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

285

360

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

286

361

287

file_id = gen_file_id(f)

362

if file_id is None:

363

file_id = gen_file_id(f)

288

364

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

289

365

290

366

if verbose:

295

371

self._write_inventory(inv)

296

372

297

373

374

def print_file(self, file, revno):

375

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

376

self._need_readlock()

377

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

378

# use inventory as it was in that revision

379

file_id = tree.inventory.path2id(file)

380

if not file_id:

381

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

382

tree.print_file(file_id)

383

298

384

299

385

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

300

386

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

301

387

302

388

This does not remove their text. This does not run on

303

389

304

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

305

306

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

307

>>> b.add('foo')

308

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

309

True

310

>>> b.remove('foo')

311

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

312

True

313

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

314

False

315

316

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

317

>>> b.add('foo')

318

>>> b.commit('one')

319

>>> b.remove('foo')

320

>>> b.commit('two')

321

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

322

False

323

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

324

False

325

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

326

True

327

328

:todo: Do something useful with directories.

329

330

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

390

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

391

392

TODO: Do something useful with directories.

393

394

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

331

395

removing may be useful and the user can just use use rm, and

332

396

is the opposite of add. Removing it is consistent with most

333

397

other tools. Maybe an option.

334

398

"""

335

399

## TODO: Normalize names

336

400

## TODO: Remove nested loops; better scalability

401

self._need_writelock()

337

402

338

403

if isinstance(files, types.StringTypes):

339

404

files = [files]

358

423

359

424

self._write_inventory(inv)

360

425

426

def set_inventory(self, new_inventory_list):

427

inv = Inventory()

428

for path, file_id, parent, kind in new_inventory_list:

429

name = os.path.basename(path)

430

if name == "":

431

continue

432

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

433

self._write_inventory(inv)

434

361

435

362

436

def unknowns(self):

363

437

"""Return all unknown files.

378

452

return self.working_tree().unknowns()

379

453

380

454

381

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

382

committer=None,

383

verbose=False):

384

"""Commit working copy as a new revision.

385

386

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

387

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

388

to that inventory and store that.

389

390

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

391

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

392

approach is to make a temporary copy of the files before

393

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

394

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

395

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

396

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

397

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

398

whole thing is a bit hard.

399

400

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

401

postdated/predated commit.

402

"""

403

404

## TODO: Show branch names

405

406

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

407

408

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

409

# and also build a new revision inventory. The revision

410

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

411

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

412

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

413

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

414

# working inventory.

415

416

work_inv = self.read_working_inventory()

417

inv = Inventory()

418

basis = self.basis_tree()

419

basis_inv = basis.inventory

420

missing_ids = []

421

for path, entry in work_inv.iter_entries():

422

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

423

424

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

425

## revision of this file (if any).

426

427

entry = entry.copy()

428

429

p = self.abspath(path)

430

file_id = entry.file_id

431

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

432

433

if not os.path.exists(p):

434

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

435

if verbose:

436

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

437

missing_ids.append(file_id)

438

continue

439

440

# TODO: Handle files that have been deleted

441

442

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

443

# waste to store them many times.

444

445

inv.add(entry)

446

447

if basis_inv.has_id(file_id):

448

old_kind = basis_inv[file_id].kind

449

if old_kind != entry.kind:

450

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

451

% (file_id, old_kind, entry.kind))

452

453

if entry.kind == 'directory':

454

if not isdir(p):

455

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

456

elif entry.kind == 'file':

457

if not isfile(p):

458

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

459

460

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

461

462

entry.text_sha1 = sha_string(content)

463

entry.text_size = len(content)

464

465

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

466

if (old_ie

467

and (old_ie.text_size == entry.text_size)

468

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

469

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

470

entry.text_id = basis_inv[file_id].text_id

471

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

472

entry.text_id)

473

474

else:

475

entry.text_id = gen_file_id(entry.name)

476

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

477

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

478

if verbose:

479

if not old_ie:

480

state = 'A'

481

elif (old_ie.name == entry.name

482

and old_ie.parent_id == entry.parent_id):

483

state = 'R'

484

else:

485

state = 'M'

486

487

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

488

489

for file_id in missing_ids:

490

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

491

# since parents may be removed before their children we

492

# have to test.

493

494

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

495

# the workingtree should know how to filter itself.

496

if work_inv.has_id(file_id):

497

del work_inv[file_id]

498

499

500

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

501

502

inv_tmp = tempfile.TemporaryFile()

503

inv.write_xml(inv_tmp)

504

inv_tmp.seek(0)

505

self.inventory_store.add(inv_tmp, inv_id)

506

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

507

508

self._write_inventory(work_inv)

509

510

if timestamp == None:

511

timestamp = time.time()

512

513

if committer == None:

514

committer = username()

515

516

if timezone == None:

517

timezone = local_time_offset()

518

519

mutter("building commit log message")

520

rev = Revision(timestamp=timestamp,

521

timezone=timezone,

522

committer=committer,

523

precursor = self.last_patch(),

524

message = message,

525

inventory_id=inv_id,

526

revision_id=rev_id)

527

528

rev_tmp = tempfile.TemporaryFile()

529

rev.write_xml(rev_tmp)

530

rev_tmp.seek(0)

531

self.revision_store.add(rev_tmp, rev_id)

532

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

533

534

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

535

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

536

## matter.

537

538

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

539

## applies and recreates the right state.

540

541

## TODO: Also calculate and store the inventory SHA1

542

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

543

544

mutter("append to revision-history")

545

self.controlfile('revision-history', 'at').write(rev_id + '\n')

546

547

mutter("done!")

455

def append_revision(self, revision_id):

456

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

457

rev_history = self.revision_history()

458

459

tmprhname = self.controlfilename('revision-history.tmp')

460

rhname = self.controlfilename('revision-history')

461

462

f = file(tmprhname, 'wt')

463

rev_history.append(revision_id)

464

f.write('\n'.join(rev_history))

465

f.write('\n')

466

f.close()

467

468

if sys.platform == 'win32':

469

os.remove(rhname)

470

os.rename(tmprhname, rhname)

471

548

472

549

473

550

474

def get_revision(self, revision_id):

551

475

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

476

self._need_readlock()

552

477

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

553

478

assert r.revision_id == revision_id

554

479

return r

557

482

def get_inventory(self, inventory_id):

558

483

"""Get Inventory object by hash.

559

484

560

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

485

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

561

486

parameter which can be either an integer revno or a

562

487

string hash."""

488

self._need_readlock()

563

489

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

564

490

return i

565

491

566

492

567

493

def get_revision_inventory(self, revision_id):

568

494

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

495

self._need_readlock()

569

496

if revision_id == None:

570

497

return Inventory()

571

498

else:

578

505

>>> ScratchBranch().revision_history()

579

506

[]

580

507

"""

581

return [chomp(l) for l in self.controlfile('revision-history').readlines()]

508

self._need_readlock()

509

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

510

511

512

def enum_history(self, direction):

513

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

514

515

direction

516

'forward' is from earliest to latest

517

'reverse' is from latest to earliest

518

"""

519

rh = self.revision_history()

520

if direction == 'forward':

521

i = 1

522

for rid in rh:

523

yield i, rid

524

i += 1

525

elif direction == 'reverse':

526

i = len(rh)

527

while i > 0:

528

yield i, rh[i-1]

529

i -= 1

530

else:

531

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

582

532

583

533

584

534

def revno(self):

586

536

587

537

That is equivalent to the number of revisions committed to

588

538

this branch.

589

590

>>> b = ScratchBranch()

591

>>> b.revno()

592

0

593

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

594

>>> b.revno()

595

1

596

539

"""

597

540

return len(self.revision_history())

598

541

599

542

600

543

def last_patch(self):

601

544

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

602

603

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

604

True

605

545

"""

606

546

ph = self.revision_history()

607

547

if ph:

608

548

return ph[-1]

609

549

else:

550

return None

551

552

553

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

554

"""Deprecated"""

555

from bzrlib.commit import commit

556

commit(self, *args, **kw)

557

610

558

611

559

def lookup_revision(self, revno):

612

560

"""Return revision hash for revision number."""

617

565

# list is 0-based; revisions are 1-based

618

566

return self.revision_history()[revno-1]

619

567

except IndexError:

620

bailout("no such revision %s" % revno)

568

raise BzrError("no such revision %s" % revno)

621

569

622

570

623

571

def revision_tree(self, revision_id):

625

573

626

574

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

627

575

an `EmptyTree` is returned."""

628

576

self._need_readlock()

629

577

if revision_id == None:

630

578

return EmptyTree()

631

579

else:

635

583

636

584

def working_tree(self):

637

585

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

586

from workingtree import WorkingTree

638

587

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

639

588

640

589

642

591

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

643

592

644

593

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

645

646

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

647

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

648

False

649

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

650

True

651

>>> b.add('foo')

652

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

653

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

654

True

655

594

"""

656

595

r = self.last_patch()

657

596

if r == None:

661

600

662

601

663

602

664

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

665

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

666

667

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

668

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

669

revno = 1

670

precursor = None

671

for p in self.revision_history():

672

print '-' * 40

673

print 'revno:', revno

674

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

675

##print 'revision-hash:', p

676

rev = self.get_revision(p)

677

print 'committer:', rev.committer

678

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

679

show_timezone))

680

681

## opportunistic consistency check, same as check_patch_chaining

682

if rev.precursor != precursor:

683

bailout("mismatched precursor!")

684

685

print 'message:'

686

if not rev.message:

687

print ' (no message)'

688

else:

689

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

690

print ' ' + l

691

692

revno += 1

693

precursor = p

694

695

696

697

def show_status(branch, show_all=False):

698

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

699

700

The list is show sorted in order by file name.

701

702

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

703

>>> b.show_status()

704

? foo

705

>>> b.add('foo')

706

>>> b.show_status()

707

A foo

708

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

709

>>> b.show_status()

710

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

711

>>> b.show_status()

712

D foo

603

def rename_one(self, from_rel, to_rel):

604

"""Rename one file.

605

606

This can change the directory or the filename or both.

607

"""

608

self._need_writelock()

609

tree = self.working_tree()

610

inv = tree.inventory

611

if not tree.has_filename(from_rel):

612

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

613

if tree.has_filename(to_rel):

614

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

615

616

file_id = inv.path2id(from_rel)

617

if file_id == None:

618

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

619

620

if inv.path2id(to_rel):

621

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

622

623

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

624

to_dir_id = inv.path2id(to_dir)

625

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

626

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

627

628

mutter("rename_one:")

629

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

630

mutter(" from_rel %r" % from_rel)

631

mutter(" to_rel %r" % to_rel)

632

mutter(" to_dir %r" % to_dir)

633

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

634

635

inv.rename(file_id, to_dir_id, to_tail)

636

637

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

713

638

714

715

:todo: Get state for single files.

716

717

:todo: Perhaps show a slash at the end of directory names.

718

639

from_abs = self.abspath(from_rel)

640

to_abs = self.abspath(to_rel)

641

try:

642

os.rename(from_abs, to_abs)

643

except OSError, e:

644

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

645

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

646

["rename rolled back"])

647

648

self._write_inventory(inv)

649

650

651

652

def move(self, from_paths, to_name):

653

"""Rename files.

654

655

to_name must exist as a versioned directory.

656

657

If to_name exists and is a directory, the files are moved into

658

it, keeping their old names. If it is a directory,

659

660

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

661

this doesn't change the directory.

719

662

"""

720

721

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

722

# sorted by name, incorporating all the different sources.

723

724

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

725

# just step through in order.

726

727

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

728

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

729

730

old = branch.basis_tree()

731

old_inv = old.inventory

732

new = branch.working_tree()

733

new_inv = new.inventory

734

735

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

736

if fs == 'R':

737

show_status(fs, kind,

738

oldname + ' => ' + newname)

739

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

740

show_status(fs, kind, newname)

741

elif fs == 'D':

742

show_status(fs, kind, oldname)

743

elif fs == '.':

744

if show_all:

745

show_status(fs, kind, newname)

746

elif fs == 'I':

747

if show_all:

748

show_status(fs, kind, newname)

749

elif fs == '?':

750

show_status(fs, kind, newname)

751

else:

752

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

753

663

self._need_writelock()

664

## TODO: Option to move IDs only

665

assert not isinstance(from_paths, basestring)

666

tree = self.working_tree()

667

inv = tree.inventory

668

to_abs = self.abspath(to_name)

669

if not isdir(to_abs):

670

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

671

if not tree.has_filename(to_name):

672

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

673

to_dir_id = inv.path2id(to_name)

674

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

675

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

676

to_dir_ie = inv[to_dir_id]

677

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

678

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

679

680

to_idpath = Set(inv.get_idpath(to_dir_id))

681

682

for f in from_paths:

683

if not tree.has_filename(f):

684

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

685

f_id = inv.path2id(f)

686

if f_id == None:

687

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

688

name_tail = splitpath(f)[-1]

689

dest_path = appendpath(to_name, name_tail)

690

if tree.has_filename(dest_path):

691

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

692

if f_id in to_idpath:

693

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

694

695

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

696

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

697

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

698

699

for f in from_paths:

700

name_tail = splitpath(f)[-1]

701

dest_path = appendpath(to_name, name_tail)

702

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

703

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

704

try:

705

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

706

except OSError, e:

707

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

708

["rename rolled back"])

709

710

self._write_inventory(inv)

711

712

754

713

755

714

756

715

class ScratchBranch(Branch):

760

719

>>> isdir(b.base)

761

720

True

762

721

>>> bd = b.base

763

>>> del b

722

>>> b.destroy()

764

723

>>> isdir(bd)

765

724

False

766

725

"""

767

def __init__(self, files = []):

726

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

768

727

"""Make a test branch.

769

728

770

729

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

772

731

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

773

732

"""

774

733

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

734

for d in dirs:

735

os.mkdir(self.abspath(d))

736

775

737

for f in files:

776

738

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

777

739

778

740

779

741

def __del__(self):

742

self.destroy()

743

744

def destroy(self):

780

745

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

781

shutil.rmtree(self.base)

746

try:

747

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

748

shutil.rmtree(self.base)

749

except OSError, e:

750

# Work around for shutil.rmtree failing on Windows when

751

# readonly files are encountered

752

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

753

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

754

for name in files:

755

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

756

shutil.rmtree(self.base)

757

self.base = None

782

758

783

759

784

760

801

777

802

778

803

779

804

def _gen_revision_id(when):

805

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

806

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

807

s += hexlify(rand_bytes(8))

808

return s

809

810

811

780

def gen_file_id(name):

812

781

"""Return new file id.

813

782

817

786

idx = name.rfind('/')

818

787

if idx != -1:

819

788

name = name[idx+1 : ]

789

idx = name.rfind('\\')

790

if idx != -1:

791

name = name[idx+1 : ]

820

792

821

793

name = name.lstrip('.')

822

794

823

795

s = hexlify(rand_bytes(8))

824

796

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

825

826