~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

- prepare for 0.0.9 release

Show diffs side-by-side

added added

removed removed

Lines of Context:
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
"""WorkingTree object and friends.
18
 
 
19
 
A WorkingTree represents the editable working copy of a branch.
20
 
Operations which represent the WorkingTree are also done here, 
21
 
such as renaming or adding files.  The WorkingTree has an inventory 
22
 
which is updated by these operations.  A commit produces a 
23
 
new revision based on the workingtree and its inventory.
24
 
 
25
 
At the moment every WorkingTree has its own branch.  Remote
26
 
WorkingTrees aren't supported.
27
 
 
28
 
To get a WorkingTree, call Branch.working_tree():
29
 
"""
30
 
 
31
 
 
32
 
# TODO: Don't allow WorkingTrees to be constructed for remote branches if 
33
 
# they don't work.
 
17
# TODO: Don't allow WorkingTrees to be constructed for remote branches.
34
18
 
35
19
# FIXME: I don't know if writing out the cache from the destructor is really a
36
 
# good idea, because destructors are considered poor taste in Python, and it's
37
 
# not predictable when it will be written out.
38
 
 
39
 
# TODO: Give the workingtree sole responsibility for the working inventory;
40
 
# remove the variable and references to it from the branch.  This may require
41
 
# updating the commit code so as to update the inventory within the working
42
 
# copy, and making sure there's only one WorkingTree for any directory on disk.
43
 
# At the momenthey may alias the inventory and have old copies of it in memory.
44
 
 
45
 
from copy import deepcopy
 
20
# good idea, because destructors are considered poor taste in Python, and
 
21
# it's not predictable when it will be written out.
 
22
 
46
23
import os
47
 
import stat
48
24
import fnmatch
49
 
 
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
 
                           WeaveRevisionNotPresent,
59
 
                           NotBranchError,
60
 
                           NotVersionedError)
61
 
from bzrlib.inventory import InventoryEntry
62
 
from bzrlib.osutils import (appendpath,
63
 
                            compact_date,
64
 
                            file_kind,
65
 
                            isdir,
66
 
                            getcwd,
67
 
                            pathjoin,
68
 
                            pumpfile,
69
 
                            splitpath,
70
 
                            rand_bytes,
71
 
                            abspath,
72
 
                            normpath,
73
 
                            realpath,
74
 
                            relpath,
75
 
                            rename)
76
 
from bzrlib.textui import show_status
 
25
        
77
26
import bzrlib.tree
 
27
from bzrlib.osutils import appendpath, file_kind, isdir, splitpath
 
28
from bzrlib.errors import BzrCheckError
78
29
from bzrlib.trace import mutter
79
 
import bzrlib.xml5
80
 
 
81
 
 
82
 
def gen_file_id(name):
83
 
    """Return new file id.
84
 
 
85
 
    This should probably generate proper UUIDs, but for the moment we
86
 
    cope with just randomness because running uuidgen every time is
87
 
    slow."""
88
 
    import re
89
 
    from binascii import hexlify
90
 
    from time import time
91
 
 
92
 
    # get last component
93
 
    idx = name.rfind('/')
94
 
    if idx != -1:
95
 
        name = name[idx+1 : ]
96
 
    idx = name.rfind('\\')
97
 
    if idx != -1:
98
 
        name = name[idx+1 : ]
99
 
 
100
 
    # make it not a hidden file
101
 
    name = name.lstrip('.')
102
 
 
103
 
    # remove any wierd characters; we don't escape them but rather
104
 
    # just pull them out
105
 
    name = re.sub(r'[^\w.]', '', name)
106
 
 
107
 
    s = hexlify(rand_bytes(8))
108
 
    return '-'.join((name, compact_date(time()), s))
109
 
 
110
 
 
111
 
def gen_root_id():
112
 
    """Return a new tree-root file id."""
113
 
    return gen_file_id('TREE_ROOT')
114
 
 
115
 
 
116
 
