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

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)

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

75

69

76

70

77

71

def find_branch_root(f=None):

104

98

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

105

99

f = head

106

100

107

class DivergedBranches(Exception):

108

def __init__(self, branch1, branch2):

109

self.branch1 = branch1

110

self.branch2 = branch2

111

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

101

112

102

113

103

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

114

104

# branch objects

126

116

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

127

117

lock has been taken.

128

118

129

_lock

130

Lock object from bzrlib.lock.

119

_lockfile

120

Open file used for locking.

131

121

"""

132

122

base = None

133

123

_lock_mode = None

134

124

_lock_count = None

135

_lock = None

136

125

137

126

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

138

127

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

162

151

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

163

152

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

164

153

self._check_format()

154

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

165

155

166

156

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

167

157

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

176

166

177

167

178

168

def __del__(self):

179

if self._lock_mode or self._lock:

169

if self._lock_mode:

180

170

from warnings import warn

181

171

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

182

self._lock.unlock()

183

184

185

186

def lock_write(self):

187

if self._lock_mode:

188

if self._lock_mode != 'w':

189

from errors import LockError

190

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

191

self._lock_mode)

192

self._lock_count += 1

193

else:

194

from bzrlib.lock import WriteLock

195

196

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

197

self._lock_mode = 'w'

198

self._lock_count = 1

199

200

201

202

def lock_read(self):

203

if self._lock_mode:

204

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

205

"invalid lock mode %r" % self._lock_mode

206

self._lock_count += 1

207

else:

208

from bzrlib.lock import ReadLock

209

210

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

211

self._lock_mode = 'r'

212

self._lock_count = 1

213

214

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

215

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

216

196

def unlock(self):

217

197

if not self._lock_mode:

218

from errors import LockError

219

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

198

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

220

199

221

200

if self._lock_count > 1:

222

201

self._lock_count -= 1

223

202

else:

224

self._lock.unlock()

225

self._lock = None

203

assert self._lock_count == 1

204

from bzrlib.lock import unlock

205

unlock(self._lockfile)

226

206

self._lock_mode = self._lock_count = None

227

207

228

208

235

215

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

236

216

237

217

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

238

return _relpath(self.base, path)

218

rp = os.path.realpath(path)

219

# FIXME: windows

220

if not rp.startswith(self.base):

221

from errors import NotBranchError

222

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

223

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

224

rp = rp.lstrip(os.sep)

225

return rp

239

226

240

227

241

228

def controlfilename(self, file_or_path):

308

295

309

296

310

297

298

@with_readlock

311

299

def read_working_inventory(self):

312

300

"""Read the working inventory."""

313

301

before = time.time()

314

302

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

315

303

# binary.

316

self.lock_read()

317

try:

318

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

319

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

320

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

321

return inv

322

finally:

323

self.unlock()

304

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

305

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

306

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

307

return inv

324

308

325

309

326

310

def _write_inventory(self, inv):

346

330

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

347

331

348

332

333

@with_writelock

349

334

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

350

335

"""Make files versioned.

351

336

354

339

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

355

340

recorded by the next commit.

356

341

357

files

358

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

359

360

ids

361

If set, use these instead of automatically generated ids.

362

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

363

contain None for ids that are to be autogenerated.

364

365

342

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

366

not (yet) exist.

343

not (yet) exist.

367

344

368

345

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

369

is easy to retrieve them if they're needed.

346

is easy to retrieve them if they're needed.

347

348

TODO: Option to specify file id.

370

349

371

350

TODO: Adding a directory should optionally recurse down and

372

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

373

higher-level method.

351

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

352

higher-level method.

374

353

