/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/workingtree.py

  • Committer: John Arbash Meinel
  • Date: 2006-05-02 20:46:11 UTC
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: john@arbash-meinel.com-20060502204611-02caa5c20fb84ef8
Moved url functions into bzrlib.urlutils

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
 
1
# Copyright (C) 2005, 2006 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
"""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 bzrdir.open_workingtree() or
 
29
WorkingTree.open(dir).
 
30
"""
 
31
 
 
32
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
 
33
CONFLICT_HEADER_1 = "BZR conflict list format 1"
 
34
 
 
35
# TODO: Give the workingtree sole responsibility for the working inventory;
 
36
# remove the variable and references to it from the branch.  This may require
 
37
# updating the commit code so as to update the inventory within the working
 
38
# copy, and making sure there's only one WorkingTree for any directory on disk.
 
39
# At the moment they may alias the inventory and have old copies of it in
 
40
# memory.  (Now done? -- mbp 20060309)
 
41
 
 
42
from copy import deepcopy
 
43
from cStringIO import StringIO
 
44
import errno
 
45
import fnmatch
 
46
import os
 
47
import re
 
48
import stat
 
49
 
 
50
 
 
51
from bzrlib.atomicfile import AtomicFile
 
52
from bzrlib.branch import (Branch,
 
53
                           quotefn)
 
54
from bzrlib.conflicts import Conflict, ConflictList, CONFLICT_SUFFIXES
 
55
import bzrlib.bzrdir as bzrdir
 
56
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
57
import bzrlib.errors as errors
 
58
from bzrlib.errors import (BzrCheckError,
 
59
                           BzrError,
 
60
                           ConflictFormatError,
 
61
                           DivergedBranches,
 
62
                           WeaveRevisionNotPresent,
 
63
                           NotBranchError,
 
64
                           NoSuchFile,
 
65
                           NotVersionedError,
 
66
                           MergeModifiedFormatError,
 
67
                           UnsupportedOperation,
 
68
                           )
 
69
from bzrlib.inventory import InventoryEntry, Inventory
 
70
from bzrlib.lockable_files import LockableFiles, TransportLock
 
71
from bzrlib.lockdir import LockDir
 
72
from bzrlib.merge import merge_inner, transform_tree
 
73
from bzrlib.osutils import (
 
74
                            abspath,
 
75
                            appendpath,
 
76
                            compact_date,
 
77
                            file_kind,
 
78
                            isdir,
 
79
                            getcwd,
 
80
                            pathjoin,
 
81
                            pumpfile,
 
82
                            safe_unicode,
 
83
                            splitpath,
 
84
                            rand_bytes,
 
85
                            normpath,
 
86
                            realpath,
 
87
                            relpath,
 
88
                            rename,
 
89
                            supports_executable,
 
90
                            )
 
91
from bzrlib.progress import DummyProgress, ProgressPhase
 
92
from bzrlib.revision import NULL_REVISION
 
93
from bzrlib.rio import RioReader, rio_file, Stanza
 
94
from bzrlib.symbol_versioning import *
 
95
from bzrlib.textui import show_status
 
96
import bzrlib.tree
 
97
from bzrlib.transform import build_tree
 
98
from bzrlib.trace import mutter, note
 
99
from bzrlib.transport import get_transport
 
100
from bzrlib.transport.local import LocalTransport
 
101
import bzrlib.urlutils as urlutils
 
102
import bzrlib.ui
 
103
import bzrlib.xml5
 
104
 
 
105
 
 
106
_non_word_re = None
 
107
def _get_non_word_re():
 
108
    """Get the compiled regular expression for non-unicode words."""
 
109
    global _non_word_re
 
110
    if _non_word_re is None:
 
111
 
 
112
        # TODO: jam 20060106 Currently the BZR codebase can't really handle
 
113
        #           unicode ids. There are a lot of code paths which don't
 
114
        #           expect them. And we need to do more serious testing
 
115
        #           before we enable unicode in ids.
 
116
        #_non_word_re = re.compile(r'[^\w.]', re.UNICODE)
 
117
        _non_word_re = re.compile(r'[^\w.]')
 
118
    return _non_word_re
 
119
 
 
120
 
 
121
def gen_file_id(name):
 
122
    """Return new file id.
 
123
 
 
124
    This should probably generate proper UUIDs, but for the moment we
 
125
    cope with just randomness because running uuidgen every time is
 
126
    slow.
 
127
    """
 
128
    from binascii import hexlify
 
129
    from time import time
 
130
 
 
131
    # get last component
 
132
    idx = name.rfind('/')
 
133
    if idx != -1:
 
134
        name = name[idx+1 : ]
 
135
    idx = name.rfind('\\')
 
136
    if idx != -1:
 
137
        name = name[idx+1 : ]
 
138
 
 
139
    # make it not a hidden file
 
140
    name = name.lstrip('.')
 
141
 
 
142
    # remove any wierd characters; we don't escape them but rather
 
143
    # just pull them out
 
144
    non_word = _get_non_word_re()
 
145
    name = non_word.sub('', name)
 
146
 
 
147
    s = hexlify(rand_bytes(8))
 
148
    return '-'.join((name, compact_date(time()), s))
 
149
 
 
150
 
 
151
def gen_root_id():
 
152
    """Return a new tree-root file id."""
 
153
    return gen_file_id('TREE_ROOT')
 
154
 
 
155
 
 
156
class TreeEntry(object):
 
157
    """An entry that implements the minium interface used by commands.
 
158
 
 
159
    This needs further inspection, it may be better to have 
 
160
    InventoryEntries without ids - though that seems wrong. For now,
 
161
    this is a parallel hierarchy to InventoryEntry, and needs to become
 
162
    one of several things: decorates to that hierarchy, children of, or
 
163
    parents of it.
 
164
    Another note is that these objects are currently only used when there is
 
165
    no InventoryEntry available - i.e. for unversioned objects.
 
166
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
 
167
    """
 
168
 
 
169
    def __eq__(self, other):
 
170
        # yes, this us ugly, TODO: best practice __eq__ style.
 
171
        return (isinstance(other, TreeEntry)
 
172
                and other.__class__ == self.__class__)
 
173
 
 
174
    def kind_character(self):
 
175
        return "???"
 
176
 
 
177
 
 
178
class TreeDirectory(TreeEntry):
 
179
    """See TreeEntry. This is a directory in a working tree."""
 
180
 
 
181
    def __eq__(self, other):
 
182
        return (isinstance(other, TreeDirectory)
 
183
                and other.__class__ == self.__class__)
 
184
 
 
185
    def kind_character(self):
 
186
        return "/"
 
187
 
 
188
 
 
189
class TreeFile(TreeEntry):
 
190
    """See TreeEntry. This is a regular file in a working tree."""
 
191
 
 
192
    def __eq__(self, other):
 
193
        return (isinstance(other, TreeFile)
 
194
                and other.__class__ == self.__class__)
 
195
 
 
196
    def kind_character(self):
 
197
        return ''
 
198
 
 
199
 
 
200
class TreeLink(TreeEntry):
 
201
    """See TreeEntry. This is a symlink in a working tree."""
 
202
 
 
203
    def __eq__(self, other):
 
204
        return (isinstance(other, TreeLink)
 
205
                and other.__class__ == self.__class__)
 
206
 
 
207
    def kind_character(self):
 
208
        return ''
 
209
 
 
210
 
 
211
class WorkingTree(bzrlib.tree.Tree):
 
212
    """Working copy tree.
 
213
 
 
214
    The inventory is held in the `Branch` working-inventory, and the
 
215
    files are in a directory on disk.
 
216
 
 
217
    It is possible for a `WorkingTree` to have a filename which is
 
218
    not listed in the Inventory and vice versa.
 
219
    """
 
220
 
 
221
    def __init__(self, basedir='.',
 
222
                 branch=DEPRECATED_PARAMETER,
 
223
                 _inventory=None,
 
224
                 _control_files=None,
 
225
                 _internal=False,
 
226
                 _format=None,
 
227
                 _bzrdir=None):
 
228
        """Construct a WorkingTree for basedir.
 
229
 
 
230
        If the branch is not supplied, it is opened automatically.
 
231
        If the branch is supplied, it must be the branch for this basedir.
 
232
        (branch.base is not cross checked, because for remote branches that
 
233
        would be meaningless).
 
234
        """
 
235
        self._format = _format
 
236
        self.bzrdir = _bzrdir
 
237
        if not _internal:
 
238
            # not created via open etc.
 