class TreeEntry(object):
117
 
    """An entry that implements the minium interface used by commands.
118
 
 
119
 
    This needs further inspection, it may be better to have 
120
 
    InventoryEntries without ids - though that seems wrong. For now,
121
 
    this is a parallel hierarchy to InventoryEntry, and needs to become
122
 
    one of several things: decorates to that hierarchy, children of, or
123
 
    parents of it.
124
 
    Another note is that these objects are currently only used when there is
125
 
    no InventoryEntry available - i.e. for unversioned objects.
126
 
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
127
 
    """
128
 
 
129
 
    def __eq__(self, other):
130
 
        # yes, this us ugly, TODO: best practice __eq__ style.
131
 
        return (isinstance(other, TreeEntry)
132
 
                and other.__class__ == self.__class__)
133
 
 
134
 
    def kind_character(self):
135
 
        return "???"
136
 
 
137
 
 
138
 
class TreeDirectory(TreeEntry):
139
 
    """See TreeEntry. This is a directory in a working tree."""
140
 
 
141
 
    def __eq__(self, other):
142
 
        return (isinstance(other, TreeDirectory)
143
 
                and other.__class__ == self.__class__)
144
 
 
145
 
    def kind_character(self):
146
 
        return "/"
147
 
 
148
 
 
149
 
class TreeFile(TreeEntry):
150
 
    """See TreeEntry. This is a regular file in a working tree."""
151
 
 
152
 
    def __eq__(self, other):
153
 
        return (isinstance(other, TreeFile)
154
 
                and other.__class__ == self.__class__)
155
 
 
156
 
    def kind_character(self):
157
 
        return ''
158
 
 
159
 
 
160
 
class TreeLink(TreeEntry):
161
 
    """See TreeEntry. This is a symlink in a working tree."""
162
 
 
163
 
    def __eq__(self, other):
164
 
        return (isinstance(other, TreeLink)
165
 
                and other.__class__ == self.__class__)
166
 
 
167
 
    def kind_character(self):
168
 
        return ''
169
 
 
170
30
 
171
31
class WorkingTree(bzrlib.tree.Tree):
172
32
    """Working copy tree.
177
37
    It is possible for a `WorkingTree` to have a filename which is
178
38
    not listed in the Inventory and vice versa.
179
39
    """
180
 
 
181
 
    def __init__(self, basedir=u'.', branch=None):
182
 
        """Construct a WorkingTree for basedir.
183
 
 
184
 
        If the branch is not supplied, it is opened automatically.
185
 
        If the branch is supplied, it must be the branch for this basedir.
186
 
        (branch.base is not cross checked, because for remote branches that
187
 
        would be meaningless).
188
 
        """
 
40
    def __init__(self, basedir, inv):
189
41
        from bzrlib.hashcache import HashCache
190
42
        from bzrlib.trace import note, mutter
191
 
        assert isinstance(basedir, basestring), \
192
 
            "base directory %r is not a string" % basedir
193
 
        if branch is None:
194
 
            branch = Branch.open(basedir)
195
 
        assert isinstance(branch, Branch), \
196
 
            "branch %r is not a Branch" % branch
197
 
        self.branch = branch
198
 
        self.basedir = realpath(basedir)
 
43
 
 
44
        self._inventory = inv
 
45
        self.basedir = basedir
 
46
        self.path2id = inv.path2id
199
47
 
200
48
        # update the whole cache up front and write to disk if anything changed;
201
49
        # in the future we might want to do this more selectively
202
 
        # two possible ways offer themselves : in self._unlock, write the cache
203
 
        # if needed, or, when the cache sees a change, append it to the hash
204
 
        # cache file, and have the parser take the most recent entry for a
205
 
        # given path only.
206
50
        hc = self._hashcache = HashCache(basedir)
207
51
        hc.read()
208
52
        hc.scan()
210
54
        if hc.needs_write:
211
55
            mutter("write hc")
212
56
            hc.write()
213
 
 
214
 
        self._set_inventory(self.read_working_inventory())
215
 
 
216
 
    def _set_inventory(self, inv):
217
 
        self._inventory = inv
218
 
        self.path2id = self._inventory.path2id
219
 
 
220
 
    @staticmethod
221
 
    def open_containing(path=None):
