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

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

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

27

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

30

28

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

31

joinpath, sha_string, file_kind, local_time_offset

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

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 _relpath(base, path):

50

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

51

52

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

53

current working directory.

54

55

Lifted out of Branch.relpath for ease of testing.

56

57

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

58

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

59

avoids that problem."""

60

rp = os.path.abspath(path)

61

62

s = []

63

head = rp

64

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

65

if head == base:

66

break

67

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

68

if tail:

69

s.insert(0, tail)

70

else:

71

from errors import NotBranchError

72

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

73

74

return os.sep.join(s)

75

76

43

77

def find_branch_root(f=None):

44

78

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

45

79

80

f may be a filename or a URL.

81

46

82

It is not necessary that f exists.

47

83

48

84

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

49

85

run into the root."""

50

if f is None:

86

if f == None:

51

87

f = os.getcwd()

52

88

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

53

89

f = os.path.realpath(f)

54

90

else:

55

91

f = os.path.abspath(f)

92

if not os.path.exists(f):

93

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

94

56

95

57

96

orig_f = f

58

97

59

last_f = f

60

98

while True:

61

99

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

62

100

return f

63

101

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

64

102

if head == f:

65

103

# reached the root, whatever that may be

66

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

104

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

67

105

f = head

68

106

69

107

71

109

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

72

110

# branch objects

73

111

74

class Branch:

112

class Branch(object):

75

113

"""Branch holding a history of revisions.

76

114

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.

115

base

116

Base directory of the branch.

117

118

_lock_mode

119

None, or 'r' or 'w'

120

121

_lock_count

122

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

123

lock has been taken.

124

125

_lock

126

Lock object from bzrlib.lock.

89

127

"""

128

base = None

129

_lock_mode = None

130

_lock_count = None

131

_lock = None

132

90

133

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

91

134

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

92

135

93

:param base: Base directory for the branch.

136

base -- Base directory for the branch.

94

137

95

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

138

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

96

139

unversioned directory. If False, the branch must already

97

140

be versioned.

98

141

99

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

142

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

100

143

existing branch containing base.

101

144

102

145

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

110

153

else:

111

154

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

112

155

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

113

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

114

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

115

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

156

from errors import NotBranchError

157

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

158

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

159

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

116

160

self._check_format()

117

161

118

162

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

127

171

__repr__ = __str__

128

172

129

173

174

def __del__(self):

175

if self._lock_mode or self._lock:

176

from warnings import warn

177

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

178

self._lock.unlock()

179

180

181

182

def lock_write(self):

183

if self._lock_mode:

184

if self._lock_mode != 'w':

185

from errors import LockError

186

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

187

self._lock_mode)

188

self._lock_count += 1

189

else:

190

from bzrlib.lock import WriteLock

191

192

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

193

self._lock_mode = 'w'

194

self._lock_count = 1

195

196

197

198

def lock_read(self):

199

if self._lock_mode:

200

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

201

"invalid lock mode %r" % self._lock_mode

202

self._lock_count += 1

203

else:

204

from bzrlib.lock import ReadLock

205

206

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

207

self._lock_mode = 'r'

208

self._lock_count = 1

209

210

211

212

def unlock(self):

213

if not self._lock_mode:

214

from errors import LockError

215

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

216

217

if self._lock_count > 1:

218

self._lock_count -= 1

219

else:

220

self._lock.unlock()

221

self._lock = None

222

self._lock_mode = self._lock_count = None

223

224

130

225

def abspath(self, name):

131

226

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

132

227

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

136

231

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

137

232

138

233

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

139

rp = os.path.realpath(path)

140

# FIXME: windows

141

if not rp.startswith(self.base):

142

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

143

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

144

rp = rp.lstrip(os.sep)

145

return rp

234

return _relpath(self.base, path)

146

235

147

236

148

237

def controlfilename(self, file_or_path):

153

242

154

243

155

244

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)

245

"""Open a control file for this branch.

246

247

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

248

and binary. binary files are untranslated byte streams. Text

249

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

250

if the platform or locale defaults are different.

251

252

Controlfiles should almost never be opened in write mode but

253

rather should be atomically copied and replaced using atomicfile.

254

"""

