/brz/remove-bazaar

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

  • Committer: Martin Pool
  • Date: 2005-06-01 07:44:39 UTC
  • Revision ID: mbp@sourcefrog.net-20050601074439-f3178be2d71d2db8
- ignore .git

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
 
108
 
 
109
######################################################################
 
110
# branch objects
 
111
 
 
112
class Branch(object):
 
113
    """Branch holding a history of revisions.
 
114
 
 
115
    base
 
116
        Base directory of the branch.
 
117
 
 
118
    _lock_mode
 
119
        None, or 'r' or 'w'
 
120
 
 
121
    _lock_count
 
122
        If _lock_mode is true, a positive count of the number of times the
 
123
        lock has been taken.
 
124
 
 
125
    _lock
 
126
        Lock object from bzrlib.lock.
 
127
    """
 
128
    base = None
 
129
    _lock_mode = None
 
130
    _lock_count = None
 
131
    _lock = None
 
132
    
 
133
    def __init__(self, base, init=False, find_root=True):
 
134
        """Create new branch object at a particular location.
 
135
 
 
136
        base -- Base directory for the branch.
 
137
        
 
138
        init -- If True, create new control files in a previously
 
139
             unversioned directory.  If False, the branch must already
 
140
             be versioned.
 
141
 
 
142
        find_root -- If true and init is false, find the root of the
 
143
             existing branch containing base.
 
144
 
 
145
        In the test suite, creation of new trees is tested using the
 
146
        `ScratchBranch` class.
 
147
        """
 
148
        if init:
 
149
            self.base = os.path.realpath(base)
 
150
            self._make_control()
 
151
        elif find_root:
 
152
            self.base = find_branch_root(base)
 
153
        else:
 
154
            self.base = os.path.realpath(base)
 
155
            if not isdir(self.controlfilename('.')):
 
156
                from errors import NotBranchError
 
157
                raise NotBranchError("not a bzr branch: %s" % quotefn(base),
 
158
                                     ['use "bzr init" to initialize a new working tree',
 
159
                                      'current bzr can only operate from top-of-tree'])
 
160
        self._check_format()
 
161
 
 
162
        self.text_store = ImmutableStore(self.controlfilename('text-store'))
 
163
        self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
 
164
        self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
 
165
 
 
166
 
 
167
    def __str__(self):
 
168
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
169
 
 
170
 
 
171
    __repr__ = __str__
 
172
 
 
173
 
 
174
    def __del__(self):
 
175
        if self._lock_mode or self._lock:
 
176
            from warnings import warn
 
177
            warn("branch %r was not explicitly unlocked" % self)
 
178
            self._lock.unlock()
 
179
 
 
180
 
 
181
 
 
182
    def lock_write(self):
 
183
        if self._lock_mode:
 
184
            if self._lock_mode != 'w':
 
185
                from errors import LockError
 
186
                raise LockError("can't upgrade to a write lock from %r" %
 
187
                                self._lock_mode)
 
188
            self._lock_count += 1
 
189
        else:
 
190
            from bzrlib.lock import WriteLock
 
191
 
 
192
            self._lock = WriteLock(self.controlfilename('branch-lock'))
 
193
            self._lock_mode = 'w'
 
194
            self._lock_count = 1
 
195
 
 
196
 
 
197
 
 
198
    def lock_read(self):
 
199
        if self._lock_mode:
 
200
            assert self._lock_mode in ('r', 'w'), \
 
201
                   "invalid lock mode %r" % self._lock_mode
 
202
            self._lock_count += 1
 
203
        else:
 
204
            from bzrlib.lock import ReadLock
 
205
 
 
206
            self._lock = ReadLock(self.controlfilename('branch-lock'))
 
207
            self._lock_mode = 'r'
 
208
            self._lock_count = 1
 
209
                        
 
210
 
 
211
            
 
212
    def unlock(self):
 
213
        if not self._lock_mode:
 
214
            from errors import LockError
 
215
            raise LockError('branch %r is not locked' % (self))
 
216
 
 
217
        if self._lock_count > 1:
 
218
            self._lock_count -= 1
 
219
        else:
 