"""

375

354

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

376

355

# should probably put it back with the previous ID.

385

364

else:

386

365

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

387

366

388

self.lock_write()

389

try:

390

inv = self.read_working_inventory()

391

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

392

if is_control_file(f):

393

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

394

395

fp = splitpath(f)

396

397

if len(fp) == 0:

398

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

399

400

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

401

402

try:

403

kind = file_kind(fullpath)

404

except OSError:

405

# maybe something better?

406

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

407

408

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

409

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

410

411

if file_id is None:

412

file_id = gen_file_id(f)

413

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

414

415

if verbose:

416

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

417

418

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

419

420

self._write_inventory(inv)

421

finally:

422

self.unlock()

367

inv = self.read_working_inventory()

368

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

369

if is_control_file(f):

370

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

371

372

fp = splitpath(f)

373

374

if len(fp) == 0:

375

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

376

377

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

378

379

try:

380

kind = file_kind(fullpath)

381

except OSError:

382

# maybe something better?

383

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

384

385

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

386

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

387

388

if file_id is None:

389

file_id = gen_file_id(f)

390

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

391

392

if verbose:

393

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

394

395

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

396

397

self._write_inventory(inv)

423

398

424

399

425

400

def print_file(self, file, revno):

426

401

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

427

self.lock_read()

428

try:

429

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

430

# use inventory as it was in that revision

431

file_id = tree.inventory.path2id(file)

432

if not file_id:

433

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

434

tree.print_file(file_id)

435

finally:

436

self.unlock()

437

438

402

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

403

# use inventory as it was in that revision

404

file_id = tree.inventory.path2id(file)

405

if not file_id:

406

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

407

tree.print_file(file_id)

408

409

410

@with_writelock

439

411

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

440

412

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

441

413

455

427

if isinstance(files, types.StringTypes):

456

428

files = [files]

457

429

458

self.lock_write()

459

460

try:

461

tree = self.working_tree()

462

inv = tree.inventory

463

464

# do this before any modifications

465

for f in files:

466

fid = inv.path2id(f)

467

if not fid:

468

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

469

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

470

if verbose:

471

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

472

if tree.is_ignored(f):

473

new_status = 'I'

474

else:

475

new_status = '?'

476

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

477

del inv[fid]

478

479

self._write_inventory(inv)

480

finally:

481

self.unlock()

482

483

484

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

430

tree = self.working_tree()

431

inv = tree.inventory

432

433

# do this before any modifications

434

for f in files:

435

fid = inv.path2id(f)

436

if not fid:

437

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

438

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

439

if verbose:

440

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

441

if tree.is_ignored(f):

442

new_status = 'I'

443

else:

444

new_status = '?'

445

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

446

del inv[fid]

447

448

self._write_inventory(inv)

449

450

485

451

def set_inventory(self, new_inventory_list):

486

452

inv = Inventory()

487

453

for path, file_id, parent, kind in new_inventory_list:

555

521

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

556

522

557

523

524

@with_readlock

558

525

def revision_history(self):

559

526

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

560

527

561

528

>>> ScratchBranch().revision_history()

562

529

[]

563

530

"""

564

self.lock_read()

565

try:

566

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

567

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

568

finally:

569

self.unlock()

570

571

572

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

573

"""

574

>>> import commit

575

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

576

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

577

True

578

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

579

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

580

1

581

>>> clone = sb.clone()

582

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

583

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

584

2

585

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

586

1

587

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

588

... verbose=False)

589

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

590

1

591

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

592

True

593

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

594

True

595

>>> clone2 = sb.clone()

596

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

597

2

598

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

599

1

600

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

601

1

602

"""

603

my_history = self.revision_history()

604

other_history = other.revision_history()

605

if self_revno is None:

606

self_revno = len(my_history)

607

if other_revno is None:

608

other_revno = len(other_history)

609

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

610

indices.reverse()

611

for r in indices:

612

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

613

return r+1, my_history[r]

614

return None, None

531

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

532

615

533

616

534

def enum_history(self, direction):

617

535

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

654

572

return None

655

573

656

574

657

def missing_revisions(self, other):

658

"""

659

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

660

present in other, but missing from self.

661

662

>>> from bzrlib.commit import commit

663

>>> bzrlib.trace.silent = True

664

>>> br1 = ScratchBranch()

665

>>> br2 = ScratchBranch()

666

>>> br1.missing_revisions(br2)

667

[]

668

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

669

>>> br1.missing_revisions(br2)

670

[u'REVISION-ID-1']

671

>>> br2.missing_revisions(br1)

672

[]

673

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

674

>>> br1.missing_revisions(br2)

675

[]

676

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

677

>>> br1.missing_revisions(br2)

678

[u'REVISION-ID-2A']

679

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

680

>>> br1.missing_revisions(br2)

681

Traceback (most recent call last):

682

DivergedBranches: These branches have diverged.

683

"""

