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

29

joinpath, sha_string, file_kind, local_time_offset, appendpath

30

from store import ImmutableStore

31

from revision import Revision

32

from errors import BzrError

32

from errors import bailout, BzrError

33

from textui import show_status

34

35

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

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

46

76

47

77

48

def find_branch_root(f=None):

104

75

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

105

76

f = head

106

77

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

78

112

79

113

80

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

114

81

# branch objects

115

82

116

class Branch(object):

83

class Branch:

117

84

"""Branch holding a history of revisions.

118

85

119

86

base

120

87

Base directory of the branch.

121

122

_lock_mode

123

None, or 'r' or 'w'

124

125

_lock_count

126

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

127

lock has been taken.

128

129

_lock

130

Lock object from bzrlib.lock.

131

88

"""

132

base = None

133

_lock_mode = None

134

_lock_count = None

135

_lock = None

89

_lockmode = None

136

90

137

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

91

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

138

92

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

139

93

140

94

base -- Base directory for the branch.

157

111

else:

158

112

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

159

113

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

160

from errors import NotBranchError

161

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

162

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

163

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

114

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

115

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

116

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

164

117

self._check_format()

118

self.lock(lock_mode)

165

119

166

120

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

167

121

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

175

129

__repr__ = __str__

176

130

177

131

178

def __del__(self):

179

if self._lock_mode or self._lock:

180

from warnings import warn

181

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

132

133

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

134

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

135

try:

136

import fcntl, errno

137

138

if mode == 'w':

139

lm = fcntl.LOCK_EX

140

om = os.O_WRONLY | os.O_CREAT

141

elif mode == 'r':

142

lm = fcntl.LOCK_SH

143

om = os.O_RDONLY

144

else:

145

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

146

147

try:

148

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

149

except OSError, e:

150

if e.errno == errno.ENOENT:

151

# might not exist on branches from <0.0.4

152

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

153

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

154

else:

155

raise e

215

156

216

def unlock(self):

217

if not self._lock_mode:

218

from errors import LockError

219

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

220

221

if self._lock_count > 1:

222

self._lock_count -= 1

223

else:

224

self._lock.unlock()

225

self._lock = None

226

self._lock_mode = self._lock_count = None

157

fcntl.lockf(lockfile, lm)

158

def unlock():

159

fcntl.lockf(lockfile, fcntl.LOCK_UN)

160

os.close(lockfile)

161

self._lockmode = None

162

self.unlock = unlock

163

self._lockmode = mode

164

except ImportError:

165

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

166

def unlock():

167

self._lockmode = None

168

self.unlock = unlock

169

self._lockmode = mode

170

171

172

def _need_readlock(self):

173

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

174

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

175

176

def _need_writelock(self):

177

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

178

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

227

179

228

180

229

181

def abspath(self, name):

235

187

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

236

188

237

189

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

238

return _relpath(self.base, path)

190

rp = os.path.realpath(path)

191

# FIXME: windows

192

if not rp.startswith(self.base):

193

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

194

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

195

rp = rp.lstrip(os.sep)

196

return rp

239

197

240

198

241

199

def controlfilename(self, file_or_path):

302

260

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

303

261

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

304

262

if fmt != BZR_BRANCH_FORMAT:

305

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

306