220
            self._lock.unlock()
 
221
            self._lock = None
 
222
            self._lock_mode = self._lock_count = None
 
223
 
 
224
 
 
225
    def abspath(self, name):
 
226
        """Return absolute filename for something in the branch"""
 
227
        return os.path.join(self.base, name)
 
228
 
 
229
 
 
230
    def relpath(self, path):
 
231
        """Return path relative to this branch of something inside it.
 
232
 
 
233
        Raises an error if path is not in this branch."""
 
234
        return _relpath(self.base, path)
 
235
 
 
236
 
 
237
    def controlfilename(self, file_or_path):
 
238
        """Return location relative to branch."""
 
239
        if isinstance(file_or_path, types.StringTypes):
 
240
            file_or_path = [file_or_path]
 
241
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
 
242
 
 
243
 
 
244
    def controlfile(self, file_or_path, mode='r'):
 
245
        """Open a control file for this branch.
 
246
 
 
247
        There are two classes of file in the control directory: text
 
248
        and binary.  binary files are untranslated byte streams.  Text
 
249
        control files are stored with Unix newlines and in UTF-8, even
 
250
        if the platform or locale defaults are different.
 
251
 
 
252
        Controlfiles should almost never be opened in write mode but
 
253
        rather should be atomically copied and replaced using atomicfile.
 
254
        """
 
255
 
 
256
        fn = self.controlfilename(file_or_path)
 
257
 
 
258
        if mode == 'rb' or mode == 'wb':
 
259
            return file(fn, mode)
 
260
        elif mode == 'r' or mode == 'w':
 
261
            # open in binary mode anyhow so there's no newline translation;
 
262
            # codecs uses line buffering by default; don't want that.
 
263
            import codecs
 
264
            return codecs.open(fn, mode + 'b', 'utf-8',
 
265
                               buffering=60000)
 
266
        else:
 
267
            raise BzrError("invalid controlfile mode %r" % mode)
 
268
 
 
269
 
 
270
 
 
271
    def _make_control(self):
 
272
        os.mkdir(self.controlfilename([]))
 
273
        self.controlfile('README', 'w').write(
 
274
            "This is a Bazaar-NG control directory.\n"
 
275
            "Do not change any files in this directory.")
 
276
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
 
277
        for d in ('text-store', 'inventory-store', 'revision-store'):
 
278
            os.mkdir(self.controlfilename(d))
 
279
        for f in ('revision-history', 'merged-patches',
 
280
                  'pending-merged-patches', 'branch-name',
 
281
                  'branch-lock'):
 
282
            self.controlfile(f, 'w').write('')
 
283
        mutter('created control directory in ' + self.base)
 
284
        Inventory().write_xml(self.controlfile('inventory','w'))
 
285
 
 
286
 
 
287
    def _check_format(self):
 
288
        """Check this branch format is supported.
 
289
 
 
290
        The current tool only supports the current unstable format.
 
291
 
 
292
        In the future, we might need different in-memory Branch
 
293
        classes to support downlevel branches.  But not yet.
 
294
        """
 
295
        # This ignores newlines so that we can open branches created
 
296
        # on Windows from Linux and so on.  I think it might be better
 
297
        # to always make all internal files in unix format.
 
298
        fmt = self.controlfile('branch-format', 'r').read()
 
299
        fmt.replace('\r\n', '')
 
300
        if fmt != BZR_BRANCH_FORMAT:
 
301
            raise BzrError('sorry, branch format %r not supported' % fmt,
 
302
                           ['use a different bzr version',
 
303
                            'or remove the .bzr directory and "bzr init" again'])
 
304
 
 
305
 
 
306
 
 
307
    def read_working_inventory(self):
 
308
        """Read the working inventory."""
 
309
        before = time.time()
 
310
        # ElementTree does its own conversion from UTF-8, so open in
 
311
        # binary.
 
312
        self.lock_read()
 
313
        try:
 
314
            inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
 
315
            mutter("loaded inventory of %d items in %f"
 
316
                   % (len(inv), time.time() - before))
 
317
            return inv
 
318
        finally:
 
319
            self.unlock()
 