222
 
        """Open an existing working tree which has its root about path.
223
 
        
224
 
        This probes for a working tree at path and searches upwards from there.
225
 
 
226
 
        Basically we keep looking up until we find the control directory or
227
 
        run into /.  If there isn't one, raises NotBranchError.
228
 
        TODO: give this a new exception.
229
 
        If there is one, it is returned, along with the unused portion of path.
230
 
        """
231
 
        if path is None:
232
 
            path = getcwd()
233
 
        else:
234
 
            # sanity check.
235
 
            if path.find('://') != -1:
236
 
                raise NotBranchError(path=path)
237
 
        path = abspath(path)
238
 
        tail = u''
239
 
        while True:
240
 
            try:
241
 
                return WorkingTree(path), tail
242
 
            except NotBranchError:
243
 
                pass
244
 
            if tail:
245
 
                tail = pathjoin(os.path.basename(path), tail)
246
 
            else:
247
 
                tail = os.path.basename(path)
248
 
            lastpath = path
249
 
            path = os.path.dirname(path)
250
 
            if lastpath == path:
251
 
                # reached the root, whatever that may be
252
 
                raise NotBranchError(path=path)
 
57
            
 
58
            
 
59
    def __del__(self):
 
60
        if self._hashcache.needs_write:
 
61
            self._hashcache.write()
 
62
 
253
63
 
254
64
    def __iter__(self):
255
65
        """Iterate through file_ids for this tree.
259
69
        """
260
70
        inv = self._inventory
261
71
        for path, ie in inv.iter_entries():
262
 
            if bzrlib.osutils.lexists(self.abspath(path)):
 
72
            if os.path.exists(self.abspath(path)):
263
73
                yield ie.file_id
264
74
 
 
75
 
265
76
    def __repr__(self):
266
77
        return "<%s of %s>" % (self.__class__.__name__,
267
78
                               getattr(self, 'basedir', None))
268
79
 
 
80
 
 
81
 
269
82
    def abspath(self, filename):
270
 
        return pathjoin(self.basedir, filename)
271
 
 
272
 
    def relpath(self, abs):
273
 
        """Return the local path portion from a given absolute path."""
274
 
        return relpath(self.basedir, abs)
 
83
        return os.path.join(self.basedir, filename)
275
84
 
276
85
    def has_filename(self, filename):
277
 
        return bzrlib.osutils.lexists(self.abspath(filename))
 
86
        return os.path.exists(self.abspath(filename))
278
87
 
279
88
    def get_file(self, file_id):
280
89
        return self.get_file_byname(self.id2path(file_id))
282
91
    def get_file_byname(self, filename):
283
92
        return file(self.abspath(filename), 'rb')
284
93
 
285
 
    def get_root_id(self):
286
 
        """Return the id of this trees root"""
287
 
        inv = self.read_working_inventory()
288
 
        return inv.root.file_id
289
 
        
290
94
    def _get_store_filename(self, file_id):
291
 
        ## XXX: badly named; this is not in the store at all
292
 
        return self.abspath(self.id2path(file_id))
293
 
 
294
 
    @needs_write_lock
295
 
    def commit(self, *args, **kw):
296
 
        from bzrlib.commit import Commit
297
 
        Commit().commit(self.branch, *args, **kw)
298
 
        self._set_inventory(self.read_working_inventory())
299
 
 
300
 
    def id2abspath(self, file_id):
301
 
        return self.abspath(self.id2path(file_id))
302
 
 
 
95
        ## XXX: badly named; this isn't in the store at all
 
96
        return self.abspath(self.id2path(file_id))
 
97
 
 
98
                
303
99
    def has_id(self, file_id):
304
100
        # files that have been deleted are excluded
305
101
        inv = self._inventory
306
102
        if not inv.has_id(file_id):
307
103
            return False
308
104
        path = inv.id2path(file_id)
309
 
        return bzrlib.osutils.lexists(self.abspath(path))
 
105
        return os.path.exists(self.abspath(path))
310
106
 
311
 
    def has_or_had_id(self, file_id):
312
 
        if file_id == self.inventory.root.file_id:
313
 
            return True
314
 
        return self.inventory.has_id(file_id)
315
107
 
316
108
    __contains__ = has_id
 
