~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

[merge] robert's knit-performance work

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2011 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""WorkingTree object and friends.
18
18
 
19
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
 
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
23
new revision based on the workingtree and its inventory.
24
24
 
25
25
At the moment every WorkingTree has its own branch.  Remote
29
29
WorkingTree.open(dir).
30
30
"""
31
31
 
32
 
 
 
32
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
 
33
 
 
34
# TODO: Give the workingtree sole responsibility for the working inventory;
 
35
# remove the variable and references to it from the branch.  This may require
 
36
# updating the commit code so as to update the inventory within the working
 
37
# copy, and making sure there's only one WorkingTree for any directory on disk.
 
38
# At the moment they may alias the inventory and have old copies of it in
 
39
# memory.  (Now done? -- mbp 20060309)
 
40
 
 
41
from copy import deepcopy
33
42
from cStringIO import StringIO
 
43
import errno
 
44
import fnmatch
34
45
import os
35
 
import sys
36
 
 
37
 
from bzrlib.lazy_import import lazy_import
38
 
lazy_import(globals(), """
39
 
from bisect import bisect_left
40
 
import collections
41
 
import errno
42
 
import itertools
43
 
import operator
44
46
import stat
45
 
import re
46
 
 
47
 
from bzrlib import (
48
 
    branch,
49
 
    bzrdir,
50
 
    conflicts as _mod_conflicts,
51
 
    controldir,
52
 
    errors,
53
 
    filters as _mod_filters,
54
 
    generate_ids,
55
 
    globbing,
56
 
    graph as _mod_graph,
57
 
    ignores,
58
 
    inventory,
59
 
    merge,
60
 
    revision as _mod_revision,
61
 
    revisiontree,
62
 
    rio as _mod_rio,
63
 
    transform,
64
 
    transport,
65
 
    ui,
66
 
    views,
67
 
    xml5,
68
 
    xml7,
69
 
    )
70
 
""")
71
 
 
72
 
from bzrlib import symbol_versioning
 
47
 
 
48
 
 
49
from bzrlib.atomicfile import AtomicFile
 
50
from bzrlib.branch import (Branch,
 
51
                           quotefn)
 
52
import bzrlib.bzrdir as bzrdir
73
53
from bzrlib.decorators import needs_read_lock, needs_write_lock
74
 
from bzrlib.i18n import gettext
75
 
from bzrlib.lock import LogicalLockResult
76
 
import bzrlib.mutabletree
77
 
from bzrlib.mutabletree import needs_tree_write_lock
78
 
from bzrlib import osutils
 
54
import bzrlib.errors as errors
 
55
from bzrlib.errors import (BzrCheckError,
 
56
                           BzrError,
 
57
                           DivergedBranches,
 
58
                           WeaveRevisionNotPresent,
 
59
                           NotBranchError,
 
60
                           NoSuchFile,
 
61
                           NotVersionedError,
 
62
                           MergeModifiedFormatError)
 
63
from bzrlib.inventory import InventoryEntry, Inventory
 
64
from bzrlib.lockable_files import LockableFiles, TransportLock
 
65
from bzrlib.lockdir import LockDir
 
66
from bzrlib.merge import merge_inner, transform_tree
79
67
from bzrlib.osutils import (
80
 
    file_kind,
81
 
    isdir,
82
 
    normpath,
83
 
    pathjoin,
84
 
    realpath,
85
 
    safe_unicode,
86
 
    splitpath,
87
 
    supports_executable,
88
 
    )
89
 
from bzrlib.trace import mutter, note
90
 
from bzrlib.revision import CURRENT_REVISION
91
 
from bzrlib.symbol_versioning import (
92
 
    deprecated_passed,
93
 
    DEPRECATED_PARAMETER,
94
 
    )
95
 
 
96
 
 
97
 
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
98
 
# TODO: Modifying the conflict objects or their type is currently nearly
99
 
# impossible as there is no clear relationship between the working tree format
100
 
# and the conflict list file format.
101
 
CONFLICT_HEADER_1 = "BZR conflict list format 1"
102
 
 
103
 
ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT
 
68
                            abspath,
 
69
                            appendpath,
 
70
                            compact_date,
 
71
                            file_kind,
 
72
                            isdir,
 
73
                            getcwd,
 
74
                            pathjoin,
 
75
                            pumpfile,
 
76
                            safe_unicode,
 
77
                            splitpath,
 
78
                            rand_bytes,
 
79
                            normpath,
 
80
                            realpath,
 
81
                            relpath,
 
82
                            rename,
 
83
                            supports_executable,
 
84
                            )
 
85
from bzrlib.progress import DummyProgress, ProgressPhase
 
86
from bzrlib.revision import NULL_REVISION
 
87
from bzrlib.rio import RioReader, RioWriter, Stanza
 
88
from bzrlib.symbol_versioning import *
 
89
from bzrlib.textui import show_status
 
90
import bzrlib.tree
 
91
from bzrlib.trace import mutter
 
92
from bzrlib.transform import build_tree
 
93
from bzrlib.transport import get_transport
 
94
from bzrlib.transport.local import LocalTransport
 
95
import bzrlib.ui
 
96
import bzrlib.xml5
 
97
 
 
98
 
 
99
def gen_file_id(name):
 
100
    """Return new file id.
 
101
 
 
102
    This should probably generate proper UUIDs, but for the moment we
 
103
    cope with just randomness because running uuidgen every time is
 
104
    slow."""
 
105
    import re
 
106
    from binascii import hexlify
 
107
    from time import time
 
108
 
 
109
    # get last component
 
110
    idx = name.rfind('/')
 
111
    if idx != -1:
 
112
        name = name[idx+1 : ]
 
113
    idx = name.rfind('\\')
 
114
    if idx != -1:
 
115
        name = name[idx+1 : ]
 
116
 
 
117
    # make it not a hidden file
 
118
    name = name.lstrip('.')
 
119
 
 
120
    # remove any wierd characters; we don't escape them but rather
 
121
    # just pull them out
 
122
    name = re.sub(r'[^\w.]', '', name)
 
123
 
 
124
    s = hexlify(rand_bytes(8))
 
125
    return '-'.join((name, compact_date(time()), s))
 
126
 
 
127
 
 
128
def gen_root_id():
 
129
    """Return a new tree-root file id."""
 
130
    return gen_file_id('TREE_ROOT')
104
131
 
105
132
 
106
133
class TreeEntry(object):
107
 
    """An entry that implements the minimum interface used by commands.
 
134
    """An entry that implements the minium interface used by commands.
108
135
 
109
 
    This needs further inspection, it may be better to have
 
136
    This needs further inspection, it may be better to have 
110
137
    InventoryEntries without ids - though that seems wrong. For now,
111
138
    this is a parallel hierarchy to InventoryEntry, and needs to become
112
139
    one of several things: decorates to that hierarchy, children of, or
115
142
    no InventoryEntry available - i.e. for unversioned objects.
116
143
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
117
144
    """
118
 
 
 
145
 
119
146
    def __eq__(self, other):
120
147
        # yes, this us ugly, TODO: best practice __eq__ style.
121
148
        return (isinstance(other, TreeEntry)
122
149
                and other.__class__ == self.__class__)
123
 
 
 
150
 
124
151
    def kind_character(self):
125
152
        return "???"
126
153
 
158
185
        return ''
159
186
 
160
187
 
161
 
class WorkingTree(bzrlib.mutabletree.MutableTree,
162
 
    controldir.ControlComponent):
 
188
class WorkingTree(bzrlib.tree.Tree):
163
189
    """Working copy tree.
164
190
 
165
 
    :ivar basedir: The root of the tree on disk. This is a unicode path object
166
 
        (as opposed to a URL).
 
191
    The inventory is held in the `Branch` working-inventory, and the
 
192
    files are in a directory on disk.
 
193
 
 
194
    It is possible for a `WorkingTree` to have a filename which is
 
195
    not listed in the Inventory and vice versa.
167
196
    """
168
197
 
169
 
    # override this to set the strategy for storing views
170
 
    def _make_views(self):
171
 
        return views.DisabledViews(self)
172
 
 
173
198
    def __init__(self, basedir='.',
174
199
                 branch=DEPRECATED_PARAMETER,
 
200
                 _inventory=None,
175
201
                 _control_files=None,
176
202
                 _internal=False,
177
203
                 _format=None,
178
204
                 _bzrdir=None):
179
 
        """Construct a WorkingTree instance. This is not a public API.
 
205
        """Construct a WorkingTree for basedir.
180
206
 
181
 
        :param branch: A branch to override probing for the branch.
 
207
        If the branch is not supplied, it is opened automatically.
 
208
        If the branch is supplied, it must be the branch for this basedir.
 
209
        (branch.base is not cross checked, because for remote branches that
 
210
        would be meaningless).
182
211
        """
183
212
        self._format = _format
184
213
        self.bzrdir = _bzrdir
185
214
        if not _internal:
186
 
            raise errors.BzrError("Please use bzrdir.open_workingtree or "
187
 
                "WorkingTree.open() to obtain a WorkingTree.")
 
215
            # not created via open etc.
 
216
            warn("WorkingTree() is deprecated as of bzr version 0.8. "
 
217
                 "Please use bzrdir.open_workingtree or WorkingTree.open().",
 
218
                 DeprecationWarning,
 
219
                 stacklevel=2)
 
220
            wt = WorkingTree.open(basedir)
 
221
            self.branch = wt.branch
 
222
            self.basedir = wt.basedir
 
223
            self._control_files = wt._control_files
 
224
            self._hashcache = wt._hashcache
 
225
            self._set_inventory(wt._inventory)
 
226
            self._format = wt._format
 
227
            self.bzrdir = wt.bzrdir
 
228
        from bzrlib.hashcache import HashCache
 
229
        from bzrlib.trace import note, mutter
 
230
        assert isinstance(basedir, basestring), \
 
231
            "base directory %r is not a string" % basedir
188
232
        basedir = safe_unicode(basedir)
189
233
        mutter("opening working tree %r", basedir)
190
234
        if deprecated_passed(branch):
191
 
            self._branch = branch
 
235
            if not _internal:
 
236
                warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
 
237
                     " Please use bzrdir.open_workingtree() or WorkingTree.open().",
 
238
                     DeprecationWarning,
 
239
                     stacklevel=2
 
240
                     )
 
241
            self.branch = branch
192
242
        else:
193
 
            self._branch = self.bzrdir.open_branch()
 
243
            self.branch = self.bzrdir.open_branch()
 
244
        assert isinstance(self.branch, Branch), \
 
245
            "branch %r is not a Branch" % self.branch
194
246
        self.basedir = realpath(basedir)
195
 
        self._control_files = _control_files
196
 
        self._transport = self._control_files._transport
197
 
        self._rules_searcher = None
198
 
        self.views = self._make_views()
199
 
 
200
 
    @property
201
 
    def user_transport(self):
202
 
        return self.bzrdir.user_transport
203
 
 
204
 
    @property
205
 
    def control_transport(self):
206
 
        return self._transport
 
247
        # if branch is at our basedir and is a format 6 or less
 
248
        if isinstance(self._format, WorkingTreeFormat2):
 
249
            # share control object
 
250
            self._control_files = self.branch.control_files
 
251
        else:
 
252
            # only ready for format 3
 
253
            assert isinstance(self._format, WorkingTreeFormat3)
 
254
            assert isinstance(_control_files, LockableFiles), \
 
255
                    "_control_files must be a LockableFiles, not %r" \
 
256
                    % _control_files
 
257
            self._control_files = _control_files
 
258
        # update the whole cache up front and write to disk if anything changed;
 
259
        # in the future we might want to do this more selectively
 
260
        # two possible ways offer themselves : in self._unlock, write the cache
 
261
        # if needed, or, when the cache sees a change, append it to the hash
 
262
        # cache file, and have the parser take the most recent entry for a
 
263
        # given path only.
 
264
        cache_filename = self.bzrdir.get_workingtree_transport(None).abspath('stat-cache')
 
265
        hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
 
266
        hc.read()
 
267
        # is this scan needed ? it makes things kinda slow.
 
268
        hc.scan()
 
269
 
 
270
        if hc.needs_write:
 
271
            mutter("write hc")
 
272
            hc.write()
 
273
 
 
274
        if _inventory is None:
 
275
            self._set_inventory(self.read_working_inventory())
 
276
        else:
 
277
            self._set_inventory(_inventory)
 
278
 
 
279
    def _set_inventory(self, inv):
 
280
        self._inventory = inv
 
281
        self.path2id = self._inventory.path2id
207
282
 
208
283
    def is_control_filename(self, filename):
209
284
        """True if filename is the name of a control file in this tree.
210
 
 
211
 
        :param filename: A filename within the tree. This is a relative path
212
 
            from the root of this tree.
213
 
 
 
285
        
214
286
        This is true IF and ONLY IF the filename is part of the meta data
215
287
        that bzr controls in this tree. I.E. a random .bzr directory placed
216
288
        on disk will not be a control file for this tree.
217
289
        """
218
 
        return self.bzrdir.is_control_filename(filename)
219
 
 
220
 
    branch = property(
221
 
        fget=lambda self: self._branch,
222
 
        doc="""The branch this WorkingTree is connected to.
223
 
 
224
 
            This cannot be set - it is reflective of the actual disk structure
225
 
            the working tree has been constructed from.
226
 
            """)
227
 
 
228
 
    def has_versioned_directories(self):
229
 
        """See `Tree.has_versioned_directories`."""
230
 
        return self._format.supports_versioned_directories
231
 
 
232
 
    def break_lock(self):
233
 
        """Break a lock if one is present from another instance.
234
 
 
235
 
        Uses the ui factory to ask for confirmation if the lock may be from
236
 
        an active process.
237
 
 
238
 
        This will probe the repository for its lock as well.
239
 
        """
240
 
        self._control_files.break_lock()
241
 
        self.branch.break_lock()
242
 
 
243
 
    def requires_rich_root(self):
244
 
        return self._format.requires_rich_root
245
 
 
246
 
    def supports_tree_reference(self):
247
 
        return False
248
 
 
249
 
    def supports_content_filtering(self):
250
 
        return self._format.supports_content_filtering()
251
 
 
252
 
    def supports_views(self):
253
 
        return self.views.supports_views()
 
290
        try:
 
291
            self.bzrdir.transport.relpath(self.abspath(filename))
 
292
            return True
 
293
        except errors.PathNotChild:
 
294
            return False
254
295
 
255
296
    @staticmethod
256
297
    def open(path=None, _unsupported=False):
258
299
 
259
300
        """
260
301
        if path is None:
261
 
            path = osutils.getcwd()
 
302
            path = os.path.getcwdu()
262
303
        control = bzrdir.BzrDir.open(path, _unsupported)
263
304
        return control.open_workingtree(_unsupported)
264
 
 
 
305
        
265
306
    @staticmethod
266
307
    def open_containing(path=None):
267
308
        """Open an existing working tree which has its root about path.
268
 
 
 
309
        
269
310
        This probes for a working tree at path and searches upwards from there.
270
311
 
271
312
        Basically we keep looking up until we find the control directory or
272
313
        run into /.  If there isn't one, raises NotBranchError.
273
314
        TODO: give this a new exception.
274
315
        If there is one, it is returned, along with the unused portion of path.
275
 
 
276
 
        :return: The WorkingTree that contains 'path', and the rest of path
277
316
        """
278
317
        if path is None:
279
 
            path = osutils.getcwd()
 
318
            path = os.getcwdu()
280
319
        control, relpath = bzrdir.BzrDir.open_containing(path)
281
320
        return control.open_workingtree(), relpath
282
321
 
283
322
    @staticmethod
284
 
    def open_containing_paths(file_list, default_directory=None,
285
 
                              canonicalize=True, apply_view=True):
286
 
        """Open the WorkingTree that contains a set of paths.
287
 
 
288
 
        Fail if the paths given are not all in a single tree.
289
 
 
290
 
        This is used for the many command-line interfaces that take a list of
291
 
        any number of files and that require they all be in the same tree.
292
 
        """
293
 
        if default_directory is None:
294
 
            default_directory = u'.'
295
 
        # recommended replacement for builtins.internal_tree_files
296
 
        if file_list is None or len(file_list) == 0:
297
 
            tree = WorkingTree.open_containing(default_directory)[0]
298
 
            # XXX: doesn't really belong here, and seems to have the strange
299
 
            # side effect of making it return a bunch of files, not the whole
300
 
            # tree -- mbp 20100716
301
 
            if tree.supports_views() and apply_view:
302
 
                view_files = tree.views.lookup_view()
303
 
                if view_files:
304
 
                    file_list = view_files
305
 
                    view_str = views.view_display_str(view_files)
306
 
                    note(gettext("Ignoring files outside view. View is %s") % view_str)
307
 
            return tree, file_list
308
 
        if default_directory == u'.':
309
 
            seed = file_list[0]
310
 
        else:
311
 
            seed = default_directory
312
 
            file_list = [osutils.pathjoin(default_directory, f)
313
 
                         for f in file_list]
314
 
        tree = WorkingTree.open_containing(seed)[0]
315
 
        return tree, tree.safe_relpath_files(file_list, canonicalize,
316
 
                                             apply_view=apply_view)
317
 
 
318
 
    def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):
319
 
        """Convert file_list into a list of relpaths in tree.
320
 
 
321
 
        :param self: A tree to operate on.
322
 
        :param file_list: A list of user provided paths or None.
323
 
        :param apply_view: if True and a view is set, apply it or check that
324
 
            specified files are within it
325
 
        :return: A list of relative paths.
326
 
        :raises errors.PathNotChild: When a provided path is in a different self
327
 
            than self.
328
 
        """
329
 
        if file_list is None:
330
 
            return None
331
 
        if self.supports_views() and apply_view:
332
 
            view_files = self.views.lookup_view()
333
 
        else:
334
 
            view_files = []
335
 
        new_list = []
336
 
        # self.relpath exists as a "thunk" to osutils, but canonical_relpath
337
 
        # doesn't - fix that up here before we enter the loop.
338
 
        if canonicalize:
339
 
            fixer = lambda p: osutils.canonical_relpath(self.basedir, p)
340
 
        else:
341
 
            fixer = self.relpath
342
 
        for filename in file_list:
343
 
            relpath = fixer(osutils.dereference_path(filename))
344
 
            if view_files and not osutils.is_inside_any(view_files, relpath):
345
 
                raise errors.FileOutsideView(filename, view_files)
346
 
            new_list.append(relpath)
347
 
        return new_list
348
 
 
349
 
    @staticmethod
350
323
    def open_downlevel(path=None):
351
324
        """Open an unsupported working tree.
352
325
 
354
327
        """
355
328
        return WorkingTree.open(path, _unsupported=True)
356
329
 
357
 
    @staticmethod
358
 
    def find_trees(location):
359
 
        def list_current(transport):
360
 
            return [d for d in transport.list_dir('') if d != '.bzr']
361
 
        def evaluate(bzrdir):
362
 
            try:
363
 
                tree = bzrdir.open_workingtree()
364
 
            except errors.NoWorkingTree:
365
 
                return True, None
366
 
            else:
367
 
                return True, tree
368
 
        t = transport.get_transport(location)
369
 
        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
370
 
                                              list_current=list_current)
371
 
        return [tr for tr in iterator if tr is not None]
 
330
    def __iter__(self):
 
331
        """Iterate through file_ids for this tree.
372
332
 
373
 
    def all_file_ids(self):
374
 
        """See Tree.iter_all_file_ids"""
375
 
        raise NotImplementedError(self.all_file_ids)
 
333
        file_ids are in a WorkingTree if they are in the working inventory
 
334
        and the working file exists.
 
335
        """
 
336
        inv = self._inventory
 
337
        for path, ie in inv.iter_entries():
 
338
            if bzrlib.osutils.lexists(self.abspath(path)):
 
339
                yield ie.file_id
376
340
 
377
341
    def __repr__(self):