320
            
 
321
 
 
322
    def _write_inventory(self, inv):
 
323
        """Update the working inventory.
 
324
 
 
325
        That is to say, the inventory describing changes underway, that
 
326
        will be committed to the next revision.
 
327
        """
 
328
        ## TODO: factor out to atomicfile?  is rename safe on windows?
 
329
        ## TODO: Maybe some kind of clean/dirty marker on inventory?
 
330
        tmpfname = self.controlfilename('inventory.tmp')
 
331
        tmpf = file(tmpfname, 'wb')
 
332
        inv.write_xml(tmpf)
 
333
        tmpf.close()
 
334
        inv_fname = self.controlfilename('inventory')
 
335
        if sys.platform == 'win32':
 
336
            os.remove(inv_fname)
 
337
        os.rename(tmpfname, inv_fname)
 
338
        mutter('wrote working inventory')
 
339
            
 
340
 
 
341
    inventory = property(read_working_inventory, _write_inventory, None,
 
342
                         """Inventory for the working copy.""")
 
343
 
 
344
 
 
345
    def add(self, files, verbose=False, ids=None):
 
346
        """Make files versioned.
 
347
 
 
348
        Note that the command line normally calls smart_add instead.
 
349
 
 
350
        This puts the files in the Added state, so that they will be
 
351
        recorded by the next commit.
 
352
 
 
353
        files
 
354
            List of paths to add, relative to the base of the tree.
 
355
 
 
356
        ids
 
357
            If set, use these instead of automatically generated ids.
 
358
            Must be the same length as the list of files, but may
 
359
            contain None for ids that are to be autogenerated.
 
360
 
 
361
        TODO: Perhaps have an option to add the ids even if the files do
 
362
              not (yet) exist.
 
363
 
 
364
        TODO: Perhaps return the ids of the files?  But then again it
 
365
              is easy to retrieve them if they're needed.
 
366
 
 
367
        TODO: Adding a directory should optionally recurse down and
 
368
              add all non-ignored children.  Perhaps do that in a
 
369
              higher-level method.
 
370
        """
 
371
        # TODO: Re-adding a file that is removed in the working copy
 
372
        # should probably put it back with the previous ID.
 
373
        if isinstance(files, types.StringTypes):
 
374
            assert(ids is None or isinstance(ids, types.StringTypes))
 
375
            files = [files]
 
376
            if ids is not None:
 
377
                ids = [ids]
 
378
 
 
379
        if ids is None:
 
380
            ids = [None] * len(files)
 
381
        else:
 
382
            assert(len(ids) == len(files))
 
383
 
 
384
        self.lock_write()
 
385
        try:
 
386
            inv = self.read_working_inventory()
 
387
            for f,file_id in zip(files, ids):
 
388
                if is_control_file(f):
 
389
                    raise BzrError("cannot add control file %s" % quotefn(f))
 
390
 
 
391
                fp = splitpath(f)
 
392
 
 
393
                if len(fp) == 0:
 
394
                    raise BzrError("cannot add top-level %r" % f)
 
395
 
 
396
                fullpath = os.path.normpath(self.abspath(f))
 
397
 
 
398
                try:
 
399
                    kind = file_kind(fullpath)
 
400
                except OSError:
 
401
                    # maybe something better?
 
402
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
403
 
 
404
                if kind != 'file' and kind != 'directory':
 
405
                    raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
 
406
 
 
407
                if file_id is None:
 
408
                    file_id = gen_file_id(f)
 
409
                inv.add_path(f, kind=kind, file_id=file_id)
 
410
 
 
411
                if verbose:
 
412
                    show_status('A', kind, quotefn(f))
 
413
 
 
414
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
415
 
 
416
            self._write_inventory(inv)
 
417
        finally:
 
418
            self.unlock()
 
419
            
 
420
 
 
421
    def print_file(self, file, revno):
 
422
        """Print `file` to stdout."""
 
423
        self.lock_read()
 
424
        try:
 
425
            tree = self.revision_tree(self.lookup_revision(revno))
 
426
            # use inventory as it was in that revision
 
427
            file_id = tree.inventory.path2id(file)
 