109
    
317
110
 
318
111
    def get_file_size(self, file_id):
319
 
        return os.path.getsize(self.id2abspath(file_id))
320
 
 
321
 
    @needs_read_lock
 
112
        # is this still called?
 
113
        raise NotImplementedError()
 
114
 
 
115
 
322
116
    def get_file_sha1(self, file_id):
323
117
        path = self._inventory.id2path(file_id)
324
118
        return self._hashcache.get_sha1(path)
325
119
 
326
 
    def is_executable(self, file_id):
327
 
        if os.name == "nt":
328
 
            return self._inventory[file_id].executable
329
 
        else:
330
 
            path = self._inventory.id2path(file_id)
331
 
            mode = os.lstat(self.abspath(path)).st_mode
332
 
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
333
 
 
334
 
    @needs_write_lock
335
 
    def add(self, files, ids=None):
336
 
        """Make files versioned.
337
 
 
338
 
        Note that the command line normally calls smart_add instead,
339
 
        which can automatically recurse.
340
 
 
341
 
        This adds the files to the inventory, so that they will be
342
 
        recorded by the next commit.
343
 
 
344
 
        files
345
 
            List of paths to add, relative to the base of the tree.
346
 
 
347
 
        ids
348
 
            If set, use these instead of automatically generated ids.
349
 
            Must be the same length as the list of files, but may
350
 
            contain None for ids that are to be autogenerated.
351
 
 
352
 
        TODO: Perhaps have an option to add the ids even if the files do
353
 
              not (yet) exist.
354
 
 
355
 
        TODO: Perhaps callback with the ids and paths as they're added.
356
 
        """
357
 
        # TODO: Re-adding a file that is removed in the working copy
358
 
        # should probably put it back with the previous ID.
359
 
        if isinstance(files, basestring):
360
 
            assert(ids is None or isinstance(ids, basestring))
361
 
            files = [files]
362
 
            if ids is not None:
363
 
                ids = [ids]
364
 
 
365
 
        if ids is None:
366
 
            ids = [None] * len(files)
367
 
        else:
368
 
            assert(len(ids) == len(files))
369
 
 
370
 
        inv = self.read_working_inventory()
371
 
        for f,file_id in zip(files, ids):
372
 
            if is_control_file(f):
373
 
                raise BzrError("cannot add control file %s" % quotefn(f))
374
 
 
375
 
            fp = splitpath(f)
376
 
 
377
 
            if len(fp) == 0:
378
 
                raise BzrError("cannot add top-level %r" % f)
379
 
 
380
 
            fullpath = normpath(self.abspath(f))
381
 
 
382
 
            try:
383
 
                kind = file_kind(fullpath)
384
 
            except OSError:
385
 
                # maybe something better?
386
 
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
387
 
 
388
 
            if not InventoryEntry.versionable_kind(kind):
389
 
                raise BzrError('cannot add: not a versionable file ('
390
 
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
391
 
 
392
 
            if file_id is None:
393
 
                file_id = gen_file_id(f)
394
 
            inv.add_path(f, kind=kind, file_id=file_id)
395
 
 
396
 
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
397
 
        self._write_inventory(inv)
398
 
 
399
 
    @needs_write_lock
400
 
    def add_pending_merge(self, *revision_ids):
401
 
        # TODO: Perhaps should check at this point that the
402
 
        # history of the revision is actually present?
403
 
        p = self.pending_merges()
404
 
        updated = False
405
 
        for rev_id in revision_ids:
406
 
            if rev_id in p:
407
 
                continue
408
 
            p.append(rev_id)
409
 
            updated = True
410
 
        if updated:
411
 
            self.set_pending_merges(p)
412
 
 
413
 
    def pending_merges(self):
414
 
        """Return a list of pending merges.
415
 
 
416
 
        These are revisions that have been merged into the working
417
 
        directory but not yet committed.
418
 
        """
419
 
        cfn = self.branch._rel_controlfilename('pending-merges')
420
 
        if not self.branch._transport.has(cfn):
421
 
            return []
422
 
        p = []
423
 
        for l in self.branch.controlfile('pending-merges', 'r').readlines():
424
 
            p.append(l.rstrip('\n'))
425
 
        return p
426
 
 
427
 
    @needs_write_lock
428
 
    def set_pending_merges(self, rev_list):
429
 
        self.branch.put_controlfile('pending-merges', '\n'.join(rev_list))
430
 
 
431
 
    def get_symlink_target(self, file_id):
432
 
        return os.readlink(self.id2abspath(file_id))
433
120
 
434
121
    def file_class(self, filename):
435
122
        if self.path2id(filename):
484
171
                                            "now of kind %r"
485
172
                                            % (fap, f_ie.kind, f_ie.file_id, fk))