239
            warn("WorkingTree() is deprecated as of bzr version 0.8. "
 
240
                 "Please use bzrdir.open_workingtree or WorkingTree.open().",
 
241
                 DeprecationWarning,
 
242
                 stacklevel=2)
 
243
            wt = WorkingTree.open(basedir)
 
244
            self._branch = wt.branch
 
245
            self.basedir = wt.basedir
 
246
            self._control_files = wt._control_files
 
247
            self._hashcache = wt._hashcache
 
248
            self._set_inventory(wt._inventory)
 
249
            self._format = wt._format
 
250
            self.bzrdir = wt.bzrdir
 
251
        from bzrlib.hashcache import HashCache
 
252
        from bzrlib.trace import note, mutter
 
253
        assert isinstance(basedir, basestring), \
 
254
            "base directory %r is not a string" % basedir
 
255
        basedir = safe_unicode(basedir)
 
256
        mutter("opening working tree %r", basedir)
 
257
        if deprecated_passed(branch):
 
258
            if not _internal:
 
259
                warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
 
260
                     " Please use bzrdir.open_workingtree() or"
 
261
                     " WorkingTree.open().",
 
262
                     DeprecationWarning,
 
263
                     stacklevel=2
 
264
                     )
 
265
            self._branch = branch
 
266
        else:
 
267
            self._branch = self.bzrdir.open_branch()
 
268
        assert isinstance(self.branch, Branch), \
 
269
            "branch %r is not a Branch" % self.branch
 
270
        self.basedir = realpath(basedir)
 
271
        # if branch is at our basedir and is a format 6 or less
 
272
        if isinstance(self._format, WorkingTreeFormat2):
 
273
            # share control object
 
274
            self._control_files = self.branch.control_files
 
275
        else:
 
276
            # only ready for format 3
 
277
            assert isinstance(self._format, WorkingTreeFormat3)
 
278
            assert isinstance(_control_files, LockableFiles), \
 
279
                    "_control_files must be a LockableFiles, not %r" \
 
280
                    % _control_files
 
281
            self._control_files = _control_files
 
282
        # update the whole cache up front and write to disk if anything changed;
 
283
        # in the future we might want to do this more selectively
 
284
        # two possible ways offer themselves : in self._unlock, write the cache
 
285
        # if needed, or, when the cache sees a change, append it to the hash
 
286
        # cache file, and have the parser take the most recent entry for a
 
287
        # given path only.
 
288
        cache_filename = self.bzrdir.get_workingtree_transport(None).local_abspath('stat-cache')
 
289
        hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
 
290
        hc.read()
 
291
        # is this scan needed ? it makes things kinda slow.
 
292
        hc.scan()
 
293
 
 
294
        if hc.needs_write:
 
295
            mutter("write hc")
 
296
            hc.write()
 
297
 
 
298
        if _inventory is None:
 
299
            self._set_inventory(self.read_working_inventory())
 
300
        else:
 
301
            self._set_inventory(_inventory)
 
302
 
 
303
    branch = property(
 
304
        fget=lambda self: self._branch,
 
305
        doc="""The branch this WorkingTree is connected to.
 
306
 
 
307
            This cannot be set - it is reflective of the actual disk structure
 
308
            the working tree has been constructed from.
 
309
            """)
 
310
 
 
311
    def _set_inventory(self, inv):
 
312
        self._inventory = inv
 
313
        self.path2id = self._inventory.path2id
 
314
 
 
315
    def is_control_filename(self, filename):
 
316
        """True if filename is the name of a control file in this tree.
 
317
        
 
318
        This is true IF and ONLY IF the filename is part of the meta data
 
319
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
320
        on disk will not be a control file for this tree.
 
321
        """
 
322
        try:
 
323
            url = urlutils.local_path_to_url(self.abspath(filename))
 
324
            self.bzrdir.transport.relpath(url)
 
325
            return True
 
326
        except errors.PathNotChild:
 
327
            return False
 
328
 
 
329
    @staticmethod
 
330
    def open(path=None, _unsupported=False):
 
331
        """Open an existing working tree at path.
 
332
 
 
333
        """
 
334
        if path is None:
 
335
            path = os.path.getcwdu()
 
336
        control = bzrdir.BzrDir.open(path, _unsupported)
 
337
        return control.open_workingtree(_unsupported)
 
338
        
 
339
    @staticmethod
 
340
    def open_containing(path=None):
 
341
        """Open an existing working tree which has its root about path.
 
342
        
 
343
        This probes for a working tree at path and searches upwards from there.
 
344
 
 
345
        Basically we keep looking up until we find the control directory or
 
346
        run into /.  If there isn't one, raises NotBranchError.
 
347
        TODO: give this a new exception.
 
348
        If there is one, it is returned, along with the unused portion of path.
 
349
 
 
350
        :return: The WorkingTree that contains 'path', and the rest of path
 
351
        """
 
352
        if path is None:
 
353
            path = os.getcwdu()
 
354
        control, relpath = bzrdir.BzrDir.open_containing(path)
 
355
 
 
356
        return control.open_workingtree(), relpath
 
357
 
 
358
    @staticmethod
 
359
    def open_downlevel(path=None):
 
360
        """Open an unsupported working tree.
 
361
 
 
362
        Only intended for advanced situations like upgrading part of a bzrdir.
 
363
        """
 
364
        return WorkingTree.open(path, _unsupported=True)
 
365
 
 
366
    def __iter__(self):
 
367
        """Iterate through file_ids for this tree.
 
368
 
 
369
        file_ids are in a WorkingTree if they are in the working inventory
 
370
        and the working file exists.
 
371
        """
 
372
        inv = self._inventory
 
373
        for path, ie in inv.iter_entries():
 
374
            if bzrlib.osutils.lexists(self.abspath(path)):
 
375
                yield ie.file_id
 
376
 
 
377
    def __repr__(self):
 
378
        return "<%s of %s>" % (self.__class__.__name__,
 
379
                               getattr(self, 'basedir', None))
 
380
 
 
381
    def abspath(self, filename):
 
382
        return pathjoin(self.basedir, filename)
 
383
    
 
384
    def basis_tree(self):
 
385
        """Return RevisionTree for the current last revision."""
 
386
        revision_id = self.last_revision()
 
387
        if revision_id is not None:
 
388
            try:
 
389
                xml = self.read_basis_inventory()
 
390
                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
391
            except NoSuchFile:
 
392
                inv = None
 
393
            if inv is not None and inv.revision_id == revision_id:
 
394
                return bzrlib.tree.RevisionTree(self.branch.repository, inv,
 
395
                                                revision_id)
 
396
        # FIXME? RBC 20060403 should we cache the inventory here ?
 
397
        return self.branch.repository.revision_tree(revision_id)
 
398
 
 
399
    @staticmethod
 
400
    @deprecated_method(zero_eight)
 
401
    def create(branch, directory):
 
402
        """Create a workingtree for branch at directory.
 
403
 
 
404
        If existing_directory already exists it must have a .bzr directory.
 
405
        If it does not exist, it will be created.
 
406
 
 
407
        This returns a new WorkingTree object for the new checkout.
 
408
 
 
409
        TODO FIXME RBC 20060124 when we have checkout formats in place this
 
410
        should accept an optional revisionid to checkout [and reject this if
 
411
        checking out into the same dir as a pre-checkout-aware branch format.]
 
412
 
 
413
        XXX: When BzrDir is present, these should be created through that 
 
414
        interface instead.
 
415
        """
 
416
        warn('delete WorkingTree.create', stacklevel=3)
 
417
        transport = get_transport(directory)
 
418
        if branch.bzrdir.root_transport.base == transport.base:
 
419
            # same dir 
 
420
            return branch.bzrdir.create_workingtree()
 
421
        # different directory, 
 
422
        # create a branch reference
 
423
        # and now a working tree.
 
424
        raise NotImplementedError
 
425
 
 
426
    @staticmethod
 
427
    @deprecated_method(zero_eight)
 
428
    def create_standalone(directory):
 
429
        """Create a checkout and a branch and a repo at directory.
 
430
 
 
431
        Directory must exist and be empty.
 
432
 
 
433
        please use BzrDir.create_standalone_workingtree
 
434
        """
 
435
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
 
436
 
 
437
    def relpath(self, abs):
 
438
        """Return the local path portion from a given absolute path."""
 
439
        return relpath(self.basedir, abs)
 
440
 
 
441
    def has_filename(self, filename):
 
442
        return bzrlib.osutils.lexists(self.abspath(filename))
 
443
 
 
444
    def get_file(self, file_id):
 
445
        return self.get_file_byname(self.id2path(file_id))
 