428
            if not file_id:
 
429
                raise BzrError("%r is not present in revision %d" % (file, revno))
 
430
            tree.print_file(file_id)
 
431
        finally:
 
432
            self.unlock()
 
433
 
 
434
 
 
435
    def remove(self, files, verbose=False):
 
436
        """Mark nominated files for removal from the inventory.
 
437
 
 
438
        This does not remove their text.  This does not run on 
 
439
 
 
440
        TODO: Refuse to remove modified files unless --force is given?
 
441
 
 
442
        TODO: Do something useful with directories.
 
443
 
 
444
        TODO: Should this remove the text or not?  Tough call; not
 
445
        removing may be useful and the user can just use use rm, and
 
446
        is the opposite of add.  Removing it is consistent with most
 
447
        other tools.  Maybe an option.
 
448
        """
 
449
        ## TODO: Normalize names
 
450
        ## TODO: Remove nested loops; better scalability
 
451
        if isinstance(files, types.StringTypes):
 
452
            files = [files]
 
453
 
 
454
        self.lock_write()
 
455
 
 
456
        try:
 
457
            tree = self.working_tree()
 
458
            inv = tree.inventory
 
459
 
 
460
            # do this before any modifications
 
461
            for f in files:
 
462
                fid = inv.path2id(f)
 
463
                if not fid:
 
464
                    raise BzrError("cannot remove unversioned file %s" % quotefn(f))
 
465
                mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
 
466
                if verbose:
 
467
                    # having remove it, it must be either ignored or unknown
 
468
                    if tree.is_ignored(f):
 
469
                        new_status = 'I'
 
470
                    else:
 
471
                        new_status = '?'
 
472
                    show_status(new_status, inv[fid].kind, quotefn(f))
 
473
                del inv[fid]
 
474
 
 
475
            self._write_inventory(inv)
 
476
        finally:
 
477
            self.unlock()
 
478
 
 
479
 
 
480
    # FIXME: this doesn't need to be a branch method
 
481
    def set_inventory(self, new_inventory_list):
 
482
        inv = Inventory()
 
483
        for path, file_id, parent, kind in new_inventory_list:
 
484
            name = os.path.basename(path)
 
485
            if name == "":
 
486
                continue
 
487
            inv.add(InventoryEntry(file_id, name, kind, parent))
 
488
        self._write_inventory(inv)
 
489
 
 
490
 
 
491
    def unknowns(self):
 
492
        """Return all unknown files.
 
493
 
 
494
        These are files in the working directory that are not versioned or
 
495
        control files or ignored.
 
496
        
 
497
        >>> b = ScratchBranch(files=['foo', 'foo~'])
 
498
        >>> list(b.unknowns())
 
499
        ['foo']
 
500
        >>> b.add('foo')
 
501
        >>> list(b.unknowns())
 
502
        []
 
503
        >>> b.remove('foo')
 
504
        >>> list(b.unknowns())
 
505
        ['foo']
 
506
        """
 
507
        return self.working_tree().unknowns()
 
508
 
 
509
 
 
510
    def append_revision(self, revision_id):
 
511
        mutter("add {%s} to revision-history" % revision_id)
 
512
        rev_history = self.revision_history()
 
513
 
 
514
        tmprhname = self.controlfilename('revision-history.tmp')
 
515
        rhname = self.controlfilename('revision-history')
 
516
        
 
517
        f = file(tmprhname, 'wt')
 
518
        rev_history.append(revision_id)
 
519
        f.write('\n'.join(rev_history))
 
520
        f.write('\n')
 
521
        f.close()
 
522
 
 
523
        if sys.platform == 'win32':
 
524
            os.remove(rhname)
 
525
        os.rename(tmprhname, rhname)
 
526
        
 
527
 
 
528
 
 
529
    def get_revision(self, revision_id):
 
530
        """Return the Revision object for a named revision"""
 
531
        r = Revision.read_xml(self.revision_store[revision_id])
 
532
        assert r.revision_id == revision_id
 
533
        return r
 
534
 
 
535
 
 
536
    def get_inventory(self, inventory_id):
 