486
173
 
487
 
                # make a last minute entry
488
 
                if f_ie:
489
 
                    entry = f_ie
490
 
                else:
491
 
                    if fk == 'directory':
492
 
                        entry = TreeDirectory()
493
 
                    elif fk == 'file':
494
 
                        entry = TreeFile()
495
 
                    elif fk == 'symlink':
496
 
                        entry = TreeLink()
497
 
                    else:
498
 
                        entry = TreeEntry()
499
 
                
500
 
                yield fp, c, fk, (f_ie and f_ie.file_id), entry
 
174
                yield fp, c, fk, (f_ie and f_ie.file_id)
501
175
 
502
176
                if fk != 'directory':
503
177
                    continue
509
183
                for ff in descend(fp, f_ie.file_id, fap):
510
184
                    yield ff
511
185
 
512
 
        for f in descend(u'', inv.root.file_id, self.basedir):
 
186
        for f in descend('', inv.root.file_id, self.basedir):
513
187
            yield f
514
 
 
515
 
    @needs_write_lock
516
 
    def move(self, from_paths, to_name):
517
 
        """Rename files.
518
 
 
519
 
        to_name must exist in the inventory.
520
 
 
521
 
        If to_name exists and is a directory, the files are moved into
522
 
        it, keeping their old names.  
523
 
 
524
 
        Note that to_name is only the last component of the new name;
525
 
        this doesn't change the directory.
526
 
 
527
 
        This returns a list of (from_path, to_path) pairs for each
528
 
        entry that is moved.
529
 
        """
530
 
        result = []
531
 
        ## TODO: Option to move IDs only
532
 
        assert not isinstance(from_paths, basestring)
533
 
        inv = self.inventory
534
 
        to_abs = self.abspath(to_name)
535
 
        if not isdir(to_abs):
536
 
            raise BzrError("destination %r is not a directory" % to_abs)
537
 
        if not self.has_filename(to_name):
538
 
            raise BzrError("destination %r not in working directory" % to_abs)
539
 
        to_dir_id = inv.path2id(to_name)
540
 
        if to_dir_id == None and to_name != '':
541
 
            raise BzrError("destination %r is not a versioned directory" % to_name)
542
 
        to_dir_ie = inv[to_dir_id]
543
 
        if to_dir_ie.kind not in ('directory', 'root_directory'):
544
 
            raise BzrError("destination %r is not a directory" % to_abs)
545
 
 
546
 
        to_idpath = inv.get_idpath(to_dir_id)
547
 
 
548
 
        for f in from_paths:
549
 
            if not self.has_filename(f):
550
 
                raise BzrError("%r does not exist in working tree" % f)
551
 
            f_id = inv.path2id(f)
552
 
            if f_id == None:
553
 
                raise BzrError("%r is not versioned" % f)
554
 
            name_tail = splitpath(f)[-1]
555
 
            dest_path = appendpath(to_name, name_tail)
556
 
            if self.has_filename(dest_path):
557
 
                raise BzrError("destination %r already exists" % dest_path)
558
 
            if f_id in to_idpath:
559
 
                raise BzrError("can't move %r to a subdirectory of itself" % f)
560
 
 
561
 
        # OK, so there's a race here, it's possible that someone will
562
 
        # create a file in this interval and then the rename might be
563
 
        # left half-done.  But we should have caught most problems.
564
 
        orig_inv = deepcopy(self.inventory)
565
 
        try:
566
 
            for f in from_paths:
567
 
                name_tail = splitpath(f)[-1]