378
342
        return "<%s of %s>" % (self.__class__.__name__,
380
344
 
381
345
    def abspath(self, filename):
382
346
        return pathjoin(self.basedir, filename)
383
 
 
 
347
    
384
348
    def basis_tree(self):
385
 
        """Return RevisionTree for the current last revision.
386
 
 
387
 
        If the left most parent is a ghost then the returned tree will be an
388
 
        empty tree - one obtained by calling
389
 
        repository.revision_tree(NULL_REVISION).
390
 
        """
391
 
        try:
392
 
            revision_id = self.get_parent_ids()[0]
393
 
        except IndexError:
394
 
            # no parents, return an empty revision tree.
395
 
            # in the future this should return the tree for
396
 
            # 'empty:' - the implicit root empty tree.
397
 
            return self.branch.repository.revision_tree(
398
 
                       _mod_revision.NULL_REVISION)
399
 
        try:
400
 
            return self.revision_tree(revision_id)
401
 
        except errors.NoSuchRevision:
402
 
            pass
403
 
        # No cached copy available, retrieve from the repository.
404
 
        # FIXME? RBC 20060403 should we cache the inventory locally
405
 
        # at this point ?
406
 
        try:
407
 
            return self.branch.repository.revision_tree(revision_id)
408
 
        except (errors.RevisionNotPresent, errors.NoSuchRevision):
409
 
            # the basis tree *may* be a ghost or a low level error may have
410
 
            # occurred. If the revision is present, its a problem, if its not
411
 
            # its a ghost.
412
 
            if self.branch.repository.has_revision(revision_id):
413
 
                raise
414
 
            # the basis tree is a ghost so return an empty tree.
415
 
            return self.branch.repository.revision_tree(
416
 
                       _mod_revision.NULL_REVISION)
417
 
 
418
 
    def _cleanup(self):
419
 
        self._flush_ignore_list_cache()
420
 
 
421
 
    def relpath(self, path):
422
 
        """Return the local path portion from a given path.
423
 
 
424
 
        The path may be absolute or relative. If its a relative path it is
425
 
        interpreted relative to the python current working directory.
426
 
        """
427
 
        return osutils.relpath(self.basedir, path)
 
349
        """Return RevisionTree for the current last revision."""
 
350
        revision_id = self.last_revision()
 
351
        if revision_id is not None:
 
352
            try:
 
353
                xml = self.read_basis_inventory(revision_id)
 
354
                inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
355
                return bzrlib.tree.RevisionTree(self.branch.repository, inv,
 
356
                                                revision_id)
 
357
            except NoSuchFile:
 
358
                pass
 
359
        return self.branch.repository.revision_tree(revision_id)
 
360
 
 
361
    @staticmethod
 
362
    @deprecated_method(zero_eight)
 
363
    def create(branch, directory):
 
364
        """Create a workingtree for branch at directory.
 
365
 
 
366
        If existing_directory already exists it must have a .bzr directory.
 
367
        If it does not exist, it will be created.
 
368
 
 
369
        This returns a new WorkingTree object for the new checkout.
 
370
 
 
371
        TODO FIXME RBC 20060124 when we have checkout formats in place this
 
372
        should accept an optional revisionid to checkout [and reject this if
 
373
        checking out into the same dir as a pre-checkout-aware branch format.]
 
374
 
 
375
        XXX: When BzrDir is present, these should be created through that 
 
376
        interface instead.
 
377
        """
 
378
        warn('delete WorkingTree.create', stacklevel=3)
 
379
        transport = get_transport(directory)
 
380
        if branch.bzrdir.root_transport.base == transport.base:
 
381
            # same dir 
 
382
            return branch.bzrdir.create_workingtree()
 
383
        # different directory, 
 
384
        # create a branch reference
 
385
        # and now a working tree.
 
386
        raise NotImplementedError
 
387
 
 
388
    @staticmethod
 
389
    @deprecated_method(zero_eight)
 
390
    def create_standalone(directory):
 
391
        """Create a checkout and a branch and a repo at directory.
 
392
 
 
393
        Directory must exist and be empty.
 
394
 
 
395
        please use BzrDir.create_standalone_workingtree
 
396
        """
 
397
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
 
398
 
 
399
    def relpath(self, abs):
 
400
        """Return the local path portion from a given absolute path."""
 
401
        return relpath(self.basedir, abs)
428
402
 
429
403
    def has_filename(self, filename):
430
 
        return osutils.lexists(self.abspath(filename))
431
 
 
432
 
    def get_file(self, file_id, path=None, filtered=True):
433
 
        return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
434
 
 
435
 
    def get_file_with_stat(self, file_id, path=None, filtered=True,
436
 
                           _fstat=osutils.fstat):
437
 
        """See Tree.get_file_with_stat."""
438
 
        if path is None:
439
 
            path = self.id2path(file_id)
440
 
        file_obj = self.get_file_byname(path, filtered=False)
441
 
        stat_value = _fstat(file_obj.fileno())
442
 
        if filtered and self.supports_content_filtering():
443
 
            filters = self._content_filter_stack(path)
444
 
            file_obj = _mod_filters.filtered_input_file(file_obj, filters)
445
 
        return (file_obj, stat_value)
446
 
 
447
 
    def get_file_text(self, file_id, path=None, filtered=True):
448
 
        my_file = self.get_file(file_id, path=path, filtered=filtered)
449
 
        try:
450
 
            return my_file.read()
451
 
        finally:
452
 
            my_file.close()
453
 
 
454
 
    def get_file_byname(self, filename, filtered=True):
455
 
        path = self.abspath(filename)
456
 
        f = file(path, 'rb')
457
 
        if filtered and self.supports_content_filtering():
458
 
            filters = self._content_filter_stack(filename)
459
 
            return _mod_filters.filtered_input_file(f, filters)
460
 
        else:
461
 
            return f
462
 
 
463
 
    def get_file_lines(self, file_id, path=None, filtered=True):
464
 
        """See Tree.get_file_lines()"""
465
 
        file = self.get_file(file_id, path, filtered=filtered)
466
 
        try:
467
 
            return file.readlines()
468
 
        finally:
469
 
            file.close()
470
 
 
471
 
    def get_parent_ids(self):
472
 
        """See Tree.get_parent_ids.
473
 
 
474
 
        This implementation reads the pending merges list and last_revision
475
 
        value and uses that to decide what the parents list should be.
476
 
        """
477
 
        last_rev = _mod_revision.ensure_null(self._last_revision())
478
 
        if _mod_revision.NULL_REVISION == last_rev:
479
 
            parents = []
480
 
        else:
481
 
            parents = [last_rev]
482
 
        try:
483
 
            merges_bytes = self._transport.get_bytes('pending-merges')
484
 
        except errors.NoSuchFile:
485
 
            pass
486
 
        else:
487
 
            for l in osutils.split_lines(merges_bytes):
488
 
                revision_id = l.rstrip('\n')
489
 
                parents.append(revision_id)
490
 
        return parents
 
404
        return bzrlib.osutils.lexists(self.abspath(filename))
 
405
 
 
406
    def get_file(self, file_id):
 
407
        return self.get_file_byname(self.id2path(file_id))
 
408
 
 
409
    def get_file_byname(self, filename):
 
410
        return file(self.abspath(filename), 'rb')
491
411
 
492
412
    def get_root_id(self):
493
413
        """Return the id of this trees root"""
494
 
        raise NotImplementedError(self.get_root_id)
 
414
        inv = self.read_working_inventory()
 
415
        return inv.root.file_id
 
416
        
 
417
    def _get_store_filename(self, file_id):
 
418
        ## XXX: badly named; this is not in the store at all
 
419
        return self.abspath(self.id2path(file_id))
495
420
 
496
421
    @needs_read_lock
497
 
    def clone(self, to_bzrdir, revision_id=None):
 
422
    def clone(self, to_bzrdir, revision_id=None, basis=None):
498
423
        """Duplicate this working tree into to_bzr, including all state.
499
 
 
 
424
        
500
425
        Specifically modified files are kept as modified, but
501
426
        ignored and unknown files are discarded.
502
427
 
503
428
        If you want to make a new line of development, see bzrdir.sprout()
504
429
 
505
430
        revision
506
 
            If not None, the cloned tree will have its last revision set to
507
 
            revision, and difference between the source trees last revision
 
431
            If not None, the cloned tree will have its last revision set to 
 
432
            revision, and and difference between the source trees last revision
508
433
            and this one merged in.
 
434
 
 
435
        basis
 
436
            If not None, a closer copy of a tree which may have some files in
 
437
            common, and which file content should be preferentially copied from.
509
438
        """
510
439
        # assumes the target bzr dir format is compatible.
511
 
        result = to_bzrdir.create_workingtree()
 
440
        result = self._format.initialize(to_bzrdir)
512
441
        self.copy_content_into(result, revision_id)
513
442
        return result
514
443
 
515
444
    @needs_read_lock
516
445
    def copy_content_into(self, tree, revision_id=None):
517
446
        """Copy the current content and user files of this tree into tree."""
518
 
        tree.set_root_id(self.get_root_id())
519
447
        if revision_id is None:
520
 
            merge.transform_tree(tree, self)
 
448
            transform_tree(tree, self)
521
449
        else:
522
 
            # TODO now merge from tree.last_revision to revision (to preserve
523
 
            # user local changes)
524
 
            merge.transform_tree(tree, self)
525
 
            tree.set_parent_ids([revision_id])
 
450
            # TODO now merge from tree.last_revision to revision
 
451
            transform_tree(tree, self)
 
452
            tree.set_last_revision(revision_id)
 
453
 
 
454
    @needs_write_lock
 
455
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
456
        # avoid circular imports
 
457
        from bzrlib.commit import Commit
 
458
        if revprops is None:
 
459
            revprops = {}
 
460
        if not 'branch-nick' in revprops:
 
461
            revprops['branch-nick'] = self.branch.nick
 
462
        # args for wt.commit start at message from the Commit.commit method,
 
463
        # but with branch a kwarg now, passing in args as is results in the
 
464
        #message being used for the branch
 
465
        args = (DEPRECATED_PARAMETER, message, ) + args
 
466
        Commit().commit(working_tree=self, revprops=revprops, *args, **kwargs)
 
467
        self._set_inventory(self.read_working_inventory())
526
468
 
527
469
    def id2abspath(self, file_id):
528
470
        return self.abspath(self.id2path(file_id))
529
471
 
530
 
    def _check_for_tree_references(self, iterator):
531
 
        """See if directories have become tree-references."""
532
 
        blocked_parent_ids = set()
533
 
        for path, ie in iterator:
534
 
            if ie.parent_id in blocked_parent_ids:
535
 
                # This entry was pruned because one of its parents became a
536
 
                # TreeReference. If this is a directory, mark it as blocked.
537
 
                if ie.kind == 'directory':
538
 
                    blocked_parent_ids.add(ie.file_id)
539
 
                continue
540
 
            if ie.kind == 'directory' and self._directory_is_tree_reference(path):
541
 
                # This InventoryDirectory needs to be a TreeReference
542
 
                ie = inventory.TreeReference(ie.file_id, ie.name, ie.parent_id)
543
 
                blocked_parent_ids.add(ie.file_id)
544
 
            yield path, ie
545
 
 
546
 
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
547
 
        """See Tree.iter_entries_by_dir()"""
548
 
        # The only trick here is that if we supports_tree_reference then we
549
 
        # need to detect if a directory becomes a tree-reference.
550
 
        iterator = super(WorkingTree, self).iter_entries_by_dir(
551
 
                specific_file_ids=specific_file_ids,
552
 
                yield_parents=yield_parents)
553
 
        if not self.supports_tree_reference():
554
 
            return iterator
555
 
        else:
556
 
            return self._check_for_tree_references(iterator)
 
472
    def has_id(self, file_id):
 
473
        # files that have been deleted are excluded
 
474
        inv = self._inventory
 
475
        if not inv.has_id(file_id):
 
476
            return False
 
477
        path = inv.id2path(file_id)
 
478
        return bzrlib.osutils.lexists(self.abspath(path))
 
479
 
 
480
    def has_or_had_id(self, file_id):
 
481
        if file_id == self.inventory.root.file_id:
 
482
            return True
 
483
        return self.inventory.has_id(file_id)
 
484
 
 
485
    __contains__ = has_id
557
486
 
558
487
    def get_file_size(self, file_id):
559
 
        """See Tree.get_file_size"""
560
 
        # XXX: this returns the on-disk size; it should probably return the
561
 
        # canonical size
562
 
        try:
563
 
            return os.path.getsize(self.id2abspath(file_id))
564
 
        except OSError, e:
565
 
            if e.errno != errno.ENOENT:
566
 
                raise
567
 
            else:
568
 
                return None
569
 
 
570
 
    @needs_tree_write_lock
571
 
    def _gather_kinds(self, files, kinds):
572
 
        """See MutableTree._gather_kinds."""
573
 
        for pos, f in enumerate(files):
574
 
            if kinds[pos] is None:
575
 
                fullpath = normpath(self.abspath(f))
576
 
                try:
577
 
                    kinds[pos] = file_kind(fullpath)
578
 
                except OSError, e:
579
 
                    if e.errno == errno.ENOENT:
580
 
                        raise errors.NoSuchFile(fullpath)
581
 
 
582
 
    @needs_write_lock
583
 
    def add_parent_tree_id(self, revision_id, allow_leftmost_as_ghost=False):
584
 
        """Add revision_id as a parent.
585
 
 
586
 
        This is equivalent to retrieving the current list of parent ids
587
 
        and setting the list to its value plus revision_id.
588
 
 
589
 
        :param revision_id: The revision id to add to the parent list. It may
590
 
            be a ghost revision as long as its not the first parent to be
591
 
            added, or the allow_leftmost_as_ghost parameter is set True.
592
 
        :param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
593
 
        """
594
 
        parents = self.get_parent_ids() + [revision_id]
595
 
        self.set_parent_ids(parents, allow_leftmost_as_ghost=len(parents) > 1
596
 
            or allow_leftmost_as_ghost)
597
 
 
598
 
    @needs_tree_write_lock
599
 
    def add_parent_tree(self, parent_tuple, allow_leftmost_as_ghost=False):
600
 
        """Add revision_id, tree tuple as a parent.
601
 
 
602
 
        This is equivalent to retrieving the current list of parent trees
603
 
        and setting the list to its value plus parent_tuple. See also
604
 
        add_parent_tree_id - if you only have a parent id available it will be
605
 
        simpler to use that api. If you have the parent already available, using
606
 
        this api is preferred.
607
 
 
608
 
        :param parent_tuple: The (revision id, tree) to add to the parent list.
609
 
            If the revision_id is a ghost, pass None for the tree.
610
 
        :param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
611
 
        """
612
 
        parent_ids = self.get_parent_ids() + [parent_tuple[0]]
613
 
        if len(parent_ids) > 1:
614
 
            # the leftmost may have already been a ghost, preserve that if it
615
 
            # was.
616
 
            allow_leftmost_as_ghost = True
617
 
        self.set_parent_ids(parent_ids,
618
 
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
619
 
 
620
 
    @needs_tree_write_lock
 
488
        return os.path.getsize(self.id2abspath(file_id))
 
489
 
 
490
    @needs_read_lock
 
491
    def get_file_sha1(self, file_id):
 
492
        path = self._inventory.id2path(file_id)
 
493
        return self._hashcache.get_sha1(path)
 
494
 
 
495
    def is_executable(self, file_id):
 
496
        if not supports_executable():
 
497
            return self._inventory[file_id].executable
 
498
        else:
 
499
            path = self._inventory.id2path(file_id)
 
500
            mode = os.lstat(self.abspath(path)).st_mode
 
501
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
 
502
 
 
503
    @needs_write_lock
 
504
    def add(self, files, ids=None):
 
505
        """Make files versioned.
 
506
 
 
507
        Note that the command line normally calls smart_add instead,
 
508
        which can automatically recurse.
 
509
 
 
510
        This adds the files to the inventory, so that they will be
 
511
        recorded by the next commit.
 
512
 
 
513
        files
 
514
            List of paths to add, relative to the base of the tree.
 
515
 
 
516
        ids
 
517
            If set, use these instead of automatically generated ids.
 
518
            Must be the same length as the list of files, but may
 
519
            contain None for ids that are to be autogenerated.
 
520
 
 
521
        TODO: Perhaps have an option to add the ids even if the files do
 
522
              not (yet) exist.
 
523
 
 
524
        TODO: Perhaps callback with the ids and paths as they're added.
 
525
        """
 
526
        # TODO: Re-adding a file that is removed in the working copy
 
527
        # should probably put it back with the previous ID.
 
528
        if isinstance(files, basestring):
 
529
            assert(ids is None or isinstance(ids, basestring))
 
530
            files = [files]
 
531
            if ids is not None:
 
532
                ids = [ids]
 
533
 
 
534
        if ids is None:
 
535
            ids = [None] * len(files)
 
536
        else:
 
537
            assert(len(ids) == len(files))
 
538
 
 
539
        inv = self.read_working_inventory()
 
540
        for f,file_id in zip(files, ids):
 
541
            if self.is_control_filename(f):
 
542
                raise BzrError("cannot add control file %s" % quotefn(f))
 
543
 
 
544
            fp = splitpath(f)
 
545
 
 
546
            if len(fp) == 0:
 
547
                raise BzrError("cannot add top-level %r" % f)
 
548
 
 
549
            fullpath = normpath(self.abspath(f))
 
550
 
 
551
            try:
 
552
                kind = file_kind(fullpath)
 
553
            except OSError, e:
 
554
                if e.errno == errno.ENOENT:
 
555
                    raise NoSuchFile(fullpath)
 
556
                # maybe something better?
 
557
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
 
558
 
 
559
            if not InventoryEntry.versionable_kind(kind):
 
560
                raise BzrError('cannot add: not a versionable file ('
 
561
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
 
562
 
 
563
            if file_id is None:
 
564
                file_id = gen_file_id(f)
 
565
            inv.add_path(f, kind=kind, file_id=file_id)
 
566
 
 
567
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
568
        self._write_inventory(inv)
 
569
 
 
570
    @needs_write_lock
621
571
    def add_pending_merge(self, *revision_ids):
622
572
        # TODO: Perhaps should check at this point that the
623
573
        # history of the revision is actually present?
624
 
        parents = self.get_parent_ids()
 
574
        p = self.pending_merges()
625
575
        updated = False
626
576
        for rev_id in revision_ids:
627
 
            if rev_id in parents:
 
577
            if rev_id in p:
628
578
                continue
629
 
            parents.append(rev_id)
 
579
            p.append(rev_id)
630
580
            updated = True
631
581
        if updated:
632
 
            self.set_parent_ids(parents, allow_leftmost_as_ghost=True)
633
 
 
634
 
    def path_content_summary(self, path, _lstat=os.lstat,
635
 
        _mapper=osutils.file_kind_from_stat_mode):
636
 
        """See Tree.path_content_summary."""
637
 
        abspath = self.abspath(path)
 
582
            self.set_pending_merges(p)
 
583
 
 
584
    @needs_read_lock
 
585
    def pending_merges(self):
 
586
        """Return a list of pending merges.
 
587
 
 
588
        These are revisions that have been merged into the working
 
589
        directory but not yet committed.
 
590
        """
638
591
        try:
639
 
            stat_result = _lstat(abspath)
 
592
            merges_file = self._control_files.get_utf8('pending-merges')
640
593
        except OSError, e:
641
 
            if getattr(e, 'errno', None) == errno.ENOENT:
642
 
                # no file.
643
 
                return ('missing', None, None, None)
644
 
            # propagate other errors
645
 
            raise
646
 
        kind = _mapper(stat_result.st_mode)
647
 
        if kind == 'file':
648
 
            return self._file_content_summary(path, stat_result)
649
 
        elif kind == 'directory':
650
 
            # perhaps it looks like a plain directory, but it's really a
651
 
            # reference.
652
 
            if self._directory_is_tree_reference(path):
653
 
                kind = 'tree-reference'
654
 
            return kind, None, None, None
655
 
        elif kind == 'symlink':
656
 
            target = osutils.readlink(abspath)
657
 
            return ('symlink', None, None, target)
658
 
        else:
659
 
            return (kind, None, None, None)
660
 
 
661
 
    def _file_content_summary(self, path, stat_result):
662
 
        size = stat_result.st_size
663
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
664
 
        # try for a stat cache lookup
665
 
        return ('file', size, executable, self._sha_from_stat(
666
 
            path, stat_result))
667
 
 
668
 
    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
669
 
        """Common ghost checking functionality from set_parent_*.
670
 
 
671
 
        This checks that the left hand-parent exists if there are any
672
 
        revisions present.
673
 
        """
674
 
        if len(revision_ids) > 0:
675
 
            leftmost_id = revision_ids[0]
676
 
            if (not allow_leftmost_as_ghost and not
677
 
                self.branch.repository.has_revision(leftmost_id)):
678
 
                raise errors.GhostRevisionUnusableHere(leftmost_id)
679
 
 
680
 
    def _set_merges_from_parent_ids(self, parent_ids):
681
 
        merges = parent_ids[1:]
682
 
        self._transport.put_bytes('pending-merges', '\n'.join(merges),
683
 
            mode=self.bzrdir._get_file_mode())
684
 
 
685
 
    def _filter_parent_ids_by_ancestry(self, revision_ids):
686
 
        """Check that all merged revisions are proper 'heads'.
687
 
 
688
 
        This will always return the first revision_id, and any merged revisions
689
 
        which are
690
 
        """
691
 
        if len(revision_ids) == 0:
692
 
            return revision_ids
693
 
        graph = self.branch.repository.get_graph()
694
 
        heads = graph.heads(revision_ids)
695
 
        new_revision_ids = revision_ids[:1]
696
 
        for revision_id in revision_ids[1:]:
697
 
            if revision_id in heads and revision_id not in new_revision_ids:
698
 
                new_revision_ids.append(revision_id)
699
 
        if new_revision_ids != revision_ids:
700
 
            mutter('requested to set revision_ids = %s,'
701
 
                         ' but filtered to %s', revision_ids, new_revision_ids)
702
 
        return new_revision_ids
703
 
 
704
 
    @needs_tree_write_lock
705
 
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
706
 
        """Set the parent ids to revision_ids.
707
 
 
708
 
        See also set_parent_trees. This api will try to retrieve the tree data
709
 
        for each element of revision_ids from the trees repository. If you have
710
 
        tree data already available, it is more efficient to use
711
 
        set_parent_trees rather than set_parent_ids. set_parent_ids is however
712
 
        an easier API to use.
713
 
 
714
 
        :param revision_ids: The revision_ids to set as the parent ids of this
715
 
            working tree. Any of these may be ghosts.
716
 
        """
717
 
        self._check_parents_for_ghosts(revision_ids,
718
 
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
719
 
        for revision_id in revision_ids:
720
 
            _mod_revision.check_not_reserved_id(revision_id)
721
 
 
722
 
        revision_ids = self._filter_parent_ids_by_ancestry(revision_ids)
723
 
 
724
 
        if len(revision_ids) > 0:
725
 
            self.set_last_revision(revision_ids[0])
726
 
        else:
727
 
            self.set_last_revision(_mod_revision.NULL_REVISION)
728
 
 
729
 
        self._set_merges_from_parent_ids(revision_ids)
730
 
 
731
 
    @needs_tree_write_lock
 
594
            if e.errno != errno.ENOENT:
 
595
                raise
 
596
            return []
 
597
        p = []
 
598
        for l in merges_file.readlines():
 
599
            p.append(l.rstrip('\n'))
 
600
        return p
 
601
 
 
602
    @needs_write_lock
732
603
    def set_pending_merges(self, rev_list):
733
 
        parents = self.get_parent_ids()
734
 
        leftmost = parents[:1]
735
 
        new_parents = leftmost + rev_list
736
 
        self.set_parent_ids(new_parents)
 
604
        self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
737
605
 
738
 
    @needs_tree_write_lock
 
606
    @needs_write_lock
739
607
    def set_merge_modified(self, modified_hashes):
740
 
        def iter_stanzas():
741
 
            for file_id, hash in modified_hashes.iteritems():
742
 
                yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
743
 
                    hash=hash)
744
 
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
745
 
 
746
 
    def _sha_from_stat(self, path, stat_result):
747
 
        """Get a sha digest from the tree's stat cache.
748
 
 
749
 
        The default implementation assumes no stat cache is present.
750
 
 
751
 
        :param path: The path.
752
 
        :param stat_result: The stat result being looked up.
753
 
        """
754
 
        return None
755
 
 
756
 
    def _put_rio(self, filename, stanzas, header):
757
 
        self._must_be_locked()
758
 
        my_file = _mod_rio.rio_file(stanzas, header)
759
 
        self._transport.put_file(filename, my_file,
760
 
            mode=self.bzrdir._get_file_mode())
761
 
 
762
 
    @needs_write_lock # because merge pulls data into the branch.
763
 
    def merge_from_branch(self, branch, to_revision=None, from_revision=None,
764
 
                          merge_type=None, force=False):
765
 
        """Merge from a branch into this working tree.
766
 
 
767
 
        :param branch: The branch to merge from.
768
 
        :param to_revision: If non-None, the merge will merge to to_revision,
769
 
            but not beyond it. to_revision does not need to be in the history
770
 
            of the branch when it is supplied. If None, to_revision defaults to
771
 
            branch.last_revision().
772
 
        """
773
 
        from bzrlib.merge import Merger, Merge3Merger
774
 
        merger = Merger(self.branch, this_tree=self)
775
 
        # check that there are no local alterations
776
 
        if not force and self.has_changes():
777
 
            raise errors.UncommittedChanges(self)
778
 
        if to_revision is None:
779
 
            to_revision = _mod_revision.ensure_null(branch.last_revision())
780
 
        merger.other_rev_id = to_revision
781
 
        if _mod_revision.is_null(merger.other_rev_id):
782
 
            raise errors.NoCommits(branch)
783
 
        self.branch.fetch(branch, last_revision=merger.other_rev_id)
784
 
        merger.other_basis = merger.other_rev_id
785
 
        merger.other_tree = self.branch.repository.revision_tree(
786
 
            merger.other_rev_id)
787
 
        merger.other_branch = branch
788
 
        if from_revision is None:
789
 
            merger.find_base()
790
 
        else:
791
 
            merger.set_base_revision(from_revision, branch)
792
 
        if merger.base_rev_id == merger.other_rev_id:
793
 
            raise errors.PointlessMerge
794
 
        merger.backup_files = False
795
 
        if merge_type is None:
796
 
            merger.merge_type = Merge3Merger
797
 
        else:
798
 
            merger.merge_type = merge_type
799
 
        merger.set_interesting_files(None)
800
 
        merger.show_base = False
801
 
        merger.reprocess = False
802
 
        conflicts = merger.do_merge()
803
 
        merger.set_pending()
804
 
        return conflicts
805
 
 
 
608
        my_file = StringIO()
 
609
        my_file.write(MERGE_MODIFIED_HEADER_1 + '\n')
 
610
        writer = RioWriter(my_file)
 
611
        for file_id, hash in modified_hashes.iteritems():
 
612
            s = Stanza(file_id=file_id, hash=hash)
 
613
            writer.write_stanza(s)
 
614
        my_file.seek(0)
 
615
        self._control_files.put('merge-hashes', my_file)
 
616
 
 
617
    @needs_read_lock
806
618
    def merge_modified(self):
807
 
        """Return a dictionary of files modified by a merge.
808
 
 
809
 
        The list is initialized by WorkingTree.set_merge_modified, which is
810
 
        typically called after we make some automatic updates to the tree
811
 
        because of a merge.
812
 
 
813
 
        This returns a map of file_id->sha1, containing only files which are
814
 
        still in the working inventory and have that text hash.
815
 
        """
816
 
        raise NotImplementedError(self.merge_modified)
817
 
 
818
 
    @needs_write_lock
819
 
    def mkdir(self, path, file_id=None):
820
 
        """See MutableTree.mkdir()."""
821
 
        if file_id is None:
822
 
            file_id = generate_ids.gen_file_id(os.path.basename(path))
823
 
        os.mkdir(self.abspath(path))
824
 
        self.add(path, file_id, 'directory')
825
 
        return file_id
826
 
 
827
 
    def get_symlink_target(self, file_id, path=None):
828
 
        if path is not None:
829
 
            abspath = self.abspath(path)
830
 
        else:
831
 
            abspath = self.id2abspath(file_id)
832
 
        target = osutils.readlink(abspath)
833
 
        return target
834
 
 
835
 
    def subsume(self, other_tree):
836
 
        raise NotImplementedError(self.subsume)
837
 
 
838
 
    def _setup_directory_is_tree_reference(self):
839
 
        if self._branch.repository._format.supports_tree_reference:
840
 
            self._directory_is_tree_reference = \
841
 
                self._directory_may_be_tree_reference
842
 
        else:
843
 
            self._directory_is_tree_reference = \
844
 
                self._directory_is_never_tree_reference
845
 
 
846
 
    def _directory_is_never_tree_reference(self, relpath):
847
 
        return False
848
 
 
849
 
    def _directory_may_be_tree_reference(self, relpath):
850
 
        # as a special case, if a directory contains control files then
851
 
        # it's a tree reference, except that the root of the tree is not
852
 
        return relpath and osutils.isdir(self.abspath(relpath) + u"/.bzr")
853
 
        # TODO: We could ask all the control formats whether they
854
 
        # recognize this directory, but at the moment there's no cheap api
855
 
        # to do that.  Since we probably can only nest bzr checkouts and
856
 
        # they always use this name it's ok for now.  -- mbp 20060306
857
 
        #
858
 
        # FIXME: There is an unhandled case here of a subdirectory
859
 
        # containing .bzr but not a branch; that will probably blow up
860
 
        # when you try to commit it.  It might happen if there is a
861
 
        # checkout in a subdirectory.  This can be avoided by not adding
862
 
        # it.  mbp 20070306
863
 
 
864
 
    def extract(self, file_id, format=None):
865
 
        """Extract a subtree from this tree.
866
 
 
867
 
        A new branch will be created, relative to the path for this tree.
868
 
        """
869
 
        raise NotImplementedError(self.extract)
870
 
 
871
 
    def flush(self):
872
 
        """Write the in memory meta data to disk."""
873
 
        raise NotImplementedError(self.flush)
874
 
 
875
 
    def _kind(self, relpath):
876
 
        return osutils.file_kind(self.abspath(relpath))
877
 
 
878
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
879
 
        """List all files as (path, class, kind, id, entry).
 
619
        try:
 
620
            hashfile = self._control_files.get('merge-hashes')
 
621
        except NoSuchFile:
 
622
            return {}
 
623
        merge_hashes = {}
 
624
        try:
 
625
            if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
 
626
                raise MergeModifiedFormatError()
 
627
        except StopIteration:
 
628
            raise MergeModifiedFormatError()
 
629
        for s in RioReader(hashfile):
 
630
            file_id = s.get("file_id")
 
631
            hash = s.get("hash")
 
632
            if hash == self.get_file_sha1(file_id):
 
633
                merge_hashes[file_id] = hash
 
634
        return merge_hashes
 
635
 
 
636
    def get_symlink_target(self, file_id):
 
637
        return os.readlink(self.id2abspath(file_id))
 
638
 
 
639
    def file_class(self, filename):
 
640
        if self.path2id(filename):
 
641
            return 'V'
 
642
        elif self.is_ignored(filename):
 
643
            return 'I'
 
644
        else:
 
645
            return '?'
 
646
 
 
647
    def list_files(self):
 
648
        """Recursively list all files as (path, class, kind, id).
880
649
 
881
650
        Lists, but does not descend into unversioned directories.
 
651
 
882
652
        This does not include files that have been deleted in this
883
 
        tree. Skips the control directory.
 
653
        tree.
884
654
 
885
 
        :param include_root: if True, return an entry for the root
886
 
        :param from_dir: start from this directory or None for the root
887
 
        :param recursive: whether to recurse into subdirectories or not
 
655
        Skips the control directory.
888
656
        """
889
 
        raise NotImplementedError(self.list_files)
890
 
 
891
 
    def move(self, from_paths, to_dir=None, after=False):
 
657
        inv = self._inventory
 
658
 
 
659
        def descend(from_dir_relpath, from_dir_id, dp):
 
660
            ls = os.listdir(dp)
 
661
            ls.sort()
 
662
            for f in ls:
 
663
                ## TODO: If we find a subdirectory with its own .bzr
 
664
                ## directory, then that is a separate tree and we
 
665
                ## should exclude it.
 
666
 
 
667
                # the bzrdir for this tree
 
668
                if self.bzrdir.transport.base.endswith(f + '/'):
 
669
                    continue
 
670
 
 
671
                # path within tree
 
672
                fp = appendpath(from_dir_relpath, f)
 
673
 
 
674
                # absolute path
 
675
                fap = appendpath(dp, f)
 
676
                
 
677
                f_ie = inv.get_child(from_dir_id, f)
 
678
                if f_ie:
 
679
                    c = 'V'
 
680
                elif self.is_ignored(fp):
 
681
                    c = 'I'
 
682
                else:
 
683
                    c = '?'
 
684
 
 
685
                fk = file_kind(fap)
 
686
 
 
687
                if f_ie:
 
688
                    if f_ie.kind != fk:
 
689
                        raise BzrCheckError("file %r entered as kind %r id %r, "
 
690
                                            "now of kind %r"
 
691
                                            % (fap, f_ie.kind, f_ie.file_id, fk))
 
692
 
 
693
                # make a last minute entry
 
694
                if f_ie:
 
695
                    entry = f_ie
 
696
                else:
 
697
                    if fk == 'directory':
 
698
                        entry = TreeDirectory()
 
699
                    elif fk == 'file':
 
700
                        entry = TreeFile()
 
701
                    elif fk == 'symlink':
 
702
                        entry = TreeLink()
 
703
                    else:
 
704
                        entry = TreeEntry()
 
705
                
 
706
                yield fp, c, fk, (f_ie and f_ie.file_id), entry
 
707
 
 
708
                if fk != 'directory':
 
709
                    continue
 
710
 
 
711
                if c != 'V':
 
712
                    # don't descend unversioned directories
 
713
                    continue
 
714
                
 
715
                for ff in descend(fp, f_ie.file_id, fap):
 
716
                    yield ff
 
717
 
 
718
        for f in descend(u'', inv.root.file_id, self.basedir):
 
719
            yield f
 
720
 
 
721
    @needs_write_lock
 
722
    def move(self, from_paths, to_name):
892
723
        """Rename files.
893
724
 
894
 
        to_dir must be known to the working tree.
895
 
 
896
 
        If to_dir exists and is a directory, the files are moved into
897
 
        it, keeping their old names.
898
 
 
899
 
        Note that to_dir is only the last component of the new name;
 
725
        to_name must exist in the inventory.
 
726
 
 
727
        If to_name exists and is a directory, the files are moved into
 
728
        it, keeping their old names.  
 
729
 
 
730
        Note that to_name is only the last component of the new name;
900
731
        this doesn't change the directory.
901
732
 
902
 
        For each entry in from_paths the move mode will be determined
903
 
        independently.
904
 
 
905
 
        The first mode moves the file in the filesystem and updates the
906
 
        working tree metadata. The second mode only updates the working tree
907
 
        metadata without touching the file on the filesystem.
908
 
 
909
 
        move uses the second mode if 'after == True' and the target is not
910
 
        versioned but present in the working tree.
911
 
 
912
 
        move uses the second mode if 'after == False' and the source is
913
 
        versioned but no longer in the working tree, and the target is not
914
 
        versioned but present in the working tree.
915
 
 
916
 
        move uses the first mode if 'after == False' and the source is
917
 
        versioned and present in the working tree, and the target is not
918
 
        versioned and not present in the working tree.
919
 
 
920
 
        Everything else results in an error.
921
 
 
922
733
        This returns a list of (from_path, to_path) pairs for each
923
734
        entry that is moved.
924
735
        """
925
 
        raise NotImplementedError(self.move)
926
 
 
927
 
    @needs_tree_write_lock
928
 
    def rename_one(self, from_rel, to_rel, after=False):
 
736
        result = []
 
737
        ## TODO: Option to move IDs only
 
738
        assert not isinstance(from_paths, basestring)
 
739
        inv = self.inventory
 
740
        to_abs = self.abspath(to_name)
 
741
        if not isdir(to_abs):
 
742
            raise BzrError("destination %r is not a directory" % to_abs)
 
743
        if not self.has_filename(to_name):
 
744
            raise BzrError("destination %r not in working directory" % to_abs)
 
745
        to_dir_id = inv.path2id(to_name)
 
746
        if to_dir_id == None and to_name != '':
 
747
            raise BzrError("destination %r is not a versioned directory" % to_name)
 
748
        to_dir_ie = inv[to_dir_id]
 
749
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
750
            raise BzrError("destination %r is not a directory" % to_abs)
 
751
 
 
752
        to_idpath = inv.get_idpath(to_dir_id)
 
753
 
 
754
        for f in from_paths:
 
755
            if not self.has_filename(f):
 
756
                raise BzrError("%r does not exist in working tree" % f)
 
757
            f_id = inv.path2id(f)
 
758
            if f_id == None:
 
759
                raise BzrError("%r is not versioned" % f)
 
760
            name_tail = splitpath(f)[-1]
 
761
            dest_path = appendpath(to_name, name_tail)
 
762
            if self.has_filename(dest_path):
 
763
                raise BzrError("destination %r already exists" % dest_path)
 
764
            if f_id in to_idpath:
 
765
                raise BzrError("can't move %r to a subdirectory of itself" % f)
 
766
 
 
767
        # OK, so there's a race here, it's possible that someone will
 
768
        # create a file in this interval and then the rename might be
 
769
        # left half-done.  But we should have caught most problems.
 
770
        orig_inv = deepcopy(self.inventory)
 
771
        try:
 
772
            for f in from_paths:
 
773
                name_tail = splitpath(f)[-1]
 
774
                dest_path = appendpath(to_name, name_tail)
 
775
                result.append((f, dest_path))
 
776
                inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
777
                try:
 
778
                    rename(self.abspath(f), self.abspath(dest_path))
 
779
                except OSError, e:
 
780
                    raise BzrError("failed to rename %r to %r: %s" %
 
781
                                   (f, dest_path, e[1]),
 
782
                            ["rename rolled back"])
 
783
        except:
 
784
            # restore the inventory on error
 
785
            self._set_inventory(orig_inv)
 
786
            raise
 
787
        self._write_inventory(inv)
 
788
        return result
 
789
 
 
790
    @needs_write_lock
 
791
    def rename_one(self, from_rel, to_rel):
929
792
        """Rename one file.
930
793
 
931
794
        This can change the directory or the filename or both.
932
 
 
933
 
        rename_one has several 'modes' to work. First, it can rename a physical
934
 
        file and change the file_id. That is the normal mode. Second, it can
935
 
        only change the file_id without touching any physical file.
936
 
 
937
 
        rename_one uses the second mode if 'after == True' and 'to_rel' is
938
 
        either not versioned or newly added, and present in the working tree.
939
 
 
940
 
        rename_one uses the second mode if 'after == False' and 'from_rel' is
941
 
        versioned but no longer in the working tree, and 'to_rel' is not
942
 
        versioned but present in the working tree.
943
 
 
944
 
        rename_one uses the first mode if 'after == False' and 'from_rel' is
945
 
        versioned and present in the working tree, and 'to_rel' is not
946
 
        versioned and not present in the working tree.
947
 
 
948
 
        Everything else results in an error.
949
795
        """
950
 
        raise NotImplementedError(self.rename_one)
 
796
        inv = self.inventory
 
797
        if not self.has_filename(from_rel):
 
798
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
799
        if self.has_filename(to_rel):
 
800
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
801
 
 
802
        file_id = inv.path2id(from_rel)
 
803
        if file_id == None:
 
804
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
805
 
 
806
        entry = inv[file_id]
 
807
        from_parent = entry.parent_id
 
808
        from_name = entry.name
 
809
        
 
810
        if inv.path2id(to_rel):
 
811
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
812
 
 
813
        to_dir, to_tail = os.path.split(to_rel)
 
814
        to_dir_id = inv.path2id(to_dir)
 
815
        if to_dir_id == None and to_dir != '':
 
816
            raise BzrError("can't determine destination directory id for %r" % to_dir)
 
817
 
 
818
        mutter("rename_one:")
 
819
        mutter("  file_id    {%s}" % file_id)
 
820
        mutter("  from_rel   %r" % from_rel)
 
821
        mutter("  to_rel     %r" % to_rel)
 
822
        mutter("  to_dir     %r" % to_dir)
 
823
        mutter("  to_dir_id  {%s}" % to_dir_id)
 
824
 
 
825
        inv.rename(file_id, to_dir_id, to_tail)
 
826
 
 
827
        from_abs = self.abspath(from_rel)
 
828
        to_abs = self.abspath(to_rel)
 
829
        try:
 
830
            rename(from_abs, to_abs)
 
831
        except OSError, e:
 
832
            inv.rename(file_id, from_parent, from_name)
 
833
            raise BzrError("failed to rename %r to %r: %s"
 
834
                    % (from_abs, to_abs, e[1]),
 
835
                    ["rename rolled back"])
 
836
        self._write_inventory(inv)
951
837
 
952
838
    @needs_read_lock
953
839
    def unknowns(self):
955
841
 
956
842
        These are files in the working directory that are not versioned or
957
843
        control files or ignored.
958
 
        """
959
 
        # force the extras method to be fully executed before returning, to
960
 
        # prevent race conditions with the lock
961
 
        return iter(
962
 
            [subp for subp in self.extras() if not self.is_ignored(subp)])
963
 
 
964
 
    def unversion(self, file_ids):
965
 
        """Remove the file ids in file_ids from the current versioned set.
966
 
 
967
 
        When a file_id is unversioned, all of its children are automatically
968
 
        unversioned.
969
 
 
970
 
        :param file_ids: The file ids to stop versioning.
971
 
        :raises: NoSuchId if any fileid is not currently versioned.
972
 
        """
973
 
        raise NotImplementedError(self.unversion)
 
844
        
 
845
        >>> from bzrlib.bzrdir import ScratchDir
 
846
        >>> d = ScratchDir(files=['foo', 'foo~'])
 
847
        >>> b = d.open_branch()
 
848
        >>> tree = d.open_workingtree()
 
849
        >>> map(str, tree.unknowns())
 
850
        ['foo']
 
851
        >>> tree.add('foo')
 
852
        >>> list(b.unknowns())
 
853
        []
 
854
        >>> tree.remove('foo')
 
855
        >>> list(b.unknowns())
 
856
        [u'foo']
 
857
        """
 
858
        for subp in self.extras():
 
859
            if not self.is_ignored(subp):
 
860
                yield subp
 
861
 
 
862
    def iter_conflicts(self):
 
863
        conflicted = set()
 
864
        for path in (s[0] for s in self.list_files()):
 
865
            stem = get_conflicted_stem(path)
 
866
            if stem is None:
 
867
                continue
 
868
            if stem not in conflicted:
 
869
                conflicted.add(stem)
 
870
                yield stem
974
871
 
975
872
    @needs_write_lock
976
 
    def pull(self, source, overwrite=False, stop_revision=None,
977
 
             change_reporter=None, possible_transports=None, local=False,
978
 
             show_base=False):
 
873
    def pull(self, source, overwrite=False, stop_revision=None):
 
874
        top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
979
875
        source.lock_read()
980
876
        try:
981
 
            old_revision_info = self.branch.last_revision_info()
 
877
            pp = ProgressPhase("Pull phase", 2, top_pb)
 
878
            pp.next_phase()
 
879
            old_revision_history = self.branch.revision_history()
982
880
            basis_tree = self.basis_tree()
983
 
            count = self.branch.pull(source, overwrite, stop_revision,
984
 
                                     possible_transports=possible_transports,
985
 
                                     local=local)
986
 
            new_revision_info = self.branch.last_revision_info()
987
 
            if new_revision_info != old_revision_info:
 
881
            count = self.branch.pull(source, overwrite, stop_revision)
 
882
            new_revision_history = self.branch.revision_history()
 
883
            if new_revision_history != old_revision_history:
 
884
                pp.next_phase()
 
885
                if len(old_revision_history):
 
886
                    other_revision = old_revision_history[-1]
 
887
                else:
 
888
                    other_revision = None
988
889
                repository = self.branch.repository
989
 
                if repository._format.fast_deltas:
990
 
                    parent_ids = self.get_parent_ids()
991
 
                    if parent_ids:
992
 
                        basis_id = parent_ids[0]
993
 
                        basis_tree = repository.revision_tree(basis_id)
994
 
                basis_tree.lock_read()
 
890
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
995
891
                try:
996
 
                    new_basis_tree = self.branch.basis_tree()
997
 
                    merge.merge_inner(
998
 
                                self.branch,
999
 
                                new_basis_tree,
1000
 
                                basis_tree,
1001
 
                                this_tree=self,
1002
 
                                pb=None,
1003
 
                                change_reporter=change_reporter,
1004
 
                                show_base=show_base)
1005
 
                    basis_root_id = basis_tree.get_root_id()
1006
 
                    new_root_id = new_basis_tree.get_root_id()
1007
 
                    if basis_root_id != new_root_id:
1008
 
                        self.set_root_id(new_root_id)
 
892
                    merge_inner(self.branch,
 
893
                                self.branch.basis_tree(),
 
894
                                basis_tree, 
 
895
                                this_tree=self, 
 
896
                                pb=pb)
1009
897
                finally:
1010
 
                    basis_tree.unlock()
1011
 
                # TODO - dedup parents list with things merged by pull ?
1012
 
                # reuse the revisiontree we merged against to set the new
1013
 
                # tree data.
1014
 
                parent_trees = [(self.branch.last_revision(), new_basis_tree)]
1015
 
                # we have to pull the merge trees out again, because
1016
 
                # merge_inner has set the ids. - this corner is not yet
1017
 
                # layered well enough to prevent double handling.
1018
 
                # XXX TODO: Fix the double handling: telling the tree about
1019
 
                # the already known parent data is wasteful.
1020
 
                merges = self.get_parent_ids()[1:]
1021
 
                parent_trees.extend([
1022
 
                    (parent, repository.revision_tree(parent)) for
1023
 
                     parent in merges])
1024
 
                self.set_parent_trees(parent_trees)
 
898
                    pb.finished()
 
899
                self.set_last_revision(self.branch.last_revision())
1025
900
            return count
1026
901
        finally:
1027
902
            source.unlock()
1028
 
 
1029
 
    @needs_write_lock
1030
 
    def put_file_bytes_non_atomic(self, file_id, bytes):
1031
 
        """See MutableTree.put_file_bytes_non_atomic."""
1032
 
        stream = file(self.id2abspath(file_id), 'wb')
1033
 
        try:
1034
 
            stream.write(bytes)
1035
 
        finally:
1036
 
            stream.close()
 
903
            top_pb.finished()
1037
904
 
1038
905
    def extras(self):
1039
 
        """Yield all unversioned files in this WorkingTree.
 
906
        """Yield all unknown files in this WorkingTree.
1040
907
 
1041
 
        If there are any unversioned directories then only the directory is
1042
 
        returned, not all its children.  But if there are unversioned files
 
908
        If there are any unknown directories then only the directory is
 
909
        returned, not all its children.  But if there are unknown files
1043
910
        under a versioned subdirectory, they are returned.
1044
911
 
1045
912
        Currently returned depth-first, sorted by name within directories.
1046
 
        This is the same order used by 'osutils.walkdirs'.
1047
913
        """
1048
 
        raise NotImplementedError(self.extras)
 
914
        ## TODO: Work from given directory downwards
 
915
        for path, dir_entry in self.inventory.directories():
 
916
            mutter("search for unknowns in %r", path)
 
917
            dirabs = self.abspath(path)
 
918
            if not isdir(dirabs):
 
919
                # e.g. directory deleted
 
920
                continue
 
921
 
 
922
            fl = []
 
923
            for subf in os.listdir(dirabs):
 
924
                if (subf != '.bzr'
 
925
                    and (subf not in dir_entry.children)):
 
926
                    fl.append(subf)
 
927
            
 
928
            fl.sort()
 
929
            for subf in fl:
 
930
                subp = appendpath(path, subf)
 
931
                yield subp
 
932
 
1049
933
 
1050
934
    def ignored_files(self):
1051
935
        """Yield list of PATH, IGNORE_PATTERN"""
1052
936
        for subp in self.extras():
1053
937
            pat = self.is_ignored(subp)
1054
 
            if pat is not None:
 
938
            if pat != None:
1055
939
                yield subp, pat
1056
940
 
 
941
 
1057
942
    def get_ignore_list(self):
1058
943
        """Return list of ignore patterns.
1059
944
 
1060
945
        Cached in the Tree object after the first call.
1061
946
        """
1062
 
        ignoreset = getattr(self, '_ignoreset', None)
1063
 
        if ignoreset is not None:
1064
 
            return ignoreset
 
947
        if hasattr(self, '_ignorelist'):
 
948
            return self._ignorelist
1065
949
 
1066
 
        ignore_globs = set()
1067
 
        ignore_globs.update(ignores.get_runtime_ignores())
1068
 
        ignore_globs.update(ignores.get_user_ignores())
 
950
        l = bzrlib.DEFAULT_IGNORE[:]
1069
951
        if self.has_filename(bzrlib.IGNORE_FILENAME):
1070
952
            f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
1071
 
            try:
1072
 
                ignore_globs.update(ignores.parse_ignore_file(f))
1073
 
            finally:
1074
 
                f.close()
1075
 
        self._ignoreset = ignore_globs
1076
 
        return ignore_globs
 
953
            l.extend([line.rstrip("\n\r") for line in f.readlines()])
 
954
        self._ignorelist = l
 
955
        return l
1077
956
 
1078
 
    def _flush_ignore_list_cache(self):
1079
 
        """Resets the cached ignore list to force a cache rebuild."""
1080
 
        self._ignoreset = None
1081
 
        self._ignoreglobster = None
1082
957
 
1083
958
    def is_ignored(self, filename):
1084
959
        r"""Check whether the filename matches an ignore pattern.
1085
960
 
1086
961
        Patterns containing '/' or '\' need to match the whole path;
1087
 
        others match against only the last component.  Patterns starting
1088
 
        with '!' are ignore exceptions.  Exceptions take precedence
1089
 
        over regular patterns and cause the filename to not be ignored.
 
962
        others match against only the last component.
1090
963
 
1091
964
        If the file is ignored, returns the pattern which caused it to
1092
965
        be ignored, otherwise None.  So this can simply be used as a
1093
966
        boolean if desired."""
1094
 
        if getattr(self, '_ignoreglobster', None) is None:
1095
 
            self._ignoreglobster = globbing.ExceptionGlobster(self.get_ignore_list())
1096
 
        return self._ignoreglobster.match(filename)
 
967
 
 
968
        # TODO: Use '**' to match directories, and other extended
 
969
        # globbing stuff from cvs/rsync.
 
970
 
 
971
        # XXX: fnmatch is actually not quite what we want: it's only
 
972
        # approximately the same as real Unix fnmatch, and doesn't
 
973
        # treat dotfiles correctly and allows * to match /.
 
974
        # Eventually it should be replaced with something more
 
975
        # accurate.
 
976
        
 
977
        for pat in self.get_ignore_list():
 
978
            if '/' in pat or '\\' in pat:
 
979
                
 
980
                # as a special case, you can put ./ at the start of a
 
981
                # pattern; this is good to match in the top-level
 
982
                # only;
 
983
                
 
984
                if (pat[:2] == './') or (pat[:2] == '.\\'):
 
985
                    newpat = pat[2:]
 
986
                else:
 
987
                    newpat = pat
 
988
                if fnmatch.fnmatchcase(filename, newpat):
 
989
                    return pat
 
990
            else:
 
991
                if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
 
992
                    return pat
 
993
        else:
 
994
            return None
1097
995
 
1098
996
    def kind(self, file_id):
1099
997
        return file_kind(self.id2abspath(file_id))
1100
998
 
1101
 
    def stored_kind(self, file_id):
1102
 
        """See Tree.stored_kind"""
1103
 
        raise NotImplementedError(self.stored_kind)
1104
 
 
1105
 
    def _comparison_data(self, entry, path):
1106
 
        abspath = self.abspath(path)
1107
 
        try:
1108
 
            stat_value = os.lstat(abspath)
1109
 
        except OSError, e:
1110
 
            if getattr(e, 'errno', None) == errno.ENOENT:
1111
 
                stat_value = None
1112
 
                kind = None
1113
 
                executable = False
1114
 
            else:
1115
 
                raise
1116
 
        else:
1117
 
            mode = stat_value.st_mode
1118
 
            kind = osutils.file_kind_from_stat_mode(mode)
1119
 
            if not supports_executable():
1120
 
                executable = entry is not None and entry.executable
1121
 
            else:
1122
 
                executable = bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
1123
 
        return kind, executable, stat_value
1124
 
 
1125
 
    def _file_size(self, entry, stat_value):
1126
 
        return stat_value.st_size
1127
 
 
 
999
    @needs_read_lock
1128
1000
    def last_revision(self):
1129
 
        """Return the last revision of the branch for this tree.
1130
 
 
1131
 
        This format tree does not support a separate marker for last-revision
1132
 
        compared to the branch.
1133
 
 
1134
 
        See MutableTree.last_revision
 
1001
        """Return the last revision id of this working tree.
 
1002
 
 
1003
        In early branch formats this was == the branch last_revision,
 
1004
        but that cannot be relied upon - for working tree operations,
 
1005
        always use tree.last_revision().
1135
1006
        """
1136
 
        return self._last_revision()
1137
 
 
1138
 
    @needs_read_lock
1139
 
    def _last_revision(self):
1140
 
        """helper for get_parent_ids."""
1141
 
        return _mod_revision.ensure_null(self.branch.last_revision())
1142
 
 
1143
 
    def is_locked(self):
1144
 
        return self._control_files.is_locked()
1145
 
 
1146
 
    def _must_be_locked(self):
1147
 
        if not self.is_locked():
1148
 
            raise errors.ObjectNotLocked(self)
 
1007
        return self.branch.last_revision()
1149
1008
 
1150
1009
    def lock_read(self):
1151
 
        """Lock the tree for reading.
1152
 
 
1153
 
        This also locks the branch, and can be unlocked via self.unlock().
1154
 
 
1155
 
        :return: A bzrlib.lock.LogicalLockResult.
1156
 
        """
1157
 
        if not self.is_locked():
1158
 
            self._reset_data()
1159
 
        self.branch.lock_read()
1160
 
        try:
1161
 
            self._control_files.lock_read()
1162
 
            return LogicalLockResult(self.unlock)
1163
 
        except:
1164
 
            self.branch.unlock()
1165
 
            raise
1166
 
 
1167
 
    def lock_tree_write(self):
1168
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
1169
 
 
1170
 
        :return: A bzrlib.lock.LogicalLockResult.
1171
 
        """
1172
 
        if not self.is_locked():
1173
 
            self._reset_data()
1174
 
        self.branch.lock_read()
1175
 
        try:
1176
 
            self._control_files.lock_write()
1177
 
            return LogicalLockResult(self.unlock)
 
1010
        """See Branch.lock_read, and WorkingTree.unlock."""
 
1011
        self.branch.lock_read()
 
1012
        try:
 
1013
            return self._control_files.lock_read()
1178
1014
        except:
1179
1015
            self.branch.unlock()
1180
1016
            raise
1181
1017
 
1182
1018
    def lock_write(self):
1183
 
        """See MutableTree.lock_write, and WorkingTree.unlock.
1184
 
 
1185
 
        :return: A bzrlib.lock.LogicalLockResult.
1186
 
        """
1187
 
        if not self.is_locked():
1188
 
            self._reset_data()
 
1019
        """See Branch.lock_write, and WorkingTree.unlock."""
1189
1020
        self.branch.lock_write()
1190
1021
        try:
1191
 
            self._control_files.lock_write()
1192
 
            return LogicalLockResult(self.unlock)
 
1022
            return self._control_files.lock_write()
1193
1023
        except:
1194
1024
            self.branch.unlock()
1195
1025
            raise
1196
1026
 
1197
 
    def get_physical_lock_status(self):
1198
 
        return self._control_files.get_physical_lock_status()
1199
 
 
1200
 
    def _reset_data(self):
1201
 
        """Reset transient data that cannot be revalidated."""
1202
 
        raise NotImplementedError(self._reset_data)
1203
 
 
1204
 
    def set_last_revision(self, new_revision):
 
1027
    def _basis_inventory_name(self, revision_id):
 
1028
        return 'basis-inventory.%s' % revision_id
 
1029
 
 
1030
    @needs_write_lock
 
1031
    def set_last_revision(self, new_revision, old_revision=None):
1205
1032
        """Change the last revision in the working tree."""
1206
 
        raise NotImplementedError(self.set_last_revision)
 
1033
        self._remove_old_basis(old_revision)
 
1034
        if self._change_last_revision(new_revision):
 
1035
            self._cache_basis_inventory(new_revision)
1207
1036
 
1208
1037
    def _change_last_revision(self, new_revision):
1209
 
        """Template method part of set_last_revision to perform the change.
1210
 
 
1211
 
        This is used to allow WorkingTree3 instances to not affect branch
1212
 
        when their last revision is set.
1213
 
        """
1214
 
        if _mod_revision.is_null(new_revision):
1215
 
            self.branch.set_last_revision_info(0, new_revision)
 
1038
        """Template method part of set_last_revision to perform the change."""
 
1039
        if new_revision is None:
 
1040
            self.branch.set_revision_history([])
1216
1041
            return False
1217
 
        _mod_revision.check_not_reserved_id(new_revision)
 
1042
        # current format is locked in with the branch
 
1043
        revision_history = self.branch.revision_history()
1218
1044
        try:
1219
 
            self.branch.generate_revision_history(new_revision)
1220
 
        except errors.NoSuchRevision:
1221
 
            # not present in the repo - dont try to set it deeper than the tip
1222
 
            self.branch._set_revision_history([new_revision])
 
1045
            position = revision_history.index(new_revision)
 
1046
        except ValueError:
 
1047
            raise errors.NoSuchRevision(self.branch, new_revision)
 
1048
        self.branch.set_revision_history(revision_history[:position + 1])
1223
1049
        return True
1224
1050
 
1225
 
    @needs_tree_write_lock
1226
 
    def remove(self, files, verbose=False, to_file=None, keep_files=True,
1227
 
        force=False):
1228
 
        """Remove nominated files from the working tree metadata.
1229
 
 
1230
 
        :files: File paths relative to the basedir.
1231
 
        :keep_files: If true, the files will also be kept.
1232
 
        :force: Delete files and directories, even if they are changed and
1233
 
            even if the directories are not empty.
 
1051
    def _cache_basis_inventory(self, new_revision):
 
1052
        """Cache new_revision as the basis inventory."""
 
1053
        try:
 
1054
            xml = self.branch.repository.get_inventory_xml(new_revision)
 
1055
            path = self._basis_inventory_name(new_revision)
 
1056
            self._control_files.put_utf8(path, xml)
 
1057
        except WeaveRevisionNotPresent:
 
1058
            pass
 
1059
 
 
1060
    def _remove_old_basis(self, old_revision):
 
1061
        """Remove the old basis inventory 'old_revision'."""
 
1062
        if old_revision is not None:
 
1063
            try:
 
1064
                path = self._basis_inventory_name(old_revision)
 
1065
                path = self._control_files._escape(path)
 
1066
                self._control_files._transport.delete(path)
 
1067
            except NoSuchFile:
 
1068
                pass
 
1069
 
 
1070
    def read_basis_inventory(self, revision_id):
 
1071
        """Read the cached basis inventory."""
 
1072
        path = self._basis_inventory_name(revision_id)
 
1073
        return self._control_files.get_utf8(path).read()
 
1074
        
 
1075
    @needs_read_lock
 
1076
    def read_working_inventory(self):
 
1077
        """Read the working inventory."""
 
1078
        # ElementTree does its own conversion from UTF-8, so open in
 
1079
        # binary.
 
1080
        result = bzrlib.xml5.serializer_v5.read_inventory(
 
1081
            self._control_files.get('inventory'))
 
1082
        self._set_inventory(result)
 
1083
        return result
 
1084
 
 
1085
    @needs_write_lock
 
1086
    def remove(self, files, verbose=False):
 
1087
        """Remove nominated files from the working inventory..
 
1088
 
 
1089
        This does not remove their text.  This does not run on XXX on what? RBC
 
1090
 
 
1091
        TODO: Refuse to remove modified files unless --force is given?
 
1092
 
 
1093
        TODO: Do something useful with directories.
 
1094
 
 
1095
        TODO: Should this remove the text or not?  Tough call; not
 
1096
        removing may be useful and the user can just use use rm, and
 
1097
        is the opposite of add.  Removing it is consistent with most
 
1098
        other tools.  Maybe an option.
1234
1099
        """
 
1100
        ## TODO: Normalize names
 
1101
        ## TODO: Remove nested loops; better scalability
1235
1102
        if isinstance(files, basestring):
1236
1103
            files = [files]
1237
1104
 
1238
 
        inv_delta = []
1239
 
 
1240
 
        all_files = set() # specified and nested files 
1241
 
        unknown_nested_files=set()
1242
 
        if to_file is None:
1243
 
            to_file = sys.stdout
1244
 
 
1245
 
        files_to_backup = []
1246
 
 
1247
 
        def recurse_directory_to_add_files(directory):
1248
 
            # Recurse directory and add all files
1249
 
            # so we can check if they have changed.
1250
 
            for parent_info, file_infos in self.walkdirs(directory):
1251
 
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1252
 
                    # Is it versioned or ignored?
1253
 
                    if self.path2id(relpath):
1254
 
                        # Add nested content for deletion.
1255
 
                        all_files.add(relpath)
1256
 
                    else:
1257
 
                        # Files which are not versioned
1258
 
                        # should be treated as unknown.
1259
 
                        files_to_backup.append(relpath)
1260
 
 
1261
 
        for filename in files:
1262
 
            # Get file name into canonical form.
1263
 
            abspath = self.abspath(filename)
1264
 
            filename = self.relpath(abspath)
1265
 
            if len(filename) > 0:
1266
 
                all_files.add(filename)
1267
 
                recurse_directory_to_add_files(filename)
1268
 
 
1269
 
        files = list(all_files)
1270
 
 
1271
 
        if len(files) == 0:
1272
 
            return # nothing to do
1273
 
 
1274
 
        # Sort needed to first handle directory content before the directory
1275
 
        files.sort(reverse=True)
1276
 
 
1277
 
        # Bail out if we are going to delete files we shouldn't
1278
 
        if not keep_files and not force:
1279
 
            for (file_id, path, content_change, versioned, parent_id, name,
1280
 
                 kind, executable) in self.iter_changes(self.basis_tree(),
1281
 
                     include_unchanged=True, require_versioned=False,
1282
 
                     want_unversioned=True, specific_files=files):
1283
 
                if versioned[0] == False:
1284
 
                    # The record is unknown or newly added
1285
 
                    files_to_backup.append(path[1])
1286
 
                elif (content_change and (kind[1] is not None) and
1287
 
                        osutils.is_inside_any(files, path[1])):
1288
 
                    # Versioned and changed, but not deleted, and still
1289
 
                    # in one of the dirs to be deleted.
1290
 
                    files_to_backup.append(path[1])
1291
 
 
1292
 
        def backup(file_to_backup):
1293
 
            backup_name = self.bzrdir._available_backup_name(file_to_backup)
1294
 
            osutils.rename(abs_path, self.abspath(backup_name))
1295
 
            return "removed %s (but kept a copy: %s)" % (file_to_backup,
1296
 
                                                         backup_name)
1297
 
 
1298
 
        # Build inv_delta and delete files where applicable,
1299
 
        # do this before any modifications to meta data.
 
1105
        inv = self.inventory
 
1106
 
 
1107
        # do this before any modifications
1300
1108
        for f in files:
1301
 
            fid = self.path2id(f)
1302
 
            message = None
 
1109
            fid = inv.path2id(f)
1303
1110
            if not fid:
1304
 
                message = "%s is not versioned." % (f,)
1305
 
            else:
1306
 
                if verbose:
1307
 
                    # having removed it, it must be either ignored or unknown
1308
 
                    if self.is_ignored(f):
1309
 
                        new_status = 'I'
1310
 
                    else:
1311
 
                        new_status = '?'
1312
 
                    # XXX: Really should be a more abstract reporter interface
1313
 
                    kind_ch = osutils.kind_marker(self.kind(fid))
1314
 
                    to_file.write(new_status + '       ' + f + kind_ch + '\n')
1315
 
                # Unversion file
1316
 
                inv_delta.append((f, None, fid, None))
1317
 
                message = "removed %s" % (f,)
1318
 
 
1319
 
            if not keep_files:
1320
 
                abs_path = self.abspath(f)
1321
 
                if osutils.lexists(abs_path):
1322
 
                    if (osutils.isdir(abs_path) and
1323
 
                        len(os.listdir(abs_path)) > 0):
1324
 
                        if force:
1325
 
                            osutils.rmtree(abs_path)
1326
 
                            message = "deleted %s" % (f,)
1327
 
                        else:
1328
 
                            message = backup(f)
1329
 
                    else:
1330
 
                        if f in files_to_backup:
1331
 
                            message = backup(f)
1332
 
                        else:
1333
 
                            osutils.delete_any(abs_path)
1334
 
                            message = "deleted %s" % (f,)
1335
 
                elif message is not None:
1336
 
                    # Only care if we haven't done anything yet.
1337
 
                    message = "%s does not exist." % (f,)
1338
 
 
1339
 
            # Print only one message (if any) per file.
1340
 
            if message is not None:
1341
 
                note(message)
1342
 
        self.apply_inventory_delta(inv_delta)
1343
 
 
1344
 
    @needs_tree_write_lock
1345
 
    def revert(self, filenames=None, old_tree=None, backups=True,
1346
 
               pb=None, report_changes=False):
1347
 
        from bzrlib.conflicts import resolve
 
1111
                # TODO: Perhaps make this just a warning, and continue?
 
1112
                # This tends to happen when 
 
1113
                raise NotVersionedError(path=f)
 
1114
            mutter("remove inventory entry %s {%s}", quotefn(f), fid)
 
1115
            if verbose:
 
1116
                # having remove it, it must be either ignored or unknown
 
1117
                if self.is_ignored(f):
 
1118
                    new_status = 'I'
 
1119
                else:
 
1120
                    new_status = '?'
 
1121
                show_status(new_status, inv[fid].kind, quotefn(f))
 
1122
            del inv[fid]
 
1123
 
 
1124
        self._write_inventory(inv)
 
1125
 
 
1126
    @needs_write_lock
 
1127
    def revert(self, filenames, old_tree=None, backups=True, 
 
1128
               pb=DummyProgress()):
 
1129
        from transform import revert
1348
1130
        if old_tree is None:
1349
 
            basis_tree = self.basis_tree()
1350
 
            basis_tree.lock_read()
1351
 
            old_tree = basis_tree
1352
 
        else:
1353
 
            basis_tree = None
1354
 
        try:
1355
 
            conflicts = transform.revert(self, old_tree, filenames, backups, pb,
1356
 
                                         report_changes)
1357
 
            if filenames is None and len(self.get_parent_ids()) > 1:
1358
 
                parent_trees = []
1359
 
                last_revision = self.last_revision()
1360
 
                if last_revision != _mod_revision.NULL_REVISION:
1361
 
                    if basis_tree is None:
1362
 
                        basis_tree = self.basis_tree()
1363
 
                        basis_tree.lock_read()
1364
 
                    parent_trees.append((last_revision, basis_tree))
1365
 
                self.set_parent_trees(parent_trees)
1366
 
                resolve(self)
1367
 
            else:
1368
 
                resolve(self, filenames, ignore_misses=True, recursive=True)
1369
 
        finally:
1370
 
            if basis_tree is not None:
1371
 
                basis_tree.unlock()
1372
 
        return conflicts
1373
 
 
1374
 
    def revision_tree(self, revision_id):
1375
 
        """See Tree.revision_tree.
1376
 
 
1377
 
        WorkingTree can supply revision_trees for the basis revision only
1378
 
        because there is only one cached inventory in the bzr directory.
1379
 
        """
1380
 
        raise NotImplementedError(self.revision_tree)
1381
 
 
1382
 
    @needs_tree_write_lock
1383
 
    def set_root_id(self, file_id):
1384
 
        """Set the root id for this tree."""
1385
 
        # for compatability
1386
 
        if file_id is None:
1387
 
            raise ValueError(
1388
 
                'WorkingTree.set_root_id with fileid=None')
1389
 
        file_id = osutils.safe_file_id(file_id)
1390
 
        self._set_root_id(file_id)
1391
 
 
1392
 
    def _set_root_id(self, file_id):
1393
 
        """Set the root id for this tree, in a format specific manner.
1394
 
 
1395
 
        :param file_id: The file id to assign to the root. It must not be
1396
 
            present in the current inventory or an error will occur. It must
1397
 
            not be None, but rather a valid file id.
1398
 
        """
1399
 
        raise NotImplementedError(self._set_root_id)
1400
 
 
1401
 
    def unlock(self):
1402
 
        """See Branch.unlock.
1403
 
 
1404
 
        WorkingTree locking just uses the Branch locking facilities.
1405
 
        This is current because all working trees have an embedded branch
1406
 
        within them. IF in the future, we were to make branch data shareable
1407
 
        between multiple working trees, i.e. via shared storage, then we
1408
 
        would probably want to lock both the local tree, and the branch.
1409
 
        """
1410
 
        raise NotImplementedError(self.unlock)
1411
 
 
1412
 
    _marker = object()
1413
 
 
1414
 
    def update(self, change_reporter=None, possible_transports=None,
1415
 
               revision=None, old_tip=_marker, show_base=False):
1416
 
        """Update a working tree along its branch.
1417
 
 
1418
 
        This will update the branch if its bound too, which means we have
1419
 
        multiple trees involved:
1420
 
 
1421
 
        - The new basis tree of the master.
1422
 
        - The old basis tree of the branch.
1423
 
        - The old basis tree of the working tree.
1424
 
        - The current working tree state.
1425
 
 
1426
 
        Pathologically, all three may be different, and non-ancestors of each
1427
 
        other.  Conceptually we want to:
1428
 
 
1429
 
        - Preserve the wt.basis->wt.state changes
1430
 
        - Transform the wt.basis to the new master basis.
1431
 
        - Apply a merge of the old branch basis to get any 'local' changes from
1432
 
          it into the tree.
1433
 
        - Restore the wt.basis->wt.state changes.
1434
 
 
1435
 
        There isn't a single operation at the moment to do that, so we:
1436
 
 
1437
 
        - Merge current state -> basis tree of the master w.r.t. the old tree
1438
 
          basis.
1439
 
        - Do a 'normal' merge of the old branch basis if it is relevant.
1440
 
 
1441
 
        :param revision: The target revision to update to. Must be in the
1442
 
            revision history.
1443
 
        :param old_tip: If branch.update() has already been run, the value it
1444
 
            returned (old tip of the branch or None). _marker is used
1445
 
            otherwise.
1446
 
        """
1447
 
        if self.branch.get_bound_location() is not None:
1448
 
            self.lock_write()
1449
 
            update_branch = (old_tip is self._marker)
1450
 
        else:
1451
 
            self.lock_tree_write()
1452
 
            update_branch = False
1453
 
        try:
1454
 
            if update_branch:
1455
 
                old_tip = self.branch.update(possible_transports)
1456
 
            else:
1457
 
                if old_tip is self._marker:
1458
 
                    old_tip = None
1459
 
            return self._update_tree(old_tip, change_reporter, revision, show_base)
1460
 
        finally:
1461
 
            self.unlock()
1462
 
 
1463
 
    @needs_tree_write_lock
1464
 
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None,
1465
 
                     show_base=False):
1466
 
        """Update a tree to the master branch.
1467
 
 
1468
 
        :param old_tip: if supplied, the previous tip revision the branch,
1469
 
            before it was changed to the master branch's tip.
1470
 
        """
1471
 
        # here if old_tip is not None, it is the old tip of the branch before
1472
 
        # it was updated from the master branch. This should become a pending
1473
 
        # merge in the working tree to preserve the user existing work.  we
1474
 
        # cant set that until we update the working trees last revision to be
1475
 
        # one from the new branch, because it will just get absorbed by the
1476
 
        # parent de-duplication logic.
1477
 
        #
1478
 
        # We MUST save it even if an error occurs, because otherwise the users
1479
 
        # local work is unreferenced and will appear to have been lost.
1480
 
        #
1481
 
        nb_conflicts = 0
1482
 
        try:
1483
 
            last_rev = self.get_parent_ids()[0]
1484
 
        except IndexError:
1485
 
            last_rev = _mod_revision.NULL_REVISION
1486
 
        if revision is None:
1487
 
            revision = self.branch.last_revision()
1488
 
 
1489
 
        old_tip = old_tip or _mod_revision.NULL_REVISION
1490
 
 
1491
 
        if not _mod_revision.is_null(old_tip) and old_tip != last_rev:
1492
 
            # the branch we are bound to was updated
1493
 
            # merge those changes in first
1494
 
            base_tree  = self.basis_tree()
1495
 
            other_tree = self.branch.repository.revision_tree(old_tip)
1496
 
            nb_conflicts = merge.merge_inner(self.branch, other_tree,
1497
 
                                             base_tree, this_tree=self,
1498
 
                                             change_reporter=change_reporter,
1499
 
                                             show_base=show_base)
1500
 
            if nb_conflicts:
1501
 
                self.add_parent_tree((old_tip, other_tree))
1502
 
                note(gettext('Rerun update after fixing the conflicts.'))
1503
 
                return nb_conflicts
1504
 
 
1505
 
        if last_rev != _mod_revision.ensure_null(revision):
1506
 
            # the working tree is up to date with the branch
1507
 
            # we can merge the specified revision from master
1508
 
            to_tree = self.branch.repository.revision_tree(revision)
1509
 
            to_root_id = to_tree.get_root_id()
1510
 
 
1511
 
            basis = self.basis_tree()
1512
 
            basis.lock_read()
1513
 
            try:
1514
 
                if (basis.get_root_id() is None or basis.get_root_id() != to_root_id):
1515
 
                    self.set_root_id(to_root_id)
1516
 
                    self.flush()
1517
 
            finally:
1518
 
                basis.unlock()
1519
 
 
1520
 
            # determine the branch point
1521
 
            graph = self.branch.repository.get_graph()
1522
 
            base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
1523
 
                                                last_rev)
1524
 
            base_tree = self.branch.repository.revision_tree(base_rev_id)
1525
 
 
1526
 
            nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
1527
 
                                             this_tree=self,
1528
 
                                             change_reporter=change_reporter,
1529
 
                                             show_base=show_base)
1530
 
            self.set_last_revision(revision)
1531
 
            # TODO - dedup parents list with things merged by pull ?
1532
 
            # reuse the tree we've updated to to set the basis:
1533
 
            parent_trees = [(revision, to_tree)]
1534
 
            merges = self.get_parent_ids()[1:]
1535
 
            # Ideally we ask the tree for the trees here, that way the working
1536
 
            # tree can decide whether to give us the entire tree or give us a
1537
 
            # lazy initialised tree. dirstate for instance will have the trees
1538
 
            # in ram already, whereas a last-revision + basis-inventory tree
1539
 
            # will not, but also does not need them when setting parents.
1540
 
            for parent in merges:
1541
 
                parent_trees.append(
1542
 
                    (parent, self.branch.repository.revision_tree(parent)))
1543
 
            if not _mod_revision.is_null(old_tip):
1544
 
                parent_trees.append(
1545
 
                    (old_tip, self.branch.repository.revision_tree(old_tip)))
1546
 
            self.set_parent_trees(parent_trees)
1547
 
            last_rev = parent_trees[0][0]
1548
 
        return nb_conflicts
1549
 
 
1550
 
    def set_conflicts(self, arg):
1551
 
        raise errors.UnsupportedOperation(self.set_conflicts, self)
1552
 
 
1553
 
    def add_conflicts(self, arg):
1554
 
        raise errors.UnsupportedOperation(self.add_conflicts, self)
1555
 
 
1556
 
    def conflicts(self):
1557
 
        raise NotImplementedError(self.conflicts)
1558
 
 
1559
 
    def walkdirs(self, prefix=""):
1560
 
        """Walk the directories of this tree.
1561
 
 
1562
 
        returns a generator which yields items in the form:
1563
 
                ((curren_directory_path, fileid),
1564
 
                 [(file1_path, file1_name, file1_kind, (lstat), file1_id,
1565
 
                   file1_kind), ... ])
1566
 
 
1567
 
        This API returns a generator, which is only valid during the current
1568
 
        tree transaction - within a single lock_read or lock_write duration.
1569
 
 
1570
 
        If the tree is not locked, it may cause an error to be raised,
1571
 
        depending on the tree implementation.
1572
 
        """
1573
 
        disk_top = self.abspath(prefix)
1574
 
        if disk_top.endswith('/'):
1575
 
            disk_top = disk_top[:-1]
1576
 
        top_strip_len = len(disk_top) + 1
1577
 
        inventory_iterator = self._walkdirs(prefix)
1578
 
        disk_iterator = osutils.walkdirs(disk_top, prefix)
1579
 
        try:
1580
 
            current_disk = disk_iterator.next()
1581
 
            disk_finished = False
1582
 
        except OSError, e:
1583
 
            if not (e.errno == errno.ENOENT or
1584
 
                (sys.platform == 'win32' and e.errno == ERROR_PATH_NOT_FOUND)):
1585
 
                raise
1586
 
            current_disk = None
1587
 
            disk_finished = True
1588
 
        try:
1589
 
            current_inv = inventory_iterator.next()
1590
 
            inv_finished = False
1591
 
        except StopIteration:
1592
 
            current_inv = None
1593
 
            inv_finished = True
1594
 
        while not inv_finished or not disk_finished:
1595
 
            if current_disk:
1596
 
                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
1597
 
                    cur_disk_dir_content) = current_disk
1598
 
            else:
1599
 
                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
1600
 
                    cur_disk_dir_content) = ((None, None), None)
1601
 
            if not disk_finished:
1602
 
                # strip out .bzr dirs
1603
 
                if (cur_disk_dir_path_from_top[top_strip_len:] == '' and
1604
 
                    len(cur_disk_dir_content) > 0):
1605
 
                    # osutils.walkdirs can be made nicer -
1606
 
                    # yield the path-from-prefix rather than the pathjoined
1607
 
                    # value.
1608
 
                    bzrdir_loc = bisect_left(cur_disk_dir_content,
1609
 
                        ('.bzr', '.bzr'))
1610
 
                    if (bzrdir_loc < len(cur_disk_dir_content)
1611
 
                        and self.bzrdir.is_control_filename(
1612
 
                            cur_disk_dir_content[bzrdir_loc][0])):
1613
 
                        # we dont yield the contents of, or, .bzr itself.
1614
 
                        del cur_disk_dir_content[bzrdir_loc]
1615
 
            if inv_finished:
1616
 
                # everything is unknown
1617
 
                direction = 1
1618
 
            elif disk_finished:
1619
 
                # everything is missing
1620
 
                direction = -1
1621
 
            else:
1622
 
                direction = cmp(current_inv[0][0], cur_disk_dir_relpath)
1623
 
            if direction > 0:
1624
 
                # disk is before inventory - unknown
1625
 
                dirblock = [(relpath, basename, kind, stat, None, None) for
1626
 
                    relpath, basename, kind, stat, top_path in
1627
 
                    cur_disk_dir_content]
1628
 
                yield (cur_disk_dir_relpath, None), dirblock
1629
 
                try:
1630
 
                    current_disk = disk_iterator.next()
1631
 
                except StopIteration:
1632
 
                    disk_finished = True
1633
 
            elif direction < 0:
1634
 
                # inventory is before disk - missing.
1635
 
                dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
1636
 
                    for relpath, basename, dkind, stat, fileid, kind in
1637
 
                    current_inv[1]]
1638
 
                yield (current_inv[0][0], current_inv[0][1]), dirblock
1639
 
                try:
1640
 
                    current_inv = inventory_iterator.next()
1641
 
                except StopIteration:
1642
 
                    inv_finished = True
1643
 
            else:
1644
 
                # versioned present directory
1645
 
                # merge the inventory and disk data together
1646
 
                dirblock = []
1647
 
                for relpath, subiterator in itertools.groupby(sorted(
1648
 
                    current_inv[1] + cur_disk_dir_content,
1649
 
                    key=operator.itemgetter(0)), operator.itemgetter(1)):
1650
 
                    path_elements = list(subiterator)
1651
 
                    if len(path_elements) == 2:
1652
 
                        inv_row, disk_row = path_elements
1653
 
                        # versioned, present file
1654
 
                        dirblock.append((inv_row[0],
1655
 
                            inv_row[1], disk_row[2],
1656
 
                            disk_row[3], inv_row[4],
1657
 
                            inv_row[5]))
1658
 
                    elif len(path_elements[0]) == 5:
1659
 
                        # unknown disk file
1660
 
                        dirblock.append((path_elements[0][0],
1661
 
                            path_elements[0][1], path_elements[0][2],
1662
 
                            path_elements[0][3], None, None))
1663
 
                    elif len(path_elements[0]) == 6:
1664
 
                        # versioned, absent file.
1665
 
                        dirblock.append((path_elements[0][0],
1666
 
                            path_elements[0][1], 'unknown', None,
1667
 
                            path_elements[0][4], path_elements[0][5]))
1668
 
                    else:
1669
 
                        raise NotImplementedError('unreachable code')
1670
 
                yield current_inv[0], dirblock
1671
 
                try:
1672
 
                    current_inv = inventory_iterator.next()
1673
 
                except StopIteration:
1674
 
                    inv_finished = True
1675
 
                try:
1676
 
                    current_disk = disk_iterator.next()
1677
 
                except StopIteration:
1678
 
                    disk_finished = True
1679
 
 
1680
 
    def _walkdirs(self, prefix=""):
1681
 
        """Walk the directories of this tree.
1682
 
 
1683
 
        :param prefix: is used as the directrory to start with.
1684
 
        :returns: a generator which yields items in the form::
1685
 
 
1686
 
            ((curren_directory_path, fileid),
1687
 
             [(file1_path, file1_name, file1_kind, None, file1_id,
1688
 
               file1_kind), ... ])
1689
 
        """
1690
 
        raise NotImplementedError(self._walkdirs)
1691
 
 
1692
 
    @needs_tree_write_lock
1693
 
    def auto_resolve(self):
1694
 
        """Automatically resolve text conflicts according to contents.
1695
 
 
1696
 
        Only text conflicts are auto_resolvable. Files with no conflict markers
1697
 
        are considered 'resolved', because bzr always puts conflict markers
1698
 
        into files that have text conflicts.  The corresponding .THIS .BASE and
1699
 
        .OTHER files are deleted, as per 'resolve'.
1700
 
 
1701
 
        :return: a tuple of ConflictLists: (un_resolved, resolved).
1702
 
        """
1703
 
        un_resolved = _mod_conflicts.ConflictList()
1704
 
        resolved = _mod_conflicts.ConflictList()
1705
 
        conflict_re = re.compile('^(<{7}|={7}|>{7})')
1706
 
        for conflict in self.conflicts():
1707
 
            if (conflict.typestring != 'text conflict' or
1708
 
                self.kind(conflict.file_id) != 'file'):
1709
 
                un_resolved.append(conflict)
1710
 
                continue
1711
 
            my_file = open(self.id2abspath(conflict.file_id), 'rb')
1712
 
            try:
1713
 
                for line in my_file:
1714
 
                    if conflict_re.search(line):
1715
 
                        un_resolved.append(conflict)
1716
 
                        break
1717
 
                else:
1718
 
                    resolved.append(conflict)
1719
 
            finally:
1720
 
                my_file.close()
1721
 
        resolved.remove_files(self)
1722
 
        self.set_conflicts(un_resolved)
1723
 
        return un_resolved, resolved
1724
 
 
1725
 
    def _validate(self):
1726
 
        """Validate internal structures.
1727
 
 
1728
 
        This is meant mostly for the test suite. To give it a chance to detect
1729
 
        corruption after actions have occurred. The default implementation is a
1730
 
        just a no-op.
1731
 
 
1732
 
        :return: None. An exception should be raised if there is an error.
1733
 
        """
1734
 
        return
1735
 
 
1736
 
    def check_state(self):
1737
 
        """Check that the working state is/isn't valid."""
1738
 
        raise NotImplementedError(self.check_state)
1739
 
 
1740
 
    def reset_state(self, revision_ids=None):
1741
 
        """Reset the state of the working tree.
1742
 
 
1743
 
        This does a hard-reset to a last-known-good state. This is a way to
1744
 
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
1745
 
        """
1746
 
        raise NotImplementedError(self.reset_state)
1747
 
 
1748
 
    def _get_rules_searcher(self, default_searcher):
1749
 
        """See Tree._get_rules_searcher."""
1750
 
        if self._rules_searcher is None:
1751
 
            self._rules_searcher = super(WorkingTree,
1752
 
                self)._get_rules_searcher(default_searcher)
1753
 
        return self._rules_searcher
1754
 
 
1755
 
    def get_shelf_manager(self):
1756
 
        """Return the ShelfManager for this WorkingTree."""
1757
 
        from bzrlib.shelf import ShelfManager
1758
 
        return ShelfManager(self, self._transport)
1759
 
 
1760
 
 
1761
 
class InventoryWorkingTree(WorkingTree,
1762
 
        bzrlib.mutabletree.MutableInventoryTree):
1763
 
    """Base class for working trees that are inventory-oriented.
1764
 
 
1765
 
    The inventory is held in the `Branch` working-inventory, and the
1766
 
    files are in a directory on disk.
1767
 
 
1768
 
    It is possible for a `WorkingTree` to have a filename which is
1769
 
    not listed in the Inventory and vice versa.
1770
 
    """
1771
 
 
1772
 
    def __init__(self, basedir='.',
1773
 
                 branch=DEPRECATED_PARAMETER,
1774
 
                 _inventory=None,
1775
 
                 _control_files=None,
1776
 
                 _internal=False,
1777
 
                 _format=None,
1778
 
                 _bzrdir=None):
1779
 
        """Construct a InventoryWorkingTree instance. This is not a public API.
1780
 
 
1781
 
        :param branch: A branch to override probing for the branch.
1782
 
        """
1783
 
        super(InventoryWorkingTree, self).__init__(basedir=basedir,
1784
 
            branch=branch, _control_files=_control_files, _internal=_internal,
1785
 
            _format=_format, _bzrdir=_bzrdir)
1786
 
 
1787
 
        self._detect_case_handling()
1788
 
 
1789
 
        if _inventory is None:
1790
 
            # This will be acquired on lock_read() or lock_write()
1791
 
            self._inventory_is_modified = False
1792
 
            self._inventory = None
1793
 
        else:
1794
 
            # the caller of __init__ has provided an inventory,
1795
 
            # we assume they know what they are doing - as its only
1796
 
            # the Format factory and creation methods that are
1797
 
            # permitted to do this.
1798
 
            self._set_inventory(_inventory, dirty=False)
1799
 
 
1800
 
    def _set_inventory(self, inv, dirty):
1801
 
        """Set the internal cached inventory.
1802
 
 
1803
 
        :param inv: The inventory to set.
1804
 
        :param dirty: A boolean indicating whether the inventory is the same
1805
 
            logical inventory as whats on disk. If True the inventory is not
1806
 
            the same and should be written to disk or data will be lost, if
1807
 
            False then the inventory is the same as that on disk and any
1808
 
            serialisation would be unneeded overhead.
1809
 
        """
1810
 
        self._inventory = inv
1811
 
        self._inventory_is_modified = dirty
1812
 
 
1813
 
    def _detect_case_handling(self):
1814
 
        wt_trans = self.bzrdir.get_workingtree_transport(None)
1815
 
        try:
1816
 
            wt_trans.stat(self._format.case_sensitive_filename)
1817
 
        except errors.NoSuchFile:
1818
 
            self.case_sensitive = True
1819
 
        else:
1820
 
            self.case_sensitive = False
1821
 
 
1822
 
        self._setup_directory_is_tree_reference()
1823
 
 
1824
 
    def _serialize(self, inventory, out_file):
1825
 
        xml5.serializer_v5.write_inventory(self._inventory, out_file,
1826
 
            working=True)
1827
 
 
1828
 
    def _deserialize(selt, in_file):
1829
 
        return xml5.serializer_v5.read_inventory(in_file)
1830
 
 
1831
 
    @needs_tree_write_lock
1832
 
    def _write_inventory(self, inv):
1833
 
        """Write inventory as the current inventory."""
1834
 
        self._set_inventory(inv, dirty=True)
1835
 
        self.flush()
1836
 
 
1837
 
    # XXX: This method should be deprecated in favour of taking in a proper
1838
 
    # new Inventory object.
1839
 
    @needs_tree_write_lock
 
1131
            old_tree = self.basis_tree()
 
1132
        revert(self, old_tree, filenames, backups, pb)
 
1133
        if not len(filenames):
 
1134
            self.set_pending_merges([])
 
1135
 
 
1136
    @needs_write_lock
1840
1137
    def set_inventory(self, new_inventory_list):
1841
1138
        from bzrlib.inventory import (Inventory,
1842
1139
                                      InventoryDirectory,
 
1140
                                      InventoryEntry,
1843
1141
                                      InventoryFile,
1844
1142
                                      InventoryLink)
1845
1143
        inv = Inventory(self.get_root_id())
1847
1145
            name = os.path.basename(path)
1848
1146
            if name == "":
1849
1147
                continue
1850
 
            # fixme, there should be a factory function inv,add_??
 
1148
            # fixme, there should be a factory function inv,add_?? 
1851
1149
            if kind == 'directory':
1852
1150
                inv.add(InventoryDirectory(file_id, name, parent))
1853
1151
            elif kind == 'file':
1855
1153
            elif kind == 'symlink':
1856
1154
                inv.add(InventoryLink(file_id, name, parent))
1857
1155
            else:
1858
 
                raise errors.BzrError("unknown kind %r" % kind)
 
1156
                raise BzrError("unknown kind %r" % kind)
1859
1157
        self._write_inventory(inv)
1860
1158
 
1861
 
    def _write_basis_inventory(self, xml):
1862
 
        """Write the basis inventory XML to the basis-inventory file"""
1863
 
        path = self._basis_inventory_name()
1864
 
        sio = StringIO(xml)
1865
 
        self._transport.put_file(path, sio,
1866
 
            mode=self.bzrdir._get_file_mode())
1867
 
 
1868
 
    def _reset_data(self):
1869
 
        """Reset transient data that cannot be revalidated."""
1870
 
        self._inventory_is_modified = False
1871
 
        f = self._transport.get('inventory')
1872
 
        try:
1873
 
            result = self._deserialize(f)
1874
 
        finally:
1875
 
            f.close()
1876
 
        self._set_inventory(result, dirty=False)
1877
 
 
1878
 
    def _set_root_id(self, file_id):
1879
 
        """Set the root id for this tree, in a format specific manner.
1880
 
 
1881
 
        :param file_id: The file id to assign to the root. It must not be
1882
 
            present in the current inventory or an error will occur. It must
1883
 
            not be None, but rather a valid file id.
1884
 
        """
1885
 
        inv = self._inventory
 
1159
    @needs_write_lock
 
1160
    def set_root_id(self, file_id):
 
1161
        """Set the root id for this tree."""
 
1162
        inv = self.read_working_inventory()
1886
1163
        orig_root_id = inv.root.file_id
1887
 
        # TODO: it might be nice to exit early if there was nothing
1888
 
        # to do, saving us from trigger a sync on unlock.
1889
 
        self._inventory_is_modified = True
1890
 
        # we preserve the root inventory entry object, but
1891
 
        # unlinkit from the byid index
1892
1164
        del inv._byid[inv.root.file_id]
1893
1165
        inv.root.file_id = file_id
1894
 
        # and link it into the index with the new changed id.
1895
1166
        inv._byid[inv.root.file_id] = inv.root
1896
 
        # and finally update all children to reference the new id.
1897
 
        # XXX: this should be safe to just look at the root.children
1898
 
        # list, not the WHOLE INVENTORY.
1899
1167
        for fid in inv:
1900
1168
            entry = inv[fid]
1901
1169
            if entry.parent_id == orig_root_id:
1902
1170
                entry.parent_id = inv.root.file_id
1903
 
 
1904
 
    def all_file_ids(self):
1905
 
        """See Tree.iter_all_file_ids"""
1906
 
        return set(self.inventory)
1907
 
 
1908
 
    @needs_tree_write_lock
1909
 
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
1910
 
        """See MutableTree.set_parent_trees."""
1911
 
        parent_ids = [rev for (rev, tree) in parents_list]
1912
 
        for revision_id in parent_ids:
1913
 
            _mod_revision.check_not_reserved_id(revision_id)
1914
 
 
1915
 
        self._check_parents_for_ghosts(parent_ids,
1916
 
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
1917
 
 
1918
 
        parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
1919
 
 
1920
 
        if len(parent_ids) == 0:
1921
 
            leftmost_parent_id = _mod_revision.NULL_REVISION
1922
 
            leftmost_parent_tree = None
1923
 
        else:
1924
 
            leftmost_parent_id, leftmost_parent_tree = parents_list[0]
1925
 
 
1926
 
        if self._change_last_revision(leftmost_parent_id):
1927
 
            if leftmost_parent_tree is None:
1928
 
                # If we don't have a tree, fall back to reading the
1929
 
                # parent tree from the repository.
1930
 
                self._cache_basis_inventory(leftmost_parent_id)
1931
 
            else:
1932
 
                inv = leftmost_parent_tree.inventory
1933
 
                xml = self._create_basis_xml_from_inventory(
1934
 
                                        leftmost_parent_id, inv)
1935
 
                self._write_basis_inventory(xml)
1936
 
        self._set_merges_from_parent_ids(parent_ids)
1937
 
 
1938
 
    def _cache_basis_inventory(self, new_revision):
1939
 
        """Cache new_revision as the basis inventory."""
1940
 
        # TODO: this should allow the ready-to-use inventory to be passed in,
1941
 
        # as commit already has that ready-to-use [while the format is the
1942
 
        # same, that is].
1943
 
        try:
1944
 
            # this double handles the inventory - unpack and repack -
1945
 
            # but is easier to understand. We can/should put a conditional
1946
 
            # in here based on whether the inventory is in the latest format
1947
 
            # - perhaps we should repack all inventories on a repository
1948
 
            # upgrade ?
1949
 
            # the fast path is to copy the raw xml from the repository. If the
1950
 
            # xml contains 'revision_id="', then we assume the right
1951
 
            # revision_id is set. We must check for this full string, because a
1952
 
            # root node id can legitimately look like 'revision_id' but cannot
1953
 
            # contain a '"'.
1954
 
            xml = self.branch.repository._get_inventory_xml(new_revision)
1955
 
            firstline = xml.split('\n', 1)[0]
1956
 
            if (not 'revision_id="' in firstline or
1957
 
                'format="7"' not in firstline):
1958
 
                inv = self.branch.repository._serializer.read_inventory_from_string(
1959
 
                    xml, new_revision)
1960
 
                xml = self._create_basis_xml_from_inventory(new_revision, inv)
1961
 
            self._write_basis_inventory(xml)
1962
 
        except (errors.NoSuchRevision, errors.RevisionNotPresent):
1963
 
            pass
1964
 
 
1965
 
    def _basis_inventory_name(self):
1966
 
        return 'basis-inventory-cache'
1967
 
 
1968
 
    def _create_basis_xml_from_inventory(self, revision_id, inventory):
1969
 
        """Create the text that will be saved in basis-inventory"""
1970
 
        inventory.revision_id = revision_id
1971
 
        return xml7.serializer_v7.write_inventory_to_string(inventory)
1972
 
 
1973
 
    @needs_tree_write_lock
1974
 
    def set_conflicts(self, conflicts):
1975
 
        self._put_rio('conflicts', conflicts.to_stanzas(),
1976
 
                      CONFLICT_HEADER_1)
1977
 
 
1978
 
    @needs_tree_write_lock
1979
 
    def add_conflicts(self, new_conflicts):
1980
 
        conflict_set = set(self.conflicts())
1981
 
        conflict_set.update(set(list(new_conflicts)))
1982
 
        self.set_conflicts(_mod_conflicts.ConflictList(sorted(conflict_set,
1983
 
                                       key=_mod_conflicts.Conflict.sort_key)))
1984
 
 
1985
 
    @needs_read_lock
1986
 
    def conflicts(self):
1987
 
        try:
1988
 
            confile = self._transport.get('conflicts')
1989
 
        except errors.NoSuchFile:
1990
 
            return _mod_conflicts.ConflictList()
1991
 
        try:
1992
 
            try:
1993
 
                if confile.next() != CONFLICT_HEADER_1 + '\n':
1994
 
                    raise errors.ConflictFormatError()
1995
 
            except StopIteration:
1996
 
                raise errors.ConflictFormatError()
1997
 
            reader = _mod_rio.RioReader(confile)
1998
 
            return _mod_conflicts.ConflictList.from_stanzas(reader)
1999
 
        finally:
2000
 
            confile.close()
2001
 
 
2002
 
    def read_basis_inventory(self):
2003
 
        """Read the cached basis inventory."""
2004
 
        path = self._basis_inventory_name()
2005
 
        return self._transport.get_bytes(path)
2006
 
 
2007
 
    @needs_read_lock
2008
 
    def read_working_inventory(self):
2009
 
        """Read the working inventory.
2010
 
 
2011
 
        :raises errors.InventoryModified: read_working_inventory will fail
2012
 
            when the current in memory inventory has been modified.
2013
 
        """
2014
 
        # conceptually this should be an implementation detail of the tree.
2015
 
        # XXX: Deprecate this.
2016
 
        # ElementTree does its own conversion from UTF-8, so open in
2017
 
        # binary.
2018
 
        if self._inventory_is_modified:
2019
 
            raise errors.InventoryModified(self)
2020
 
        f = self._transport.get('inventory')
2021
 
        try:
2022
 
            result = self._deserialize(f)
2023
 
        finally:
2024
 
            f.close()
2025
 
        self._set_inventory(result, dirty=False)
2026
 
        return result
2027
 
 
2028
 
    @needs_read_lock
2029
 
    def get_root_id(self):
2030
 
        """Return the id of this trees root"""
2031
 
        return self._inventory.root.file_id
2032
 
 
2033
 
    def has_id(self, file_id):
2034
 
        # files that have been deleted are excluded
2035
 
        inv = self.inventory
2036
 
        if not inv.has_id(file_id):
2037
 
            return False
2038
 
        path = inv.id2path(file_id)
2039
 
        return osutils.lexists(self.abspath(path))
2040
 
 
2041
 
    def has_or_had_id(self, file_id):
2042
 
        if file_id == self.inventory.root.file_id:
2043
 
            return True
2044
 
        return self.inventory.has_id(file_id)
2045
 
 
2046
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2047
 
    def __iter__(self):
2048
 
        """Iterate through file_ids for this tree.
2049
 
 
2050
 
        file_ids are in a WorkingTree if they are in the working inventory
2051
 
        and the working file exists.
2052
 
        """
2053
 
        inv = self._inventory
2054
 
        for path, ie in inv.iter_entries():
2055
 
            if osutils.lexists(self.abspath(path)):
2056
 
                yield ie.file_id
2057
 
 
2058
 
    @needs_tree_write_lock
2059
 
    def set_last_revision(self, new_revision):
2060
 
        """Change the last revision in the working tree."""
2061
 
        if self._change_last_revision(new_revision):
2062
 
            self._cache_basis_inventory(new_revision)
2063
 
 
2064
 
    def _get_check_refs(self):
2065
 
        """Return the references needed to perform a check of this tree.
2066
 
        
2067
 
        The default implementation returns no refs, and is only suitable for
2068
 
        trees that have no local caching and can commit on ghosts at any time.
2069
 
 
2070
 
        :seealso: bzrlib.check for details about check_refs.
2071
 
        """
2072
 
        return []
2073
 
 
2074
 
    @needs_read_lock
2075
 
    def _check(self, references):
2076
 
        """Check the tree for consistency.
2077
 
 
2078
 
        :param references: A dict with keys matching the items returned by
2079
 
            self._get_check_refs(), and values from looking those keys up in
2080
 
            the repository.
2081
 
        """
2082
 
        tree_basis = self.basis_tree()
2083
 
        tree_basis.lock_read()
2084
 
        try:
2085
 
            repo_basis = references[('trees', self.last_revision())]
2086
 
            if len(list(repo_basis.iter_changes(tree_basis))) > 0:
2087
 
                raise errors.BzrCheckError(
2088
 
                    "Mismatched basis inventory content.")
2089
 
            self._validate()
2090
 
        finally:
2091
 
            tree_basis.unlock()
2092
 
 
2093
 
    @needs_read_lock
2094
 
    def check_state(self):
2095
 
        """Check that the working state is/isn't valid."""
2096
 
        check_refs = self._get_check_refs()
2097
 
        refs = {}
2098
 
        for ref in check_refs:
2099
 
            kind, value = ref
2100
 
            if kind == 'trees':
2101
 
                refs[ref] = self.branch.repository.revision_tree(value)
2102
 
        self._check(refs)
2103
 
 
2104
 
    @needs_tree_write_lock
2105
 
    def reset_state(self, revision_ids=None):
2106
 
        """Reset the state of the working tree.
2107
 
 
2108
 
        This does a hard-reset to a last-known-good state. This is a way to
2109
 
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
2110
 
        """
2111
 
        if revision_ids is None:
2112
 
            revision_ids = self.get_parent_ids()
2113
 
        if not revision_ids:
2114
 
            rt = self.branch.repository.revision_tree(
2115
 
                _mod_revision.NULL_REVISION)
2116
 
        else:
2117
 
            rt = self.branch.repository.revision_tree(revision_ids[0])
2118
 
        self._write_inventory(rt.inventory)
2119
 
        self.set_parent_ids(revision_ids)
2120
 
 
2121
 
    def flush(self):
2122
 
        """Write the in memory inventory to disk."""
2123
 
        # TODO: Maybe this should only write on dirty ?
2124
 
        if self._control_files._lock_mode != 'w':
2125
 
            raise errors.NotWriteLocked(self)
 
1171
        self._write_inventory(inv)
 
1172
 
 
1173
    def unlock(self):
 
1174
        """See Branch.unlock.
 
1175
        
 
1176
        WorkingTree locking just uses the Branch locking facilities.
 
1177
        This is current because all working trees have an embedded branch
 
1178
        within them. IF in the future, we were to make branch data shareable
 
1179
        between multiple working trees, i.e. via shared storage, then we 
 
1180
        would probably want to lock both the local tree, and the branch.
 
1181
        """
 
1182
        # FIXME: We want to write out the hashcache only when the last lock on
 
1183
        # this working copy is released.  Peeking at the lock count is a bit
 
1184
        # of a nasty hack; probably it's better to have a transaction object,
 
1185
        # which can do some finalization when it's either successfully or
 
1186
        # unsuccessfully completed.  (Denys's original patch did that.)
 
1187
        # RBC 20060206 hookinhg into transaction will couple lock and transaction
 
1188
        # wrongly. Hookinh into unllock on the control files object is fine though.
 
1189
        
 
1190
        # TODO: split this per format so there is no ugly if block
 
1191
        if self._hashcache.needs_write and (
 
1192
            # dedicated lock files
 
1193
            self._control_files._lock_count==1 or 
 
1194
            # shared lock files
 
1195
            (self._control_files is self.branch.control_files and 
 
1196
             self._control_files._lock_count==3)):
 
1197
            self._hashcache.write()
 
1198
        # reverse order of locking.
 
1199
        result = self._control_files.unlock()
 
1200
        try:
 
1201
            self.branch.unlock()
 
1202
        finally:
 
1203
            return result
 
1204
 
 
1205
    @needs_write_lock
 
1206
    def update(self):
 
1207
        """Update a working tree along its branch.
 
1208
 
 
1209
        This will update the branch if its bound too, which means we have multiple trees involved:
 
1210
        The new basis tree of the master.
 
1211
        The old basis tree of the branch.
 
1212
        The old basis tree of the working tree.
 
1213
        The current working tree state.
 
1214
        pathologically all three may be different, and non ancestors of each other.
 
1215
        Conceptually we want to:
 
1216
        Preserve the wt.basis->wt.state changes
 
1217
        Transform the wt.basis to the new master basis.
 
1218
        Apply a merge of the old branch basis to get any 'local' changes from it into the tree.
 
1219
        Restore the wt.basis->wt.state changes.
 
1220
 
 
1221
        There isn't a single operation at the moment to do that, so we:
 
1222
        Merge current state -> basis tree of the master w.r.t. the old tree basis.
 
1223
        Do a 'normal' merge of the old branch basis if it is relevant.
 
1224
        """
 
1225
        old_tip = self.branch.update()
 
1226
        if old_tip is not None:
 
1227
            self.add_pending_merge(old_tip)
 
1228
        self.branch.lock_read()
 
1229
        try:
 
1230
            result = 0
 
1231
            if self.last_revision() != self.branch.last_revision():
 
1232
                # merge tree state up to new branch tip.
 
1233
                basis = self.basis_tree()
 
1234
                to_tree = self.branch.basis_tree()
 
1235
                result += merge_inner(self.branch,
 
1236
                                      to_tree,
 
1237
                                      basis,
 
1238
                                      this_tree=self)
 
1239
                self.set_last_revision(self.branch.last_revision())
 
1240
            if old_tip and old_tip != self.last_revision():
 
1241
                # our last revision was not the prior branch last reivison
 
1242
                # and we have converted that last revision to a pending merge.
 
1243
                # base is somewhere between the branch tip now
 
1244
                # and the now pending merge
 
1245
                from bzrlib.revision import common_ancestor
 
1246
                try:
 
1247
                    base_rev_id = common_ancestor(self.branch.last_revision(),
 
1248
                                                  old_tip,
 
1249
                                                  self.branch.repository)
 
1250
                except errors.NoCommonAncestor:
 
1251
                    base_rev_id = None
 
1252
                base_tree = self.branch.repository.revision_tree(base_rev_id)
 
1253
                other_tree = self.branch.repository.revision_tree(old_tip)
 
1254
                result += merge_inner(self.branch,
 
1255
                                      other_tree,
 
1256
                                      base_tree,
 
1257
                                      this_tree=self)
 
1258
            return result
 
1259
        finally:
 
1260
            self.branch.unlock()
 
1261
 
 
1262
    @needs_write_lock
 
1263
    def _write_inventory(self, inv):
 
1264
        """Write inventory as the current inventory."""
2126
1265
        sio = StringIO()
2127
 
        self._serialize(self._inventory, sio)
 
1266
        bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
2128
1267
        sio.seek(0)
2129
 
        self._transport.put_file('inventory', sio,
2130
 
            mode=self.bzrdir._get_file_mode())
2131
 
        self._inventory_is_modified = False
2132
 
 
2133
 
    def get_file_mtime(self, file_id, path=None):
2134
 
        """See Tree.get_file_mtime."""
2135
 
        if not path:
2136
 
            path = self.inventory.id2path(file_id)
 
1268
        self._control_files.put('inventory', sio)
 
1269
        self._set_inventory(inv)
 
1270
        mutter('wrote working inventory')
 
1271
 
 
1272
 
 
1273
class WorkingTree3(WorkingTree):
 
1274
    """This is the Format 3 working tree.
 
1275
 
 
1276
    This differs from the base WorkingTree by:
 
1277
     - having its own file lock
 
1278
     - having its own last-revision property.
 
1279
 
 
1280
    This is new in bzr 0.8
 
1281
    """
 
1282
 
 
1283
    @needs_read_lock
 
1284
    def last_revision(self):
 
1285
        """See WorkingTree.last_revision."""
2137
1286
        try:
2138
 
            return os.lstat(self.abspath(path)).st_mtime
2139
 
        except OSError, e:
2140
 
            if e.errno == errno.ENOENT:
2141
 
                raise errors.FileTimestampUnavailable(path)
2142
 
            raise
2143
 
 
2144
 
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
2145
 
        file_id = self.path2id(path)
2146
 
        if file_id is None:
2147
 
            # For unversioned files on win32, we just assume they are not
2148
 
            # executable
2149
 
            return False
2150
 
        return self._inventory[file_id].executable
2151
 
 
2152
 
    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
2153
 
        mode = stat_result.st_mode
2154
 
        return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2155
 
 
2156
 
    if not supports_executable():
2157
 
        def is_executable(self, file_id, path=None):
2158
 
            return self._inventory[file_id].executable
2159
 
 
2160
 
        _is_executable_from_path_and_stat = \
2161
 
            _is_executable_from_path_and_stat_from_basis
2162
 
    else:
2163
 
        def is_executable(self, file_id, path=None):
2164
 
            if not path:
2165
 
                path = self.id2path(file_id)
2166
 
            mode = os.lstat(self.abspath(path)).st_mode
2167
 
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2168
 
 
2169
 
        _is_executable_from_path_and_stat = \
2170
 
            _is_executable_from_path_and_stat_from_stat
2171
 
 
2172
 
    @needs_tree_write_lock
2173
 
    def _add(self, files, ids, kinds):
2174
 
        """See MutableTree._add."""
2175
 
        # TODO: Re-adding a file that is removed in the working copy
2176
 
        # should probably put it back with the previous ID.
2177
 
        # the read and write working inventory should not occur in this
2178
 
        # function - they should be part of lock_write and unlock.
2179
 
        inv = self.inventory
2180
 
        for f, file_id, kind in zip(files, ids, kinds):
2181
 
            if file_id is None:
2182
 
                inv.add_path(f, kind=kind)
2183
 
            else:
2184
 
                inv.add_path(f, kind=kind, file_id=file_id)
2185
 
            self._inventory_is_modified = True
2186
 
 
2187
 
    def revision_tree(self, revision_id):
2188
 
        """See WorkingTree.revision_id."""
2189
 
        if revision_id == self.last_revision():
 
1287
            return self._control_files.get_utf8('last-revision').read()
 
1288
        except NoSuchFile:
 
1289
            return None
 
1290
 
 
1291
    def _change_last_revision(self, revision_id):
 
1292
        """See WorkingTree._change_last_revision."""
 
1293
        if revision_id is None or revision_id == NULL_REVISION:
2190
1294
            try:
2191
 
                xml = self.read_basis_inventory()
 
1295
                self._control_files._transport.delete('last-revision')
2192
1296
            except errors.NoSuchFile:
2193
1297
                pass
2194
 
            else:
2195
 
                try:
2196
 
                    inv = xml7.serializer_v7.read_inventory_from_string(xml)
2197
 
                    # dont use the repository revision_tree api because we want
2198
 
                    # to supply the inventory.
2199
 
                    if inv.revision_id == revision_id:
2200
 
                        return revisiontree.InventoryRevisionTree(
2201
 
                            self.branch.repository, inv, revision_id)
2202
 
                except errors.BadInventoryFormat:
2203
 
                    pass
2204
 
        # raise if there was no inventory, or if we read the wrong inventory.
2205
 
        raise errors.NoSuchRevisionInTree(self, revision_id)
2206
 
 
2207
 
    @needs_read_lock
2208
 
    def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
2209
 
        """See Tree.annotate_iter
2210
 
 
2211
 
        This implementation will use the basis tree implementation if possible.
2212
 
        Lines not in the basis are attributed to CURRENT_REVISION
2213
 
 
2214
 
        If there are pending merges, lines added by those merges will be
2215
 
        incorrectly attributed to CURRENT_REVISION (but after committing, the
2216
 
        attribution will be correct).
2217
 
        """
2218
 
        maybe_file_parent_keys = []
2219
 
        for parent_id in self.get_parent_ids():
2220
 
            try:
2221
 
                parent_tree = self.revision_tree(parent_id)
2222
 
            except errors.NoSuchRevisionInTree:
2223
 
                parent_tree = self.branch.repository.revision_tree(parent_id)
2224
 
            parent_tree.lock_read()
2225
 
            try:
2226
 
                if not parent_tree.has_id(file_id):
2227
 
                    continue
2228
 
                ie = parent_tree.inventory[file_id]
2229
 
                if ie.kind != 'file':
2230
 
                    # Note: this is slightly unnecessary, because symlinks and
2231
 
                    # directories have a "text" which is the empty text, and we
2232
 
                    # know that won't mess up annotations. But it seems cleaner
2233
 
                    continue
2234
 
                parent_text_key = (file_id, ie.revision)
2235
 
                if parent_text_key not in maybe_file_parent_keys:
2236
 
                    maybe_file_parent_keys.append(parent_text_key)
2237
 
            finally:
2238
 
                parent_tree.unlock()
2239
 
        graph = _mod_graph.Graph(self.branch.repository.texts)
2240
 
        heads = graph.heads(maybe_file_parent_keys)
2241
 
        file_parent_keys = []
2242
 
        for key in maybe_file_parent_keys:
2243
 
            if key in heads:
2244
 
                file_parent_keys.append(key)
2245
 
 
2246
 
        # Now we have the parents of this content
2247
 
        annotator = self.branch.repository.texts.get_annotator()
2248
 
        text = self.get_file_text(file_id)
2249
 
        this_key =(file_id, default_revision)
2250
 
        annotator.add_special_text(this_key, file_parent_keys, text)
2251
 
        annotations = [(key[-1], line)
2252
 
                       for key, line in annotator.annotate_flat(this_key)]
2253
 
        return annotations
2254
 
 
2255
 
    @needs_read_lock
2256
 
    def merge_modified(self):
2257
 
        """Return a dictionary of files modified by a merge.
2258
 
 
2259
 
        The list is initialized by WorkingTree.set_merge_modified, which is
2260
 
        typically called after we make some automatic updates to the tree
2261
 
        because of a merge.
2262
 
 
2263
 
        This returns a map of file_id->sha1, containing only files which are
2264
 
        still in the working inventory and have that text hash.
2265
 
        """
2266
 
        try:
2267
 
            hashfile = self._transport.get('merge-hashes')
2268
 
        except errors.NoSuchFile:
2269
 
            return {}
2270
 
        try:
2271
 
            merge_hashes = {}
2272
 
            try:
2273
 
                if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
2274
 
                    raise errors.MergeModifiedFormatError()
2275
 
            except StopIteration:
2276
 
                raise errors.MergeModifiedFormatError()
2277
 
            for s in _mod_rio.RioReader(hashfile):
2278
 
                # RioReader reads in Unicode, so convert file_ids back to utf8
2279
 
                file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
2280
 
                if not self.inventory.has_id(file_id):
2281
 
                    continue
2282
 
                text_hash = s.get("hash")
2283
 
                if text_hash == self.get_file_sha1(file_id):
2284
 
                    merge_hashes[file_id] = text_hash
2285
 
            return merge_hashes
2286
 
        finally:
2287
 
            hashfile.close()
2288
 
 
2289
 
    @needs_write_lock
2290
 
    def subsume(self, other_tree):
2291
 
        def add_children(inventory, entry):
2292
 
            for child_entry in entry.children.values():
2293
 
                inventory._byid[child_entry.file_id] = child_entry
2294
 
                if child_entry.kind == 'directory':
2295
 
                    add_children(inventory, child_entry)
2296
 
        if other_tree.get_root_id() == self.get_root_id():
2297
 
            raise errors.BadSubsumeSource(self, other_tree,
2298
 
                                          'Trees have the same root')
2299
 
        try:
2300
 
            other_tree_path = self.relpath(other_tree.basedir)
2301
 
        except errors.PathNotChild:
2302
 
            raise errors.BadSubsumeSource(self, other_tree,
2303
 
                'Tree is not contained by the other')
2304
 
        new_root_parent = self.path2id(osutils.dirname(other_tree_path))
2305
 
        if new_root_parent is None:
2306
 
            raise errors.BadSubsumeSource(self, other_tree,
2307
 
                'Parent directory is not versioned.')
2308
 
        # We need to ensure that the result of a fetch will have a
2309
 
        # versionedfile for the other_tree root, and only fetching into
2310
 
        # RepositoryKnit2 guarantees that.
2311
 
        if not self.branch.repository.supports_rich_root():
2312
 
            raise errors.SubsumeTargetNeedsUpgrade(other_tree)
2313
 
        other_tree.lock_tree_write()
2314
 
        try:
2315
 
            new_parents = other_tree.get_parent_ids()
2316
 
            other_root = other_tree.inventory.root
2317
 
            other_root.parent_id = new_root_parent
2318
 
            other_root.name = osutils.basename(other_tree_path)
2319
 
            self.inventory.add(other_root)
2320
 
            add_children(self.inventory, other_root)
2321
 
            self._write_inventory(self.inventory)
2322
 
            # normally we don't want to fetch whole repositories, but i think
2323
 
            # here we really do want to consolidate the whole thing.
2324
 
            for parent_id in other_tree.get_parent_ids():
2325
 
                self.branch.fetch(other_tree.branch, parent_id)
2326
 
                self.add_parent_tree_id(parent_id)
2327
 
        finally:
2328
 
            other_tree.unlock()
2329
 
        other_tree.bzrdir.retire_bzrdir()
2330
 
 
2331
 
    @needs_tree_write_lock
2332
 
    def extract(self, file_id, format=None):
2333
 
        """Extract a subtree from this tree.
2334
 
 
2335
 
        A new branch will be created, relative to the path for this tree.
2336
 
        """
2337
 
        self.flush()
2338
 
        def mkdirs(path):
2339
 
            segments = osutils.splitpath(path)
2340
 
            transport = self.branch.bzrdir.root_transport
2341
 
            for name in segments:
2342
 
                transport = transport.clone(name)
2343
 
                transport.ensure_base()
2344
 
            return transport
2345
 
 
2346
 
        sub_path = self.id2path(file_id)
2347
 
        branch_transport = mkdirs(sub_path)
2348
 
        if format is None:
2349
 
            format = self.bzrdir.cloning_metadir()
2350
 
        branch_transport.ensure_base()
2351
 
        branch_bzrdir = format.initialize_on_transport(branch_transport)
2352
 
        try:
2353
 
            repo = branch_bzrdir.find_repository()
2354
 
        except errors.NoRepositoryPresent:
2355
 
            repo = branch_bzrdir.create_repository()
2356
 
        if not repo.supports_rich_root():
2357
 
            raise errors.RootNotRich()
2358
 
        new_branch = branch_bzrdir.create_branch()
2359
 
        new_branch.pull(self.branch)
2360
 
        for parent_id in self.get_parent_ids():
2361
 
            new_branch.fetch(self.branch, parent_id)
2362
 
        tree_transport = self.bzrdir.root_transport.clone(sub_path)
2363
 
        if tree_transport.base != branch_transport.base:
2364
 
            tree_bzrdir = format.initialize_on_transport(tree_transport)
2365
 
            branch.BranchReferenceFormat().initialize(tree_bzrdir,
2366
 
                target_branch=new_branch)
2367
 
        else:
2368
 
            tree_bzrdir = branch_bzrdir
2369
 
        wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
2370
 
        wt.set_parent_ids(self.get_parent_ids())
2371
 
        my_inv = self.inventory
2372
 
        child_inv = inventory.Inventory(root_id=None)
2373
 
        new_root = my_inv[file_id]
2374
 
        my_inv.remove_recursive_id(file_id)
2375
 
        new_root.parent_id = None
2376
 
        child_inv.add(new_root)
2377
 
        self._write_inventory(my_inv)
2378
 
        wt._write_inventory(child_inv)
2379
 
        return wt
2380
 
 
2381
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
2382
 
        """List all files as (path, class, kind, id, entry).
2383
 
 
2384
 
        Lists, but does not descend into unversioned directories.
2385
 
        This does not include files that have been deleted in this
2386
 
        tree. Skips the control directory.
2387
 
 
2388
 
        :param include_root: if True, return an entry for the root
2389
 
        :param from_dir: start from this directory or None for the root
2390
 
        :param recursive: whether to recurse into subdirectories or not
2391
 
        """
2392
 
        # list_files is an iterator, so @needs_read_lock doesn't work properly
2393
 
        # with it. So callers should be careful to always read_lock the tree.
2394
 
        if not self.is_locked():
2395
 
            raise errors.ObjectNotLocked(self)
2396
 
 
2397
 
        inv = self.inventory
2398
 
        if from_dir is None and include_root is True:
2399
 
            yield ('', 'V', 'directory', inv.root.file_id, inv.root)
2400
 
        # Convert these into local objects to save lookup times
2401
 
        pathjoin = osutils.pathjoin
2402
 
        file_kind = self._kind
2403
 
 
2404
 
        # transport.base ends in a slash, we want the piece
2405
 
        # between the last two slashes
2406
 
        transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
2407
 
 
2408
 
        fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
2409
 
 
2410
 
        # directory file_id, relative path, absolute path, reverse sorted children
2411
 
        if from_dir is not None:
2412
 
            from_dir_id = inv.path2id(from_dir)
2413
 
            if from_dir_id is None:
2414
 
                # Directory not versioned
2415
 
                return
2416
 
            from_dir_abspath = pathjoin(self.basedir, from_dir)
2417
 
        else:
2418
 
            from_dir_id = inv.root.file_id
2419
 
            from_dir_abspath = self.basedir
2420
 
        children = os.listdir(from_dir_abspath)
2421
 
        children.sort()
2422
 
        # jam 20060527 The kernel sized tree seems equivalent whether we
2423
 
        # use a deque and popleft to keep them sorted, or if we use a plain
2424
 
        # list and just reverse() them.
2425
 
        children = collections.deque(children)
2426
 
        stack = [(from_dir_id, u'', from_dir_abspath, children)]
2427
 
        while stack:
2428
 
            from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
2429
 
 
2430
 
            while children:
2431
 
                f = children.popleft()
2432
 
                ## TODO: If we find a subdirectory with its own .bzr
2433
 
                ## directory, then that is a separate tree and we
2434
 
                ## should exclude it.
2435
 
 
2436
 
                # the bzrdir for this tree
2437
 
                if transport_base_dir == f:
2438
 
                    continue
2439
 
 
2440
 
                # we know that from_dir_relpath and from_dir_abspath never end in a slash
2441
 
                # and 'f' doesn't begin with one, we can do a string op, rather
2442
 
                # than the checks of pathjoin(), all relative paths will have an extra slash
2443
 
                # at the beginning
2444
 
                fp = from_dir_relpath + '/' + f
2445
 
 
2446
 
                # absolute path
2447
 
                fap = from_dir_abspath + '/' + f
2448
 
 
2449
 
                dir_ie = inv[from_dir_id]
2450
 
                if dir_ie.kind == 'directory':
2451
 
                    f_ie = dir_ie.children.get(f)
2452
 
                else:
2453
 
                    f_ie = None
2454
 
                if f_ie:
2455
 
                    c = 'V'
2456
 
                elif self.is_ignored(fp[1:]):
2457
 
                    c = 'I'
2458
 
                else:
2459
 
                    # we may not have found this file, because of a unicode
2460
 
                    # issue, or because the directory was actually a symlink.
2461
 
                    f_norm, can_access = osutils.normalized_filename(f)
2462
 
                    if f == f_norm or not can_access:
2463
 
                        # No change, so treat this file normally
2464
 
                        c = '?'
2465
 
                    else:
2466
 
                        # this file can be accessed by a normalized path
2467
 
                        # check again if it is versioned
2468
 
                        # these lines are repeated here for performance
2469
 
                        f = f_norm
2470
 
                        fp = from_dir_relpath + '/' + f
2471
 
                        fap = from_dir_abspath + '/' + f
2472
 
                        f_ie = inv.get_child(from_dir_id, f)
2473
 
                        if f_ie:
2474
 
                            c = 'V'
2475
 
                        elif self.is_ignored(fp[1:]):
2476
 
                            c = 'I'
2477
 
                        else:
2478
 
                            c = '?'
2479
 
 
2480
 
                fk = file_kind(fap)
2481
 
 
2482
 
                # make a last minute entry
2483
 
                if f_ie:
2484
 
                    yield fp[1:], c, fk, f_ie.file_id, f_ie
2485
 
                else:
2486
 
                    try:
2487
 
                        yield fp[1:], c, fk, None, fk_entries[fk]()
2488
 
                    except KeyError:
2489
 
                        yield fp[1:], c, fk, None, TreeEntry()
2490
 
                    continue
2491
 
 
2492
 
                if fk != 'directory':
2493
 
                    continue
2494
 
 
2495
 
                # But do this child first if recursing down
2496
 
                if recursive:
2497
 
                    new_children = os.listdir(fap)
2498
 
                    new_children.sort()
2499
 
                    new_children = collections.deque(new_children)
2500
 
                    stack.append((f_ie.file_id, fp, fap, new_children))
2501
 
                    # Break out of inner loop,
2502
 
                    # so that we start outer loop with child
2503
 
                    break
2504
 
            else:
2505
 
                # if we finished all children, pop it off the stack
2506
 
                stack.pop()
2507
 
 
2508
 
    @needs_tree_write_lock
2509
 
    def move(self, from_paths, to_dir=None, after=False):
2510
 
        """Rename files.
2511
 
 
2512
 
        to_dir must exist in the inventory.
2513
 
 
2514
 
        If to_dir exists and is a directory, the files are moved into
2515
 
        it, keeping their old names.
2516
 
 
2517
 
        Note that to_dir is only the last component of the new name;
2518
 
        this doesn't change the directory.
2519
 
 
2520
 
        For each entry in from_paths the move mode will be determined
2521
 
        independently.
2522
 
 
2523
 
        The first mode moves the file in the filesystem and updates the
2524
 
        inventory. The second mode only updates the inventory without
2525
 
        touching the file on the filesystem.
2526
 
 
2527
 
        move uses the second mode if 'after == True' and the target is
2528
 
        either not versioned or newly added, and present in the working tree.
2529
 
 
2530
 
        move uses the second mode if 'after == False' and the source is
2531
 
        versioned but no longer in the working tree, and the target is not
2532
 
        versioned but present in the working tree.
2533
 
 
2534
 
        move uses the first mode if 'after == False' and the source is
2535
 
        versioned and present in the working tree, and the target is not
2536
 
        versioned and not present in the working tree.
2537
 
 
2538
 
        Everything else results in an error.
2539
 
 
2540
 
        This returns a list of (from_path, to_path) pairs for each
2541
 
        entry that is moved.
2542
 
        """
2543
 
        rename_entries = []
2544
 
        rename_tuples = []
2545
 
 
2546
 
        # check for deprecated use of signature
2547
 
        if to_dir is None:
2548
 
            raise TypeError('You must supply a target directory')
2549
 
        # check destination directory
2550
 
        if isinstance(from_paths, basestring):
2551
 
            raise ValueError()
2552
 
        inv = self.inventory
2553
 
        to_abs = self.abspath(to_dir)
2554
 
        if not isdir(to_abs):
2555
 
            raise errors.BzrMoveFailedError('',to_dir,
2556
 
                errors.NotADirectory(to_abs))
2557
 
        if not self.has_filename(to_dir):
2558
 
            raise errors.BzrMoveFailedError('',to_dir,
2559
 
                errors.NotInWorkingDirectory(to_dir))
2560
 
        to_dir_id = inv.path2id(to_dir)
2561
 
        if to_dir_id is None:
2562
 
            raise errors.BzrMoveFailedError('',to_dir,
2563
 
                errors.NotVersionedError(path=to_dir))
2564
 
 
2565
 
        to_dir_ie = inv[to_dir_id]
2566
 
        if to_dir_ie.kind != 'directory':
2567
 
            raise errors.BzrMoveFailedError('',to_dir,
2568
 
                errors.NotADirectory(to_abs))
2569
 
 
2570
 
        # create rename entries and tuples
2571
 
        for from_rel in from_paths:
2572
 
            from_tail = splitpath(from_rel)[-1]
2573
 
            from_id = inv.path2id(from_rel)
2574
 
            if from_id is None:
2575
 
                raise errors.BzrMoveFailedError(from_rel,to_dir,
2576
 
                    errors.NotVersionedError(path=from_rel))
2577
 
 
2578
 
            from_entry = inv[from_id]
2579
 
            from_parent_id = from_entry.parent_id
2580
 
            to_rel = pathjoin(to_dir, from_tail)
2581
 
            rename_entry = InventoryWorkingTree._RenameEntry(
2582
 
                from_rel=from_rel,
2583
 
                from_id=from_id,
2584
 
                from_tail=from_tail,
2585
 
                from_parent_id=from_parent_id,
2586
 
                to_rel=to_rel, to_tail=from_tail,
2587
 
                to_parent_id=to_dir_id)
2588
 
            rename_entries.append(rename_entry)
2589
 
            rename_tuples.append((from_rel, to_rel))
2590
 
 
2591
 
        # determine which move mode to use. checks also for movability
2592
 
        rename_entries = self._determine_mv_mode(rename_entries, after)
2593
 
 
2594
 
        original_modified = self._inventory_is_modified
2595
 
        try:
2596
 
            if len(from_paths):
2597
 
                self._inventory_is_modified = True
2598
 
            self._move(rename_entries)
2599
 
        except:
2600
 
            # restore the inventory on error
2601
 
            self._inventory_is_modified = original_modified
2602
 
            raise
2603
 
        self._write_inventory(inv)
2604
 
        return rename_tuples
2605
 
 
2606
 
    @needs_tree_write_lock
2607
 
    def rename_one(self, from_rel, to_rel, after=False):
2608
 
        """Rename one file.
2609
 
 
2610
 
        This can change the directory or the filename or both.
2611
 
 
2612
 
        rename_one has several 'modes' to work. First, it can rename a physical
2613
 
        file and change the file_id. That is the normal mode. Second, it can
2614
 
        only change the file_id without touching any physical file.
2615
 
 
2616
 
        rename_one uses the second mode if 'after == True' and 'to_rel' is not
2617
 
        versioned but present in the working tree.
2618
 
 
2619
 
        rename_one uses the second mode if 'after == False' and 'from_rel' is
2620
 
        versioned but no longer in the working tree, and 'to_rel' is not
2621
 
        versioned but present in the working tree.
2622
 
 
2623
 
        rename_one uses the first mode if 'after == False' and 'from_rel' is
2624
 
        versioned and present in the working tree, and 'to_rel' is not
2625
 
        versioned and not present in the working tree.
2626
 
 
2627
 
        Everything else results in an error.
2628
 
        """
2629
 
        inv = self.inventory
2630
 
        rename_entries = []
2631
 
 
2632
 
        # create rename entries and tuples
2633
 
        from_tail = splitpath(from_rel)[-1]
2634
 
        from_id = inv.path2id(from_rel)
2635
 
        if from_id is None:
2636
 
            # if file is missing in the inventory maybe it's in the basis_tree
2637
 
            basis_tree = self.branch.basis_tree()
2638
 
            from_id = basis_tree.path2id(from_rel)
2639
 
            if from_id is None:
2640
 
                raise errors.BzrRenameFailedError(from_rel,to_rel,
2641
 
                    errors.NotVersionedError(path=from_rel))
2642
 
            # put entry back in the inventory so we can rename it
2643
 
            from_entry = basis_tree.inventory[from_id].copy()
2644
 
            inv.add(from_entry)
2645
 
        else:
2646
 
            from_entry = inv[from_id]
2647
 
        from_parent_id = from_entry.parent_id
2648
 
        to_dir, to_tail = os.path.split(to_rel)
2649
 
        to_dir_id = inv.path2id(to_dir)
2650
 
        rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
2651
 
                                     from_id=from_id,
2652
 
                                     from_tail=from_tail,
2653
 
                                     from_parent_id=from_parent_id,
2654
 
                                     to_rel=to_rel, to_tail=to_tail,
2655
 
                                     to_parent_id=to_dir_id)
2656
 
        rename_entries.append(rename_entry)
2657
 
 
2658
 
        # determine which move mode to use. checks also for movability
2659
 
        rename_entries = self._determine_mv_mode(rename_entries, after)
2660
 
 
2661
 
        # check if the target changed directory and if the target directory is
2662
 
        # versioned
2663
 
        if to_dir_id is None:
2664
 
            raise errors.BzrMoveFailedError(from_rel,to_rel,
2665
 
                errors.NotVersionedError(path=to_dir))
2666
 
 
2667
 
        # all checks done. now we can continue with our actual work
2668
 
        mutter('rename_one:\n'
2669
 
               '  from_id   {%s}\n'
2670
 
               '  from_rel: %r\n'
2671
 
               '  to_rel:   %r\n'
2672
 
               '  to_dir    %r\n'
2673
 
               '  to_dir_id {%s}\n',
2674
 
               from_id, from_rel, to_rel, to_dir, to_dir_id)
2675
 
 
2676
 
        self._move(rename_entries)
2677
 
        self._write_inventory(inv)
2678
 
 
2679
 
    class _RenameEntry(object):
2680
 
        def __init__(self, from_rel, from_id, from_tail, from_parent_id,
2681
 
                     to_rel, to_tail, to_parent_id, only_change_inv=False,
2682
 
                     change_id=False):
2683
 
            self.from_rel = from_rel
2684
 
            self.from_id = from_id
2685
 
            self.from_tail = from_tail
2686
 
            self.from_parent_id = from_parent_id
2687
 
            self.to_rel = to_rel
2688
 
            self.to_tail = to_tail
2689
 
            self.to_parent_id = to_parent_id
2690
 
            self.change_id = change_id
2691
 
            self.only_change_inv = only_change_inv
2692
 
 
2693
 
    def _determine_mv_mode(self, rename_entries, after=False):
2694
 
        """Determines for each from-to pair if both inventory and working tree
2695
 
        or only the inventory has to be changed.
2696
 
 
2697
 
        Also does basic plausability tests.
2698
 
        """
2699
 
        inv = self.inventory
2700
 
 
2701
 
        for rename_entry in rename_entries:
2702
 
            # store to local variables for easier reference
2703
 
            from_rel = rename_entry.from_rel
2704
 
            from_id = rename_entry.from_id
2705
 
            to_rel = rename_entry.to_rel
2706
 
            to_id = inv.path2id(to_rel)
2707
 
            only_change_inv = False
2708
 
            change_id = False
2709
 
 
2710
 
            # check the inventory for source and destination
2711
 
            if from_id is None:
2712
 
                raise errors.BzrMoveFailedError(from_rel,to_rel,
2713
 
                    errors.NotVersionedError(path=from_rel))
2714
 
            if to_id is not None:
2715
 
                allowed = False
2716
 
                # allow it with --after but only if dest is newly added
2717
 
                if after:
2718
 
                    basis = self.basis_tree()
2719
 
                    basis.lock_read()
2720
 
                    try:
2721
 
                        if not basis.has_id(to_id):
2722
 
                            rename_entry.change_id = True
2723
 
                            allowed = True
2724
 
                    finally:
2725
 
                        basis.unlock()
2726
 
                if not allowed:
2727
 
                    raise errors.BzrMoveFailedError(from_rel,to_rel,
2728
 
                        errors.AlreadyVersionedError(path=to_rel))
2729
 
 
2730
 
            # try to determine the mode for rename (only change inv or change
2731
 
            # inv and file system)
2732
 
            if after:
2733
 
                if not self.has_filename(to_rel):
2734
 
                    raise errors.BzrMoveFailedError(from_id,to_rel,
2735
 
                        errors.NoSuchFile(path=to_rel,
2736
 
                        extra="New file has not been created yet"))
2737
 
                only_change_inv = True
2738
 
            elif not self.has_filename(from_rel) and self.has_filename(to_rel):
2739
 
                only_change_inv = True
2740
 
            elif self.has_filename(from_rel) and not self.has_filename(to_rel):
2741
 
                only_change_inv = False
2742
 
            elif (not self.case_sensitive
2743
 
                  and from_rel.lower() == to_rel.lower()
2744
 
                  and self.has_filename(from_rel)):
2745
 
                only_change_inv = False
2746
 
            else:
2747
 
                # something is wrong, so lets determine what exactly
2748
 
                if not self.has_filename(from_rel) and \
2749
 
                   not self.has_filename(to_rel):
2750
 
                    raise errors.BzrRenameFailedError(from_rel,to_rel,
2751
 
                        errors.PathsDoNotExist(paths=(str(from_rel),
2752
 
                        str(to_rel))))
2753
 
                else:
2754
 
                    raise errors.RenameFailedFilesExist(from_rel, to_rel)
2755
 
            rename_entry.only_change_inv = only_change_inv
2756
 
        return rename_entries
2757
 
 
2758
 
    def _move(self, rename_entries):
2759
 
        """Moves a list of files.
2760
 
 
2761
 
        Depending on the value of the flag 'only_change_inv', the
2762
 
        file will be moved on the file system or not.
2763
 
        """
2764
 
        inv = self.inventory
2765
 
        moved = []
2766
 
 
2767
 
        for entry in rename_entries:
2768
 
            try:
2769
 
                self._move_entry(entry)
2770
 
            except:
2771
 
                self._rollback_move(moved)
2772
 
                raise
2773
 
            moved.append(entry)
2774
 
 
2775
 
    def _rollback_move(self, moved):
2776
 
        """Try to rollback a previous move in case of an filesystem error."""
2777
 
        inv = self.inventory
2778
 
        for entry in moved:
2779
 
            try:
2780
 
                self._move_entry(WorkingTree._RenameEntry(
2781
 
                    entry.to_rel, entry.from_id,
2782
 
                    entry.to_tail, entry.to_parent_id, entry.from_rel,
2783
 
                    entry.from_tail, entry.from_parent_id,
2784
 
                    entry.only_change_inv))
2785
 
            except errors.BzrMoveFailedError, e:
2786
 
                raise errors.BzrMoveFailedError( '', '', "Rollback failed."
2787
 
                        " The working tree is in an inconsistent state."
2788
 
                        " Please consider doing a 'bzr revert'."
2789
 
                        " Error message is: %s" % e)
2790
 
 
2791
 
    def _move_entry(self, entry):
2792
 
        inv = self.inventory
2793
 
        from_rel_abs = self.abspath(entry.from_rel)
2794
 
        to_rel_abs = self.abspath(entry.to_rel)
2795
 
        if from_rel_abs == to_rel_abs:
2796
 
            raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
2797
 
                "Source and target are identical.")
2798
 
 
2799
 
        if not entry.only_change_inv:
2800
 
            try:
2801
 
                osutils.rename(from_rel_abs, to_rel_abs)
2802
 
            except OSError, e:
2803
 
                raise errors.BzrMoveFailedError(entry.from_rel,
2804
 
                    entry.to_rel, e[1])
2805
 
        if entry.change_id:
2806
 
            to_id = inv.path2id(entry.to_rel)
2807
 
            inv.remove_recursive_id(to_id)
2808
 
        inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
2809
 
 
2810
 
    @needs_tree_write_lock
2811
 
    def unversion(self, file_ids):
2812
 
        """Remove the file ids in file_ids from the current versioned set.
2813
 
 
2814
 
        When a file_id is unversioned, all of its children are automatically
2815
 
        unversioned.
2816
 
 
2817
 
        :param file_ids: The file ids to stop versioning.
2818
 
        :raises: NoSuchId if any fileid is not currently versioned.
2819
 
        """
2820
 
        for file_id in file_ids:
2821
 
            if not self._inventory.has_id(file_id):
2822
 
                raise errors.NoSuchId(self, file_id)
2823
 
        for file_id in file_ids:
2824
 
            if self._inventory.has_id(file_id):
2825
 
                self._inventory.remove_recursive_id(file_id)
2826
 
        if len(file_ids):
2827
 
            # in the future this should just set a dirty bit to wait for the
2828
 
            # final unlock. However, until all methods of workingtree start
2829
 
            # with the current in -memory inventory rather than triggering
2830
 
            # a read, it is more complex - we need to teach read_inventory
2831
 
            # to know when to read, and when to not read first... and possibly
2832
 
            # to save first when the in memory one may be corrupted.
2833
 
            # so for now, we just only write it if it is indeed dirty.
2834
 
            # - RBC 20060907
2835
 
            self._write_inventory(self._inventory)
2836
 
 
2837
 
    def stored_kind(self, file_id):
2838
 
        """See Tree.stored_kind"""
2839
 
        return self.inventory[file_id].kind
2840
 
 
2841
 
    def extras(self):
2842
 
        """Yield all unversioned files in this WorkingTree.
2843
 
 
2844
 
        If there are any unversioned directories then only the directory is
2845
 
        returned, not all its children.  But if there are unversioned files
2846
 
        under a versioned subdirectory, they are returned.
2847
 
 
2848
 
        Currently returned depth-first, sorted by name within directories.
2849
 
        This is the same order used by 'osutils.walkdirs'.
2850
 
        """
2851
 
        ## TODO: Work from given directory downwards
2852
 
        for path, dir_entry in self.inventory.directories():
2853
 
            # mutter("search for unknowns in %r", path)
2854
 
            dirabs = self.abspath(path)
2855
 
            if not isdir(dirabs):
2856
 
                # e.g. directory deleted
2857
 
                continue
2858
 
 
2859
 
            fl = []
2860
 
            for subf in os.listdir(dirabs):
2861
 
                if self.bzrdir.is_control_filename(subf):
2862
 
                    continue
2863
 
                if subf not in dir_entry.children:
2864
 
                    try:
2865
 
                        (subf_norm,
2866
 
                         can_access) = osutils.normalized_filename(subf)
2867
 
                    except UnicodeDecodeError:
2868
 
                        path_os_enc = path.encode(osutils._fs_enc)
2869
 
                        relpath = path_os_enc + '/' + subf
2870
 
                        raise errors.BadFilenameEncoding(relpath,
2871
 
                                                         osutils._fs_enc)
2872
 
                    if subf_norm != subf and can_access:
2873
 
                        if subf_norm not in dir_entry.children:
2874
 
                            fl.append(subf_norm)
2875
 
                    else:
2876
 
                        fl.append(subf)
2877
 
 
2878
 
            fl.sort()
2879
 
            for subf in fl:
2880
 
                subp = pathjoin(path, subf)
2881
 
                yield subp
2882
 
 
2883
 
    def _walkdirs(self, prefix=""):
2884
 
        """Walk the directories of this tree.
2885
 
 
2886
 
        :param prefix: is used as the directrory to start with.
2887
 
        :returns: a generator which yields items in the form::
2888
 
 
2889
 
            ((curren_directory_path, fileid),
2890
 
             [(file1_path, file1_name, file1_kind, None, file1_id,
2891
 
               file1_kind), ... ])
2892
 
        """
2893
 
        _directory = 'directory'
2894
 
        # get the root in the inventory
2895
 
        inv = self.inventory
2896
 
        top_id = inv.path2id(prefix)
2897
 
        if top_id is None:
2898
 
            pending = []
2899
 
        else:
2900
 
            pending = [(prefix, '', _directory, None, top_id, None)]
2901
 
        while pending:
2902
 
            dirblock = []
2903
 
            currentdir = pending.pop()
2904
 
            # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2905
 
            top_id = currentdir[4]
2906
 
            if currentdir[0]:
2907
 
                relroot = currentdir[0] + '/'
2908
 
            else:
2909
 
                relroot = ""
2910
 
            # FIXME: stash the node in pending
2911
 
            entry = inv[top_id]
2912
 
            if entry.kind == 'directory':
2913
 
                for name, child in entry.sorted_children():
2914
 
                    dirblock.append((relroot + name, name, child.kind, None,
2915
 
                        child.file_id, child.kind
2916
 
                        ))
2917
 
            yield (currentdir[0], entry.file_id), dirblock
2918
 
            # push the user specified dirs from dirblock
2919
 
            for dir in reversed(dirblock):
2920
 
                if dir[2] == _directory:
2921
 
                    pending.append(dir)
2922
 
 
2923
 
 
2924
 
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
2925
 
    """Registry for working tree formats."""
2926
 
 
2927
 
    def __init__(self, other_registry=None):
2928
 
        super(WorkingTreeFormatRegistry, self).__init__(other_registry)
2929
 
        self._default_format = None
2930
 
        self._default_format_key = None
2931
 
 
2932
 
    def get_default(self):
2933
 
        """Return the current default format."""
2934
 
        if (self._default_format_key is not None and
2935
 
            self._default_format is None):
2936
 
            self._default_format = self.get(self._default_format_key)
2937
 
        return self._default_format
2938
 
 
2939
 
    def set_default(self, format):
2940
 
        """Set the default format."""
2941
 
        self._default_format = format
2942
 
        self._default_format_key = None
2943
 
 
2944
 
    def set_default_key(self, format_string):
2945
 
        """Set the default format by its format string."""
2946
 
        self._default_format_key = format_string
2947
 
        self._default_format = None
2948
 
 
2949
 
 
2950
 
format_registry = WorkingTreeFormatRegistry()
2951
 
 
2952
 
 
2953
 
class WorkingTreeFormat(controldir.ControlComponentFormat):
 
1298
            return False
 
1299
        else:
 
1300
            try:
 
1301
                self.branch.revision_history().index(revision_id)
 
1302
            except ValueError:
 
1303
                raise errors.NoSuchRevision(self.branch, revision_id)
 
1304
            self._control_files.put_utf8('last-revision', revision_id)
 
1305
            return True
 
1306
 
 
1307
 
 
1308
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
 
1309
def get_conflicted_stem(path):
 
1310
    for suffix in CONFLICT_SUFFIXES:
 
1311
        if path.endswith(suffix):
 
1312
            return path[:-len(suffix)]
 
1313
 
 
1314
@deprecated_function(zero_eight)
 
1315
def is_control_file(filename):
 
1316
    """See WorkingTree.is_control_filename(filename)."""
 
1317
    ## FIXME: better check
 
1318
    filename = normpath(filename)
 
1319
    while filename != '':
 
1320
        head, tail = os.path.split(filename)
 
1321
        ## mutter('check %r for control file' % ((head, tail),))
 
1322
        if tail == '.bzr':
 
1323
            return True
 
1324
        if filename == head:
 
1325
            break
 
1326
        filename = head
 
1327
    return False
 
1328
 
 
1329
 
 
1330
class WorkingTreeFormat(object):
2954
1331
    """An encapsulation of the initialization and open routines for a format.
2955
1332
 
2956
1333
    Formats provide three things:
2958
1335
     * a format string,
2959
1336
     * an open routine.
2960
1337
 
2961
 
    Formats are placed in an dict by their format string for reference
 
1338
    Formats are placed in an dict by their format string for reference 
2962
1339
    during workingtree opening. Its not required that these be instances, they
2963
 
    can be classes themselves with class methods - it simply depends on
 
1340
    can be classes themselves with class methods - it simply depends on 
2964
1341
    whether state is needed for a given format or not.
2965
1342
 
2966
1343
    Once a format is deprecated, just deprecate the initialize and open
2967
 
    methods on the format class. Do not deprecate the object, as the
 
1344
    methods on the format class. Do not deprecate the object, as the 
2968
1345
    object will be created every time regardless.
2969
1346
    """
2970
1347
 
2971
 
    requires_rich_root = False
2972
 
 
2973
 
    upgrade_recommended = False
2974
 
 
2975
 
    requires_normalized_unicode_filenames = False
2976
 
 
2977
 
    case_sensitive_filename = "FoRMaT"
2978
 
 
2979
 
    missing_parent_conflicts = False
2980
 
    """If this format supports missing parent conflicts."""
2981
 
 
2982
 
    supports_versioned_directories = None
 
1348
    _default_format = None
 
1349
    """The default format used for new trees."""
 
1350
 
 
1351
    _formats = {}
 
1352
    """The known formats."""
2983
1353
 
2984
1354
    @classmethod
2985
 
    def find_format_string(klass, a_bzrdir):
2986
 
        """Return format name for the working tree object in a_bzrdir."""
 
1355
    def find_format(klass, a_bzrdir):
 
1356
        """Return the format for the working tree object in a_bzrdir."""
2987
1357
        try:
2988
1358
            transport = a_bzrdir.get_workingtree_transport(None)
2989
 
            return transport.get_bytes("format")
2990
 
        except errors.NoSuchFile:
 
1359
            format_string = transport.get("format").read()
 
1360
            return klass._formats[format_string]
 
1361
        except NoSuchFile:
2991
1362
            raise errors.NoWorkingTree(base=transport.base)
2992
 
 
2993
 
    @classmethod
2994
 
    def find_format(klass, a_bzrdir):
2995
 
        """Return the format for the working tree object in a_bzrdir."""
2996
 
        try:
2997
 
            format_string = klass.find_format_string(a_bzrdir)
2998
 
            return format_registry.get(format_string)
2999
1363
        except KeyError:
3000
 
            raise errors.UnknownFormatError(format=format_string,
3001
 
                                            kind="working tree")
3002
 
 
3003
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3004
 
                   accelerator_tree=None, hardlink=False):
3005
 
        """Initialize a new working tree in a_bzrdir.
3006
 
 
3007
 
        :param a_bzrdir: BzrDir to initialize the working tree in.
3008
 
        :param revision_id: allows creating a working tree at a different
3009
 
            revision than the branch is at.
3010
 
        :param from_branch: Branch to checkout
3011
 
        :param accelerator_tree: A tree which can be used for retrieving file
3012
 
            contents more quickly than the revision tree, i.e. a workingtree.
3013
 
            The revision tree will be used for cases where accelerator_tree's
3014
 
            content is different.
3015
 
        :param hardlink: If true, hard-link files from accelerator_tree,
3016
 
            where possible.
3017
 
        """
3018
 
        raise NotImplementedError(self.initialize)
3019
 
 
3020
 
    def __eq__(self, other):
3021
 
        return self.__class__ is other.__class__
3022
 
 
3023
 
    def __ne__(self, other):
3024
 
        return not (self == other)
 
1364
            raise errors.UnknownFormatError(format_string)
3025
1365
 
3026
1366
    @classmethod
3027
 
    @symbol_versioning.deprecated_method(
3028
 
        symbol_versioning.deprecated_in((2, 4, 0)))
3029
1367
    def get_default_format(klass):
3030
1368
        """Return the current default format."""
3031
 
        return format_registry.get_default()
 
1369
        return klass._default_format
3032
1370
 
3033
1371
    def get_format_string(self):
3034
1372
        """Return the ASCII format string that identifies this format."""
3035
1373
        raise NotImplementedError(self.get_format_string)
3036
1374
 
3037
 
    def get_format_description(self):
3038
 
        """Return the short description for this format."""
3039
 
        raise NotImplementedError(self.get_format_description)
3040
 
 
3041
1375
    def is_supported(self):
3042
1376
        """Is this format supported?
3043
1377
 
3044
1378
        Supported formats can be initialized and opened.
3045
 
        Unsupported formats may not support initialization or committing or
 
1379
        Unsupported formats may not support initialization or committing or 
3046
1380
        some other features depending on the reason for not being supported.
3047
1381
        """
3048
1382
        return True
3049
1383
 
3050
 
    def supports_content_filtering(self):
3051
 
        """True if this format supports content filtering."""
3052
 
        return False
3053
 
 
3054
 
    def supports_views(self):
3055
 
        """True if this format supports stored views."""
3056
 
        return False
3057
 
 
3058
1384
    @classmethod
3059
 
    @symbol_versioning.deprecated_method(
3060
 
        symbol_versioning.deprecated_in((2, 4, 0)))
3061
1385
    def register_format(klass, format):
3062
 
        format_registry.register(format)
3063
 
 
3064
 
    @classmethod
3065
 
    @symbol_versioning.deprecated_method(
3066
 
        symbol_versioning.deprecated_in((2, 4, 0)))
3067
 
    def register_extra_format(klass, format):
3068
 
        format_registry.register_extra(format)
3069
 
 
3070
 
    @classmethod
3071
 
    @symbol_versioning.deprecated_method(
3072
 
        symbol_versioning.deprecated_in((2, 4, 0)))
3073
 
    def unregister_extra_format(klass, format):
3074
 
        format_registry.unregister_extra(format)
3075
 
 
3076
 
    @classmethod
3077
 
    @symbol_versioning.deprecated_method(
3078
 
        symbol_versioning.deprecated_in((2, 4, 0)))
3079
 
    def get_formats(klass):
3080
 
        return format_registry._get_all()
3081
 
 
3082
 
    @classmethod
3083
 
    @symbol_versioning.deprecated_method(
3084
 
        symbol_versioning.deprecated_in((2, 4, 0)))
 
1386
        klass._formats[format.get_format_string()] = format
 
1387
 
 
1388
    @classmethod
3085
1389
    def set_default_format(klass, format):
3086
 
        format_registry.set_default(format)
 
1390
        klass._default_format = format
3087
1391
 
3088
1392
    @classmethod
3089
 
    @symbol_versioning.deprecated_method(
3090
 
        symbol_versioning.deprecated_in((2, 4, 0)))
3091
1393
    def unregister_format(klass, format):
3092
 
        format_registry.remove(format)
3093
 
 
3094
 
 
3095
 
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
3096
 
    "bzrlib.workingtree_4", "WorkingTreeFormat4")