255

256

fn = self.controlfilename(file_or_path)

257

258

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

259

return file(fn, mode)

260

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

261

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

262

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

263

import codecs

264

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

265

buffering=60000)

266

else:

267

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

268

158

269

159

270

160

271

def _make_control(self):

166

277

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

167

278

os.mkdir(self.controlfilename(d))

168

279

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

169

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

280

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

281

'branch-lock'):

170

282

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

171

283

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

172

284

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

179

291

180

292

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

181

293

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

294

"""

295

# This ignores newlines so that we can open branches created

296

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

297

# to always make all internal files in unix format.

298

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

299

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

185

300

if fmt != BZR_BRANCH_FORMAT:

186

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

187

['use a different bzr version',

188

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

301

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

302

['use a different bzr version',

303

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

304

189

305

190

306

191

307

def read_working_inventory(self):

192

308

"""Read the working inventory."""

193

309

before = time.time()

194

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

195

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

196

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

197

return inv

198

310

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

311

# binary.

312

self.lock_read()

313

try:

314

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

315

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

316

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

317

return inv

318

finally:

319

self.unlock()

320

199

321

200

322

def _write_inventory(self, inv):

201

323

"""Update the working inventory.

206

328

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

207

329

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

208

330

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

209

tmpf = file(tmpfname, 'w')

331

tmpf = file(tmpfname, 'wb')

210

332

inv.write_xml(tmpf)

211

333

tmpf.close()

212

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

334

inv_fname = self.controlfilename('inventory')

335

if sys.platform == 'win32':

336

os.remove(inv_fname)

337

os.rename(tmpfname, inv_fname)

213

338

mutter('wrote working inventory')

214

339

215

340

216

341

