1
# Copyright (C) 2005 Canonical Ltd
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.
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.
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
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
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_file, 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
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
36
## TODO: Maybe include checks for common corruption of newlines, etc?
40
def find_branch(f, **args):
41
if f and (f.startswith('http://') or f.startswith('https://')):
43
return remotebranch.RemoteBranch(f, **args)
45
return Branch(f, **args)
49
def _relpath(base, path):
50
"""Return path relative to base, or raise exception.
52
The path may be either an absolute path or a path relative to the
53
current working directory.
55
Lifted out of Branch.relpath for ease of testing.
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)
64
while len(head) >= len(base):
67
head, tail = os.path.split(head)
71
from errors import NotBranchError
72
raise NotBranchError("path %r is not within branch %r" % (rp, base))
77
def find_branch_root(f=None):
78
"""Find the branch root enclosing f, or pwd.
80
f may be a filename or a URL.
82
It is not necessary that f exists.
84
Basically we keep looking up until we find the control directory or
88
elif hasattr(os.path, 'realpath'):
89
f = os.path.realpath(f)
91
f = os.path.abspath(f)
92
if not os.path.exists(f):
93
raise BzrError('%r does not exist' % f)
99
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
101
head, tail = os.path.split(f)
103
# reached the root, whatever that may be
104
raise BzrError('%r is not in a branch' % orig_f)
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.")
114
class NoSuchRevision(BzrError):
115
def __init__(self, branch, revision):
117
self.revision = revision
118
msg = "Branch %s has no revision %d" % (branch, revision)
119
BzrError.__init__(self, msg)
122
######################################################################
125
class Branch(object):
126
"""Branch holding a history of revisions.
129
Base directory of the branch.
135
If _lock_mode is true, a positive count of the number of times the
139
Lock object from bzrlib.lock.
146
def __init__(self, base, init=False, find_root=True):
147
"""Create new branch object at a particular location.
149
base -- Base directory for the branch.
151
init -- If True, create new control files in a previously
152
unversioned directory. If False, the branch must already
155
find_root -- If true and init is false, find the root of the
156
existing branch containing base.
158
In the test suite, creation of new trees is tested using the
159
`ScratchBranch` class.
162
self.base = os.path.realpath(base)
165
self.base = find_branch_root(base)
167
self.base = os.path.realpath(base)
168
if not isdir(self.controlfilename('.')):
169
from errors import NotBranchError
170
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
171
['use "bzr init" to initialize a new working tree',
172
'current bzr can only operate from top-of-tree'])
175
self.text_store = ImmutableStore(self.controlfilename('text-store'))
176
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
177
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
181
return '%s(%r)' % (self.__class__.__name__, self.base)
188
if self._lock_mode or self._lock:
189
from warnings import warn
190
warn("branch %r was not explicitly unlocked" % self)
195
def lock_write(self):
197
if self._lock_mode != 'w':
198
from errors import LockError
199
raise LockError("can't upgrade to a write lock from %r" %
201
self._lock_count += 1
203
from bzrlib.lock import WriteLock
205
self._lock = WriteLock(self.controlfilename('branch-lock'))
206
self._lock_mode = 'w'
213
assert self._lock_mode in ('r', 'w'), \
214
"invalid lock mode %r" % self._lock_mode
215
self._lock_count += 1
217
from bzrlib.lock import ReadLock
219
self._lock = ReadLock(self.controlfilename('branch-lock'))
220
self._lock_mode = 'r'
226
if not self._lock_mode:
227
from errors import LockError
228
raise LockError('branch %r is not locked' % (self))
230
if self._lock_count > 1:
231
self._lock_count -= 1
235
self._lock_mode = self._lock_count = None
238
def abspath(self, name):
239
"""Return absolute filename for something in the branch"""
240
return os.path.join(self.base, name)
243
def relpath(self, path):
244
"""Return path relative to this branch of something inside it.
246
Raises an error if path is not in this branch."""
247
return _relpath(self.base, path)
250
def controlfilename(self, file_or_path):
251
"""Return location relative to branch."""
252
if isinstance(file_or_path, types.StringTypes):
253
file_or_path = [file_or_path]
254
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
257
def controlfile(self, file_or_path, mode='r'):
258
"""Open a control file for this branch.
260
There are two classes of file in the control directory: text
261
and binary. binary files are untranslated byte streams. Text
262
control files are stored with Unix newlines and in UTF-8, even
263
if the platform or locale defaults are different.
265
Controlfiles should almost never be opened in write mode but
266
rather should be atomically copied and replaced using atomicfile.
269
fn = self.controlfilename(file_or_path)
271
if mode == 'rb' or mode == 'wb':
272
return file(fn, mode)
273
elif mode == 'r' or mode == 'w':
274
# open in binary mode anyhow so there's no newline translation;
275
# codecs uses line buffering by default; don't want that.
277
return codecs.open(fn, mode + 'b', 'utf-8',
280
raise BzrError("invalid controlfile mode %r" % mode)
284
def _make_control(self):
285
os.mkdir(self.controlfilename([]))
286
self.controlfile('README', 'w').write(
287
"This is a Bazaar-NG control directory.\n"
288
"Do not change any files in this directory.\n")
289
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
290
for d in ('text-store', 'inventory-store', 'revision-store'):
291
os.mkdir(self.controlfilename(d))
292
for f in ('revision-history', 'merged-patches',
293
'pending-merged-patches', 'branch-name',
295
self.controlfile(f, 'w').write('')
296
mutter('created control directory in ' + self.base)
297
Inventory().write_xml(self.controlfile('inventory','w'))
300
def _check_format(self):
301
"""Check this branch format is supported.
303
The current tool only supports the current unstable format.
305
In the future, we might need different in-memory Branch
306
classes to support downlevel branches. But not yet.
308
# This ignores newlines so that we can open branches created
309
# on Windows from Linux and so on. I think it might be better
310
# to always make all internal files in unix format.
311
fmt = self.controlfile('branch-format', 'r').read()
312
fmt.replace('\r\n', '')
313
if fmt != BZR_BRANCH_FORMAT:
314
raise BzrError('sorry, branch format %r not supported' % fmt,
315
['use a different bzr version',
316
'or remove the .bzr directory and "bzr init" again'])
320
def read_working_inventory(self):
321
"""Read the working inventory."""
323
# ElementTree does its own conversion from UTF-8, so open in
327
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
328
mutter("loaded inventory of %d items in %f"
329
% (len(inv), time.time() - before))
335
def _write_inventory(self, inv):
336
"""Update the working inventory.
338
That is to say, the inventory describing changes underway, that
339
will be committed to the next revision.
341
## TODO: factor out to atomicfile? is rename safe on windows?
342
## TODO: Maybe some kind of clean/dirty marker on inventory?
343
tmpfname = self.controlfilename('inventory.tmp')
344
tmpf = file(tmpfname, 'wb')
347
inv_fname = self.controlfilename('inventory')
348
if sys.platform == 'win32':
350
os.rename(tmpfname, inv_fname)
351
mutter('wrote working inventory')
354
inventory = property(read_working_inventory, _write_inventory, None,
355
"""Inventory for the working copy.""")
358
def add(self, files, verbose=False, ids=None):
359
"""Make files versioned.
361
Note that the command line normally calls smart_add instead.
363
This puts the files in the Added state, so that they will be
364
recorded by the next commit.
367
List of paths to add, relative to the base of the tree.
370
If set, use these instead of automatically generated ids.
371
Must be the same length as the list of files, but may
372
contain None for ids that are to be autogenerated.
374
TODO: Perhaps have an option to add the ids even if the files do
377
TODO: Perhaps return the ids of the files? But then again it
378
is easy to retrieve them if they're needed.
380
TODO: Adding a directory should optionally recurse down and
381
add all non-ignored children. Perhaps do that in a
384
# TODO: Re-adding a file that is removed in the working copy
385
# should probably put it back with the previous ID.
386
if isinstance(files, types.StringTypes):
387
assert(ids is None or isinstance(ids, types.StringTypes))
393
ids = [None] * len(files)
395
assert(len(ids) == len(files))
399
inv = self.read_working_inventory()
400
for f,file_id in zip(files, ids):
401
if is_control_file(f):
402
raise BzrError("cannot add control file %s" % quotefn(f))
407
raise BzrError("cannot add top-level %r" % f)
409
fullpath = os.path.normpath(self.abspath(f))
412
kind = file_kind(fullpath)
414
# maybe something better?
415
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
417
if kind != 'file' and kind != 'directory':
418
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
421
file_id = gen_file_id(f)
422
inv.add_path(f, kind=kind, file_id=file_id)
425
show_status('A', kind, quotefn(f))
427
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
429
self._write_inventory(inv)
434
def print_file(self, file, revno):
435
"""Print `file` to stdout."""
438
tree = self.revision_tree(self.lookup_revision(revno))
439
# use inventory as it was in that revision
440
file_id = tree.inventory.path2id(file)
442
raise BzrError("%r is not present in revision %d" % (file, revno))
443
tree.print_file(file_id)
448
def remove(self, files, verbose=False):
449
"""Mark nominated files for removal from the inventory.
451
This does not remove their text. This does not run on
453
TODO: Refuse to remove modified files unless --force is given?
455
TODO: Do something useful with directories.
457
TODO: Should this remove the text or not? Tough call; not
458
removing may be useful and the user can just use use rm, and
459
is the opposite of add. Removing it is consistent with most
460
other tools. Maybe an option.
462
## TODO: Normalize names
463
## TODO: Remove nested loops; better scalability
464
if isinstance(files, types.StringTypes):
470
tree = self.working_tree()
473
# do this before any modifications
477
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
478
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
480
# having remove it, it must be either ignored or unknown
481
if tree.is_ignored(f):
485
show_status(new_status, inv[fid].kind, quotefn(f))
488
self._write_inventory(inv)
493
# FIXME: this doesn't need to be a branch method
494
def set_inventory(self, new_inventory_list):
496
for path, file_id, parent, kind in new_inventory_list:
497
name = os.path.basename(path)
500
inv.add(InventoryEntry(file_id, name, kind, parent))
501
self._write_inventory(inv)
505
"""Return all unknown files.
507
These are files in the working directory that are not versioned or
508
control files or ignored.
510
>>> b = ScratchBranch(files=['foo', 'foo~'])
511
>>> list(b.unknowns())
514
>>> list(b.unknowns())
517
>>> list(b.unknowns())
520
return self.working_tree().unknowns()
523
def append_revision(self, revision_id):
524
mutter("add {%s} to revision-history" % revision_id)
525
rev_history = self.revision_history()
527
tmprhname = self.controlfilename('revision-history.tmp')
528
rhname = self.controlfilename('revision-history')
530
f = file(tmprhname, 'wt')
531
rev_history.append(revision_id)
532
f.write('\n'.join(rev_history))
536
if sys.platform == 'win32':
538
os.rename(tmprhname, rhname)
542
def get_revision(self, revision_id):
543
"""Return the Revision object for a named revision"""
544
if not revision_id or not isinstance(revision_id, basestring):
545
raise ValueError('invalid revision-id: %r' % revision_id)
546
r = Revision.read_xml(self.revision_store[revision_id])
547
assert r.revision_id == revision_id
550
def get_revision_sha1(self, revision_id):
551
"""Hash the stored value of a revision, and return it."""
552
# In the future, revision entries will be signed. At that
553
# point, it is probably best *not* to include the signature
554
# in the revision hash. Because that lets you re-sign
555
# the revision, (add signatures/remove signatures) and still
556
# have all hash pointers stay consistent.
557
# But for now, just hash the contents.
558
return sha_file(self.revision_store[revision_id])
561
def get_inventory(self, inventory_id):
562
"""Get Inventory object by hash.
564
TODO: Perhaps for this and similar methods, take a revision
565
parameter which can be either an integer revno or a
567
i = Inventory.read_xml(self.inventory_store[inventory_id])
570
def get_inventory_sha1(self, inventory_id):
571
"""Return the sha1 hash of the inventory entry
573
return sha_file(self.inventory_store[inventory_id])
576
def get_revision_inventory(self, revision_id):
577
"""Return inventory of a past revision."""
578
if revision_id == None:
581
return self.get_inventory(self.get_revision(revision_id).inventory_id)
584
def revision_history(self):
585
"""Return sequence of revision hashes on to this branch.
587
>>> ScratchBranch().revision_history()
592
return [l.rstrip('\r\n') for l in
593
self.controlfile('revision-history', 'r').readlines()]
598
def common_ancestor(self, other, self_revno=None, other_revno=None):
601
>>> sb = ScratchBranch(files=['foo', 'foo~'])
602
>>> sb.common_ancestor(sb) == (None, None)
604
>>> commit.commit(sb, "Committing first revision", verbose=False)
605
>>> sb.common_ancestor(sb)[0]
607
>>> clone = sb.clone()
608
>>> commit.commit(sb, "Committing second revision", verbose=False)
609
>>> sb.common_ancestor(sb)[0]
611
>>> sb.common_ancestor(clone)[0]
613
>>> commit.commit(clone, "Committing divergent second revision",
615
>>> sb.common_ancestor(clone)[0]
617
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
619
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
621
>>> clone2 = sb.clone()
622
>>> sb.common_ancestor(clone2)[0]
624
>>> sb.common_ancestor(clone2, self_revno=1)[0]
626
>>> sb.common_ancestor(clone2, other_revno=1)[0]
629
my_history = self.revision_history()
630
other_history = other.revision_history()
631
if self_revno is None:
632
self_revno = len(my_history)
633
if other_revno is None:
634
other_revno = len(other_history)
635
indices = range(min((self_revno, other_revno)))
638
if my_history[r] == other_history[r]:
639
return r+1, my_history[r]
642
def enum_history(self, direction):
643
"""Return (revno, revision_id) for history of branch.
646
'forward' is from earliest to latest
647
'reverse' is from latest to earliest
649
rh = self.revision_history()
650
if direction == 'forward':
655
elif direction == 'reverse':
661
raise ValueError('invalid history direction', direction)
665
"""Return current revision number for this branch.
667
That is equivalent to the number of revisions committed to
670
return len(self.revision_history())
673
def last_patch(self):
674
"""Return last patch hash, or None if no history.
676
ph = self.revision_history()
683
def missing_revisions(self, other, stop_revision=None):
685
If self and other have not diverged, return a list of the revisions
686
present in other, but missing from self.
688
>>> from bzrlib.commit import commit
689
>>> bzrlib.trace.silent = True
690
>>> br1 = ScratchBranch()
691
>>> br2 = ScratchBranch()
692
>>> br1.missing_revisions(br2)
694
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
695
>>> br1.missing_revisions(br2)
697
>>> br2.missing_revisions(br1)
699
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
700
>>> br1.missing_revisions(br2)
702
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
703
>>> br1.missing_revisions(br2)
705
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
706
>>> br1.missing_revisions(br2)
707
Traceback (most recent call last):
708
DivergedBranches: These branches have diverged.
710
self_history = self.revision_history()
711
self_len = len(self_history)
712
other_history = other.revision_history()
713
other_len = len(other_history)
714
common_index = min(self_len, other_len) -1
715
if common_index >= 0 and \
716
self_history[common_index] != other_history[common_index]:
717
raise DivergedBranches(self, other)
719
if stop_revision is None:
720
stop_revision = other_len
721
elif stop_revision > other_len:
722
raise NoSuchRevision(self, stop_revision)
724
return other_history[self_len:stop_revision]
727
def update_revisions(self, other, stop_revision=None):
728
"""Pull in all new revisions from other branch.
730
>>> from bzrlib.commit import commit
731
>>> bzrlib.trace.silent = True
732
>>> br1 = ScratchBranch(files=['foo', 'bar'])
735
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
736
>>> br2 = ScratchBranch()
737
>>> br2.update_revisions(br1)
741
>>> br2.revision_history()
743
>>> br2.update_revisions(br1)
747
>>> br1.text_store.total_size() == br2.text_store.total_size()
750
from bzrlib.progress import ProgressBar
754
pb.update('comparing histories')
755
revision_ids = self.missing_revisions(other, stop_revision)
757
needed_texts = sets.Set()
759
for rev_id in revision_ids:
761
pb.update('fetching revision', i, len(revision_ids))
762
rev = other.get_revision(rev_id)
763
revisions.append(rev)
764
inv = other.get_inventory(str(rev.inventory_id))
765
for key, entry in inv.iter_entries():
766
if entry.text_id is None:
768
if entry.text_id not in self.text_store:
769
needed_texts.add(entry.text_id)
773
count = self.text_store.copy_multi(other.text_store, needed_texts)
774
print "Added %d texts." % count
775
inventory_ids = [ f.inventory_id for f in revisions ]
776
count = self.inventory_store.copy_multi(other.inventory_store,
778
print "Added %d inventories." % count
779
revision_ids = [ f.revision_id for f in revisions]
780
count = self.revision_store.copy_multi(other.revision_store,
782
for revision_id in revision_ids:
783
self.append_revision(revision_id)
784
print "Added %d revisions." % count
787
def commit(self, *args, **kw):
789
from bzrlib.commit import commit
790
commit(self, *args, **kw)
793
def lookup_revision(self, revno):
794
"""Return revision hash for revision number."""
799
# list is 0-based; revisions are 1-based
800
return self.revision_history()[revno-1]
802
raise BzrError("no such revision %s" % revno)
805
def revision_tree(self, revision_id):
806
"""Return Tree for a revision on this branch.
808
`revision_id` may be None for the null revision, in which case
809
an `EmptyTree` is returned."""
810
# TODO: refactor this to use an existing revision object
811
# so we don't need to read it in twice.
812
if revision_id == None:
815
inv = self.get_revision_inventory(revision_id)
816
return RevisionTree(self.text_store, inv)
819
def working_tree(self):
820
"""Return a `Tree` for the working copy."""
821
from workingtree import WorkingTree
822
return WorkingTree(self.base, self.read_working_inventory())
825
def basis_tree(self):
826
"""Return `Tree` object for last revision.
828
If there are no revisions yet, return an `EmptyTree`.
830
r = self.last_patch()
834
return RevisionTree(self.text_store, self.get_revision_inventory(r))
838
def rename_one(self, from_rel, to_rel):
841
This can change the directory or the filename or both.
845
tree = self.working_tree()
847
if not tree.has_filename(from_rel):
848
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
849
if tree.has_filename(to_rel):
850
raise BzrError("can't rename: new working file %r already exists" % to_rel)
852
file_id = inv.path2id(from_rel)
854
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
856
if inv.path2id(to_rel):
857
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
859
to_dir, to_tail = os.path.split(to_rel)
860
to_dir_id = inv.path2id(to_dir)
861
if to_dir_id == None and to_dir != '':
862
raise BzrError("can't determine destination directory id for %r" % to_dir)
864
mutter("rename_one:")
865
mutter(" file_id {%s}" % file_id)
866
mutter(" from_rel %r" % from_rel)
867
mutter(" to_rel %r" % to_rel)
868
mutter(" to_dir %r" % to_dir)
869
mutter(" to_dir_id {%s}" % to_dir_id)
871
inv.rename(file_id, to_dir_id, to_tail)
873
print "%s => %s" % (from_rel, to_rel)
875
from_abs = self.abspath(from_rel)
876
to_abs = self.abspath(to_rel)
878
os.rename(from_abs, to_abs)
880
raise BzrError("failed to rename %r to %r: %s"
881
% (from_abs, to_abs, e[1]),
882
["rename rolled back"])
884
self._write_inventory(inv)
889
def move(self, from_paths, to_name):
892
to_name must exist as a versioned directory.
894
If to_name exists and is a directory, the files are moved into
895
it, keeping their old names. If it is a directory,
897
Note that to_name is only the last component of the new name;
898
this doesn't change the directory.
902
## TODO: Option to move IDs only
903
assert not isinstance(from_paths, basestring)
904
tree = self.working_tree()
906
to_abs = self.abspath(to_name)
907
if not isdir(to_abs):
908
raise BzrError("destination %r is not a directory" % to_abs)
909
if not tree.has_filename(to_name):
910
raise BzrError("destination %r not in working directory" % to_abs)
911
to_dir_id = inv.path2id(to_name)
912
if to_dir_id == None and to_name != '':
913
raise BzrError("destination %r is not a versioned directory" % to_name)
914
to_dir_ie = inv[to_dir_id]
915
if to_dir_ie.kind not in ('directory', 'root_directory'):
916
raise BzrError("destination %r is not a directory" % to_abs)
918
to_idpath = inv.get_idpath(to_dir_id)
921
if not tree.has_filename(f):
922
raise BzrError("%r does not exist in working tree" % f)
923
f_id = inv.path2id(f)
925
raise BzrError("%r is not versioned" % f)
926
name_tail = splitpath(f)[-1]
927
dest_path = appendpath(to_name, name_tail)
928
if tree.has_filename(dest_path):
929
raise BzrError("destination %r already exists" % dest_path)
930
if f_id in to_idpath:
931
raise BzrError("can't move %r to a subdirectory of itself" % f)
933
# OK, so there's a race here, it's possible that someone will
934
# create a file in this interval and then the rename might be
935
# left half-done. But we should have caught most problems.
938
name_tail = splitpath(f)[-1]
939
dest_path = appendpath(to_name, name_tail)
940
print "%s => %s" % (f, dest_path)
941
inv.rename(inv.path2id(f), to_dir_id, name_tail)
943
os.rename(self.abspath(f), self.abspath(dest_path))
945
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
946
["rename rolled back"])
948
self._write_inventory(inv)
954
class ScratchBranch(Branch):
955
"""Special test class: a branch that cleans up after itself.
957
>>> b = ScratchBranch()
965
def __init__(self, files=[], dirs=[], base=None):
966
"""Make a test branch.
968
This creates a temporary directory and runs init-tree in it.
970
If any files are listed, they are created in the working copy.
974
base = tempfile.mkdtemp()
976
Branch.__init__(self, base, init=init)
978
os.mkdir(self.abspath(d))
981
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
986
>>> orig = ScratchBranch(files=["file1", "file2"])
987
>>> clone = orig.clone()
988
>>> os.path.samefile(orig.base, clone.base)
990
>>> os.path.isfile(os.path.join(clone.base, "file1"))
993
base = tempfile.mkdtemp()
995
shutil.copytree(self.base, base, symlinks=True)
996
return ScratchBranch(base=base)
1002
"""Destroy the test branch, removing the scratch directory."""
1005
mutter("delete ScratchBranch %s" % self.base)
1006
shutil.rmtree(self.base)
1008
# Work around for shutil.rmtree failing on Windows when
1009
# readonly files are encountered
1010
mutter("hit exception in destroying ScratchBranch: %s" % e)
1011
for root, dirs, files in os.walk(self.base, topdown=False):
1013
os.chmod(os.path.join(root, name), 0700)
1014
shutil.rmtree(self.base)
1019
######################################################################
1023
def is_control_file(filename):
1024
## FIXME: better check
1025
filename = os.path.normpath(filename)
1026
while filename != '':
1027
head, tail = os.path.split(filename)
1028
## mutter('check %r for control file' % ((head, tail), ))
1029
if tail == bzrlib.BZRDIR:
1031
if filename == head:
1038
def gen_file_id(name):
1039
"""Return new file id.
1041
This should probably generate proper UUIDs, but for the moment we
1042
cope with just randomness because running uuidgen every time is
1046
# get last component
1047
idx = name.rfind('/')
1049
name = name[idx+1 : ]
1050
idx = name.rfind('\\')
1052
name = name[idx+1 : ]
1054
# make it not a hidden file
1055
name = name.lstrip('.')
1057
# remove any wierd characters; we don't escape them but rather
1058
# just pull them out
1059
name = re.sub(r'[^\w.]', '', name)
1061
s = hexlify(rand_bytes(8))
1062
return '-'.join((name, compact_date(time.time()), s))
added
removed
bzrlib/branch.py