446
 
 
447
    def get_file_byname(self, filename):
 
448
        return file(self.abspath(filename), 'rb')
 
449
 
 
450
    def get_root_id(self):
 
451
        """Return the id of this trees root"""
 
452
        inv = self.read_working_inventory()
 
453
        return inv.root.file_id
 
454
        
 
455
    def _get_store_filename(self, file_id):
 
456
        ## XXX: badly named; this is not in the store at all
 
457
        return self.abspath(self.id2path(file_id))
 
458
 
 
459
    @needs_read_lock
 
460
    def clone(self, to_bzrdir, revision_id=None, basis=None):
 
461
        """Duplicate this working tree into to_bzr, including all state.
 
462
        
 
463
        Specifically modified files are kept as modified, but
 
464
        ignored and unknown files are discarded.
 
465
 
 
466
        If you want to make a new line of development, see bzrdir.sprout()
 
467
 
 
468
        revision
 
469
            If not None, the cloned tree will have its last revision set to 
 
470
            revision, and and difference between the source trees last revision
 
471
            and this one merged in.
 
472
 
 
473
        basis
 
474
            If not None, a closer copy of a tree which may have some files in
 
475
            common, and which file content should be preferentially copied from.
 
476
        """
 
477
        # assumes the target bzr dir format is compatible.
 
478
        result = self._format.initialize(to_bzrdir)
 
479
        self.copy_content_into(result, revision_id)
 
480
        return result
 
481
 
 
482
    @needs_read_lock
 
483
    def copy_content_into(self, tree, revision_id=None):
 
484
        """Copy the current content and user files of this tree into tree."""
 
485
        if revision_id is None:
 
486
            transform_tree(tree, self)
 
487
        else:
 
488
            # TODO now merge from tree.last_revision to revision
 
489
            transform_tree(tree, self)
 
490
            tree.set_last_revision(revision_id)
 
491
 
 
492
    @needs_write_lock
 
493
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
494
        # avoid circular imports
 
495
        from bzrlib.commit import Commit
 
496
        if revprops is None:
 
497
            revprops = {}
 
498
        if not 'branch-nick' in revprops:
 
499
            revprops['branch-nick'] = self.branch.nick
 
500
        # args for wt.commit start at message from the Commit.commit method,
 
501
        # but with branch a kwarg now, passing in args as is results in the
 
502
        #message being used for the branch
 
503
        args = (DEPRECATED_PARAMETER, message, ) + args
 
504
        Commit().commit(working_tree=self, revprops=revprops, *args, **kwargs)
 
505
        self._set_inventory(self.read_working_inventory())
 
506
 
 
507
    def id2abspath(self, file_id):
 
508
        return self.abspath(self.id2path(file_id))
 
509
 
 
510
    def has_id(self, file_id):
 
511
        # files that have been deleted are excluded
 
512
        inv = self._inventory
 
513
        if not inv.has_id(file_id):
 
514
            return False
 
515
        path = inv.id2path(file_id)
 
516
        return bzrlib.osutils.lexists(self.abspath(path))
 
517
 
 
518
    def has_or_had_id(self, file_id):
 
519
        if file_id == self.inventory.root.file_id:
 
520
            return True
 
521
        return self.inventory.has_id(file_id)
 
522
 
 
523
    __contains__ = has_id
 
524
 
 
525
    def get_file_size(self, file_id):
 
526
        return os.path.getsize(self.id2abspath(file_id))
 
527
 
 
528
    @needs_read_lock
 
529
    def get_file_sha1(self, file_id):
 
530
        path = self._inventory.id2path(file_id)
 
531
        return self._hashcache.get_sha1(path)
 
532
 
 
533
    def is_executable(self, file_id):
 
534
        if not supports_executable():
 
535
            return self._inventory[file_id].executable
 
536
        else:
 
537
            path = self._inventory.id2path(file_id)
 
538
            mode = os.lstat(self.abspath(path)).st_mode
 
539
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
 
540
 
 
541
    @needs_write_lock
 
542
    def add(self, files, ids=None):
 
543
        """Make files versioned.
 
544
 
 
545
        Note that the command line normally calls smart_add instead,
 
546
        which can automatically recurse.
 
547
 
 
548
        This adds the files to the inventory, so that they will be
 
549
        recorded by the next commit.
 
550
 
 
551
        files
 
552
            List of paths to add, relative to the base of the tree.
 
553
 
 
554
        ids
 
555
            If set, use these instead of automatically generated ids.
 
556
            Must be the same length as the list of files, but may
 
557
            contain None for ids that are to be autogenerated.
 
558
 
 
559
        TODO: Perhaps have an option to add the ids even if the files do
 
560
              not (yet) exist.
 
561
 
 
562
        TODO: Perhaps callback with the ids and paths as they're added.
 
563
        """
 
564
        # TODO: Re-adding a file that is removed in the working copy
 
565
        # should probably put it back with the previous ID.
 
566
        if isinstance(files, basestring):
 
567
            assert(ids is None or isinstance(ids, basestring))
 
568
            files = [files]
 
569
            if ids is not None:
 
570
                ids = [ids]
 
571
 
 
572
        if ids is None:
 
573
            ids = [None] * len(files)
 
574
        else:
 
575
            assert(len(ids) == len(files))
 
576
 
 
577
        inv = self.read_working_inventory()
 
578
        for f,file_id in zip(files, ids):
 
579
            if self.is_control_filename(f):
 
580
                raise BzrError("cannot add control file %s" % quotefn(f))
 
581
 
 
582
            fp = splitpath(f)
 
583
 
 
584
            if len(fp) == 0:
 
585
                raise BzrError("cannot add top-level %r" % f)
 
586
 
 
587
            fullpath = normpath(self.abspath(f))
 
588
 
 
589
            try:
 
590
                kind = file_kind(fullpath)
 
591
            except OSError, e:
 
592
                if e.errno == errno.ENOENT:
 
593
                    raise NoSuchFile(fullpath)
 
594
                # maybe something better?
 
595
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
 
596
 
 
597
            if not InventoryEntry.versionable_kind(kind):
 