inventory = property(read_working_inventory, _write_inventory, None,

217

342

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

218

343

219

344

220

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

345

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

221

346

"""Make files versioned.

222

347

348

Note that the command line normally calls smart_add instead.

349

223

350

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

224

351

recorded by the next commit.

225

352

226

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

227

not (yet) exist.

228

229

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

230

is easy to retrieve them if they're needed.

231

232

:todo: Option to specify file id.

233

234

:todo: Adding a directory should optionally recurse down and

235

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

236

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

353

files

354

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

355

356

ids

357

If set, use these instead of automatically generated ids.

358

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

359

contain None for ids that are to be autogenerated.

360

361

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

362

not (yet) exist.

363

364

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

365

is easy to retrieve them if they're needed.

366

367

TODO: Adding a directory should optionally recurse down and

368

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

369

higher-level method.

259

370

"""

260

261

371

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

262

372

# should probably put it back with the previous ID.

263

373

if isinstance(files, types.StringTypes):

374

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

264

375

files = [files]

265

266

inv = self.read_working_inventory()

267

for f in files:

268

if is_control_file(f):

269

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

270

271

fp = splitpath(f)

272

273

if len(fp) == 0:

274

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

275

276

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

277

278

try:

279

kind = file_kind(fullpath)

280

except OSError:

281

# maybe something better?

282

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

283

284

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

285

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

286

287

file_id = gen_file_id(f)

288

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

289

290

if verbose:

291

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

292

293

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

294

295

self._write_inventory(inv)

296

376

if ids is not None:

377

ids = [ids]

378

379

if ids is None:

380

ids = [None] * len(files)

381

else:

382

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

383

384

self.lock_write()

385

try:

386

inv = self.read_working_inventory()

387

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

388

if is_control_file(f):

389

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

390

391

fp = splitpath(f)

392

393

if len(fp) == 0:

394

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

395

396

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

397

398

try:

399

kind = file_kind(fullpath)

400

except OSError:

401

# maybe something better?

402

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

403

404

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

405

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

406

407

if file_id is None:

408

file_id = gen_file_id(f)

409

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

410

411

if verbose:

412

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

413

414

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

415

416

self._write_inventory(inv)

417

finally:

418

self.unlock()

419

420

421

def print_file(self, file, revno):

422

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

423

self.lock_read()

424

try:

425

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

426

# use inventory as it was in that revision

427

file_id = tree.inventory.path2id(file)

428

if not file_id:

429

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

430

tree.print_file(file_id)

431

finally:

432

self.unlock()

297

433

298

434

299

435

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

301

437

302

438

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

303

439

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

440

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

441

442

TODO: Do something useful with directories.

443

444

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

331

445

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

332

446

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

333

447

other tools. Maybe an option.

334

448

"""

335

449

## TODO: Normalize names

336

450

## TODO: Remove nested loops; better scalability

337

338

451

if isinstance(files, types.StringTypes):

339

452

files = [files]

340

341

tree = self.working_tree()

342

inv = tree.inventory

343

344

# do this before any modifications

345

for f in files:

346

fid = inv.path2id(f)

347

if not fid:

348

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

349

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

350

if verbose:

351

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

352

if tree.is_ignored(f):

353

new_status = 'I'

354

else:

355

new_status = '?'

356

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

357

del inv[fid]

358

453

454

self.lock_write()

455

456

try:

457

tree = self.working_tree()

458

inv = tree.inventory

459

460

# do this before any modifications

461

for f in files:

462

fid = inv.path2id(f)

463

if not fid:

464

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

465

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

466

if verbose:

467

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

468

if tree.is_ignored(f):

469

new_status = 'I'

470

else:

471

new_status = '?'

472

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

473

del inv[fid]

474

475

self._write_inventory(inv)

476

finally:

477

self.unlock()

478

479

480

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

481

def set_inventory(self, new_inventory_list):

482

inv = Inventory()

483

for path, file_id, parent, kind in new_inventory_list:

484

name = os.path.basename(path)

485

if name == "":

486

continue

487

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

359

488

self._write_inventory(inv)

360

489

361

490

378

507

return self.working_tree().unknowns()

379

508

380

509

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 = 'M'

484

else:

485

state = 'R'

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

f = self.controlfile('revision-history', 'at')

546

f.write(rev_id + '\n')

510

def append_revision(self, revision_id):

511

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

512

rev_history = self.revision_history()

513

514

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

515

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

516

517

f = file(tmprhname, 'wt')

518

rev_history.append(revision_id)

519

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

520

f.write('\n')

547

521

f.close()

548

522

549

if verbose:

550

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

523

if sys.platform == 'win32':

524

os.remove(rhname)

525

os.rename(tmprhname, rhname)

526

551

527

552

528

553

529

def get_revision(self, revision_id):

560

536

def get_inventory(self, inventory_id):

561

537

"""Get Inventory object by hash.

562

538

563

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

539

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

564

540

parameter which can be either an integer revno or a

565

541

string hash."""

566

542

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

581

557

>>> ScratchBranch().revision_history()

582

558

[]

583

559

"""

584

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

560

self.lock_read()

561

try:

562

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

563

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

564

finally:

565

self.unlock()

566

567

568

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

569

"""

570

>>> import commit

571

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

572

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

573

True

574

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

575

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

576

1

577

>>> clone = sb.clone()

578

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

579

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

580

2

581

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

582

1

583

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

584

... verbose=False)

585

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

586

1

587

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

588

True

589

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

590

True

591

>>> clone2 = sb.clone()

592

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

593

2

594

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

595

1

596

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

597

1

598

"""

599

my_history = self.revision_history()

600

other_history = other.revision_history()

601

if self_revno is None:

602

self_revno = len(my_history)

603

if other_revno is None:

604

other_revno = len(other_history)

605

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

606

indices.reverse()

607

for r in indices:

608

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

609

return r+1, my_history[r]

610

return None, None

611

612

def enum_history(self, direction):

613

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

614

615

direction

616

'forward' is from earliest to latest

617

'reverse' is from latest to earliest

618

"""

619

rh = self.revision_history()

620

if direction == 'forward':

621

i = 1

622

for rid in rh:

623

yield i, rid

624

i += 1

625

elif direction == 'reverse':

626

i = len(rh)

627

while i > 0:

628

yield i, rh[i-1]

629

i -= 1

630

else:

631

raise ValueError('invalid history direction', direction)

585

632

586

633

587

634

def revno(self):

589

636

590

637

That is equivalent to the number of revisions committed to

591

638

this branch.

592

593

>>> b = ScratchBranch()

594

>>> b.revno()

595

0

596

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

597

>>> b.revno()

598

1

599

639

"""

600

640

return len(self.revision_history())

601

641

602

642

603

643

def last_patch(self):

604

644

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

605

606

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

607

True

608

645

"""

609

646

ph = self.revision_history()

610

647

if ph:

611

648

return ph[-1]

612

649

else:

650

return None

651

652

653

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

654

"""Deprecated"""

655

from bzrlib.commit import commit

656

commit(self, *args, **kw)

657

613

658

614

659

def lookup_revision(self, revno):

615

660

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

620

665

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

621

666

return self.revision_history()[revno-1]

622

667

except IndexError:

623

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

668

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

624

669

625

670

626

671

def revision_tree(self, revision_id):

628

673

629

674

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

630

675

an `EmptyTree` is returned."""

631

676

# TODO: refactor this to use an existing revision object

677

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

632

678

if revision_id == None:

633

679

return EmptyTree()

634

680

else:

638

684

639

685

def working_tree(self):

640

686

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

687

from workingtree import WorkingTree

641

688

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

642

689

643

690

645

692

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

646

693

647

694

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

648

649

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

650

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

651

False

652

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

653

True

654

>>> b.add('foo')

655

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

656

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

657

True

658

695

"""

659

696

r = self.last_patch()

660

697

if r == None:

664

701

665

702

666

703

667

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

668

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

669

670

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

671

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

672

revno = 1

673

precursor = None

674

for p in self.revision_history():

675

print '-' * 40

676

print 'revno:', revno

677

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

678

##print 'revision-hash:', p

679

rev = self.get_revision(p)

680

print 'committer:', rev.committer

681

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

682

show_timezone))

683

684

## opportunistic consistency check, same as check_patch_chaining

685

if rev.precursor != precursor:

686

bailout("mismatched precursor!")

687

688

print 'message:'

689

if not rev.message:

690

print ' (no message)'

691

else:

692

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

693

print ' ' + l

694

695

revno += 1

696

precursor = p

697

698

699

700

def show_status(branch, show_all=False):

701

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

702

703

The list is show sorted in order by file name.

704

705

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

706

>>> b.show_status()

707

? foo

708

>>> b.add('foo')

709

>>> b.show_status()

710

A foo

711

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

712

>>> b.show_status()

713

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

714

>>> b.show_status()

715

D foo

716

717

718

:todo: Get state for single files.

719

720

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

721

722

"""

723

724

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

725

# sorted by name, incorporating all the different sources.

726

727

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

728

# just step through in order.

729

730

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

731

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

732

733

old = branch.basis_tree()

734

old_inv = old.inventory

735

new = branch.working_tree()

736

new_inv = new.inventory

737

738

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

739

if fs == 'R':

740

show_status(fs, kind,

741

oldname + ' => ' + newname)

742

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

743

show_status(fs, kind, newname)

744

elif fs == 'D':

745

show_status(fs, kind, oldname)

746

elif fs == '.':

747

if show_all:

748

show_status(fs, kind, newname)

749

elif fs == 'I':

750

if show_all:

751

show_status(fs, kind, newname)

752

elif fs == '?':

753

show_status(fs, kind, newname)

754

else:

755

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

756

704

def rename_one(self, from_rel, to_rel):

705

"""Rename one file.

706

707

This can change the directory or the filename or both.

708

"""

709

self.lock_write()

710

try:

711

tree = self.working_tree()

712

inv = tree.inventory

713

if not tree.has_filename(from_rel):

714

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

715

if tree.has_filename(to_rel):

716

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

717

718

file_id = inv.path2id(from_rel)

719

if file_id == None:

720

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

721

722

if inv.path2id(to_rel):

723

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

724

725

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

726

to_dir_id = inv.path2id(to_dir)

727

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

728

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

729

730

mutter("rename_one:")

731

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

732

mutter(" from_rel %r" % from_rel)

733

mutter(" to_rel %r" % to_rel)

734

mutter(" to_dir %r" % to_dir)

735

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

736

737

inv.rename(file_id, to_dir_id, to_tail)

738

739

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

740

741

from_abs = self.abspath(from_rel)

742

to_abs = self.abspath(to_rel)

743

try:

744

os.rename(from_abs, to_abs)

745

except OSError, e:

746

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

747

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

748

["rename rolled back"])