3097
 
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
3098
 
    "bzrlib.workingtree_4", "WorkingTreeFormat5")
3099
 
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
3100
 
    "bzrlib.workingtree_4", "WorkingTreeFormat6")
3101
 
format_registry.register_lazy("Bazaar-NG Working Tree format 3",
3102
 
    "bzrlib.workingtree_3", "WorkingTreeFormat3")
3103
 
format_registry.set_default_key("Bazaar Working Tree Format 6 (bzr 1.14)\n")
 
1394
        assert klass._formats[format.get_format_string()] is format
 
1395
        del klass._formats[format.get_format_string()]
 
1396
 
 
1397
 
 
1398
 
 
1399
class WorkingTreeFormat2(WorkingTreeFormat):
 
1400
    """The second working tree format. 
 
1401
 
 
1402
    This format modified the hash cache from the format 1 hash cache.
 
1403
    """
 
1404
 
 
1405
    def initialize(self, a_bzrdir, revision_id=None):
 
1406
        """See WorkingTreeFormat.initialize()."""
 
1407
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1408
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1409
        branch = a_bzrdir.open_branch()
 
1410
        if revision_id is not None:
 
1411
            branch.lock_write()
 
1412
            try:
 
1413
                revision_history = branch.revision_history()
 
1414
                try:
 