537
        """Get Inventory object by hash.
 
538
 
 
539
        TODO: Perhaps for this and similar methods, take a revision
 
540
               parameter which can be either an integer revno or a
 
541
               string hash."""
 
542
        i = Inventory.read_xml(self.inventory_store[inventory_id])
 
543
        return i
 
544
 
 
545
 
 
546
    def get_revision_inventory(self, revision_id):
 
547
        """Return inventory of a past revision."""
 
548
        if revision_id == None:
 
549
            return Inventory()
 
550
        else:
 
551
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
 
552
 
 
553
 
 
554
    def revision_history(self):
 
555
        """Return sequence of revision hashes on to this branch.
 
556
 
 
557
        >>> ScratchBranch().revision_history()
 
558
        []
 
559
        """
 
560
        self.lock_read()
 
561
        try:
 
562
            return [l.rstrip('\r\n') for l in
 
563
                    self.controlfile('revision-history', 'r').readlines()]
 
564
        finally:
 
565
            self.unlock()
 
566
 
 
567
 
 
568
    def enum_history(self, direction):
 
569
        """Return (revno, revision_id) for history of branch.
 
570
 
 
571
        direction
 
572
            'forward' is from earliest to latest
 
573
            'reverse' is from latest to earliest
 
574
        """
 
575
        rh = self.revision_history()
 
576
        if direction == 'forward':
 
577
            i = 1
 
578
            for rid in rh:
 
579
                yield i, rid
 
580
                i += 1
 
581
        elif direction == 'reverse':
 
582
            i = len(rh)
 
583
            while i > 0:
 
584
                yield i, rh[i-1]
 
585
                i -= 1
 
586
        else:
 
587
            raise ValueError('invalid history direction', direction)
 
588
 
 
589
 
 
590
    def revno(self):
 
591
        """Return current revision number for this branch.
 
592
 
 
593
        That is equivalent to the number of revisions committed to
 
594
        this branch.
 
595
        """
 
596
        return len(self.revision_history())
 
597
 
 
598
 
 
599
    def last_patch(self):
 
600
        """Return last patch hash, or None if no history.
 
601
        """
 
602
        ph = self.revision_history()
 
603
        if ph:
 
604
            return ph[-1]
 
605
        else:
 
606
            return None
 
607
 
 
608
 
 
609
    def commit(self, *args, **kw):
 
610
        """Deprecated"""
 
611
        from bzrlib.commit import commit
 
612
        commit(self, *args, **kw)
 
613
        
 
614
 
 
615
    def lookup_revision(self, revno):
 
616
        """Return revision hash for revision number."""
 
617
        if revno == 0:
 
618
            return None
 
619
 
 
620
        try:
 
621
            # list is 0-based; revisions are 1-based
 
622
            return self.revision_history()[revno-1]
 
623
        except IndexError:
 
624
            raise BzrError("no such revision %s" % revno)
 
625
 
 
626
 
 
627
    def revision_tree(self, revision_id):
 
628
        """Return Tree for a revision on this branch.
 
629
 
 
630
        `revision_id` may be None for the null revision, in which case
 
631
        an `EmptyTree` is returned."""
 
632
        # TODO: refactor this to use an existing revision object
 
633
        # so we don't need to read it in twice.
 
634
        if revision_id == None:
 
635
            return EmptyTree()
 
636
        else:
 
637
            inv = self.get_revision_inventory(revision_id)
 
638
            return RevisionTree(self.text_store, inv)
 
639
 
 
640
 
 
641
    def working_tree(self):
 
642
        """Return a `Tree` for the working copy."""
 
643
        from workingtree import WorkingTree
 
644
        return WorkingTree(self.base, self.read_working_inventory())
 
645
 
 
646
 
 
647
    def basis_tree(self):
 
648
        """Return `Tree` object for last revision.
 
649
 
 
650
        If there are no revisions yet, return an `EmptyTree`.
 
651
        """
 
652
        r = self.last_patch()
 
653
        if r == None:
 
654
            return EmptyTree()
 
655
        else:
 
656
            return RevisionTree(self.text_store, self.get_revision_inventory(r))
 