['use a different bzr version',

307

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

308

263

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

264

['use a different bzr version',

265

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

309

266

310

267

311

268

def read_working_inventory(self):

312

269

"""Read the working inventory."""

270

self._need_readlock()

313

271

before = time.time()

314

272

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

315

273

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

324

274

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

275

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

276

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

277

return inv

278

325

279

326

280

def _write_inventory(self, inv):

327

281

"""Update the working inventory.

329

283

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

330

284

will be committed to the next revision.

331

285

"""

286

self._need_writelock()

332

287

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

333

288

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

334

289

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

340

295

os.remove(inv_fname)

341

296

os.rename(tmpfname, inv_fname)

342

297

mutter('wrote working inventory')

343

298

344

299

345

300

inventory = property(read_working_inventory, _write_inventory, None,

346

301

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

354

309

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

355

310

recorded by the next commit.

356

311

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

312

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

366

not (yet) exist.

313

not (yet) exist.

367

314

368

315

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

369

is easy to retrieve them if they're needed.

316

is easy to retrieve them if they're needed.

317

318

TODO: Option to specify file id.

370

319

371

320

TODO: Adding a directory should optionally recurse down and

372

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

373

higher-level method.

321

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

322

higher-level method.

374

323

"""

324

self._need_writelock()

325

375

326

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

376

327

# should probably put it back with the previous ID.

377

328

if isinstance(files, types.StringTypes):

384

335

ids = [None] * len(files)

385

336

else:

386

337

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

387

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

423

338

339

inv = self.read_working_inventory()

340

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

341

if is_control_file(f):

342

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

343

344

fp = splitpath(f)

345

346

if len(fp) == 0:

347

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

348

349

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

350

351

try:

352

kind = file_kind(fullpath)

353

except OSError:

354

# maybe something better?

355

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

356

357

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

358

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

359

360

if file_id is None:

361

file_id = gen_file_id(f)

362

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

363

364

if verbose:

365

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

366

367

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

368

369

self._write_inventory(inv)

370

424

371

425

372

def print_file(self, file, revno):

426

373

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

374

self._need_readlock()

375

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

376

# use inventory as it was in that revision

377

file_id = tree.inventory.path2id(file)

378

if not file_id:

379

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

380

tree.print_file(file_id)

381

438

382

439

383

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

440

384

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

452

396

"""

453

397

## TODO: Normalize names

454

398

## TODO: Remove nested loops; better scalability

399

self._need_writelock()

400

455

401

if isinstance(files, types.StringTypes):

456

402

files = [files]

457

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

403

404

tree = self.working_tree()

405

inv = tree.inventory

406

407

# do this before any modifications

408

for f in files:

409

fid = inv.path2id(f)

410

if not fid:

411

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

412

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

413

if verbose:

414

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

415

if tree.is_ignored(f):

416

new_status = 'I'

417

else:

418

new_status = '?'

419

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

420

del inv[fid]

421

422

self._write_inventory(inv)

423

485

424

def set_inventory(self, new_inventory_list):

486

425

inv = Inventory()

487

426

for path, file_id, parent, kind in new_inventory_list:

532

471

533

472

def get_revision(self, revision_id):

534

473

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

474

self._need_readlock()

535

475

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

536

476

assert r.revision_id == revision_id

537

477

return r

543

483

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

544

484

parameter which can be either an integer revno or a

545

485

string hash."""

486

self._need_readlock()

546

487

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

547

488

return i

548

489

549

490

550

491

def get_revision_inventory(self, revision_id):

551

492

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

493

self._need_readlock()

552

494

if revision_id == None:

553

495

return Inventory()

554

496

else:

561

503

>>> ScratchBranch().revision_history()

562

504

[]

563

505

"""

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

506

self._need_readlock()

507

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

508

615

509

616

510

def enum_history(self, direction):

617

511

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

654

548

return None

655

549

656

550

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

551

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

746

552

"""Deprecated"""

747

553

from bzrlib.commit import commit

767

573

an `EmptyTree` is returned."""

768

574

# TODO: refactor this to use an existing revision object

769

575

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

576

self._need_readlock()

770

577

if revision_id == None:

771

578

return EmptyTree()

772

579

else:

798

605

799

606

This can change the directory or the filename or both.

800

607

"""

801

self.lock_write()

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)

638

639

from_abs = self.abspath(from_rel)

640

to_abs = self.abspath(to_rel)

802

641

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

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

845

650

846

651

847

652

def move(self, from_paths, to_name):

855

660

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

856

661

this doesn't change the directory.

857

662

"""

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

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

909

712

910

713

911

714

920

723

>>> isdir(bd)

921

724

False

922

725

"""

923

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

726

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

924

727

"""Make a test branch.

925

728

926

729

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

927

730

928

731

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

929

732

"""

930

init = False

931

if base is None:

932

base = tempfile.mkdtemp()

933

init = True

934

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

733

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

935

734

for d in dirs:

936

735

os.mkdir(self.abspath(d))

937

736

939

738

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

940

739

941

740

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

741

def __del__(self):

957

742

self.destroy()

958

743

959

744

def destroy(self):

960

745

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

961

746

try:

962

if self.base:

963

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

964

shutil.rmtree(self.base)

747

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

748

shutil.rmtree(self.base)

965

749

except OSError, e:

966

750

# Work around for shutil.rmtree failing on Windows when

967

751

# readonly files are encountered