1415
                    position = revision_history.index(revision_id)
 
1416
                except ValueError:
 
1417
                    raise errors.NoSuchRevision(branch, revision_id)
 
1418
                branch.set_revision_history(revision_history[:position + 1])
 
1419
            finally:
 
1420
                branch.unlock()
 
1421
        revision = branch.last_revision()
 
1422
        inv = Inventory() 
 
1423
        wt = WorkingTree(a_bzrdir.root_transport.base,
 
1424
                         branch,
 
1425
                         inv,
 
1426
                         _internal=True,
 
1427
                         _format=self,
 
1428
                         _bzrdir=a_bzrdir)
 
1429
        wt._write_inventory(inv)
 
1430
        wt.set_root_id(inv.root.file_id)
 
1431
        wt.set_last_revision(revision)
 
1432
        wt.set_pending_merges([])
 
1433
        build_tree(wt.basis_tree(), wt)
 
1434
        return wt
 
1435
 
 
1436
    def __init__(self):
 
1437
        super(WorkingTreeFormat2, self).__init__()
 
1438
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
1439
 
 
1440
    def open(self, a_bzrdir, _found=False):
 
1441
        """Return the WorkingTree object for a_bzrdir
 
1442
 
 
1443
        _found is a private parameter, do not use it. It is used to indicate
 
1444
               if format probing has already been done.
 
1445
        """
 
