← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

[merge] refactoring of branch vs working tree, etc (robertc)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
42
42
# copy, and making sure there's only one WorkingTree for any directory on disk.
43
43
# At the momenthey may alias the inventory and have old copies of it in memory.
44
44
 
 
45
from copy import deepcopy
45
46
import os
46
47
import stat
47
48
import fnmatch
48
49
 
49
 
from bzrlib.branch import Branch, needs_read_lock, needs_write_lock, quotefn
50
 
import bzrlib.tree
 
50
from bzrlib.branch import (Branch,
 
51
                           is_control_file,
 
52
                           needs_read_lock,
 
53
                           needs_write_lock,
 
54
                           quotefn)
 
55
from bzrlib.errors import (BzrCheckError,
 
56
                           BzrError,
 
57
                           DivergedBranches,
 
58
                           NotBranchError,
 
59
                           NotVersionedError)
 
60
from bzrlib.inventory import InventoryEntry
51
61
from bzrlib.osutils import (appendpath,
 
62
                            compact_date,
52
63
                            file_kind,
53
64
                            isdir,
54
65
                            pumpfile,
55
66
                            splitpath,
56
 
                            relpath)
57
 
from bzrlib.errors import BzrCheckError, DivergedBranches, NotVersionedError
 
67
                            rand_bytes,
 
68
                            realpath,
 
69
                            relpath,
 
70
                            rename)
 
71
import bzrlib.tree
58
72
from bzrlib.trace import mutter
59
73
import bzrlib.xml5
60
74
 
61
75
 
 
76
def gen_file_id(name):
 
77
    """Return new file id.
 
78
 
 
79
    This should probably generate proper UUIDs, but for the moment we
 
80
    cope with just randomness because running uuidgen every time is
 
81
    slow."""
 
82
    import re
 
83
    from binascii import hexlify
 
84
    from time import time
 
85
 
 
86
    # get last component
 
87
    idx = name.rfind('/')
 
88
    if idx != -1:
 
89
        name = name[idx+1 : ]
 
90
    idx = name.rfind('\\')
 
91
    if idx != -1:
 
92
        name = name[idx+1 : ]
 
93
 
 
94
    # make it not a hidden file
 
95
    name = name.lstrip('.')
 
96
 
 
97
    # remove any wierd characters; we don't escape them but rather
 
98
    # just pull them out
 
99
    name = re.sub(r'[^\w.]', '', name)
 
100
 
 
101
    s = hexlify(rand_bytes(8))
 
102
    return '-'.join((name, compact_date(time()), s))
 
103
 
 
104
 
 
105
def gen_root_id():
 
106
    """Return a new tree-root file id."""
 
107
    return gen_file_id('TREE_ROOT')
 
108
 
 
109
 
62
110
class TreeEntry(object):
63
111
    """An entry that implements the minium interface used by commands.
64
112
 
124
172
    not listed in the Inventory and vice versa.
125
173
    """
126
174
 
127
 
    def __init__(self, basedir, branch=None):
 
175
    def __init__(self, basedir='.', branch=None):
128
176
        """Construct a WorkingTree for basedir.
129
177
 
130
178
        If the branch is not supplied, it is opened automatically.
141
189
        assert isinstance(branch, Branch), \
142
190
            "branch %r is not a Branch" % branch
143
191
        self.branch = branch
144
 
        self.basedir = basedir
145
 
        self._inventory = self.read_working_inventory()
146
 
        self.path2id = self._inventory.path2id
 
192
        self.basedir = realpath(basedir)
 
193
 
 
194
        self._set_inventory(self.read_working_inventory())
147
195
 
148
196
        # update the whole cache up front and write to disk if anything changed;
149
197
        # in the future we might want to do this more selectively
159
207
            mutter("write hc")
160
208
            hc.write()
161
209
 
 
210
    def _set_inventory(self, inv):
 
211
        self._inventory = inv
 
212
        self.path2id = self._inventory.path2id
 
213
 
 
214
    @staticmethod
 
215
    def open_containing(path=None):
 
216
        """Open an existing working tree which has its root about path.
 