598
                raise BzrError('cannot add: not a versionable file ('
 
599
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
 
600
 
 
601
            if file_id is None:
 
602
                file_id = gen_file_id(f)
 
603
            inv.add_path(f, kind=kind, file_id=file_id)
 
604
 
 
605
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
606
        self._write_inventory(inv)
 
607
 
 
608
    @needs_write_lock
 
609
    def add_pending_merge(self, *revision_ids):
 
610
        # TODO: Perhaps should check at this point that the
 
611
        # history of the revision is actually present?
 
612
        p = self.pending_merges()
 
613
        updated = False
 
614
        for rev_id in revision_ids:
 
615
            if rev_id in p:
 
616
                continue
 
617
            p.append(rev_id)
 
618
            updated = True
 
619
        if updated:
 
620
            self.set_pending_merges(p)
 
621
 
 
622
    @needs_read_lock
 
623
    def pending_merges(self):
 
624
        """Return a list of pending merges.
 
625
 
 
626
        These are revisions that have been merged into the working
 
627
        directory but not yet committed.
 
628
        """
 
629
        try:
 
630
            merges_file = self._control_files.get_utf8('pending-merges')
 
631
        except OSError, e:
 
632
            if e.errno != errno.ENOENT:
 
633
                raise
 
634
            return []
 
635
        p = []
 
636
        for l in merges_file.readlines():
 
637
            p.append(l.rstrip('\n'))
 
638
        return p
 
639
 
 
640
    @needs_write_lock
 
641
    def set_pending_merges(self, rev_list):
 
642
        self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
 
643
 
 
644
    @needs_write_lock
 
645
    def set_merge_modified(self, modified_hashes):
 
646
        def iter_stanzas():
 
647
            for file_id, hash in modified_hashes.iteritems():
 
648
                yield Stanza(file_id=file_id, hash=hash)
 
649
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
 
650
 
 
651
    @needs_write_lock
 
652
    def _put_rio(self, filename, stanzas, header):
 
653
        my_file = rio_file(stanzas, header)
 
654
        self._control_files.put(filename, my_file)
 
655
 
 
656
    @needs_read_lock
 
657
    def merge_modified(self):
 
658
        try:
 
659
            hashfile = self._control_files.get('merge-hashes')
 
660
        except NoSuchFile:
 
661
            return {}
 
662
        merge_hashes = {}
 
663
        try:
 
664
            if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
 
665
                raise MergeModifiedFormatError()
 
666
        except StopIteration:
 
667
            raise MergeModifiedFormatError()
 
668
        for s in RioReader(hashfile):
 
669
            file_id = s.get("file_id")
 
670
            if file_id not in self.inventory:
 
671
                continue
 
672
            hash = s.get("hash")
 
673
            if hash == self.get_file_sha1(file_id):
 
674
                merge_hashes[file_id] = hash
 
675
        return merge_hashes
 
676
 
 
677
    def get_symlink_target(self, file_id):
 
678
        return os.readlink(self.id2abspath(file_id))
 
679
 
 
680
    def file_class(self, filename):
 
681
        if self.path2id(filename):
 
682
            return 'V'
 
683
        elif self.is_ignored(filename):
 
684
            return 'I'
 
685
        else:
 
686
            return '?'
 
687
 
 
688
    def list_files(self):
 
689
        """Recursively list all files as (path, class, kind, id).
 
690
 
 
691
        Lists, but does not descend into unversioned directories.
 
692
 
 
693
        This does not include files that have been deleted in this
 
694
        tree.
 
695
 
 
696
        Skips the control directory.
 
697
        """
 
698
        inv = self._inventory
 
699
 
 
700
        def descend(from_dir_relpath, from_dir_id, dp):
 
701
            ls = os.listdir(dp)
 
702
            ls.sort()
 
703
            for f in ls:
 
704
                ## TODO: If we find a subdirectory with its own .bzr
 
705
                ## directory, then that is a separate tree and we
 
706
                ## should exclude it.
 
707
 
 
708
                # the bzrdir for this tree
 
709
                # TODO: jam 20060426 I think this is now broken
 
710
                #       but it needs to be tested
 
711
                if self.bzrdir.transport.base.endswith(f + '/'):
 
712
                    continue
 
713
 
 
714
                # path within tree
 
715
                fp = appendpath(from_dir_relpath, f)
 
716
 
 
717
                # absolute path
 
718
                fap = appendpath(dp, f)
 
719
                
 
720
                f_ie = inv.get_child(from_dir_id, f)
 
721
                if f_ie:
 
722
                    c = 'V'
 
723
                elif self.is_ignored(fp):
 
724
                    c = 'I'
 
725
                else:
 
726
                    c = '?'
 
727
 
 
728
                fk = file_kind(fap)
 
729
 
 
730
                if f_ie:
 
731
                    if f_ie.kind != fk:
 
732
                        raise BzrCheckError("file %r entered as kind %r id %r, "
 
733
                                            "now of kind %r"
 
734
                                            % (fap, f_ie.kind, f_ie.file_id, fk))
 
735
 
 
736
                # make a last minute entry
 
737
                if f_ie:
 
738
                    entry = f_ie
 
739
                else:
 
740
                    if fk == 'directory':
 
741
                        entry = TreeDirectory()
 
742
                    elif fk == 'file':
 
743
                        entry = TreeFile()
 
744
                    elif fk == 'symlink':
 
745
                        entry = TreeLink()
 
746
                    else:
 
747
                        entry = TreeEntry()
 
748
                
 
749
                yield fp, c, fk, (f_ie and f_ie.file_id), entry
 
750
 
 
751
                if fk != 'directory':
 
752
                    continue
 
753
 
 
754
                if c != 'V':
 
755
                    # don't descend unversioned directories
 
756
                    continue
 
757
                
 
758
                for ff in descend(fp, f_ie.file_id, fap):
 
759
                    yield ff
 
760
 
 
761
        for f in descend(u'', inv.root.file_id, self.basedir):
 
762
            yield f
 
763
 
 
764
    @needs_write_lock
 
765
    def move(self, from_paths, to_name):
 
766
        """Rename files.
 
767
 
 
768
        to_name must exist in the inventory.
 
769
 
 
770
        If to_name exists and is a directory, the files are moved into
 
771
        it, keeping their old names.  
 
772
 
 
773
        Note that to_name is only the last component of the new name;
 
774
        this doesn't change the directory.
 
775
 
 
776
        This returns a list of (from_path, to_path) pairs for each
 
777
        entry that is moved.
 
778
        """
 
779
        result = []
 
780
        ## TODO: Option to move IDs only
 
781
        assert not isinstance(from_paths, basestring)
 
782
        inv = self.inventory
 
783
        to_abs = self.abspath(to_name)
 
784
        if not isdir(to_abs):
 
785
            raise BzrError("destination %r is not a directory" % to_abs)
 
786
        if not self.has_filename(to_name):
 
787
            raise BzrError("destination %r not in working directory" % to_abs)
 
788
        to_dir_id = inv.path2id(to_name)
 
789
        if to_dir_id == None and to_name != '':
 
790
            raise BzrError("destination %r is not a versioned directory" % to_name)
 
791
        to_dir_ie = inv[to_dir_id]
 
792
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
793
            raise BzrError("destination %r is not a directory" % to_abs)
 
794
 
 
795
        to_idpath = inv.get_idpath(to_dir_id)
 
796
 
 
797
        for f in from_paths:
 
798
            if not self.has_filename(f):
 
799
                raise BzrError("%r does not exist in working tree" % f)
 
800
            f_id = inv.path2id(f)
 
801
            if f_id == None:
 
802
                raise BzrError("%r is not versioned" % f)
 
803
            name_tail = splitpath(f)[-1]
 
804
            dest_path = appendpath(to_name, name_tail)
 
805
            if self.has_filename(dest_path):
 
806
                raise BzrError("destination %r already exists" % dest_path)
 
807
            if f_id in to_idpath:
 
808
                raise BzrError("can't move %r to a subdirectory of itself" % f)
 
809
 
 
810
        # OK, so there's a race here, it's possible that someone will
 
811
        # create a file in this interval and then the rename might be
 
812
        # left half-done.  But we should have caught most problems.
 
813
        orig_inv = deepcopy(self.inventory)
 
814
        try:
 
815
            for f in from_paths:
 
816
                name_tail = splitpath(f)[-1]
 
817
                dest_path = appendpath(to_name, name_tail)
 
818
                result.append((f, dest_path))
 
819
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
820
                try:
 
821
                    rename(self.abspath(f), self.abspath(dest_path))
 
822
                except OSError, e:
 
823
                    raise BzrError("failed to rename %r to %r: %s" %
 
824
                                   (f, dest_path, e[1]),
 
825
                            ["rename rolled back"])
 
826
        except:
 
827
            # restore the inventory on error
 
828
            self._set_inventory(orig_inv)
 
829
            raise
 
830
        self._write_inventory(inv)
 
831
        return result
 
832
 
 
833
    @needs_write_lock
 
834
    def rename_one(self, from_rel, to_rel):
 
835
        """Rename one file.
 
836
 
 
837
        This can change the directory or the filename or both.
 
838
        """
 
839
        inv = self.inventory
 
840
        if not self.has_filename(from_rel):
 
841
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
842
        if self.has_filename(to_rel):
 
843
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
844
 
 
845
        file_id = inv.path2id(from_rel)
 
846
        if file_id == None:
 
847
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
848
 
 
849
        entry = inv[file_id]
 
850
        from_parent = entry.parent_id
 
851
        from_name = entry.name
 
852
        
 
853
        if inv.path2id(to_rel):
 
854
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
855
 
 
856
        to_dir, to_tail = os.path.split(to_rel)
 
857
        to_dir_id = inv.path2id(to_dir)
 
858
        if to_dir_id == None and to_dir != '':
 
859
            raise BzrError("can't determine destination directory id for %r" % to_dir)
 
860
 
 
861
        mutter("rename_one:")
 
862
        mutter("  file_id    {%s}" % file_id)
 
863
        mutter("  from_rel   %r" % from_rel)
 
864
        mutter("  to_rel     %r" % to_rel)
 
865
        mutter("  to_dir     %r" % to_dir)
 
866
        mutter("  to_dir_id  {%s}" % to_dir_id)
 
867
 
 
868
        inv.rename(file_id, to_dir_id, to_tail)
 
869
 
 
870
        from_abs = self.abspath(from_rel)
 
871
        to_abs = self.abspath(to_rel)
 
872
        try:
 
873
            rename(from_abs, to_abs)
 
874
        except OSError, e:
 
875
            inv.rename(file_id, from_parent, from_name)
 
876
            raise BzrError("failed to rename %r to %r: %s"
 
877
                    % (from_abs, to_abs, e[1]),
 
878
                    ["rename rolled back"])
 
879
        self._write_inventory(inv)
 
880
 
 
881
    @needs_read_lock
 
882
    def unknowns(self):
 
883
        """Return all unknown files.
 
884
 
 
885
        These are files in the working directory that are not versioned or
 
886
        control files or ignored.
 
887
        
 
888
        >>> from bzrlib.bzrdir import ScratchDir
 
889
        >>> d = ScratchDir(files=['foo', 'foo~'])
 
890
        >>> b = d.open_branch()
 
891
        >>> tree = d.open_workingtree()
 
892
        >>> map(str, tree.unknowns())
 
893
        ['foo']
 
894
        >>> tree.add('foo')
 
895
        >>> list(b.unknowns())
 
896
        []
 
897
        >>> tree.remove('foo')
 
898
        >>> list(b.unknowns())
 
899
        [u'foo']
 
900
        """
 
901
        for subp in self.extras():
 
902
            if not self.is_ignored(subp):
 
903
                yield subp
 
904
 
 
905
    @deprecated_method(zero_eight)
 
906
    def iter_conflicts(self):
 
907
        """List all files in the tree that have text or content conflicts.
 
908
        DEPRECATED.  Use conflicts instead."""
 
909
        return self._iter_conflicts()
 
910
 
 
911
    def _iter_conflicts(self):
 
912
        conflicted = set()
 
913
        for path in (s[0] for s in self.list_files()):
 
914
            stem = get_conflicted_stem(path)
 
915
            if stem is None:
 
916
                continue
 
917
            if stem not in conflicted:
 
918
                conflicted.add(stem)
 
919
                yield stem
 
920
 
 
921
    @needs_write_lock
 
922
    def pull(self, source, overwrite=False, stop_revision=None):
 
923
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
924
        source.lock_read()
 
925
        try:
 
926
            pp = ProgressPhase("Pull phase", 2, top_pb)
 
927
            pp.next_phase()
 
928
            old_revision_history = self.branch.revision_history()
 
929
            basis_tree = self.basis_tree()
 
930
            count = self.branch.pull(source, overwrite, stop_revision)
 
931
            new_revision_history = self.branch.revision_history()
 
932
            if new_revision_history != old_revision_history:
 
933
                pp.next_phase()
 
934
                if len(old_revision_history):
 
935
                    other_revision = old_revision_history[-1]
 
936
                else:
 
937
                    other_revision = None
 
938
                repository = self.branch.repository
 
939
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
940
                try:
 
941
                    merge_inner(self.branch,
 
942
                                self.branch.basis_tree(),
 
943
                                basis_tree, 
 
944
                                this_tree=self, 
 
945
                                pb=pb)
 
946
                finally:
 
947
                    pb.finished()
 
948
                self.set_last_revision(self.branch.last_revision())
 
949
            return count
 
950
        finally:
 
951
            source.unlock()
 
952
            top_pb.finished()
 
953
 
 
954
    def extras(self):
 
955
        """Yield all unknown files in this WorkingTree.
 
956
 
 
957
        If there are any unknown directories then only the directory is
 
958
        returned, not all its children.  But if there are unknown files
 
959
        under a versioned subdirectory, they are returned.
 
960
 
 
961
        Currently returned depth-first, sorted by name within directories.
 
962
        """
 
963
        ## TODO: Work from given directory downwards
 
964
        for path, dir_entry in self.inventory.directories():
 
965
            mutter("search for unknowns in %r", path)
 
966
            dirabs = self.abspath(path)
 
967
            if not isdir(dirabs):
 
968
                # e.g. directory deleted
 
969
                continue
 
970
 
 
971
            fl = []
 
972
            for subf in os.listdir(dirabs):
 
973
                if (subf != '.bzr'
 
974
                    and (subf not in dir_entry.children)):
 
975
                    fl.append(subf)
 
976
            
 
977
            fl.sort()
 
978
            for subf in fl:
 
979
                subp = appendpath(path, subf)
 
980
                yield subp
 
981
 
 
982
 
 
983
    def ignored_files(self):
 
984
        """Yield list of PATH, IGNORE_PATTERN"""
 
985
        for subp in self.extras():
 
986
            pat = self.is_ignored(subp)
 
987
            if pat != None:
 
988
                yield subp, pat
 
989
 
 
990
 
 
991
    def get_ignore_list(self):
 
992
        """Return list of ignore patterns.
 
993
 
 
994
        Cached in the Tree object after the first call.
 
995
        """
 
996
        if hasattr(self, '_ignorelist'):
 
997
            return self._ignorelist
 
998
 
 
999
        l = bzrlib.DEFAULT_IGNORE[:]
 
1000
        if self.has_filename(bzrlib.IGNORE_FILENAME):
 
1001
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
 
1002
            l.extend([line.rstrip("\n\r").decode('utf-8') 
 
1003
                      for line in f.readlines()])
 
1004
        self._ignorelist = l
 
1005
        return l
 
1006
 
 
1007
 
 
1008
    def is_ignored(self, filename):
 
1009
        r"""Check whether the filename matches an ignore pattern.
 
1010
 
 
1011
        Patterns containing '/' or '\' need to match the whole path;
 
1012
        others match against only the last component.
 
1013
 
 
1014
        If the file is ignored, returns the pattern which caused it to
 
1015
        be ignored, otherwise None.  So this can simply be used as a
 
1016
        boolean if desired."""
 
1017
 
 
1018
        # TODO: Use '**' to match directories, and other extended
 
1019
        # globbing stuff from cvs/rsync.
 
1020
 
 
1021
        # XXX: fnmatch is actually not quite what we want: it's only
 
1022
        # approximately the same as real Unix fnmatch, and doesn't
 
1023
        # treat dotfiles correctly and allows * to match /.
 
1024
        # Eventually it should be replaced with something more
 
1025
        # accurate.
 
1026
 
 
1027
        # FIXME: fnmatch also won't match unicode exact path filenames.
 
1028
        #        it does seem to handle wildcard, as long as the non-wildcard
 
1029
        #        characters are ascii.
 
1030
        
 
1031
        for pat in self.get_ignore_list():
 
1032
            if '/' in pat or '\\' in pat:
 
1033
                
 
1034
                # as a special case, you can put ./ at the start of a
 
1035
                # pattern; this is good to match in the top-level
 
1036
                # only;
 
1037
                
 
1038
                if (pat[:2] == './') or (pat[:2] == '.\\'):
 
1039
                    newpat = pat[2:]
 
1040
                else:
 
1041
                    newpat = pat
 
1042
                if fnmatch.fnmatchcase(filename, newpat):
 
1043
                    return pat
 
1044
            else:
 
1045
                if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
 
1046
                    return pat
 
1047
        else:
 
1048
            return None
 
1049
 
 
1050
    def kind(self, file_id):
 
1051
        return file_kind(self.id2abspath(file_id))
 
1052
 
 
1053
    @needs_read_lock
 
1054
    def last_revision(self):
 
1055
        """Return the last revision id of this working tree.
 
1056
 
 
1057
        In early branch formats this was == the branch last_revision,
 
1058
        but that cannot be relied upon - for working tree operations,
 
1059
        always use tree.last_revision().
 
1060
        """
 
1061
        return self.branch.last_revision()
 
1062
 
 
1063
    def lock_read(self):
 
1064
        """See Branch.lock_read, and WorkingTree.unlock."""
 
1065
        self.branch.lock_read()
 
1066
        try:
 
1067
            return self._control_files.lock_read()
 
1068
        except:
 
1069
            self.branch.unlock()
 
1070
            raise
 
1071
 
 
1072
    def lock_write(self):
 
1073
        """See Branch.lock_write, and WorkingTree.unlock."""
 
1074
        self.branch.lock_write()
 
1075
        try:
 
1076
            return self._control_files.lock_write()
 
1077
        except:
 
1078
            self.branch.unlock()
 
1079
            raise
 
1080
 
 
1081
    def _basis_inventory_name(self):
 
1082
        return 'basis-inventory'
 
1083
 
 
1084
    @needs_write_lock
 
1085
    def set_last_revision(self, new_revision):
 
1086
        """Change the last revision in the working tree."""
 
1087
        if self._change_last_revision(new_revision):
 
1088
            self._cache_basis_inventory(new_revision)
 
1089
 
 
1090
    def _change_last_revision(self, new_revision):
 
1091
        """Template method part of set_last_revision to perform the change.
 
1092
        
 
1093
        This is used to allow WorkingTree3 instances to not affect branch
 
1094
        when their last revision is set.
 
1095
        """
 
1096
        if new_revision is None:
 
1097
            self.branch.set_revision_history([])
 
1098
            return False
 
1099
        # current format is locked in with the branch
 
1100
        revision_history = self.branch.revision_history()
 
1101
        try:
 
1102
            position = revision_history.index(new_revision)
 
1103
        except ValueError:
 
1104
            raise errors.NoSuchRevision(self.branch, new_revision)
 
1105
        self.branch.set_revision_history(revision_history[:position + 1])
 
1106
        return True
 
1107
 
 
1108
    def _cache_basis_inventory(self, new_revision):
 
1109
        """Cache new_revision as the basis inventory."""
 
1110
        try:
 
1111
            # this double handles the inventory - unpack and repack - 
 
1112
            # but is easier to understand. We can/should put a conditional
 
1113
            # in here based on whether the inventory is in the latest format
 
1114
            # - perhaps we should repack all inventories on a repository
 
1115
            # upgrade ?
 
1116
            inv = self.branch.repository.get_inventory(new_revision)
 
1117
            inv.revision_id = new_revision
 
1118
            xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1119
 
 
1120
            path = self._basis_inventory_name()
 
1121
            self._control_files.put_utf8(path, xml)
 
1122
        except WeaveRevisionNotPresent:
 
1123
            pass
 
1124
 
 
1125
    def read_basis_inventory(self):
 
1126
        """Read the cached basis inventory."""
 
1127
        path = self._basis_inventory_name()
 
1128
        return self._control_files.get_utf8(path).read()
 
1129
        
 
1130
    @needs_read_lock
 
1131
    def read_working_inventory(self):
 
1132
        """Read the working inventory."""
 
1133
        # ElementTree does its own conversion from UTF-8, so open in
 
1134
        # binary.
 
1135
        result = bzrlib.xml5.serializer_v5.read_inventory(
 
1136
            self._control_files.get('inventory'))
 
1137
        self._set_inventory(result)
 
1138
        return result
 
1139
 
 
1140
    @needs_write_lock
 
1141
    def remove(self, files, verbose=False):
 
1142
        """Remove nominated files from the working inventory..
 
1143
 
 
1144
        This does not remove their text.  This does not run on XXX on what? RBC
 
1145
 
 
1146
        TODO: Refuse to remove modified files unless --force is given?
 
1147
 
 
1148
        TODO: Do something useful with directories.
 
1149
 
 
1150
        TODO: Should this remove the text or not?  Tough call; not
 
1151
        removing may be useful and the user can just use use rm, and
 
1152
        is the opposite of add.  Removing it is consistent with most
 
1153
        other tools.  Maybe an option.
 
1154
        """
 
1155
        ## TODO: Normalize names
 
1156
        ## TODO: Remove nested loops; better scalability
 
1157
        if isinstance(files, basestring):
 
1158
            files = [files]
 
1159
 
 
1160
        inv = self.inventory
 
1161
 
 
1162
        # do this before any modifications
 
1163
        for f in files:
 
1164
            fid = inv.path2id(f)
 
1165
            if not fid:
 
1166
                # TODO: Perhaps make this just a warning, and continue?
 
1167
                # This tends to happen when 
 
1168
                raise NotVersionedError(path=f)
 
1169
            mutter("remove inventory entry %s {%s}", quotefn(f), fid)
 
1170
            if verbose:
 
1171
                # having remove it, it must be either ignored or unknown
 
1172
                if self.is_ignored(f):
 
1173
                    new_status = 'I'
 
1174
                else:
 
1175
                    new_status = '?'
 
1176
                show_status(new_status, inv[fid].kind, quotefn(f))
 
1177
            del inv[fid]
 
1178
 
 
1179
        self._write_inventory(inv)
 
1180
 
 
1181
    @needs_write_lock
 
1182
    def revert(self, filenames, old_tree=None, backups=True, 
 
1183
               pb=DummyProgress()):
 
1184
        from transform import revert
 
1185
        from conflicts import resolve
 
1186
        if old_tree is None:
 
1187
            old_tree = self.basis_tree()
 
1188
        conflicts = revert(self, old_tree, filenames, backups, pb)
 
1189
        if not len(filenames):
 
1190
            self.set_pending_merges([])
 
1191
            resolve(self)
 
1192
        else:
 
1193
            resolve(self, filenames, ignore_misses=True)
 
1194
        return conflicts
 
1195
 
 
1196
    # XXX: This method should be deprecated in favour of taking in a proper
 
1197
    # new Inventory object.
 
1198
    @needs_write_lock
 
1199
    def set_inventory(self, new_inventory_list):
 
1200
        from bzrlib.inventory import (Inventory,
 
1201
                                      InventoryDirectory,
 
1202
                                      InventoryEntry,
 
1203
                                      InventoryFile,
 
1204
                                      InventoryLink)
 
1205
        inv = Inventory(self.get_root_id())
 
1206
        for path, file_id, parent, kind in new_inventory_list:
 
1207
            name = os.path.basename(path)
 
1208
            if name == "":
 
1209
                continue
 
1210
            # fixme, there should be a factory function inv,add_?? 
 
1211
            if kind == 'directory':
 
1212
                inv.add(InventoryDirectory(file_id, name, parent))
 
1213
            elif kind == 'file':
 
1214
                inv.add(InventoryFile(file_id, name, parent))
 
1215
            elif kind == 'symlink':
 
1216
                inv.add(InventoryLink(file_id, name, parent))
 
1217
            else:
 
1218
                raise BzrError("unknown kind %r" % kind)
 
1219
        self._write_inventory(inv)
 
1220
 
 
1221
    @needs_write_lock
 
1222
    def set_root_id(self, file_id):
 
1223
        """Set the root id for this tree."""
 
1224
        inv = self.read_working_inventory()
 
1225
        orig_root_id = inv.root.file_id
 
1226
        del inv._byid[inv.root.file_id]
 
1227
        inv.root.file_id = file_id
 
1228
        inv._byid[inv.root.file_id] = inv.root
 
1229
        for fid in inv:
 
1230
            entry = inv[fid]
 
1231
            if entry.parent_id == orig_root_id:
 
1232
                entry.parent_id = inv.root.file_id
 
1233
        self._write_inventory(inv)
 
1234
 
 
1235
    def unlock(self):
 
1236
        """See Branch.unlock.
 
1237
        
 
1238
        WorkingTree locking just uses the Branch locking facilities.
 
1239
        This is current because all working trees have an embedded branch
 
1240
        within them. IF in the future, we were to make branch data shareable
 
1241
        between multiple working trees, i.e. via shared storage, then we 
 
1242
        would probably want to lock both the local tree, and the branch.
 
1243
        """
 
1244
        # FIXME: We want to write out the hashcache only when the last lock on
 
1245
        # this working copy is released.  Peeking at the lock count is a bit
 
1246
        # of a nasty hack; probably it's better to have a transaction object,
 
1247
        # which can do some finalization when it's either successfully or
 
1248
        # unsuccessfully completed.  (Denys's original patch did that.)
 
1249
        # RBC 20060206 hookinhg into transaction will couple lock and transaction
 
1250
        # wrongly. Hookinh into unllock on the control files object is fine though.
 
1251
        
 
1252
        # TODO: split this per format so there is no ugly if block
 
1253
        if self._hashcache.needs_write and (
 
1254
            # dedicated lock files
 
1255
            self._control_files._lock_count==1 or 
 
1256
            # shared lock files
 
1257
            (self._control_files is self.branch.control_files and 
 
1258
             self._control_files._lock_count==3)):
 
1259
            self._hashcache.write()
 
1260
        # reverse order of locking.
 
1261
        result = self._control_files.unlock()
 
1262
        try:
 
1263
            self.branch.unlock()
 
1264
        finally:
 
1265
            return result
 
1266
 
 
1267
    @needs_write_lock
 
1268
    def update(self):
 
1269
        """Update a working tree along its branch.
 
1270
 
 
1271
        This will update the branch if its bound too, which means we have multiple trees involved:
 
1272
        The new basis tree of the master.
 
1273
        The old basis tree of the branch.
 
1274
        The old basis tree of the working tree.
 
1275
        The current working tree state.
 
1276
        pathologically all three may be different, and non ancestors of each other.
 
1277
        Conceptually we want to:
 
1278
        Preserve the wt.basis->wt.state changes
 
1279
        Transform the wt.basis to the new master basis.
 
1280
        Apply a merge of the old branch basis to get any 'local' changes from it into the tree.
 
1281
        Restore the wt.basis->wt.state changes.
 
1282
 
 
1283
        There isn't a single operation at the moment to do that, so we:
 
1284
        Merge current state -> basis tree of the master w.r.t. the old tree basis.
 
1285
        Do a 'normal' merge of the old branch basis if it is relevant.
 
1286
        """
 
1287
        old_tip = self.branch.update()
 
1288
        if old_tip is not None:
 
1289
            self.add_pending_merge(old_tip)
 
1290
        self.branch.lock_read()
 
1291
        try:
 
1292
            result = 0
 
1293
            if self.last_revision() != self.branch.last_revision():
 
1294
                # merge tree state up to new branch tip.
 
1295
                basis = self.basis_tree()
 
1296
                to_tree = self.branch.basis_tree()
 
1297
                result += merge_inner(self.branch,
 
1298
                                      to_tree,
 
1299
                                      basis,
 
1300
                                      this_tree=self)
 
1301
                self.set_last_revision(self.branch.last_revision())
 
1302
            if old_tip and old_tip != self.last_revision():
 
1303
                # our last revision was not the prior branch last reivison
 
1304
                # and we have converted that last revision to a pending merge.
 
1305
                # base is somewhere between the branch tip now
 
1306
                # and the now pending merge
 
1307
                from bzrlib.revision import common_ancestor
 
1308
                try:
 
1309
                    base_rev_id = common_ancestor(self.branch.last_revision(),
 
1310
                                                  old_tip,
 
1311
                                                  self.branch.repository)
 
1312
                except errors.NoCommonAncestor:
 
1313
                    base_rev_id = None
 
1314
                base_tree = self.branch.repository.revision_tree(base_rev_id)
 
1315
                other_tree = self.branch.repository.revision_tree(old_tip)
 
1316
                result += merge_inner(self.branch,
 
1317
                                      other_tree,
 
1318
                                      base_tree,
 
1319
                                      this_tree=self)
 
1320
            return result
 
1321
        finally:
 
1322
            self.branch.unlock()
 
1323
 
 
1324
    @needs_write_lock
 
1325
    def _write_inventory(self, inv):
 
1326
        """Write inventory as the current inventory."""
 
1327
        sio = StringIO()
 
1328
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
 
1329
        sio.seek(0)
 
1330
        self._control_files.put('inventory', sio)
 
1331
        self._set_inventory(inv)
 
1332
        mutter('wrote working inventory')
 
1333
 
 
1334
    def set_conflicts(self, arg):
 
1335
        raise UnsupportedOperation(self.set_conflicts, self)
 
1336
 
 
1337
    @needs_read_lock
 
1338
    def conflicts(self):
 
1339
        conflicts = ConflictList()
 
1340
        for conflicted in self._iter_conflicts():
 
1341
            text = True
 
1342
            try:
 
1343
                if file_kind(self.abspath(conflicted)) != "file":
 
1344
                    text = False
 
1345
            except OSError, e:
 
1346
                if e.errno == errno.ENOENT:
 
1347
                    text = False
 
1348
                else:
 
1349
                    raise
 
1350
            if text is True:
 
1351
                for suffix in ('.THIS', '.OTHER'):
 
1352
                    try:
 
1353
                        kind = file_kind(self.abspath(conflicted+suffix))
 
1354
                    except OSError, e:
 
1355
                        if e.errno == errno.ENOENT:
 
1356
                            text = False
 
1357
                            break
 
1358
                        else:
 
1359
                            raise
 
1360
                    if kind != "file":
 
1361
                        text = False
 
1362
                        break
 
1363
            ctype = {True: 'text conflict', False: 'contents conflict'}[text]
 
1364
            conflicts.append(Conflict.factory(ctype, path=conflicted,
 
1365
                             file_id=self.path2id(conflicted)))
 
1366
        return conflicts
 
1367
 
 
1368
 
 
1369
class WorkingTree3(WorkingTree):
 
1370
    """This is the Format 3 working tree.
 
1371
 
 
1372
    This differs from the base WorkingTree by:
 
1373
     - having its own file lock
 
1374
     - having its own last-revision property.
 
1375
 
 
1376
    This is new in bzr 0.8
 
1377
    """
 
1378
 
 
1379
    @needs_read_lock
 
1380
    def last_revision(self):
 
1381
        """See WorkingTree.last_revision."""
 
1382
        try:
 
1383
            return self._control_files.get_utf8('last-revision').read()
 
1384
        except NoSuchFile:
 
1385
            return None
 
1386
 
 
1387
    def _change_last_revision(self, revision_id):
 
1388
        """See WorkingTree._change_last_revision."""
 
1389
        if revision_id is None or revision_id == NULL_REVISION:
 
1390
            try:
 
1391
                self._control_files._transport.delete('last-revision')
 
1392
            except errors.NoSuchFile:
 
1393
                pass
 
1394
            return False
 
1395
        else:
 
1396
            try:
 
1397
                self.branch.revision_history().index(revision_id)
 
1398
            except ValueError:
 
1399
                raise errors.NoSuchRevision(self.branch, revision_id)
 
1400
            self._control_files.put_utf8('last-revision', revision_id)
 
1401
            return True
 
1402
 
 
1403
    @needs_write_lock
 
1404
    def set_conflicts(self, conflicts):
 
1405
        self._put_rio('conflicts', conflicts.to_stanzas(), 
 
1406
                      CONFLICT_HEADER_1)
 
1407
 
 
1408
    @needs_read_lock
 
1409
    def conflicts(self):
 
1410
        try:
 
1411
            confile = self._control_files.get('conflicts')
 
1412
        except NoSuchFile:
 
1413
            return ConflictList()
 
1414
        try:
 
1415
            if confile.next() != CONFLICT_HEADER_1 + '\n':
 
1416
                raise ConflictFormatError()
 
1417
        except StopIteration:
 
1418
            raise ConflictFormatError()
 
1419
        return ConflictList.from_stanzas(RioReader(confile))
 
1420
 
 
1421
 
 
1422
def get_conflicted_stem(path):
 
1423
    for suffix in CONFLICT_SUFFIXES:
 
1424
        if path.endswith(suffix):
 
1425
            return path[:-len(suffix)]
 
1426
 
 
1427
@deprecated_function(zero_eight)
 
1428
def is_control_file(filename):
 
1429
    """See WorkingTree.is_control_filename(filename)."""
 
1430
    ## FIXME: better check
 
1431
    filename = normpath(filename)
 
1432
    while filename != '':
 
1433
        head, tail = os.path.split(filename)
 
1434
        ## mutter('check %r for control file' % ((head, tail),))
 
1435
        if tail == '.bzr':
 
1436
            return True
 
1437
        if filename == head:
 
1438
            break
 
1439
        filename = head
 
1440
    return False
 
1441
 
 
1442
 
 
1443
class WorkingTreeFormat(object):
 
1444
    """An encapsulation of the initialization and open routines for a format.
 
1445
 
 
1446
    Formats provide three things:
 
1447
     * An initialization routine,
 
1448
     * a format string,
 
1449
     * an open routine.
 
1450
 
 
1451
    Formats are placed in an dict by their format string for reference 
 
1452
    during workingtree opening. Its not required that these be instances, they
 
1453
    can be classes themselves with class methods - it simply depends on 
 
1454
    whether state is needed for a given format or not.
 
1455
 
 
1456
    Once a format is deprecated, just deprecate the initialize and open
 
1457
    methods on the format class. Do not deprecate the object, as the 
 
1458
    object will be created every time regardless.
 
1459
    """
 
1460
 
 
1461
    _default_format = None
 
1462
    """The default format used for new trees."""
 
1463
 
 
1464
    _formats = {}
 
1465
    """The known formats."""
 
1466
 
 
1467
    @classmethod
 
1468
    def find_format(klass, a_bzrdir):
 
1469
        """Return the format for the working tree object in a_bzrdir."""
 
1470
        try:
 
1471
            transport = a_bzrdir.get_workingtree_transport(None)
 
1472
            format_string = transport.get("format").read()
 
1473
            return klass._formats[format_string]
 
1474
        except NoSuchFile:
 
1475
            raise errors.NoWorkingTree(base=transport.base)
 
1476
        except KeyError:
 
1477
            raise errors.UnknownFormatError(format_string)
 
1478
 
 
1479
    @classmethod
 
1480
    def get_default_format(klass):
 
1481
        """Return the current default format."""
 
1482
        return klass._default_format
 
1483
 
 
1484
    def get_format_string(self):
 
1485
        """Return the ASCII format string that identifies this format."""
 
1486
        raise NotImplementedError(self.get_format_string)
 
1487
 
 
1488
    def get_format_description(self):
 
1489
        """Return the short description for this format."""
 
1490
        raise NotImplementedError(self.get_format_description)
 
1491
 
 
1492
    def is_supported(self):
 
1493
        """Is this format supported?
 
1494
 
 
1495
        Supported formats can be initialized and opened.
 
1496
        Unsupported formats may not support initialization or committing or 
 
1497
        some other features depending on the reason for not being supported.
 
1498
        """
 
1499
        return True
 
1500
 
 
1501
    @classmethod
 
1502
    def register_format(klass, format):
 
1503
        klass._formats[format.get_format_string()] = format
 
1504
 
 
1505
    @classmethod
 
1506
    def set_default_format(klass, format):
 
1507
        klass._default_format = format
 
1508
 
 
1509
    @classmethod
 
1510
    def unregister_format(klass, format):
 
1511
        assert klass._formats[format.get_format_string()] is format
 
1512
        del klass._formats[format.get_format_string()]
 
1513
 
 
1514
 
 
1515
 
 
1516
class WorkingTreeFormat2(WorkingTreeFormat):
 
1517
    """The second working tree format. 
 
1518
 
 
1519
    This format modified the hash cache from the format 1 hash cache.
 
1520
    """
 
1521
 
 
1522
    def get_format_description(self):
 
1523
        """See WorkingTreeFormat.get_format_description()."""
 
1524
        return "Working tree format 2"
 
1525
 
 
1526
    def initialize(self, a_bzrdir, revision_id=None):
 
1527
        """See WorkingTreeFormat.initialize()."""
 
1528
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1529
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1530
        branch = a_bzrdir.open_branch()
 
1531
        if revision_id is not None:
 
1532
            branch.lock_write()
 
1533
            try:
 
1534
                revision_history = branch.revision_history()
 
1535
                try:
 
1536
                    position = revision_history.index(revision_id)
 
1537
                except ValueError:
 
1538
                    raise errors.NoSuchRevision(branch, revision_id)
 
1539
                branch.set_revision_history(revision_history[:position + 1])
 
1540
            finally:
 
1541
                branch.unlock()
 
1542
        revision = branch.last_revision()
 
1543
        inv = Inventory() 
 
1544
        wt = WorkingTree(a_bzrdir.root_transport.local_abspath('.'),
 
1545
                         branch,
 
1546
                         inv,
 
1547
                         _internal=True,
 
1548
                         _format=self,
 
1549
                         _bzrdir=a_bzrdir)
 
1550
        wt._write_inventory(inv)
 
1551
        wt.set_root_id(inv.root.file_id)
 
1552
        wt.set_last_revision(revision)
 
1553
        wt.set_pending_merges([])
 
1554
        build_tree(wt.basis_tree(), wt)
 
1555
        return wt
 
1556
 
 
1557
    def __init__(self):
 
1558
        super(WorkingTreeFormat2, self).__init__()
 
1559
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
1560
 
 
1561
    def open(self, a_bzrdir, _found=False):
 
1562
        """Return the WorkingTree object for a_bzrdir
 
1563
 
 
1564
        _found is a private parameter, do not use it. It is used to indicate
 
1565
               if format probing has already been done.
 
1566
        """
 
1567
        if not _found:
 
1568
            # we are being called directly and must probe.
 
1569
            raise NotImplementedError
 
1570
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1571
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1572
        return WorkingTree(a_bzrdir.root_transport.local_abspath('.'),
 
1573
                           _internal=True,
 
1574
                           _format=self,
 
1575
                           _bzrdir=a_bzrdir)
 
1576
 
 
1577
 
 
1578
class WorkingTreeFormat3(WorkingTreeFormat):
 
1579
    """The second working tree format updated to record a format marker.
 
1580
 
 
1581
    This format:
 
1582
        - exists within a metadir controlling .bzr
 
1583
        - includes an explicit version marker for the workingtree control
 
1584
          files, separate from the BzrDir format
 
1585
        - modifies the hash cache format
 
1586
        - is new in bzr 0.8
 
1587
        - uses a LockDir to guard access to the repository
 
1588
    """
 
1589
 
 
1590
    def get_format_string(self):
 
1591
        """See WorkingTreeFormat.get_format_string()."""
 
1592
        return "Bazaar-NG Working Tree format 3"
 
1593
 
 
1594
    def get_format_description(self):
 
1595
        """See WorkingTreeFormat.get_format_description()."""
 
1596
        return "Working tree format 3"
 
1597
 
 
1598
    _lock_file_name = 'lock'
 
1599
    _lock_class = LockDir
 
1600
 
 
1601
    def _open_control_files(self, a_bzrdir):
 
1602
        transport = a_bzrdir.get_workingtree_transport(None)
 
1603
        return LockableFiles(transport, self._lock_file_name, 
 
1604
                             self._lock_class)
 
1605
 
 
1606
    def initialize(self, a_bzrdir, revision_id=None):
 
1607
        """See WorkingTreeFormat.initialize().
 
1608
        
 
1609
        revision_id allows creating a working tree at a differnet
 
1610
        revision than the branch is at.
 
1611
        """
 
1612
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1613
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1614
        transport = a_bzrdir.get_workingtree_transport(self)
 
1615
        control_files = self._open_control_files(a_bzrdir)
 
1616
        control_files.create_lock()
 
1617
        control_files.lock_write()
 
1618
        control_files.put_utf8('format', self.get_format_string())
 
1619
        branch = a_bzrdir.open_branch()
 
1620
        if revision_id is None:
 
1621
            revision_id = branch.last_revision()
 
1622
        inv = Inventory() 
 
1623
        wt = WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
 
1624
                         branch,
 
1625
                         inv,
 
1626
                         _internal=True,
 
1627
                         _format=self,
 
1628
                         _bzrdir=a_bzrdir,
 
1629
                         _control_files=control_files)
 