1446
        if not _found:
 
1447
            # we are being called directly and must probe.
 
1448
            raise NotImplementedError
 
1449
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1450
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1451
        return WorkingTree(a_bzrdir.root_transport.base,
 
1452
                           _internal=True,
 
1453
                           _format=self,
 
1454
                           _bzrdir=a_bzrdir)
 
1455
 
 
1456
 
 
1457
class WorkingTreeFormat3(WorkingTreeFormat):
 
1458
    """The second working tree format updated to record a format marker.
 
1459
 
 
1460
    This format:
 
1461
        - exists within a metadir controlling .bzr
 
1462
        - includes an explicit version marker for the workingtree control
 
1463
          files, separate from the BzrDir format
 
1464
        - modifies the hash cache format
 
1465
        - is new in bzr 0.8
 
1466
        - uses a LockDir to guard access to the repository
 
1467
    """
 
1468
 
 
1469
    def get_format_string(self):
 
1470
        """See WorkingTreeFormat.get_format_string()."""
 
1471
        return "Bazaar-NG Working Tree format 3"
 
1472
 
 
1473
    _lock_file_name = 'lock'
 
1474
    _lock_class = LockDir
 
1475
 
 
1476
    def _open_control_files(self, a_bzrdir):
 
1477
        transport = a_bzrdir.get_workingtree_transport(None)
 