749

750

self._write_inventory(inv)

751

finally:

752

self.unlock()

753

754

755

def move(self, from_paths, to_name):

756

"""Rename files.

757

758

to_name must exist as a versioned directory.

759

760

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

761

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

762

763

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

764

this doesn't change the directory.

765

"""

766

self.lock_write()

767

try:

768

## TODO: Option to move IDs only

769

assert not isinstance(from_paths, basestring)

770

tree = self.working_tree()

771

inv = tree.inventory

772

to_abs = self.abspath(to_name)

773

if not isdir(to_abs):

774

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

775

if not tree.has_filename(to_name):

776

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

777

to_dir_id = inv.path2id(to_name)

778

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

779

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

780

to_dir_ie = inv[to_dir_id]

781

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

782

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

783

784

to_idpath = inv.get_idpath(to_dir_id)

785

786

for f in from_paths:

787

if not tree.has_filename(f):

788

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

789

f_id = inv.path2id(f)

790

if f_id == None:

791

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

792

name_tail = splitpath(f)[-1]

793

dest_path = appendpath(to_name, name_tail)

794

if tree.has_filename(dest_path):

795

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

796

if f_id in to_idpath:

797

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

798

799

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

800

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

801

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

802

803

for f in from_paths:

804

name_tail = splitpath(f)[-1]