1630
        wt.lock_write()
 
1631
        try:
 
1632
            wt._write_inventory(inv)
 
1633
            wt.set_root_id(inv.root.file_id)
 
1634
            wt.set_last_revision(revision_id)
 
1635
            wt.set_pending_merges([])
 
1636
            build_tree(wt.basis_tree(), wt)
 
1637
        finally:
 
1638
            wt.unlock()
 
1639
            control_files.unlock()
 
1640
        return wt
 
1641
 
 
1642
    def __init__(self):
 
1643
        super(WorkingTreeFormat3, self).__init__()
 
1644
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1645
 
 
1646
    def open(self, a_bzrdir, _found=False):
 
1647
        """Return the WorkingTree object for a_bzrdir
 
1648
 
 
1649
        _found is a private parameter, do not use it. It is used to indicate
 
1650
               if format probing has already been done.
 
1651
        """
 
1652
        if not _found:
 
1653
            # we are being called directly and must probe.
 
1654
            raise NotImplementedError
 
1655
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1656
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1657
        control_files = self._open_control_files(a_bzrdir)
 
1658
        return WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
 
1659
                           _internal=True,
 
1660
                           _format=self,
 
1661
                           _bzrdir=a_bzrdir,
 
1662
                           _control_files=control_files)
 
1663
 
 
1664
    def __str__(self):
 
