/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-27 04:07:05 UTC
  • Revision ID: mbp@sourcefrog.net-20050527040705-e27f29a72af7f91d
- new exception NotBranchError

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