805

dest_path = appendpath(to_name, name_tail)

806

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

807

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

808

try:

809

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

810

except OSError, e:

811

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

812

["rename rolled back"])

813

814

self._write_inventory(inv)

815

finally:

816

self.unlock()

817

757

818

758

819

759

820

class ScratchBranch(Branch):

763

824

>>> isdir(b.base)

764

825

True

765

826

>>> bd = b.base

766

>>> del b

827

>>> b.destroy()

767

828

>>> isdir(bd)

768

829

False

769

830

"""

770

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

831

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

771

832

"""Make a test branch.

772

833

773

834

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

774

835

775

836

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

776

837

"""

777

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

838

init = False

839

if base is None:

840

base = tempfile.mkdtemp()

841

init = True

842

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

778

843

for d in dirs:

779

844

os.mkdir(self.abspath(d))

780

845

782

847

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

783

848

784

849

850

def clone(self):

851

"""

852

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

853

>>> clone = orig.clone()

854

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

855

False

856

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

857

True

858

"""

859

base = tempfile.mkdtemp()

860

os.rmdir(base)

861

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

862

return ScratchBranch(base=base)

863

785

864

def __del__(self):

865

self.destroy()

866

867

def destroy(self):

786

868

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

787

shutil.rmtree(self.base)

869

try:

870

if self.base:

871

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

872

shutil.rmtree(self.base)

873

except OSError, e:

874

# Work around for shutil.rmtree failing on Windows when

875

# readonly files are encountered

876

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

877

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

878

for name in files:

879

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

880

shutil.rmtree(self.base)

881

self.base = None

788

882

789

883

790

884

807

901

808

902

809

903

810

def _gen_revision_id(when):

811

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

812

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

813

s += hexlify(rand_bytes(8))

814

return s

815

816

817

904

def gen_file_id(name):

818

905

"""Return new file id.

819

906

820

907

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

821

908

cope with just randomness because running uuidgen every time is

822

909

slow."""

910

import re

911

912

# get last component

823

913

idx = name.rfind('/')

824

914

if idx != -1:

825

915

name = name[idx+1 : ]

916

idx = name.rfind('\\')

917

if idx != -1:

918

name = name[idx+1 : ]

826

919

920

# make it not a hidden file

827

921

name = name.lstrip('.')

828

922

923

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

924

# just pull them out

925

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

926

829

927

s = hexlify(rand_bytes(8))

830

928

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

831

832