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
20
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
21
import traceback, socket, fnmatch, difflib, time
22
from binascii import hexlify
25
from inventory import Inventory
26
from trace import mutter, note
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
28
from inventory import InventoryEntry, Inventory
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
32
from store import ImmutableStore
33
from revision import Revision
34
from errors import bailout, BzrError
35
from textui import show_status
36
from diff import diff_trees
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
## TODO: Maybe include checks for common corruption of newlines, etc?
43
def find_branch(f, **args):
44
if f.startswith('http://') or f.startswith('https://'):
46
return remotebranch.RemoteBranch(f, **args)
48
return Branch(f, **args)
51
def find_branch_root(f=None):
52
"""Find the branch root enclosing f, or pwd.
54
f may be a filename or a URL.
56
It is not necessary that f exists.
58
Basically we keep looking up until we find the control directory or
62
elif hasattr(os.path, 'realpath'):
63
f = os.path.realpath(f)
65
f = os.path.abspath(f)
70
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
72
head, tail = os.path.split(f)
74
# reached the root, whatever that may be
75
raise BzrError('%r is not in a branch' % orig_f)
80
######################################################################
84
"""Branch holding a history of revisions.
87
Base directory of the branch.
91
def __init__(self, base, init=False, find_root=True, lock_mode='w'):
92
"""Create new branch object at a particular location.
94
base -- Base directory for the branch.
96
init -- If True, create new control files in a previously
97
unversioned directory. If False, the branch must already
100
find_root -- If true and init is false, find the root of the
101
existing branch containing base.
103
In the test suite, creation of new trees is tested using the
104
`ScratchBranch` class.
107
self.base = os.path.realpath(base)
110
self.base = find_branch_root(base)
112
self.base = os.path.realpath(base)
113
if not isdir(self.controlfilename('.')):
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'])
120
self.text_store = ImmutableStore(self.controlfilename('text-store'))
121
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
122
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
126
return '%s(%r)' % (self.__class__.__name__, self.base)
133
def lock(self, mode='w'):
134
"""Lock the on-disk branch, excluding other processes."""
140
om = os.O_WRONLY | os.O_CREAT
145
raise BzrError("invalid locking mode %r" % mode)
148
lockfile = os.open(self.controlfilename('branch-lock'), om)
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)
157
fcntl.lockf(lockfile, lm)
159
fcntl.lockf(lockfile, fcntl.LOCK_UN)
161
self._lockmode = None
163
self._lockmode = mode
165
warning("please write a locking method for platform %r" % sys.platform)
167
self._lockmode = None
169
self._lockmode = mode
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)
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)
181
def abspath(self, name):
182
"""Return absolute filename for something in the branch"""
183
return os.path.join(self.base, name)
186
def relpath(self, path):
187
"""Return path relative to this branch of something inside it.
189
Raises an error if path is not in this branch."""
190
rp = os.path.realpath(path)
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)
199
def controlfilename(self, file_or_path):
200
"""Return location relative to branch."""
201
if isinstance(file_or_path, types.StringTypes):
202
file_or_path = [file_or_path]
203
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
206
def controlfile(self, file_or_path, mode='r'):
207
"""Open a control file for this branch.
209
There are two classes of file in the control directory: text
210
and binary. binary files are untranslated byte streams. Text
211
control files are stored with Unix newlines and in UTF-8, even
212
if the platform or locale defaults are different.
215
fn = self.controlfilename(file_or_path)
217
if mode == 'rb' or mode == 'wb':
218
return file(fn, mode)
219
elif mode == 'r' or mode == 'w':
220
# open in binary mode anyhow so there's no newline translation;
221
# codecs uses line buffering by default; don't want that.
223
return codecs.open(fn, mode + 'b', 'utf-8',
226
raise BzrError("invalid controlfile mode %r" % mode)
230
def _make_control(self):
231
os.mkdir(self.controlfilename([]))
232
self.controlfile('README', 'w').write(
233
"This is a Bazaar-NG control directory.\n"
234
"Do not change any files in this directory.")
235
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
236
for d in ('text-store', 'inventory-store', 'revision-store'):
237
os.mkdir(self.controlfilename(d))
238
for f in ('revision-history', 'merged-patches',
239
'pending-merged-patches', 'branch-name',
241
self.controlfile(f, 'w').write('')
242
mutter('created control directory in ' + self.base)
243
Inventory().write_xml(self.controlfile('inventory','w'))
246
def _check_format(self):
247
"""Check this branch format is supported.
249
The current tool only supports the current unstable format.
251
In the future, we might need different in-memory Branch
252
classes to support downlevel branches. But not yet.
254
# This ignores newlines so that we can open branches created
255
# on Windows from Linux and so on. I think it might be better
256
# to always make all internal files in unix format.
257
fmt = self.controlfile('branch-format', 'r').read()
258
fmt.replace('\r\n', '')
259
if fmt != BZR_BRANCH_FORMAT:
260
bailout('sorry, branch format %r not supported' % fmt,
261
['use a different bzr version',
262
'or remove the .bzr directory and "bzr init" again'])
265
def read_working_inventory(self):
266
"""Read the working inventory."""
267
self._need_readlock()
269
# ElementTree does its own conversion from UTF-8, so open in
271
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
272
mutter("loaded inventory of %d items in %f"
273
% (len(inv), time.time() - before))
277
def _write_inventory(self, inv):
278
"""Update the working inventory.
280
That is to say, the inventory describing changes underway, that
281
will be committed to the next revision.
283
self._need_writelock()
284
## TODO: factor out to atomicfile? is rename safe on windows?
285
## TODO: Maybe some kind of clean/dirty marker on inventory?
286
tmpfname = self.controlfilename('inventory.tmp')
287
tmpf = file(tmpfname, 'wb')
290
inv_fname = self.controlfilename('inventory')
291
if sys.platform == 'win32':
293
os.rename(tmpfname, inv_fname)
294
mutter('wrote working inventory')
297
inventory = property(read_working_inventory, _write_inventory, None,
298
"""Inventory for the working copy.""")
301
def add(self, files, verbose=False):
302
"""Make files versioned.
304
Note that the command line normally calls smart_add instead.
306
This puts the files in the Added state, so that they will be
307
recorded by the next commit.
309
TODO: Perhaps have an option to add the ids even if the files do
312
TODO: Perhaps return the ids of the files? But then again it
313
is easy to retrieve them if they're needed.
315
TODO: Option to specify file id.
317
TODO: Adding a directory should optionally recurse down and
318
add all non-ignored children. Perhaps do that in a
321
>>> b = ScratchBranch(files=['foo'])
322
>>> 'foo' in b.unknowns()
327
>>> 'foo' in b.unknowns()
329
>>> bool(b.inventory.path2id('foo'))
335
Traceback (most recent call last):
337
BzrError: ('foo is already versioned', [])
339
>>> b.add(['nothere'])
340
Traceback (most recent call last):
341
BzrError: ('cannot add: not a regular file or directory: nothere', [])
343
self._need_writelock()
345
# TODO: Re-adding a file that is removed in the working copy
346
# should probably put it back with the previous ID.
347
if isinstance(files, types.StringTypes):
350
inv = self.read_working_inventory()
352
if is_control_file(f):
353
bailout("cannot add control file %s" % quotefn(f))
358
bailout("cannot add top-level %r" % f)
360
fullpath = os.path.normpath(self.abspath(f))
363
kind = file_kind(fullpath)
365
# maybe something better?
366
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
368
if kind != 'file' and kind != 'directory':
369
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
371
file_id = gen_file_id(f)
372
inv.add_path(f, kind=kind, file_id=file_id)
375
show_status('A', kind, quotefn(f))
377
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
379
self._write_inventory(inv)
382
def print_file(self, file, revno):
383
"""Print `file` to stdout."""
384
self._need_readlock()
385
tree = self.revision_tree(self.lookup_revision(revno))
386
# use inventory as it was in that revision
387
file_id = tree.inventory.path2id(file)
389
bailout("%r is not present in revision %d" % (file, revno))
390
tree.print_file(file_id)
393
def remove(self, files, verbose=False):
394
"""Mark nominated files for removal from the inventory.
396
This does not remove their text. This does not run on
398
TODO: Refuse to remove modified files unless --force is given?
400
>>> b = ScratchBranch(files=['foo'])
402
>>> b.inventory.has_filename('foo')
405
>>> b.working_tree().has_filename('foo')
407
>>> b.inventory.has_filename('foo')
410
>>> b = ScratchBranch(files=['foo'])
415
>>> b.inventory.has_filename('foo')
417
>>> b.basis_tree().has_filename('foo')
419
>>> b.working_tree().has_filename('foo')
422
TODO: Do something useful with directories.
424
TODO: Should this remove the text or not? Tough call; not
425
removing may be useful and the user can just use use rm, and
426
is the opposite of add. Removing it is consistent with most
427
other tools. Maybe an option.
429
## TODO: Normalize names
430
## TODO: Remove nested loops; better scalability
431
self._need_writelock()
433
if isinstance(files, types.StringTypes):
436
tree = self.working_tree()
439
# do this before any modifications
443
bailout("cannot remove unversioned file %s" % quotefn(f))
444
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
446
# having remove it, it must be either ignored or unknown
447
if tree.is_ignored(f):
451
show_status(new_status, inv[fid].kind, quotefn(f))
454
self._write_inventory(inv)
458
"""Return all unknown files.
460
These are files in the working directory that are not versioned or
461
control files or ignored.
463
>>> b = ScratchBranch(files=['foo', 'foo~'])
464
>>> list(b.unknowns())
467
>>> list(b.unknowns())
470
>>> list(b.unknowns())
473
return self.working_tree().unknowns()
476
def commit(self, message, timestamp=None, timezone=None,
479
"""Commit working copy as a new revision.
481
The basic approach is to add all the file texts into the
482
store, then the inventory, then make a new revision pointing
483
to that inventory and store that.
485
This is not quite safe if the working copy changes during the
486
commit; for the moment that is simply not allowed. A better
487
approach is to make a temporary copy of the files before
488
computing their hashes, and then add those hashes in turn to
489
the inventory. This should mean at least that there are no
490
broken hash pointers. There is no way we can get a snapshot
491
of the whole directory at an instant. This would also have to
492
be robust against files disappearing, moving, etc. So the
493
whole thing is a bit hard.
495
timestamp -- if not None, seconds-since-epoch for a
496
postdated/predated commit.
498
self._need_writelock()
500
## TODO: Show branch names
502
# TODO: Don't commit if there are no changes, unless forced?
504
# First walk over the working inventory; and both update that
505
# and also build a new revision inventory. The revision
506
# inventory needs to hold the text-id, sha1 and size of the
507
# actual file versions committed in the revision. (These are
508
# not present in the working inventory.) We also need to
509
# detect missing/deleted files, and remove them from the
512
work_inv = self.read_working_inventory()
514
basis = self.basis_tree()
515
basis_inv = basis.inventory
517
for path, entry in work_inv.iter_entries():
518
## TODO: Cope with files that have gone missing.
520
## TODO: Check that the file kind has not changed from the previous
521
## revision of this file (if any).
525
p = self.abspath(path)
526
file_id = entry.file_id
527
mutter('commit prep file %s, id %r ' % (p, file_id))
529
if not os.path.exists(p):
530
mutter(" file is missing, removing from inventory")
532
show_status('D', entry.kind, quotefn(path))
533
missing_ids.append(file_id)
536
# TODO: Handle files that have been deleted
538
# TODO: Maybe a special case for empty files? Seems a
539
# waste to store them many times.
543
if basis_inv.has_id(file_id):
544
old_kind = basis_inv[file_id].kind
545
if old_kind != entry.kind:
546
bailout("entry %r changed kind from %r to %r"
547
% (file_id, old_kind, entry.kind))
549
if entry.kind == 'directory':
551
bailout("%s is entered as directory but not a directory" % quotefn(p))
552
elif entry.kind == 'file':
554
bailout("%s is entered as file but is not a file" % quotefn(p))
556
content = file(p, 'rb').read()
558
entry.text_sha1 = sha_string(content)
559
entry.text_size = len(content)
561
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
563
and (old_ie.text_size == entry.text_size)
564
and (old_ie.text_sha1 == entry.text_sha1)):
565
## assert content == basis.get_file(file_id).read()
566
entry.text_id = basis_inv[file_id].text_id
567
mutter(' unchanged from previous text_id {%s}' %
571
entry.text_id = gen_file_id(entry.name)
572
self.text_store.add(content, entry.text_id)
573
mutter(' stored with text_id {%s}' % entry.text_id)
577
elif (old_ie.name == entry.name
578
and old_ie.parent_id == entry.parent_id):
583
show_status(state, entry.kind, quotefn(path))
585
for file_id in missing_ids:
586
# have to do this later so we don't mess up the iterator.
587
# since parents may be removed before their children we
590
# FIXME: There's probably a better way to do this; perhaps
591
# the workingtree should know how to filter itself.
592
if work_inv.has_id(file_id):
593
del work_inv[file_id]
596
inv_id = rev_id = _gen_revision_id(time.time())
598
inv_tmp = tempfile.TemporaryFile()
599
inv.write_xml(inv_tmp)
601
self.inventory_store.add(inv_tmp, inv_id)
602
mutter('new inventory_id is {%s}' % inv_id)
604
self._write_inventory(work_inv)
606
if timestamp == None:
607
timestamp = time.time()
609
if committer == None:
610
committer = username()
613
timezone = local_time_offset()
615
mutter("building commit log message")
616
rev = Revision(timestamp=timestamp,
619
precursor = self.last_patch(),
624
rev_tmp = tempfile.TemporaryFile()
625
rev.write_xml(rev_tmp)
627
self.revision_store.add(rev_tmp, rev_id)
628
mutter("new revision_id is {%s}" % rev_id)
630
## XXX: Everything up to here can simply be orphaned if we abort
631
## the commit; it will leave junk files behind but that doesn't
634
## TODO: Read back the just-generated changeset, and make sure it
635
## applies and recreates the right state.
637
## TODO: Also calculate and store the inventory SHA1
638
mutter("committing patch r%d" % (self.revno() + 1))
641
self.append_revision(rev_id)
644
note("commited r%d" % self.revno())
647
def append_revision(self, revision_id):
648
mutter("add {%s} to revision-history" % revision_id)
649
rev_history = self.revision_history()
651
tmprhname = self.controlfilename('revision-history.tmp')
652
rhname = self.controlfilename('revision-history')
654
f = file(tmprhname, 'wt')
655
rev_history.append(revision_id)
656
f.write('\n'.join(rev_history))
660
if sys.platform == 'win32':
662
os.rename(tmprhname, rhname)
666
def get_revision(self, revision_id):
667
"""Return the Revision object for a named revision"""
668
self._need_readlock()
669
r = Revision.read_xml(self.revision_store[revision_id])
670
assert r.revision_id == revision_id
674
def get_inventory(self, inventory_id):
675
"""Get Inventory object by hash.
677
TODO: Perhaps for this and similar methods, take a revision
678
parameter which can be either an integer revno or a
680
self._need_readlock()
681
i = Inventory.read_xml(self.inventory_store[inventory_id])
685
def get_revision_inventory(self, revision_id):
686
"""Return inventory of a past revision."""
687
self._need_readlock()
688
if revision_id == None:
691
return self.get_inventory(self.get_revision(revision_id).inventory_id)
694
def revision_history(self):
695
"""Return sequence of revision hashes on to this branch.
697
>>> ScratchBranch().revision_history()
700
self._need_readlock()
701
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
704
def enum_history(self, direction):
705
"""Return (revno, revision_id) for history of branch.
708
'forward' is from earliest to latest
709
'reverse' is from latest to earliest
711
rh = self.revision_history()
712
if direction == 'forward':
717
elif direction == 'reverse':
723
raise BzrError('invalid history direction %r' % direction)
727
"""Return current revision number for this branch.
729
That is equivalent to the number of revisions committed to
732
>>> b = ScratchBranch()
735
>>> b.commit('no foo')
739
return len(self.revision_history())
742
def last_patch(self):
743
"""Return last patch hash, or None if no history.
745
>>> ScratchBranch().last_patch() == None
748
ph = self.revision_history()
755
def lookup_revision(self, revno):
756
"""Return revision hash for revision number."""
761
# list is 0-based; revisions are 1-based
762
return self.revision_history()[revno-1]
764
raise BzrError("no such revision %s" % revno)
767
def revision_tree(self, revision_id):
768
"""Return Tree for a revision on this branch.
770
`revision_id` may be None for the null revision, in which case
771
an `EmptyTree` is returned."""
772
self._need_readlock()
773
if revision_id == None:
776
inv = self.get_revision_inventory(revision_id)
777
return RevisionTree(self.text_store, inv)
780
def working_tree(self):
781
"""Return a `Tree` for the working copy."""
782
return WorkingTree(self.base, self.read_working_inventory())
785
def basis_tree(self):
786
"""Return `Tree` object for last revision.
788
If there are no revisions yet, return an `EmptyTree`.
790
>>> b = ScratchBranch(files=['foo'])
791
>>> b.basis_tree().has_filename('foo')
793
>>> b.working_tree().has_filename('foo')
796
>>> b.commit('add foo')
797
>>> b.basis_tree().has_filename('foo')
800
r = self.last_patch()
804
return RevisionTree(self.text_store, self.get_revision_inventory(r))
808
def rename_one(self, from_rel, to_rel):
811
This can change the directory or the filename or both.
813
self._need_writelock()
814
tree = self.working_tree()
816
if not tree.has_filename(from_rel):
817
bailout("can't rename: old working file %r does not exist" % from_rel)
818
if tree.has_filename(to_rel):
819
bailout("can't rename: new working file %r already exists" % to_rel)
821
file_id = inv.path2id(from_rel)
823
bailout("can't rename: old name %r is not versioned" % from_rel)
825
if inv.path2id(to_rel):
826
bailout("can't rename: new name %r is already versioned" % to_rel)
828
to_dir, to_tail = os.path.split(to_rel)
829
to_dir_id = inv.path2id(to_dir)
830
if to_dir_id == None and to_dir != '':
831
bailout("can't determine destination directory id for %r" % to_dir)
833
mutter("rename_one:")
834
mutter(" file_id {%s}" % file_id)
835
mutter(" from_rel %r" % from_rel)
836
mutter(" to_rel %r" % to_rel)
837
mutter(" to_dir %r" % to_dir)
838
mutter(" to_dir_id {%s}" % to_dir_id)
840
inv.rename(file_id, to_dir_id, to_tail)
842
print "%s => %s" % (from_rel, to_rel)
844
from_abs = self.abspath(from_rel)
845
to_abs = self.abspath(to_rel)
847
os.rename(from_abs, to_abs)
849
bailout("failed to rename %r to %r: %s"
850
% (from_abs, to_abs, e[1]),
851
["rename rolled back"])
853
self._write_inventory(inv)
857
def move(self, from_paths, to_name):
860
to_name must exist as a versioned directory.
862
If to_name exists and is a directory, the files are moved into
863
it, keeping their old names. If it is a directory,
865
Note that to_name is only the last component of the new name;
866
this doesn't change the directory.
868
self._need_writelock()
869
## TODO: Option to move IDs only
870
assert not isinstance(from_paths, basestring)
871
tree = self.working_tree()
873
to_abs = self.abspath(to_name)
874
if not isdir(to_abs):
875
bailout("destination %r is not a directory" % to_abs)
876
if not tree.has_filename(to_name):
877
bailout("destination %r not in working directory" % to_abs)
878
to_dir_id = inv.path2id(to_name)
879
if to_dir_id == None and to_name != '':
880
bailout("destination %r is not a versioned directory" % to_name)
881
to_dir_ie = inv[to_dir_id]
882
if to_dir_ie.kind not in ('directory', 'root_directory'):
883
bailout("destination %r is not a directory" % to_abs)
885
to_idpath = Set(inv.get_idpath(to_dir_id))
888
if not tree.has_filename(f):
889
bailout("%r does not exist in working tree" % f)
890
f_id = inv.path2id(f)
892
bailout("%r is not versioned" % f)
893
name_tail = splitpath(f)[-1]
894
dest_path = appendpath(to_name, name_tail)
895
if tree.has_filename(dest_path):
896
bailout("destination %r already exists" % dest_path)
897
if f_id in to_idpath:
898
bailout("can't move %r to a subdirectory of itself" % f)
900
# OK, so there's a race here, it's possible that someone will
901
# create a file in this interval and then the rename might be
902
# left half-done. But we should have caught most problems.
905
name_tail = splitpath(f)[-1]
906
dest_path = appendpath(to_name, name_tail)
907
print "%s => %s" % (f, dest_path)
908
inv.rename(inv.path2id(f), to_dir_id, name_tail)
910
os.rename(self.abspath(f), self.abspath(dest_path))
912
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
913
["rename rolled back"])
915
self._write_inventory(inv)
919
def show_status(self, show_all=False, file_list=None):
920
"""Display single-line status for non-ignored working files.
922
The list is show sorted in order by file name.
924
>>> b = ScratchBranch(files=['foo', 'foo~'])
930
>>> b.commit("add foo")
932
>>> os.unlink(b.abspath('foo'))
936
self._need_readlock()
938
# We have to build everything into a list first so that it can
939
# sorted by name, incorporating all the different sources.
941
# FIXME: Rather than getting things in random order and then sorting,
942
# just step through in order.
944
# Interesting case: the old ID for a file has been removed,
945
# but a new file has been created under that name.
947
old = self.basis_tree()
948
new = self.working_tree()
950
items = diff_trees(old, new)
951
# We want to filter out only if any file was provided in the file_list.
952
if isinstance(file_list, list) and len(file_list):
953
items = [item for item in items if item[3] in file_list]
955
for fs, fid, oldname, newname, kind in items:
957
show_status(fs, kind,
958
oldname + ' => ' + newname)
959
elif fs == 'A' or fs == 'M':
960
show_status(fs, kind, newname)
962
show_status(fs, kind, oldname)
965
show_status(fs, kind, newname)
968
show_status(fs, kind, newname)
970
show_status(fs, kind, newname)
972
bailout("weird file state %r" % ((fs, fid),))
976
class ScratchBranch(Branch):
977
"""Special test class: a branch that cleans up after itself.
979
>>> b = ScratchBranch()
987
def __init__(self, files=[], dirs=[]):
988
"""Make a test branch.
990
This creates a temporary directory and runs init-tree in it.
992
If any files are listed, they are created in the working copy.
994
Branch.__init__(self, tempfile.mkdtemp(), init=True)
996
os.mkdir(self.abspath(d))
999
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1006
"""Destroy the test branch, removing the scratch directory."""
1008
mutter("delete ScratchBranch %s" % self.base)
1009
shutil.rmtree(self.base)
1011
# Work around for shutil.rmtree failing on Windows when
1012
# readonly files are encountered
1013
mutter("hit exception in destroying ScratchBranch: %s" % e)
1014
for root, dirs, files in os.walk(self.base, topdown=False):
1016
os.chmod(os.path.join(root, name), 0700)
1017
shutil.rmtree(self.base)
1022
######################################################################
1026
def is_control_file(filename):
1027
## FIXME: better check
1028
filename = os.path.normpath(filename)
1029
while filename != '':
1030
head, tail = os.path.split(filename)
1031
## mutter('check %r for control file' % ((head, tail), ))
1032
if tail == bzrlib.BZRDIR:
1034
if filename == head:
1041
def _gen_revision_id(when):
1042
"""Return new revision-id."""
1043
s = '%s-%s-' % (user_email(), compact_date(when))
1044
s += hexlify(rand_bytes(8))
1048
def gen_file_id(name):
1049
"""Return new file id.
1051
This should probably generate proper UUIDs, but for the moment we
1052
cope with just randomness because running uuidgen every time is
1054
idx = name.rfind('/')
1056
name = name[idx+1 : ]
1057
idx = name.rfind('\\')
1059
name = name[idx+1 : ]
1061
name = name.lstrip('.')
1063
s = hexlify(rand_bytes(8))
1064
return '-'.join((name, compact_date(time.time()), s))
added
removed
bzrlib/branch.py
