~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin Pool
  • Date: 2005-06-22 09:08:43 UTC
  • Revision ID: mbp@sourcefrog.net-20050622090843-78fe9c62da9ed167
- add john's changeset plugin

Show diffs side-by-side

added added

removed removed

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