1665
        return self.get_format_string()
 
1666
 
 
1667
 
 
1668
# formats which have no format string are not discoverable
 
1669
# and not independently creatable, so are not registered.
 
1670
__default_format = WorkingTreeFormat3()
 
1671
WorkingTreeFormat.register_format(__default_format)
 
1672
WorkingTreeFormat.set_default_format(__default_format)
 
1673
_legacy_formats = [WorkingTreeFormat2(),
 
1674
                   ]
 
1675
 
 
1676
 
 
1677
class WorkingTreeTestProviderAdapter(object):
 
1678
    """A tool to generate a suite testing multiple workingtree formats at once.
 
1679
 
 
1680
    This is done by copying the test once for each transport and injecting
 
1681
    the transport_server, transport_readonly_server, and workingtree_format
 
1682
    classes into each copy. Each copy is also given a new id() to make it
 
1683
    easy to identify.
 
1684
    """
 
1685
 
 
1686
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1687
        self._transport_server = transport_server
 
1688
        self._transport_readonly_server = transport_readonly_server
 
1689
        self._formats = formats
 
1690
    
 
1691
    def adapt(self, test):
 
1692
        from bzrlib.tests import TestSuite
 
1693
        result = TestSuite()
 
1694
        for workingtree_format, bzrdir_format in self._formats:
 
1695
            new_test = deepcopy(test)
 
1696
            new_test.transport_server = self._transport_server
 
1697
            new_test.transport_readonly_server = self._transport_readonly_server
 
1698
            new_test.bzrdir_format = bzrdir_format
 
1699
            new_test.workingtree_format = workingtree_format
 
1700
            def make_new_test_id():
 
1701
                new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
 
1702
                return lambda: new_id
 
1703
            new_test.id = make_new_test_id()
 
1704
            result.addTest(new_test)
 
1705
        return result