684

self_history = self.revision_history()

685

self_len = len(self_history)

686

other_history = other.revision_history()

687

other_len = len(other_history)

688

common_index = min(self_len, other_len) -1

689

if common_index >= 0 and \

690

self_history[common_index] != other_history[common_index]:

691

raise DivergedBranches(self, other)

692

if self_len < other_len:

693

return other_history[self_len:]

694

return []

695

696

697

def update_revisions(self, other):

698

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

699

revisions in other

700

701

>>> from bzrlib.commit import commit

702

>>> bzrlib.trace.silent = True

703

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

704

>>> br1.add('foo')

705

>>> br1.add('bar')

706

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

707

>>> br2 = ScratchBranch()

708

>>> br2.update_revisions(br1)

709

Added 2 texts.

710

Added 1 inventories.

711

Added 1 revisions.

712

>>> br2.revision_history()

713

[u'REVISION-ID-1']

714

>>> br2.update_revisions(br1)

715

Added 0 texts.

716

Added 0 inventories.

717

Added 0 revisions.

718

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

719

True

720

"""

721

revision_ids = self.missing_revisions(other)

722

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

723

needed_texts = sets.Set()

724

for rev in revisions:

725

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

726

for key, entry in inv.iter_entries():

727

if entry.text_id is None:

728

continue

729

if entry.text_id not in self.text_store:

730

needed_texts.add(entry.text_id)

731

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

732

print "Added %d texts." % count

733

inventory_ids = [ f.inventory_id for f in revisions ]

734

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

735

inventory_ids)

736

print "Added %d inventories." % count

737

revision_ids = [ f.revision_id for f in revisions]

738

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

739

revision_ids)

740

for revision_id in revision_ids:

741

self.append_revision(revision_id)

742

print "Added %d revisions." % count

743

744

745

575

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

746

576

"""Deprecated"""

747

577

from bzrlib.commit import commit

793

623

794

624

795

625

626

@with_writelock

796

627

def rename_one(self, from_rel, to_rel):

797

628

"""Rename one file.

798

629

799

630

This can change the directory or the filename or both.

800

631

"""

801

self.lock_write()

632

tree = self.working_tree()

633

inv = tree.inventory

634

if not tree.has_filename(from_rel):

635

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

636

if tree.has_filename(to_rel):

637

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

638

639

file_id = inv.path2id(from_rel)

640

if file_id == None:

641

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

642

643

if inv.path2id(to_rel):

644

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

645

646

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

647

to_dir_id = inv.path2id(to_dir)

648

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

649

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

650

651

mutter("rename_one:")

652

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

653

mutter(" from_rel %r" % from_rel)

654

mutter(" to_rel %r" % to_rel)

655

mutter(" to_dir %r" % to_dir)

656

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

657

658

inv.rename(file_id, to_dir_id, to_tail)

659

660

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

661

662

from_abs = self.abspath(from_rel)

663

to_abs = self.abspath(to_rel)

802

664

try:

803

tree = self.working_tree()

804

inv = tree.inventory

805

if not tree.has_filename(from_rel):

806

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

807

if tree.has_filename(to_rel):

808

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

809

810

file_id = inv.path2id(from_rel)

811

if file_id == None:

812

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

813

814

if inv.path2id(to_rel):

815

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

816

817

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

818

to_dir_id = inv.path2id(to_dir)

819

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

820

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

821

822

mutter("rename_one:")

823

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

824

mutter(" from_rel %r" % from_rel)

825

mutter(" to_rel %r" % to_rel)

826

mutter(" to_dir %r" % to_dir)

827

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

828

829

inv.rename(file_id, to_dir_id, to_tail)

830

831

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

832

833

from_abs = self.abspath(from_rel)

834

to_abs = self.abspath(to_rel)

835

try:

836

os.rename(from_abs, to_abs)

837

except OSError, e:

838

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

839

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

840

["rename rolled back"])

841

842

self._write_inventory(inv)

843

finally:

844

self.unlock()

845

846

665

os.rename(from_abs, to_abs)

666

except OSError, e:

667

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

668

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

669

["rename rolled back"])

670

671

self._write_inventory(inv)

672

673

674

675

@with_writelock

847

676

def move(self, from_paths, to_name):

848

677

"""Rename files.