1478
        return LockableFiles(transport, self._lock_file_name, 
 
1479
                             self._lock_class)
 
1480
 
 
1481
    def initialize(self, a_bzrdir, revision_id=None):
 
1482
        """See WorkingTreeFormat.initialize().
 
1483
        
 
1484
        revision_id allows creating a working tree at a differnet
 
1485
        revision than the branch is at.
 
1486
        """
 
1487
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1488
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1489
        transport = a_bzrdir.get_workingtree_transport(self)
 
1490
        control_files = self._open_control_files(a_bzrdir)
 
1491
        control_files.create_lock()
 
1492
        control_files.put_utf8('format', self.get_format_string())
 
1493
        branch = a_bzrdir.open_branch()
 
1494
        if revision_id is None:
 
1495
            revision_id = branch.last_revision()
 
1496
        inv = Inventory() 
 
1497
        wt = WorkingTree3(a_bzrdir.root_transport.base,
 
1498
                         branch,
 
1499
                         inv,
 
1500
                         _internal=True,
 
1501
                         _format=self,
 
1502
                         _bzrdir=a_bzrdir,
 
1503
                         _control_files=control_files)
 
1504
        wt._write_inventory(inv)
 
1505
        wt.set_root_id(inv.root.file_id)
 
1506
        wt.set_last_revision(revision_id)
 