217
        
 
218
        This probes for a working tree at path and searches upwards from there.
 
219
 
 
220
        Basically we keep looking up until we find the control directory or
 
221
        run into /.  If there isn't one, raises NotBranchError.
 
222
        TODO: give this a new exception.
 
223
        If there is one, it is returned, along with the unused portion of path.
 
224
        """
 
225
        if path is None:
 
226
            path = os.getcwdu()
 
227
        else:
 
228
            # sanity check.
 
229
            if path.find('://') != -1:
 
230
                raise NotBranchError(path=path)
 
231
        path = os.path.abspath(path)
 
232
        tail = ''
 
233
        while True:
 
234
            try:
 
235
                return WorkingTree(path), tail
 
236
            except NotBranchError:
 
237
                pass
 
238
            if tail:
 
239
                tail = os.path.join(os.path.basename(path), tail)
 
240
            else:
 
241
                tail = os.path.basename(path)
 
242
            path = os.path.dirname(path)
 
243
            # FIXME: top in windows is indicated how ???
 
244
            if path == os.path.sep:
 
245
                # reached the root, whatever that may be
 
246
                raise NotBranchError(path=path)
 
247
 
162
248
    def __iter__(self):
163
249
        """Iterate through file_ids for this tree.
164
250
 
170
256
            if bzrlib.osutils.lexists(self.abspath(path)):
171
257
                yield ie.file_id
172
258
 
173
 
 
174
259
    def __repr__(self):
175
260
        return "<%s of %s>" % (self.__class__.__name__,
176
261
                               getattr(self, 'basedir', None))
177
262
 
178
 
 
179
 
 
180
263
    def abspath(self, filename):
181
264
        return os.path.join(self.basedir, filename)
182
265
 
199
282
        return inv.root.file_id
200
283
        
201
284
    def _get_store_filename(self, file_id):
202
 
        ## XXX: badly named; this isn't in the store at all
 
285
        ## XXX: badly named; this is not in the store at all
203
286
        return self.abspath(self.id2path(file_id))
204
287
 
205
288
    @needs_write_lock
206
289
    def commit(self, *args, **kw):
207
290
        from bzrlib.commit import Commit
208
291
        Commit().commit(self.branch, *args, **kw)
209
 
        self._inventory = self.read_working_inventory()
 
292
        self._set_inventory(self.read_working_inventory())
210
293
 
211
294
    def id2abspath(self, file_id):
212
295
        return self.abspath(self.id2path(file_id))
213
296
 
214
 
                
215
297
    def has_id(self, file_id):
216
298
        # files that have been deleted are excluded
217
299
        inv = self._inventory
226
308
        return self.inventory.has_id(file_id)
227
309
 
228
310
    __contains__ = has_id
229
 
    
230
311
 
231
312
    def get_file_size(self, file_id):
232
313
        return os.path.getsize(self.id2abspath(file_id))
235
316
        path = self._inventory.id2path(file_id)
236
317
        return self._hashcache.get_sha1(path)
237
318
 
238
 
 
239
319
    def is_executable(self, file_id):
240
320
        if os.name == "nt":
241
321
            return self._inventory[file_id].executable
245
325
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
246
326
 
247
327
    @needs_write_lock
 
328
    def add(self, files, ids=None):
 
329
        """Make files versioned.
 
330
 
 
331
        Note that the command line normally calls smart_add instead,
 
332
        which can automatically recurse.
 
333
 
 
334
        This adds the files to the inventory, so that they will be
 
335
        recorded by the next commit.
 
336
 
 
337
        files
 
338
            List of paths to add, relative to the base of the tree.
 
339
 
 
340
        ids
 
341
            If set, use these instead of automatically generated ids.
 
342
            Must be the same length as the list of files, but may
 
343
            contain None for ids that are to be autogenerated.
 
344
 
 
345
        TODO: Perhaps have an option to add the ids even if the files do
 
346
              not (yet) exist.
 
347
 
 
348
        TODO: Perhaps callback with the ids and paths as they're added.
 
349
        """
 
