/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-05-31 08:10:44 UTC
  • Revision ID: mbp@sourcefrog.net-20050531081044-0f6d28e39b8e19de
- replace Branch.lock(mode) with separate lock_read and lock_write 
  methods

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