849

678

855

684

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

856

685

this doesn't change the directory.

857

686

"""

858

self.lock_write()

859

try:

860

## TODO: Option to move IDs only

861

assert not isinstance(from_paths, basestring)

862

tree = self.working_tree()

863

inv = tree.inventory

864

to_abs = self.abspath(to_name)

865

if not isdir(to_abs):

866

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

867

if not tree.has_filename(to_name):

868

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

869

to_dir_id = inv.path2id(to_name)

870

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

871

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

872

to_dir_ie = inv[to_dir_id]

873

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

874

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

875

876

to_idpath = inv.get_idpath(to_dir_id)

877

878

for f in from_paths:

879

if not tree.has_filename(f):

880

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

881

f_id = inv.path2id(f)

882

if f_id == None:

883

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

884

name_tail = splitpath(f)[-1]

885

dest_path = appendpath(to_name, name_tail)

886

if tree.has_filename(dest_path):

887

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

888

if f_id in to_idpath:

889

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

890

891

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

892

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

893

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

894

895

for f in from_paths:

896

name_tail = splitpath(f)[-1]

897

dest_path = appendpath(to_name, name_tail)

898

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

899

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

900

try:

901

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

902

except OSError, e:

903

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

904

["rename rolled back"])

905

906

self._write_inventory(inv)

907

finally:

908

self.unlock()

687

## TODO: Option to move IDs only

688

assert not isinstance(from_paths, basestring)

689

tree = self.working_tree()

690

inv = tree.inventory

691

to_abs = self.abspath(to_name)

692

if not isdir(to_abs):

693

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

694

if not tree.has_filename(to_name):

695

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

696

to_dir_id = inv.path2id(to_name)

697

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

698

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

699

to_dir_ie = inv[to_dir_id]

700

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

701

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

702

703

to_idpath = inv.get_idpath(to_dir_id)

704

705

for f in from_paths:

706

if not tree.has_filename(f):

707

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

708

f_id = inv.path2id(f)

709

if f_id == None:

710

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

711

name_tail = splitpath(f)[-1]

712

dest_path = appendpath(to_name, name_tail)

713

if tree.has_filename(dest_path):

714

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

715

if f_id in to_idpath:

716

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

717

718

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

719

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

720

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

721

722

for f in from_paths:

723

name_tail = splitpath(f)[-1]

724

dest_path = appendpath(to_name, name_tail)

725

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

726

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

727

try:

728

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

729

except OSError, e:

730

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

731

["rename rolled back"])

732

733

self._write_inventory(inv)

734

909

735

910

736

911

737

920

746

>>> isdir(bd)

921

747

False

922

748

"""

923

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

749

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

924

750

"""Make a test branch.

925

751

926

752

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

927

753

928

754

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

929

755

"""

930

init = False

931

if base is None:

932

base = tempfile.mkdtemp()

933

init = True

934

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

756

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

935

757

for d in dirs:

936

758

os.mkdir(self.abspath(d))

937

759

939

761

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

940

762

941

763

942

def clone(self):

943

"""

944

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

945

>>> clone = orig.clone()

946

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

947

False

948

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

949

True

950

"""

951

base = tempfile.mkdtemp()

952

os.rmdir(base)

953

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

954

return ScratchBranch(base=base)

955

956

764

def __del__(self):

957

765

self.destroy()

958

766

959

767

def destroy(self):

960

768

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

961

769

try:

962

if self.base:

963

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

964

shutil.rmtree(self.base)

770

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

771

shutil.rmtree(self.base)

965

772

except OSError, e:

966

773

# Work around for shutil.rmtree failing on Windows when

967

774

# readonly files are encountered