657
 
 
658
 
 
659
 
 
660
    def rename_one(self, from_rel, to_rel):
 
661
        """Rename one file.
 
662
 
 
663
        This can change the directory or the filename or both.
 
664
        """
 
665
        self.lock_write()
 
666
        try:
 
667
            tree = self.working_tree()
 
668
            inv = tree.inventory
 
669
            if not tree.has_filename(from_rel):
 
670
                raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
671
            if tree.has_filename(to_rel):
 
672
                raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
673
 
 
674
            file_id = inv.path2id(from_rel)
 
675
            if file_id == None:
 
676
                raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
677
 
 
678
            if inv.path2id(to_rel):
 
679
                raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
680
 
 
681
            to_dir, to_tail = os.path.split(to_rel)
 
682
            to_dir_id = inv.path2id(to_dir)
 
683
            if to_dir_id == None and to_dir != '':
 
684
                raise BzrError("can't determine destination directory id for %r" % to_dir)
 
685
 
 
686
            mutter("rename_one:")
 
687
            mutter("  file_id    {%s}" % file_id)
 
688
            mutter("  from_rel   %r" % from_rel)
 
689
            mutter("  to_rel     %r" % to_rel)
 
690
            mutter("  to_dir     %r" % to_dir)
 
691
            mutter("  to_dir_id  {%s}" % to_dir_id)
 
692
 
 
693
            inv.rename(file_id, to_dir_id, to_tail)
 
694
 
 
695
            print "%s => %s" % (from_rel, to_rel)
 
696
 
 
697
            from_abs = self.abspath(from_rel)
 
698
            to_abs = self.abspath(to_rel)
 
699
            try:
 
700
                os.rename(from_abs, to_abs)
 
701
            except OSError, e:
 
702
                raise BzrError("failed to rename %r to %r: %s"
 
703
                        % (from_abs, to_abs, e[1]),
 
704
                        ["rename rolled back"])
 
705
 
 
706
            self._write_inventory(inv)
 
707
        finally:
 
708
            self.unlock()
 
709
 
 
710
 
 
711
    def move(self, from_paths, to_name):
 
712
        """Rename files.
 
713
 
 
714
        to_name must exist as a versioned directory.
 
715
 
 
716
        If to_name exists and is a directory, the files are moved into
 
717
        it, keeping their old names.  If it is a directory, 
 
718
 
 
719
        Note that to_name is only the last component of the new name;
 
720
        this doesn't change the directory.
 
721
        """
 
722
        self.lock_write()
 
723
        try:
 
724
            ## TODO: Option to move IDs only
 
725
            assert not isinstance(from_paths, basestring)
 
726
            tree = self.working_tree()
 
727
            inv = tree.inventory
 
728
            to_abs = self.abspath(to_name)
 
729
            if not isdir(to_abs):
 
730
                raise BzrError("destination %r is not a directory" % to_abs)
 
731
            if not tree.has_filename(to_name):
 
732
                raise BzrError("destination %r not in working directory" % to_abs)
 
733
            to_dir_id = inv.path2id(to_name)
 
734
            if to_dir_id == None and to_name != '':
 
735
                raise BzrError("destination %r is not a versioned directory" % to_name)
 
736
            to_dir_ie = inv[to_dir_id]
 
737
            if to_dir_ie.kind not in ('directory', 'root_directory'):
 
738
                raise BzrError("destination %r is not a directory" % to_abs)
 
739
 
 
740
            to_idpath = inv.get_idpath(to_dir_id)
 
741
 
 
742
            for f in from_paths:
 
743
                if not tree.has_filename(f):
 
744
                    raise BzrError("%r does not exist in working tree" % f)
 
745
                f_id = inv.path2id(f)
 
746
                if f_id == None:
 
747
                    raise BzrError("%r is not versioned" % f)
 
748
                name_tail = splitpath(f)[-1]
 
749
                dest_path = appendpath(to_name, name_tail)
 
750
                if tree.has_filename(dest_path):
 
751
                    raise BzrError("destination %r already exists" % dest_path)
 
752
                if f_id in to_idpath:
 