1507
        wt.set_pending_merges([])
 
1508
        build_tree(wt.basis_tree(), wt)
 
1509
        return wt
 
1510
 
 
1511
    def __init__(self):
 
1512
        super(WorkingTreeFormat3, self).__init__()
 
1513
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1514
 
 
1515
    def open(self, a_bzrdir, _found=False):
 
1516
        """Return the WorkingTree object for a_bzrdir
 
1517
 
 
1518
        _found is a private parameter, do not use it. It is used to indicate
 
1519
               if format probing has already been done.
 
1520
        """
 
1521
        if not _found:
 
1522
            # we are being called directly and must probe.
 
1523
            raise NotImplementedError
 
1524
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1525
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1526
        control_files = self._open_control_files(a_bzrdir)
 
1527
        return WorkingTree3(a_bzrdir.root_transport.base,
 
1528
                           _internal=True,
 
1529
                           _format=self,
 
1530
                           _bzrdir=a_bzrdir,
 
1531
                           _control_files=control_files)
 
1532
 
 
1533
    def __str__(self):
 
1534
        return self.get_format_string()
 
1535
 
 
1536
 
 
1537
# formats which have no format string are not discoverable
 
1538
# and not independently creatable, so are not registered.
 
1539
__default_format = WorkingTreeFormat3()
 
