To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 0.200.1036
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.1036
- Committer: Jelmer Vernooij
- Date: 2010-09-11 17:48:45 UTC
- mto: (0.312.1 master) (6883.23.1 bundle-git)
- mto: This revision was merged to the branch mainline in revision 6960.
- Revision ID: jelmer@samba.org-20100911174845-ro06bb6gg6ws8jit
More work on roundtrip push support.
- files added:
- .bzrignore
- notes
- tests
- files removed:
- .bzrignore
- bzrlib
- contrib
- contrib/bash
- contrib/zsh
- doc
- elementtree
- notes
- patches
- urlgrabber
added
removed
bzrlib/branch.py
1
# Copyright (C) 2005 Canonical Ltd
2
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
12
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
18
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
import traceback, socket, fnmatch, difflib, time
20
from binascii import hexlify
21
22
import bzrlib
23
from inventory import Inventory
24
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
26
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
28
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
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
33
from textui import show_status
34
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
36
## TODO: Maybe include checks for common corruption of newlines, etc?
37
38
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
77
def find_branch_root(f=None):
78
"""Find the branch root enclosing f, or pwd.
79
80
f may be a filename or a URL.
81
82
It is not necessary that f exists.
83
84
Basically we keep looking up until we find the control directory or
85
run into the root."""
86
if f == None:
87
f = os.getcwd()
88
elif hasattr(os.path, 'realpath'):
89
f = os.path.realpath(f)
90
else:
91
f = os.path.abspath(f)
92
if not os.path.exists(f):
93
raise BzrError('%r does not exist' % f)
94
95
96
orig_f = f
97
98
while True:
99
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
100
return f
101
head, tail = os.path.split(f)
102
if head == f:
103
# reached the root, whatever that may be
104
raise BzrError('%r is not in a branch' % orig_f)
105
f = head
106
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.")
112
113
######################################################################
114
# branch objects
115
116
class Branch(object):
117
"""Branch holding a history of revisions.
118
119
base
120
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
"""
132
base = None
133
_lock_mode = None
134
_lock_count = None
135
_lock = None
136
137
def __init__(self, base, init=False, find_root=True):
138
"""Create new branch object at a particular location.
139
140
base -- Base directory for the branch.
141
142
init -- If True, create new control files in a previously
143
unversioned directory. If False, the branch must already
144
be versioned.
145
146
find_root -- If true and init is false, find the root of the
147
existing branch containing base.
148
149
In the test suite, creation of new trees is tested using the
150
`ScratchBranch` class.
151
"""
152
if init:
153
self.base = os.path.realpath(base)
154
self._make_control()
155
elif find_root:
156
self.base = find_branch_root(base)
157
else:
158
self.base = os.path.realpath(base)
159
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'])
164
self._check_format()
165
166
self.text_store = ImmutableStore(self.controlfilename('text-store'))
167
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
168
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
169
170
171
def __str__(self):
172
return '%s(%r)' % (self.__class__.__name__, self.base)
173
174
175
__repr__ = __str__
176
177
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
215
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
227
228
229
def abspath(self, name):
230
"""Return absolute filename for something in the branch"""
231
return os.path.join(self.base, name)
232
233
234
def relpath(self, path):
235
"""Return path relative to this branch of something inside it.
236
237
Raises an error if path is not in this branch."""
238
return _relpath(self.base, path)
239
240
241
def controlfilename(self, file_or_path):
242
"""Return location relative to branch."""
243
if isinstance(file_or_path, types.StringTypes):
244
file_or_path = [file_or_path]
245
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
246
247
248
def controlfile(self, file_or_path, mode='r'):
249
"""Open a control file for this branch.
250
251
There are two classes of file in the control directory: text
252
and binary. binary files are untranslated byte streams. Text
253
control files are stored with Unix newlines and in UTF-8, even
254
if the platform or locale defaults are different.
255
256
Controlfiles should almost never be opened in write mode but
257
rather should be atomically copied and replaced using atomicfile.
258
"""
259
260
fn = self.controlfilename(file_or_path)
261
262
if mode == 'rb' or mode == 'wb':
263
return file(fn, mode)
264
elif mode == 'r' or mode == 'w':
265
# open in binary mode anyhow so there's no newline translation;
266
# codecs uses line buffering by default; don't want that.
267
import codecs
268
return codecs.open(fn, mode + 'b', 'utf-8',
269
buffering=60000)
270
else:
271
raise BzrError("invalid controlfile mode %r" % mode)
272
273
274
275
def _make_control(self):
276
os.mkdir(self.controlfilename([]))
277
self.controlfile('README', 'w').write(
278
"This is a Bazaar-NG control directory.\n"
279
"Do not change any files in this directory.")
280
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
281
for d in ('text-store', 'inventory-store', 'revision-store'):
282
os.mkdir(self.controlfilename(d))
283
for f in ('revision-history', 'merged-patches',
284
'pending-merged-patches', 'branch-name',
285
'branch-lock'):
286
self.controlfile(f, 'w').write('')
287
mutter('created control directory in ' + self.base)
288
Inventory().write_xml(self.controlfile('inventory','w'))
289
290
291
def _check_format(self):
292
"""Check this branch format is supported.
293
294
The current tool only supports the current unstable format.
295
296
In the future, we might need different in-memory Branch
297
classes to support downlevel branches. But not yet.
298
"""
299
# This ignores newlines so that we can open branches created
300
# on Windows from Linux and so on. I think it might be better
301
# to always make all internal files in unix format.
302
fmt = self.controlfile('branch-format', 'r').read()
303
fmt.replace('\r\n', '')
304
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
309
310
311
def read_working_inventory(self):
312
"""Read the working inventory."""
313
before = time.time()
314
# ElementTree does its own conversion from UTF-8, so open in
315
# 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
325
326
def _write_inventory(self, inv):
327
"""Update the working inventory.
328
329
That is to say, the inventory describing changes underway, that
330
will be committed to the next revision.
331
"""
332
## TODO: factor out to atomicfile? is rename safe on windows?
333
## TODO: Maybe some kind of clean/dirty marker on inventory?
334
tmpfname = self.controlfilename('inventory.tmp')
335
tmpf = file(tmpfname, 'wb')
336
inv.write_xml(tmpf)
337
tmpf.close()
338
inv_fname = self.controlfilename('inventory')
339
if sys.platform == 'win32':
340
os.remove(inv_fname)
341
os.rename(tmpfname, inv_fname)
342
mutter('wrote working inventory')
343
344
345
inventory = property(read_working_inventory, _write_inventory, None,
346
"""Inventory for the working copy.""")
347
348
349
def add(self, files, verbose=False, ids=None):
350
"""Make files versioned.
351
352
Note that the command line normally calls smart_add instead.
353
354
This puts the files in the Added state, so that they will be
355
recorded by the next commit.
356
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
TODO: Perhaps have an option to add the ids even if the files do
366
not (yet) exist.
367
368
TODO: Perhaps return the ids of the files? But then again it
369
is easy to retrieve them if they're needed.
370
371
TODO: Adding a directory should optionally recurse down and
372
add all non-ignored children. Perhaps do that in a
373
higher-level method.
374
"""
375
# TODO: Re-adding a file that is removed in the working copy
376
# should probably put it back with the previous ID.
377
if isinstance(files, types.StringTypes):
378
assert(ids is None or isinstance(ids, types.StringTypes))
379
files = [files]
380
if ids is not None:
381
ids = [ids]
382
383
if ids is None:
384
ids = [None] * len(files)
385
else:
386
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
424
425
def print_file(self, file, revno):
426
"""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
439
def remove(self, files, verbose=False):
440
"""Mark nominated files for removal from the inventory.
441
442
This does not remove their text. This does not run on
443
444
TODO: Refuse to remove modified files unless --force is given?
445
446
TODO: Do something useful with directories.
447
448
TODO: Should this remove the text or not? Tough call; not
449
removing may be useful and the user can just use use rm, and
450
is the opposite of add. Removing it is consistent with most
451
other tools. Maybe an option.
452
"""
453
## TODO: Normalize names
454
## TODO: Remove nested loops; better scalability
455
if isinstance(files, types.StringTypes):
456
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
485
def set_inventory(self, new_inventory_list):
486
inv = Inventory()
487
for path, file_id, parent, kind in new_inventory_list:
488
name = os.path.basename(path)
489
if name == "":
490
continue
491
inv.add(InventoryEntry(file_id, name, kind, parent))
492
self._write_inventory(inv)
493
494
495
def unknowns(self):
496
"""Return all unknown files.
497
498
These are files in the working directory that are not versioned or
499
control files or ignored.
500
501
>>> b = ScratchBranch(files=['foo', 'foo~'])
502
>>> list(b.unknowns())
503
['foo']
504
>>> b.add('foo')
505
>>> list(b.unknowns())
506
[]
507
>>> b.remove('foo')
508
>>> list(b.unknowns())
509
['foo']
510
"""
511
return self.working_tree().unknowns()
512
513
514
def append_revision(self, revision_id):
515
mutter("add {%s} to revision-history" % revision_id)
516
rev_history = self.revision_history()
517
518
tmprhname = self.controlfilename('revision-history.tmp')
519
rhname = self.controlfilename('revision-history')
520
521
f = file(tmprhname, 'wt')
522
rev_history.append(revision_id)
523
f.write('\n'.join(rev_history))
524
f.write('\n')
525
f.close()
526
527
if sys.platform == 'win32':
528
os.remove(rhname)
529
os.rename(tmprhname, rhname)
530
531
532
533
def get_revision(self, revision_id):
534
"""Return the Revision object for a named revision"""
535
r = Revision.read_xml(self.revision_store[revision_id])
536
assert r.revision_id == revision_id
537
return r
538
539
540
def get_inventory(self, inventory_id):
541
"""Get Inventory object by hash.
542
543
TODO: Perhaps for this and similar methods, take a revision
544
parameter which can be either an integer revno or a
545
string hash."""
546
i = Inventory.read_xml(self.inventory_store[inventory_id])
547
return i
548
549
550
def get_revision_inventory(self, revision_id):
551
"""Return inventory of a past revision."""
552
if revision_id == None:
553
return Inventory()
554
else:
555
return self.get_inventory(self.get_revision(revision_id).inventory_id)
556
557
558
def revision_history(self):
559
"""Return sequence of revision hashes on to this branch.
560
561
>>> ScratchBranch().revision_history()
562
[]
563
"""
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
615
616
def enum_history(self, direction):
617
"""Return (revno, revision_id) for history of branch.
618
619
direction
620
'forward' is from earliest to latest
621
'reverse' is from latest to earliest
622
"""
623
rh = self.revision_history()
624
if direction == 'forward':
625
i = 1
626
for rid in rh:
627
yield i, rid
628
i += 1
629
elif direction == 'reverse':
630
i = len(rh)
631
while i > 0:
632
yield i, rh[i-1]
633
i -= 1
634
else:
635
raise ValueError('invalid history direction', direction)
636
637
638
def revno(self):
639
"""Return current revision number for this branch.
640
641
That is equivalent to the number of revisions committed to
642
this branch.
643
"""
644
return len(self.revision_history())
645
646
647
def last_patch(self):
648
"""Return last patch hash, or None if no history.
649
"""
650
ph = self.revision_history()
651
if ph:
652
return ph[-1]
653
else:
654
return None
655
656
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
"""Pull in all new revisions from other branch.
699
700
>>> from bzrlib.commit import commit
701
>>> bzrlib.trace.silent = True
702
>>> br1 = ScratchBranch(files=['foo', 'bar'])
703
>>> br1.add('foo')
704
>>> br1.add('bar')
705
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
706
>>> br2 = ScratchBranch()
707
>>> br2.update_revisions(br1)
708
Added 2 texts.
709
Added 1 inventories.
710
Added 1 revisions.
711
>>> br2.revision_history()
712
[u'REVISION-ID-1']
713
>>> br2.update_revisions(br1)
714
Added 0 texts.
715
Added 0 inventories.
716
Added 0 revisions.
717
>>> br1.text_store.total_size() == br2.text_store.total_size()
718
True
719
"""
720
revision_ids = self.missing_revisions(other)
721
revisions = [other.get_revision(f) for f in revision_ids]
722
needed_texts = sets.Set()
723
for rev in revisions:
724
inv = other.get_inventory(str(rev.inventory_id))
725
for key, entry in inv.iter_entries():
726
if entry.text_id is None:
727
continue
728
if entry.text_id not in self.text_store:
729
needed_texts.add(entry.text_id)
730
count = self.text_store.copy_multi(other.text_store, needed_texts)
731
print "Added %d texts." % count
732
inventory_ids = [ f.inventory_id for f in revisions ]
733
count = self.inventory_store.copy_multi(other.inventory_store,
734
inventory_ids)
735
print "Added %d inventories." % count
736
revision_ids = [ f.revision_id for f in revisions]
737
count = self.revision_store.copy_multi(other.revision_store,
738
revision_ids)
739
for revision_id in revision_ids:
740
self.append_revision(revision_id)
741
print "Added %d revisions." % count
742
743
744
def commit(self, *args, **kw):
745
"""Deprecated"""
746
from bzrlib.commit import commit
747
commit(self, *args, **kw)
748
749
750
def lookup_revision(self, revno):
751
"""Return revision hash for revision number."""
752
if revno == 0:
753
return None
754
755
try:
756
# list is 0-based; revisions are 1-based
757
return self.revision_history()[revno-1]
758
except IndexError:
759
raise BzrError("no such revision %s" % revno)
760
761
762
def revision_tree(self, revision_id):
763
"""Return Tree for a revision on this branch.
764
765
`revision_id` may be None for the null revision, in which case
766
an `EmptyTree` is returned."""
767
# TODO: refactor this to use an existing revision object
768
# so we don't need to read it in twice.
769
if revision_id == None:
770
return EmptyTree()
771
else:
772
inv = self.get_revision_inventory(revision_id)
773
return RevisionTree(self.text_store, inv)
774
775
776
def working_tree(self):
777
"""Return a `Tree` for the working copy."""
778
from workingtree import WorkingTree
779
return WorkingTree(self.base, self.read_working_inventory())
780
781
782
def basis_tree(self):
783
"""Return `Tree` object for last revision.
784
785
If there are no revisions yet, return an `EmptyTree`.
786
"""
787
r = self.last_patch()
788
if r == None:
789
return EmptyTree()
790
else:
791
return RevisionTree(self.text_store, self.get_revision_inventory(r))
792
793
794
795
def rename_one(self, from_rel, to_rel):
796
"""Rename one file.
797
798
This can change the directory or the filename or both.
799
"""
800
self.lock_write()
801
try:
802
tree = self.working_tree()
803
inv = tree.inventory
804
if not tree.has_filename(from_rel):
805
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
806
if tree.has_filename(to_rel):
807
raise BzrError("can't rename: new working file %r already exists" % to_rel)
808
809
file_id = inv.path2id(from_rel)
810
if file_id == None:
811
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
812
813
if inv.path2id(to_rel):
814
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
815
816
to_dir, to_tail = os.path.split(to_rel)
817
to_dir_id = inv.path2id(to_dir)
818
if to_dir_id == None and to_dir != '':
819
raise BzrError("can't determine destination directory id for %r" % to_dir)
820
821
mutter("rename_one:")
822
mutter(" file_id {%s}" % file_id)
823
mutter(" from_rel %r" % from_rel)
824
mutter(" to_rel %r" % to_rel)
825
mutter(" to_dir %r" % to_dir)
826
mutter(" to_dir_id {%s}" % to_dir_id)
827
828
inv.rename(file_id, to_dir_id, to_tail)
829
830
print "%s => %s" % (from_rel, to_rel)
831
832
from_abs = self.abspath(from_rel)
833
to_abs = self.abspath(to_rel)
834
try:
835
os.rename(from_abs, to_abs)
836
except OSError, e:
837
raise BzrError("failed to rename %r to %r: %s"
838
% (from_abs, to_abs, e[1]),
839
["rename rolled back"])
840
841
self._write_inventory(inv)
842
finally:
843
self.unlock()
844
845
846
def move(self, from_paths, to_name):
847
"""Rename files.
848
849
to_name must exist as a versioned directory.
850
851
If to_name exists and is a directory, the files are moved into
852
it, keeping their old names. If it is a directory,
853
854
Note that to_name is only the last component of the new name;
855
this doesn't change the directory.
856
"""
857
self.lock_write()
858
try:
859
## TODO: Option to move IDs only
860
assert not isinstance(from_paths, basestring)
861
tree = self.working_tree()
862
inv = tree.inventory
863
to_abs = self.abspath(to_name)
864
if not isdir(to_abs):
865
raise BzrError("destination %r is not a directory" % to_abs)
866
if not tree.has_filename(to_name):
867
raise BzrError("destination %r not in working directory" % to_abs)
868
to_dir_id = inv.path2id(to_name)
869
if to_dir_id == None and to_name != '':
870
raise BzrError("destination %r is not a versioned directory" % to_name)
871
to_dir_ie = inv[to_dir_id]
872
if to_dir_ie.kind not in ('directory', 'root_directory'):
873
raise BzrError("destination %r is not a directory" % to_abs)
874
875
to_idpath = inv.get_idpath(to_dir_id)
876
877
for f in from_paths:
878
if not tree.has_filename(f):
879
raise BzrError("%r does not exist in working tree" % f)
880
f_id = inv.path2id(f)
881
if f_id == None:
882
raise BzrError("%r is not versioned" % f)
883
name_tail = splitpath(f)[-1]
884
dest_path = appendpath(to_name, name_tail)
885
if tree.has_filename(dest_path):
886
raise BzrError("destination %r already exists" % dest_path)
887
if f_id in to_idpath:
888
raise BzrError("can't move %r to a subdirectory of itself" % f)
889
890
# OK, so there's a race here, it's possible that someone will
891
# create a file in this interval and then the rename might be
892
# left half-done. But we should have caught most problems.
893
894
for f in from_paths:
895
name_tail = splitpath(f)[-1]
896
dest_path = appendpath(to_name, name_tail)
897
print "%s => %s" % (f, dest_path)
898
inv.rename(inv.path2id(f), to_dir_id, name_tail)
899
try:
900
os.rename(self.abspath(f), self.abspath(dest_path))
901
except OSError, e:
902
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
903
["rename rolled back"])
904
905
self._write_inventory(inv)
906
finally:
907
self.unlock()
908
909
910
911
class ScratchBranch(Branch):
912
"""Special test class: a branch that cleans up after itself.
913
914
>>> b = ScratchBranch()
915
>>> isdir(b.base)
916
True
917
>>> bd = b.base
918
>>> b.destroy()
919
>>> isdir(bd)
920
False
921
"""
922
def __init__(self, files=[], dirs=[], base=None):
923
"""Make a test branch.
924
925
This creates a temporary directory and runs init-tree in it.
926
927
If any files are listed, they are created in the working copy.
928
"""
929
init = False
930
if base is None:
931
base = tempfile.mkdtemp()
932
init = True
933
Branch.__init__(self, base, init=init)
934
for d in dirs:
935
os.mkdir(self.abspath(d))
936
937
for f in files:
938
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
939
940
941
def clone(self):
942
"""
943
>>> orig = ScratchBranch(files=["file1", "file2"])
944
>>> clone = orig.clone()
945
>>> os.path.samefile(orig.base, clone.base)
946
False
947
>>> os.path.isfile(os.path.join(clone.base, "file1"))
948
True
949
"""
950
base = tempfile.mkdtemp()
951
os.rmdir(base)
952
shutil.copytree(self.base, base, symlinks=True)
953
return ScratchBranch(base=base)
954
955
def __del__(self):
956
self.destroy()
957
958
def destroy(self):
959
"""Destroy the test branch, removing the scratch directory."""
960
try:
961
if self.base:
962
mutter("delete ScratchBranch %s" % self.base)
963
shutil.rmtree(self.base)
964
except OSError, e:
965
# Work around for shutil.rmtree failing on Windows when
966
# readonly files are encountered
967
mutter("hit exception in destroying ScratchBranch: %s" % e)
968
for root, dirs, files in os.walk(self.base, topdown=False):
969
for name in files:
970
os.chmod(os.path.join(root, name), 0700)
971
shutil.rmtree(self.base)
972
self.base = None
973
974
975
976
######################################################################
977
# predicates
978
979
980
def is_control_file(filename):
981
## FIXME: better check
982
filename = os.path.normpath(filename)
983
while filename != '':
984
head, tail = os.path.split(filename)
985
## mutter('check %r for control file' % ((head, tail), ))
986
if tail == bzrlib.BZRDIR:
987
return True
988
if filename == head:
989
break
990
filename = head
991
return False
992
993
994
995
def gen_file_id(name):
996
"""Return new file id.
997
998
This should probably generate proper UUIDs, but for the moment we
999
cope with just randomness because running uuidgen every time is
1000
slow."""
1001
import re
1002
1003
# get last component
1004
idx = name.rfind('/')
1005
if idx != -1:
1006
name = name[idx+1 : ]
1007
idx = name.rfind('\\')
1008
if idx != -1:
1009
name = name[idx+1 : ]
1010
1011
# make it not a hidden file
1012
name = name.lstrip('.')
1013
1014
# remove any wierd characters; we don't escape them but rather
1015
# just pull them out
1016
name = re.sub(r'[^\w.]', '', name)
1017
1018
s = hexlify(rand_bytes(8))
1019
return '-'.join((name, compact_date(time.time()), s))
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0