753
                    raise BzrError("can't move %r to a subdirectory of itself" % f)
 
754
 
 
755
            # OK, so there's a race here, it's possible that someone will
 
756
            # create a file in this interval and then the rename might be
 
757
            # left half-done.  But we should have caught most problems.
 
758
 
 
759
            for f in from_paths:
 
760
                name_tail = splitpath(f)[-1]
 
761
                dest_path = appendpath(to_name, name_tail)
 
762
                print "%s => %s" % (f, dest_path)
 
763
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
764
                try:
 
765
                    os.rename(self.abspath(f), self.abspath(dest_path))
 
766
                except OSError, e:
 
767
                    raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
768
                            ["rename rolled back"])
 
769
 
 
770
            self._write_inventory(inv)
 
771
        finally:
 
772
            self.unlock()
 
773
 
 
774
 
 
775
 
 
776
class ScratchBranch(Branch):
 
777
    """Special test class: a branch that cleans up after itself.
 
778
 
 
779
    >>> b = ScratchBranch()
 
780
    >>> isdir(b.base)
 
781
    True
 
782
    >>> bd = b.base
 
783
    >>> b.destroy()
 
784
    >>> isdir(bd)
 
785
    False
 
786
    """
 
787
    def __init__(self, files=[], dirs=[]):
 
788
        """Make a test branch.
 
789
 
 
790
        This creates a temporary directory and runs init-tree in it.
 
791
 
 
792
        If any files are listed, they are created in the working copy.
 
793
        """
 
794
        Branch.__init__(self, tempfile.mkdtemp(), init=True)
 
795
        for d in dirs:
 
796
            os.mkdir(self.abspath(d))
 
797
            
 
798
        for f in files:
 
799
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
 
800
 
 
801
 
 
802
    def __del__(self):
 
803
        self.destroy()
 
804
 
 
805
    def destroy(self):
 
806
        """Destroy the test branch, removing the scratch directory."""
 
807
        try:
 
808
            if self.base:
 
809
                mutter("delete ScratchBranch %s" % self.base)
 
810
                shutil.rmtree(self.base)
 
811
        except OSError, e:
 
812
            # Work around for shutil.rmtree failing on Windows when
 
813
            # readonly files are encountered
 
814
            mutter("hit exception in destroying ScratchBranch: %s" % e)
 
815
            for root, dirs, files in os.walk(self.base, topdown=False):
 
816
                for name in files:
 
817
                    os.chmod(os.path.join(root, name), 0700)
 
818
            shutil.rmtree(self.base)
 
819
        self.base = None
 
820
 
 
821
    
 
822
 
 
823
######################################################################
 
824
# predicates
 
825
 
 
826
 
 
827
def is_control_file(filename):
 
828
    ## FIXME: better check
 
829
    filename = os.path.normpath(filename)
 
830
    while filename != '':
 
831
        head, tail = os.path.split(filename)
 
832
        ## mutter('check %r for control file' % ((head, tail), ))
 
833
        if tail == bzrlib.BZRDIR:
 
834
            return True
 
835
        if filename == head:
 
836
            break
 
837
        filename = head
 
838
    return False
 
839
 
 
840
 
 
841
 
 
842
def gen_file_id(name):
 
843
    """Return new file id.
 
844
 
 
845
    This should probably generate proper UUIDs, but for the moment we
 
846
    cope with just randomness because running uuidgen every time is
 
847
    slow."""
 
848
    import re
 
849
 
 
850
    # get last component
 
851
    idx = name.rfind('/')
 
852
    if idx != -1:
 
853
        name = name[idx+1 : ]
 
854
    idx = name.rfind('\\')
 
855
    if idx != -1:
 
856
        name = name[idx+1 : ]
 
857
 
 
858
    # make it not a hidden file
 
859
    name = name.lstrip('.')
 
860
 
 
861
    # remove any wierd characters; we don't escape them but rather
 
862
    # just pull them out
 
863
    name = re.sub(r'[^\w.]', '', name)
 
864
 
 
865
    s = hexlify(rand_bytes(8))
 
866
    return '-'.join((name, compact_date(time.time()), s))