568
 
                dest_path = appendpath(to_name, name_tail)
569
 
                result.append((f, dest_path))
570
 
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
571
 
                try:
572
 
                    rename(self.abspath(f), self.abspath(dest_path))
573
 
                except OSError, e:
574
 
                    raise BzrError("failed to rename %r to %r: %s" %
575
 
                                   (f, dest_path, e[1]),
576
 
                            ["rename rolled back"])
577
 
        except:
578
 
            # restore the inventory on error
579
 
            self._set_inventory(orig_inv)
580
 
            raise
581
 
        self._write_inventory(inv)
582
 
        return result
583
 
 
584
 
    @needs_write_lock
585
 
    def rename_one(self, from_rel, to_rel):
586
 
        """Rename one file.
587
 
 
588
 
        This can change the directory or the filename or both.
589
 
        """
590
 
        inv = self.inventory
591
 
        if not self.has_filename(from_rel):
592
 
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
593
 
        if self.has_filename(to_rel):
594
 
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
595
 
 
596
 
        file_id = inv.path2id(from_rel)
597
 
        if file_id == None:
598
 
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
599
 
 
600
 
        entry = inv[file_id]
601
 
        from_parent = entry.parent_id
602
 
        from_name = entry.name
603
 
        
604
 
        if inv.path2id(to_rel):
605
 
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
606
 
 
607
 
        to_dir, to_tail = os.path.split(to_rel)
608
 
        to_dir_id = inv.path2id(to_dir)
609
 
        if to_dir_id == None and to_dir != '':
610
 
            raise BzrError("can't determine destination directory id for %r" % to_dir)
611
 
 
612
 
        mutter("rename_one:")
613
 
        mutter("  file_id    {%s}" % file_id)
614
 
        mutter("  from_rel   %r" % from_rel)
615
 
        mutter("  to_rel     %r" % to_rel)
616
 
        mutter("  to_dir     %r" % to_dir)
617
 
        mutter("  to_dir_id  {%s}" % to_dir_id)
618
 
 
619
 
        inv.rename(file_id, to_dir_id, to_tail)
620
 
 
621
 
        from_abs = self.abspath(from_rel)
622
 
        to_abs = self.abspath(to_rel)
623
 
        try:
624
 
            rename(from_abs, to_abs)
625
 
        except OSError, e:
626
 
            inv.rename(file_id, from_parent, from_name)
627
 
            raise BzrError("failed to rename %r to %r: %s"
628
 
                    % (from_abs, to_abs, e[1]),
629
 
                    ["rename rolled back"])
630
 
        self._write_inventory(inv)
631
 
 
632
 
    @needs_read_lock
 
188
            
 
189
 
 
190
 
633
191
    def unknowns(self):
634
 
        """Return all unknown files.
635
 
 
636
 
        These are files in the working directory that are not versioned or
637
 
        control files or ignored.
638
 
        
639
 
        >>> from bzrlib.branch import ScratchBranch
640
 
        >>> b = ScratchBranch(files=['foo', 'foo~'])
641
 
        >>> tree = WorkingTree(b.base, b)
642
 
        >>> map(str, tree.unknowns())
643
 
        ['foo']
644
 
        >>> tree.add('foo')
645
 
        >>> list(b.unknowns())
646
 
        []
647
 
        >>> tree.remove('foo')
648
 
        >>> list(b.unknowns())
649
 
        [u'foo']
650
 
        """
651
192
        for subp in self.extras():
652
193
            if not self.is_ignored(subp):
653
194
                yield subp
654
195
 
655
 
    def iter_conflicts(self):
656
 
        conflicted = set()
657
 
        for path in (s[0] for s in self.list_files()):
658
 
            stem = get_conflicted_stem(path)
659
 
            if stem is None:
660
 
                continue
661
 
            if stem not in conflicted:
662
 
                conflicted.add(stem)
663
 
                yield stem
664
 
 
665
 
    @needs_write_lock
666
 
    def pull(self, source, overwrite=False):
667
 
        from bzrlib.merge import merge_inner
668
 
        source.lock_read()
669
 
        try:
670
 
            old_revision_history = self.branch.revision_history()