1540
WorkingTreeFormat.register_format(__default_format)
 
1541
WorkingTreeFormat.set_default_format(__default_format)
 
1542
_legacy_formats = [WorkingTreeFormat2(),
 
1543
                   ]
 
1544
 
 
1545
 
 
1546
class WorkingTreeTestProviderAdapter(object):
 
1547
    """A tool to generate a suite testing multiple workingtree formats at once.
 
1548
 
 
1549
    This is done by copying the test once for each transport and injecting
 
1550
    the transport_server, transport_readonly_server, and workingtree_format
 
1551
    classes into each copy. Each copy is also given a new id() to make it
 
1552
    easy to identify.
 
1553
    """
 
1554
 
 
1555
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1556
        self._transport_server = transport_server
 
1557
        self._transport_readonly_server = transport_readonly_server
 
1558
        self._formats = formats
 
1559
    
 
1560
    def adapt(self, test):
 
1561
        from bzrlib.tests import TestSuite
 
1562
        result = TestSuite()
 
1563
        for workingtree_format, bzrdir_format in self._formats:
 
1564
            new_test = deepcopy(test)
 
1565
            new_test.transport_server = self._transport_server
 
1566
            new_test.transport_readonly_server = self._transport_readonly_server
 
1567
            new_test.bzrdir_format = bzrdir_format
 
1568
            new_test.workingtree_format = workingtree_format
 
1569
            def make_new_test_id():
 
1570
                new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
 
1571
                return lambda: new_id
 
1572
            new_test.id = make_new_test_id()
 
1573
            result.addTest(new_test)
 
1574
        return result