350
        # TODO: Re-adding a file that is removed in the working copy
 
351
        # should probably put it back with the previous ID.
 
352
        if isinstance(files, basestring):
 
353
            assert(ids is None or isinstance(ids, basestring))
 
354
            files = [files]
 
355
            if ids is not None:
 
356
                ids = [ids]
 
357
 
 
358
        if ids is None:
 
359
            ids = [None] * len(files)
 
360
        else:
 
361
            assert(len(ids) == len(files))
 
362
 
 
363
        inv = self.read_working_inventory()
 
364
        for f,file_id in zip(files, ids):
 
365
            if is_control_file(f):
 
366
                raise BzrError("cannot add control file %s" % quotefn(f))
 
367
 
 
368
            fp = splitpath(f)
 
369
 
 
370
            if len(fp) == 0:
 
371
                raise BzrError("cannot add top-level %r" % f)
 
372
 
 
373
            fullpath = os.path.normpath(self.abspath(f))
 
374
 
 
375
            try:
 
376
                kind = file_kind(fullpath)
 
377
            except OSError:
 
378
                # maybe something better?
 
379
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
 
380
 
 
381
            if not InventoryEntry.versionable_kind(kind):
 
382
                raise BzrError('cannot add: not a versionable file ('
 
383
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
 
384
 
 
385
            if file_id is None:
 
386
                file_id = gen_file_id(f)
 
387
            inv.add_path(f, kind=kind, file_id=file_id)
 
388
 
 
389
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
390
        self._write_inventory(inv)
 
391
 
 
392
    @needs_write_lock
248
393
    def add_pending_merge(self, *revision_ids):
249
394
        # TODO: Perhaps should check at this point that the
250
395
        # history of the revision is actually present?
359
504
 
360
505
        for f in descend('', inv.root.file_id, self.basedir):
361
506
            yield f
362
 
            
363
 
 
364
 
 
 
507
 
 
508
    @needs_write_lock
 
509
    def move(self, from_paths, to_name):
 
510
        """Rename files.
 
511
 
 
512
        to_name must exist in the inventory.
 
513
 
 
514
        If to_name exists and is a directory, the files are moved into
 
515
        it, keeping their old names.  
 
516
 
 
517
        Note that to_name is only the last component of the new name;
 
518
        this doesn't change the directory.
 
519
 
 
520
        This returns a list of (from_path, to_path) pairs for each
 
521
        entry that is moved.
 
522
        """
 
523
        result = []
 
524
        ## TODO: Option to move IDs only
 
525
        assert not isinstance(from_paths, basestring)
 
526
        inv = self.inventory
 
527
        to_abs = self.abspath(to_name)
 
528
        if not isdir(to_abs):
 
529
            raise BzrError("destination %r is not a directory" % to_abs)
 
530
        if not self.has_filename(to_name):
 
531
            raise BzrError("destination %r not in working directory" % to_abs)
 
532
        to_dir_id = inv.path2id(to_name)
 
533
        if to_dir_id == None and to_name != '':
 
534
            raise BzrError("destination %r is not a versioned directory" % to_name)
 
535
        to_dir_ie = inv[to_dir_id]
 
536
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
537
            raise BzrError("destination %r is not a directory" % to_abs)
 
538
 
 
539
        to_idpath = inv.get_idpath(to_dir_id)
 
540
 
 
541
        for f in from_paths:
 
542
            if not self.has_filename(f):
 
543
                raise BzrError("%r does not exist in working tree" % f)
 
544
            f_id = inv.path2id(f)
 
545
            if f_id == None:
 
546
                raise BzrError("%r is not versioned" % f)
 
547
            name_tail = splitpath(f)[-1]
 
548
            dest_path = appendpath(to_name, name_tail)
 
549
            if self.has_filename(dest_path):
 
550
                raise BzrError("destination %r already exists" % dest_path)
 
551
            if f_id in to_idpath:
 
552
                raise BzrError("can't move %r to a subdirectory of itself" % f)
 
553
 
 
554
        # OK, so there's a race here, it's possible that someone will
 
555
        # create a file in this interval and then the rename might be
 
556
        # left half-done.  But we should have caught most problems.
 
557
        orig_inv = deepcopy(self.inventory)
 
558
        try:
 
559
            for f in from_paths:
 
560
                name_tail = splitpath(f)[-1]
 
561
                dest_path = appendpath(to_name, name_tail)
 
562
                result.append((f, dest_path))
 
563
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
564
                try:
 
565
                    rename(self.abspath(f), self.abspath(dest_path))
 
566
                except OSError, e:
 
567
                    raise BzrError("failed to rename %r to %r: %s" %
 
568
                                   (f, dest_path, e[1]),
 
569
                            ["rename rolled back"])
 
570
        except:
 
571
            # restore the inventory on error
 
572
            self._set_inventory(orig_inv)
 
573
            raise
 
574
        self._write_inventory(inv)
 
575
        return result
 
576
 
 
577
    @needs_write_lock
 
578
    def rename_one(self, from_rel, to_rel):
 
579
        """Rename one file.
 
580
 
 
581
        This can change the directory or the filename or both.
 
582
        """
 
583
        inv = self.inventory
 
584
        if not self.has_filename(from_rel):
 
585
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
586
        if self.has_filename(to_rel):
 
587
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
588
 
 
589
        file_id = inv.path2id(from_rel)
 
590
        if file_id == None:
 
591
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
592
 
 
593
        entry = inv[file_id]
 
594
        from_parent = entry.parent_id
 
595
        from_name = entry.name
 
596
        
 
597
        if inv.path2id(to_rel):
 
598
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
599
 
 
600
        to_dir, to_tail = os.path.split(to_rel)
 
601
        to_dir_id = inv.path2id(to_dir)
 
602
        if to_dir_id == None and to_dir != '':
 
603
            raise BzrError("can't determine destination directory id for %r" % to_dir)
 
604
 
 
605
        mutter("rename_one:")
 
606
        mutter("  file_id    {%s}" % file_id)
 
607
        mutter("  from_rel   %r" % from_rel)
 
608
        mutter("  to_rel     %r" % to_rel)
 
609
        mutter("  to_dir     %r" % to_dir)
 
610
        mutter("  to_dir_id  {%s}" % to_dir_id)
 
611
 
 
612
        inv.rename(file_id, to_dir_id, to_tail)
 
613
 
 
614
        from_abs = self.abspath(from_rel)
 
615
        to_abs = self.abspath(to_rel)
 
616
        try:
 
617
            rename(from_abs, to_abs)
 
618
        except OSError, e:
 
619
            inv.rename(file_id, from_parent, from_name)
 
620
            raise BzrError("failed to rename %r to %r: %s"
 
621
                    % (from_abs, to_abs, e[1]),
 
622
                    ["rename rolled back"])
 
623
        self._write_inventory(inv)
 
624
 
 
625
    @needs_read_lock
365
626
    def unknowns(self):
 
627
        """Return all unknown files.
 
628
 
 
629
        These are files in the working directory that are not versioned or
 
630
        control files or ignored.
 
631
        
 
632
        >>> from bzrlib.branch import ScratchBranch
 
633
        >>> b = ScratchBranch(files=['foo', 'foo~'])
 
634
        >>> tree = WorkingTree(b.base, b)
 
635
        >>> map(str, tree.unknowns())
 
636
        ['foo']
 
637
        >>> tree.add('foo')
 
638
        >>> list(b.unknowns())
 
639
        []
 
640
        >>> tree.remove('foo')
 
641
        >>> list(b.unknowns())
 
642
        [u'foo']
 
643
        """
366
644
        for subp in self.extras():
367
645
            if not self.is_ignored(subp):
368
646
                yield subp
622
900
            f.commit()
623
901
        finally:
624
902
            f.close()
 
903
        self._set_inventory(inv)
625
904
        mutter('wrote working inventory')
626
905
            
627
906