671
 
            count = self.branch.pull(source, overwrite)
672
 
            new_revision_history = self.branch.revision_history()
673
 
            if new_revision_history != old_revision_history:
674
 
                if len(old_revision_history):
675
 
                    other_revision = old_revision_history[-1]
676
 
                else:
677
 
                    other_revision = None
678
 
                merge_inner(self.branch,
679
 
                            self.branch.basis_tree(), 
680
 
                            self.branch.revision_tree(other_revision))
681
 
            return count
682
 
        finally:
683
 
            source.unlock()
684
196
 
685
197
    def extras(self):
686
198
        """Yield all unknown files in this WorkingTree.
693
205
        """
694
206
        ## TODO: Work from given directory downwards
695
207
        for path, dir_entry in self.inventory.directories():
696
 
            mutter("search for unknowns in %r", path)
 
208
            mutter("search for unknowns in %r" % path)
697
209
            dirabs = self.abspath(path)
698
210
            if not isdir(dirabs):
699
211
                # e.g. directory deleted
772
284
                    return pat
773
285
        else:
774
286
            return None
775
 
 
776
 
    def kind(self, file_id):
777
 
        return file_kind(self.id2abspath(file_id))
778
 
 
779
 
    def lock_read(self):
780
 
        """See Branch.lock_read, and WorkingTree.unlock."""
781
 
        return self.branch.lock_read()
782
 
 
783
 
    def lock_write(self):
784
 
        """See Branch.lock_write, and WorkingTree.unlock."""
785
 
        return self.branch.lock_write()
786
 
 
787
 
    def _basis_inventory_name(self, revision_id):
788
 
        return 'basis-inventory.%s' % revision_id
789
 
 
790
 
    def set_last_revision(self, new_revision, old_revision=None):
791
 
        if old_revision:
792
 
            try:
793
 
                path = self._basis_inventory_name(old_revision)
794
 
                path = self.branch._rel_controlfilename(path)
795
 
                self.branch._transport.delete(path)
796
 
            except:
797
 
                pass
798
 
        try:
799
 
            xml = self.branch.get_inventory_xml(new_revision)
800
 
            path = self._basis_inventory_name(new_revision)
801
 
            self.branch.put_controlfile(path, xml)
802
 
        except WeaveRevisionNotPresent:
803
 
            pass
804
 
 
805
 
    def read_basis_inventory(self, revision_id):
806
 
        """Read the cached basis inventory."""
807
 
        path = self._basis_inventory_name(revision_id)
808
 
        return self.branch.controlfile(path, 'r').read()
809
 
        
810
 
    @needs_read_lock
811
 
    def read_working_inventory(self):
812
 
        """Read the working inventory."""
813
 
        # ElementTree does its own conversion from UTF-8, so open in
814
 
        # binary.
815
 
        f = self.branch.controlfile('inventory', 'rb')
816
 
        return bzrlib.xml5.serializer_v5.read_inventory(f)
817
 
 
818
 
    @needs_write_lock
819
 
    def remove(self, files, verbose=False):
820
 
        """Remove nominated files from the working inventory..
821
 
 
822
 
        This does not remove their text.  This does not run on XXX on what? RBC
823
 
 
824
 
        TODO: Refuse to remove modified files unless --force is given?
825
 
 
826
 
        TODO: Do something useful with directories.
827
 
 
828
 
        TODO: Should this remove the text or not?  Tough call; not
829
 
        removing may be useful and the user can just use use rm, and
830
 
        is the opposite of add.  Removing it is consistent with most
831
 
        other tools.  Maybe an option.
832
 
        """
833
 
        ## TODO: Normalize names
834
 
        ## TODO: Remove nested loops; better scalability
835
 
        if isinstance(files, basestring):
836
 
            files = [files]
837
 
 
838
 
        inv = self.inventory
839
 
 
840
 
        # do this before any modifications
841
 
        for f in files:
842
 
            fid = inv.path2id(f)
843
 
            if not fid:
844
 
                # TODO: Perhaps make this just a warning, and continue?
845
 
                # This tends to happen when 
846
 
                raise NotVersionedError(path=f)
847
 
            mutter("remove inventory entry %s {%s}", quotefn(f), fid)
848
 
            if verbose:
849
 
                # having remove it, it must be either ignored or unknown
850
 
                if self.is_ignored(f):
851
 
                    new_status = 'I'
852
 
                else:
853
 
                    new_status = '?'
854
 
                show_status(new_status, inv[fid].kind, quotefn(f))
855
 
            del inv[fid]
856
 
 
857
 
        self._write_inventory(inv)
858
 
 
859
 
    @needs_write_lock
860
 
    def revert(self, filenames, old_tree=None, backups=True):
861
 
        from bzrlib.merge import merge_inner
862
 
        if old_tree is None:
863
 
            old_tree = self.branch.basis_tree()
864
 
        merge_inner(self.branch, old_tree,
865
 
                    self, ignore_zero=True,
866
 
                    backup_files=backups, 
867
 
                    interesting_files=filenames)
868
 
        if not len(filenames):
869
 
            self.set_pending_merges([])
870
 
 
871
 
    @needs_write_lock
872
 
    def set_inventory(self, new_inventory_list):
873
 
        from bzrlib.inventory import (Inventory,
874
 
                                      InventoryDirectory,
875
 
                                      InventoryEntry,
876
 
                                      InventoryFile,
877
 
                                      InventoryLink)
878
 
        inv = Inventory(self.get_root_id())
879
 
        for path, file_id, parent, kind in new_inventory_list:
880
 
            name = os.path.basename(path)
881
 
            if name == "":
882
 
                continue
883
 
            # fixme, there should be a factory function inv,add_?? 
884
 
            if kind == 'directory':
885
 
                inv.add(InventoryDirectory(file_id, name, parent))
886
 
            elif kind == 'file':
887
 
                inv.add(InventoryFile(file_id, name, parent))
888
 
            elif kind == 'symlink':
889
 
                inv.add(InventoryLink(file_id, name, parent))
890
 
            else:
891
 
                raise BzrError("unknown kind %r" % kind)
892
 
        self._write_inventory(inv)
893
 
 
894
 
    @needs_write_lock
895
 
    def set_root_id(self, file_id):
896
 
        """Set the root id for this tree."""
897
 
        inv = self.read_working_inventory()
898
 
        orig_root_id = inv.root.file_id
899
 
        del inv._byid[inv.root.file_id]
900
 
        inv.root.file_id = file_id
901
 
        inv._byid[inv.root.file_id] = inv.root
902
 
        for fid in inv:
903
 
            entry = inv[fid]
904
 
            if entry.parent_id in (None, orig_root_id):
905
 
                entry.parent_id = inv.root.file_id
906
 
        self._write_inventory(inv)
907
 
 
908
 
    def unlock(self):
909
 
        """See Branch.unlock.
910
 
        
911
 
        WorkingTree locking just uses the Branch locking facilities.
912
 
        This is current because all working trees have an embedded branch
913
 
        within them. IF in the future, we were to make branch data shareable
914
 
        between multiple working trees, i.e. via shared storage, then we 
915
 
        would probably want to lock both the local tree, and the branch.
916
 
        """
917
 
        if self._hashcache.needs_write and self.branch._lock_count==1:
918
 
            self._hashcache.write()
919
 
        return self.branch.unlock()
920
 
 
921
 
    @needs_write_lock
922
 
    def _write_inventory(self, inv):
923
 
        """Write inventory as the current inventory."""
924
 
        from cStringIO import StringIO
925
 
        from bzrlib.atomicfile import AtomicFile
926
 
        sio = StringIO()
927
 
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
928
 
        sio.seek(0)
929
 
        f = AtomicFile(self.branch.controlfilename('inventory'))
930
 
        try:
931
 
            pumpfile(sio, f)
932
 
            f.commit()
933
 
        finally:
934
 
            f.close()
935
 
        self._set_inventory(inv)
936
 
        mutter('wrote working inventory')
937
 
            
938
 
 
939
 
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
940
 
def get_conflicted_stem(path):
941
 
    for suffix in CONFLICT_SUFFIXES:
942
 
        if path.endswith(suffix):
943
 
            return path[:-len(suffix)]
 
287