/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin
  • Date: 2011-03-20 18:58:43 UTC
  • mto: This revision was merged to the branch mainline in revision 5731.
  • Revision ID: gzlist@googlemail.com-20110320185843-qn8g96slbc33yw9h
Non-code fixes noticed looking at full diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
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
49
49
    branch,
50
50
    bzrdir,
51
51
    conflicts as _mod_conflicts,
 
52
    controldir,
52
53
    errors,
53
54
    generate_ids,
54
55
    globbing,
57
58
    ignores,
58
59
    inventory,
59
60
    merge,
 
61
    registry,
60
62
    revision as _mod_revision,
61
63
    revisiontree,
62
64
    trace,
63
65
    transform,
 
66
    transport,
64
67
    ui,
65
68
    views,
66
69
    xml5,
67
70
    xml7,
68
71
    )
69
 
import bzrlib.branch
70
 
from bzrlib.transport import get_transport
71
72
from bzrlib.workingtree_4 import (
72
73
    WorkingTreeFormat4,
73
74
    WorkingTreeFormat5,
77
78
 
78
79
from bzrlib import symbol_versioning
79
80
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
81
from bzrlib.lock import LogicalLockResult
80
82
from bzrlib.lockable_files import LockableFiles
81
83
from bzrlib.lockdir import LockDir
82
84
import bzrlib.mutabletree
168
170
 
169
171
 
170
172
class WorkingTree(bzrlib.mutabletree.MutableTree,
171
 
    bzrdir.ControlComponent):
 
173
    controldir.ControlComponent):
172
174
    """Working copy tree.
173
175
 
174
176
    The inventory is held in the `Branch` working-inventory, and the
176
178
 
177
179
    It is possible for a `WorkingTree` to have a filename which is
178
180
    not listed in the Inventory and vice versa.
 
181
 
 
182
    :ivar basedir: The root of the tree on disk. This is a unicode path object
 
183
        (as opposed to a URL).
179
184
    """
180
185
 
181
186
    # override this to set the strategy for storing views
205
210
        else:
206
211
            self._branch = self.bzrdir.open_branch()
207
212
        self.basedir = realpath(basedir)
208
 
        # if branch is at our basedir and is a format 6 or less
209
 
        if isinstance(self._format, WorkingTreeFormat2):
210
 
            # share control object
211
 
            self._control_files = self.branch.control_files
212
 
        else:
213
 
            # assume all other formats have their own control files.
214
 
            self._control_files = _control_files
 
213
        self._control_files = _control_files
215
214
        self._transport = self._control_files._transport
216
215
        # update the whole cache up front and write to disk if anything changed;
217
216
        # in the future we might want to do this more selectively
258
257
    def _detect_case_handling(self):
259
258
        wt_trans = self.bzrdir.get_workingtree_transport(None)
260
259
        try:
261
 
            wt_trans.stat("FoRMaT")
 
260
            wt_trans.stat(self._format.case_sensitive_filename)
262
261
        except errors.NoSuchFile:
263
262
            self.case_sensitive = True
264
263
        else:
346
345
        if path is None:
347
346
            path = osutils.getcwd()
348
347
        control, relpath = bzrdir.BzrDir.open_containing(path)
349
 
 
350
348
        return control.open_workingtree(), relpath
351
349
 
352
350
    @staticmethod
 
351
    def open_containing_paths(file_list, default_directory=None,
 
352
                              canonicalize=True, apply_view=True):
 
353
        """Open the WorkingTree that contains a set of paths.
 
354
 
 
355
        Fail if the paths given are not all in a single tree.
 
356
 
 
357
        This is used for the many command-line interfaces that take a list of
 
358
        any number of files and that require they all be in the same tree.
 
359
        """
 
360
        if default_directory is None:
 
361
            default_directory = u'.'
 
362
        # recommended replacement for builtins.internal_tree_files
 
363
        if file_list is None or len(file_list) == 0:
 
364
            tree = WorkingTree.open_containing(default_directory)[0]
 
365
            # XXX: doesn't really belong here, and seems to have the strange
 
366
            # side effect of making it return a bunch of files, not the whole
 
367
            # tree -- mbp 20100716
 
368
            if tree.supports_views() and apply_view:
 
369
                view_files = tree.views.lookup_view()
 
370
                if view_files:
 
371
                    file_list = view_files
 
372
                    view_str = views.view_display_str(view_files)
 
373
                    note("Ignoring files outside view. View is %s" % view_str)
 
374
            return tree, file_list
 
375
        if default_directory == u'.':
 
376
            seed = file_list[0]
 
377
        else:
 
378
            seed = default_directory
 
379
            file_list = [osutils.pathjoin(default_directory, f)
 
380
                         for f in file_list]
 
381
        tree = WorkingTree.open_containing(seed)[0]
 
382
        return tree, tree.safe_relpath_files(file_list, canonicalize,
 
383
                                             apply_view=apply_view)
 
384
 
 
385
    def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):
 
386
        """Convert file_list into a list of relpaths in tree.
 
387
 
 
388
        :param self: A tree to operate on.
 
389
        :param file_list: A list of user provided paths or None.
 
390
        :param apply_view: if True and a view is set, apply it or check that
 
391
            specified files are within it
 
392
        :return: A list of relative paths.
 
393
        :raises errors.PathNotChild: When a provided path is in a different self
 
394
            than self.
 
395
        """
 
396
        if file_list is None:
 
397
            return None
 
398
        if self.supports_views() and apply_view:
 
399
            view_files = self.views.lookup_view()
 
400
        else:
 
401
            view_files = []
 
402
        new_list = []
 
403
        # self.relpath exists as a "thunk" to osutils, but canonical_relpath
 
404
        # doesn't - fix that up here before we enter the loop.
 
405
        if canonicalize:
 
406
            fixer = lambda p: osutils.canonical_relpath(self.basedir, p)
 
407
        else:
 
408
            fixer = self.relpath
 
409
        for filename in file_list:
 
410
            relpath = fixer(osutils.dereference_path(filename))
 
411
            if view_files and not osutils.is_inside_any(view_files, relpath):
 
412
                raise errors.FileOutsideView(filename, view_files)
 
413
            new_list.append(relpath)
 
414
        return new_list
 
415
 
 
416
    @staticmethod
353
417
    def open_downlevel(path=None):
354
418
        """Open an unsupported working tree.
355
419
 
368
432
                return True, None
369
433
            else:
370
434
                return True, tree
371
 
        transport = get_transport(location)
372
 
        iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
 
435
        t = transport.get_transport(location)
 
436
        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
373
437
                                              list_current=list_current)
374
 
        return [t for t in iterator if t is not None]
 
438
        return [tr for tr in iterator if tr is not None]
375
439
 
376
440
    # should be deprecated - this is slow and in any case treating them as a
377
441
    # container is (we now know) bad style -- mbp 20070302
462
526
        return (file_obj, stat_value)
463
527
 
464
528
    def get_file_text(self, file_id, path=None, filtered=True):
465
 
        return self.get_file(file_id, path=path, filtered=filtered).read()
 
529
        my_file = self.get_file(file_id, path=path, filtered=filtered)
 
530
        try:
 
531
            return my_file.read()
 
532
        finally:
 
533
            my_file.close()
466
534
 
467
535
    def get_file_byname(self, filename, filtered=True):
468
536
        path = self.abspath(filename)
522
590
 
523
591
        # Now we have the parents of this content
524
592
        annotator = self.branch.repository.texts.get_annotator()
525
 
        text = self.get_file(file_id).read()
 
593
        text = self.get_file_text(file_id)
526
594
        this_key =(file_id, default_revision)
527
595
        annotator.add_special_text(this_key, file_parent_keys, text)
528
596
        annotations = [(key[-1], line)
1202
1270
                # absolute path
1203
1271
                fap = from_dir_abspath + '/' + f
1204
1272
 
1205
 
                f_ie = inv.get_child(from_dir_id, f)
 
1273
                dir_ie = inv[from_dir_id]
 
1274
                if dir_ie.kind == 'directory':
 
1275
                    f_ie = dir_ie.children.get(f)
 
1276
                else:
 
1277
                    f_ie = None
1206
1278
                if f_ie:
1207
1279
                    c = 'V'
1208
1280
                elif self.is_ignored(fp[1:]):
1209
1281
                    c = 'I'
1210
1282
                else:
1211
 
                    # we may not have found this file, because of a unicode issue
 
1283
                    # we may not have found this file, because of a unicode
 
1284
                    # issue, or because the directory was actually a symlink.
1212
1285
                    f_norm, can_access = osutils.normalized_filename(f)
1213
1286
                    if f == f_norm or not can_access:
1214
1287
                        # No change, so treat this file normally
1257
1330
                stack.pop()
1258
1331
 
1259
1332
    @needs_tree_write_lock
1260
 
    def move(self, from_paths, to_dir=None, after=False, **kwargs):
 
1333
    def move(self, from_paths, to_dir=None, after=False):
1261
1334
        """Rename files.
1262
1335
 
1263
1336
        to_dir must exist in the inventory.
1297
1370
 
1298
1371
        # check for deprecated use of signature
1299
1372
        if to_dir is None:
1300
 
            to_dir = kwargs.get('to_name', None)
1301
 
            if to_dir is None:
1302
 
                raise TypeError('You must supply a target directory')
1303
 
            else:
1304
 
                symbol_versioning.warn('The parameter to_name was deprecated'
1305
 
                                       ' in version 0.13. Use to_dir instead',
1306
 
                                       DeprecationWarning)
1307
 
 
 
1373
            raise TypeError('You must supply a target directory')
1308
1374
        # check destination directory
1309
1375
        if isinstance(from_paths, basestring):
1310
1376
            raise ValueError()
1319
1385
        to_dir_id = inv.path2id(to_dir)
1320
1386
        if to_dir_id is None:
1321
1387
            raise errors.BzrMoveFailedError('',to_dir,
1322
 
                errors.NotVersionedError(path=str(to_dir)))
 
1388
                errors.NotVersionedError(path=to_dir))
1323
1389
 
1324
1390
        to_dir_ie = inv[to_dir_id]
1325
1391
        if to_dir_ie.kind != 'directory':
1332
1398
            from_id = inv.path2id(from_rel)
1333
1399
            if from_id is None:
1334
1400
                raise errors.BzrMoveFailedError(from_rel,to_dir,
1335
 
                    errors.NotVersionedError(path=str(from_rel)))
 
1401
                    errors.NotVersionedError(path=from_rel))
1336
1402
 
1337
1403
            from_entry = inv[from_id]
1338
1404
            from_parent_id = from_entry.parent_id
1380
1446
            # check the inventory for source and destination
1381
1447
            if from_id is None:
1382
1448
                raise errors.BzrMoveFailedError(from_rel,to_rel,
1383
 
                    errors.NotVersionedError(path=str(from_rel)))
 
1449
                    errors.NotVersionedError(path=from_rel))
1384
1450
            if to_id is not None:
1385
1451
                raise errors.BzrMoveFailedError(from_rel,to_rel,
1386
 
                    errors.AlreadyVersionedError(path=str(to_rel)))
 
1452
                    errors.AlreadyVersionedError(path=to_rel))
1387
1453
 
1388
1454
            # try to determine the mode for rename (only change inv or change
1389
1455
            # inv and file system)
1390
1456
            if after:
1391
1457
                if not self.has_filename(to_rel):
1392
1458
                    raise errors.BzrMoveFailedError(from_id,to_rel,
1393
 
                        errors.NoSuchFile(path=str(to_rel),
 
1459
                        errors.NoSuchFile(path=to_rel,
1394
1460
                        extra="New file has not been created yet"))
1395
1461
                only_change_inv = True
1396
1462
            elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1498
1564
            from_id = basis_tree.path2id(from_rel)
1499
1565
            if from_id is None:
1500
1566
                raise errors.BzrRenameFailedError(from_rel,to_rel,
1501
 
                    errors.NotVersionedError(path=str(from_rel)))
 
1567
                    errors.NotVersionedError(path=from_rel))
1502
1568
            # put entry back in the inventory so we can rename it
1503
1569
            from_entry = basis_tree.inventory[from_id].copy()
1504
1570
            inv.add(from_entry)
1522
1588
        # versioned
1523
1589
        if to_dir_id is None:
1524
1590
            raise errors.BzrMoveFailedError(from_rel,to_rel,
1525
 
                errors.NotVersionedError(path=str(to_dir)))
 
1591
                errors.NotVersionedError(path=to_dir))
1526
1592
 
1527
1593
        # all checks done. now we can continue with our actual work
1528
1594
        mutter('rename_one:\n'
1587
1653
            # - RBC 20060907
1588
1654
            self._write_inventory(self._inventory)
1589
1655
 
1590
 
    def _iter_conflicts(self):
1591
 
        conflicted = set()
1592
 
        for info in self.list_files():
1593
 
            path = info[0]
1594
 
            stem = get_conflicted_stem(path)
1595
 
            if stem is None:
1596
 
                continue
1597
 
            if stem not in conflicted:
1598
 
                conflicted.add(stem)
1599
 
                yield stem
1600
 
 
1601
1656
    @needs_write_lock
1602
1657
    def pull(self, source, overwrite=False, stop_revision=None,
1603
 
             change_reporter=None, possible_transports=None, local=False):
 
1658
             change_reporter=None, possible_transports=None, local=False,
 
1659
             show_base=False):
1604
1660
        source.lock_read()
1605
1661
        try:
1606
1662
            old_revision_info = self.branch.last_revision_info()
1620
1676
                                basis_tree,
1621
1677
                                this_tree=self,
1622
1678
                                pb=None,
1623
 
                                change_reporter=change_reporter)
 
1679
                                change_reporter=change_reporter,
 
1680
                                show_base=show_base)
1624
1681
                    basis_root_id = basis_tree.get_root_id()
1625
1682
                    new_root_id = new_basis_tree.get_root_id()
1626
1683
                    if basis_root_id != new_root_id:
1798
1855
            raise errors.ObjectNotLocked(self)
1799
1856
 
1800
1857
    def lock_read(self):
1801
 
        """See Branch.lock_read, and WorkingTree.unlock."""
 
1858
        """Lock the tree for reading.
 
1859
 
 
1860
        This also locks the branch, and can be unlocked via self.unlock().
 
1861
 
 
1862
        :return: A bzrlib.lock.LogicalLockResult.
 
1863
        """
1802
1864
        if not self.is_locked():
1803
1865
            self._reset_data()
1804
1866
        self.branch.lock_read()
1805
1867
        try:
1806
 
            return self._control_files.lock_read()
 
1868
            self._control_files.lock_read()
 
1869
            return LogicalLockResult(self.unlock)
1807
1870
        except:
1808
1871
            self.branch.unlock()
1809
1872
            raise
1810
1873
 
1811
1874
    def lock_tree_write(self):
1812
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
 
1875
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
 
1876
 
 
1877
        :return: A bzrlib.lock.LogicalLockResult.
 
1878
        """
1813
1879
        if not self.is_locked():
1814
1880
            self._reset_data()
1815
1881
        self.branch.lock_read()
1816
1882
        try:
1817
 
            return self._control_files.lock_write()
 
1883
            self._control_files.lock_write()
 
1884
            return LogicalLockResult(self.unlock)
1818
1885
        except:
1819
1886
            self.branch.unlock()
1820
1887
            raise
1821
1888
 
1822
1889
    def lock_write(self):
1823
 
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
1890
        """See MutableTree.lock_write, and WorkingTree.unlock.
 
1891
 
 
1892
        :return: A bzrlib.lock.LogicalLockResult.
 
1893
        """
1824
1894
        if not self.is_locked():
1825
1895
            self._reset_data()
1826
1896
        self.branch.lock_write()
1827
1897
        try:
1828
 
            return self._control_files.lock_write()
 
1898
            self._control_files.lock_write()
 
1899
            return LogicalLockResult(self.unlock)
1829
1900
        except:
1830
1901
            self.branch.unlock()
1831
1902
            raise
1948
2019
 
1949
2020
        inv_delta = []
1950
2021
 
1951
 
        new_files=set()
 
2022
        all_files = set() # specified and nested files 
1952
2023
        unknown_nested_files=set()
1953
2024
        if to_file is None:
1954
2025
            to_file = sys.stdout
1955
2026
 
 
2027
        files_to_backup = []
 
2028
 
1956
2029
        def recurse_directory_to_add_files(directory):
1957
2030
            # Recurse directory and add all files
1958
2031
            # so we can check if they have changed.
1959
 
            for parent_info, file_infos in\
1960
 
                self.walkdirs(directory):
 
2032
            for parent_info, file_infos in self.walkdirs(directory):
1961
2033
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1962
2034
                    # Is it versioned or ignored?
1963
 
                    if self.path2id(relpath) or self.is_ignored(relpath):
 
2035
                    if self.path2id(relpath):
1964
2036
                        # Add nested content for deletion.
1965
 
                        new_files.add(relpath)
 
2037
                        all_files.add(relpath)
1966
2038
                    else:
1967
 
                        # Files which are not versioned and not ignored
 
2039
                        # Files which are not versioned
1968
2040
                        # should be treated as unknown.
1969
 
                        unknown_nested_files.add((relpath, None, kind))
 
2041
                        files_to_backup.append(relpath)
1970
2042
 
1971
2043
        for filename in files:
1972
2044
            # Get file name into canonical form.
1973
2045
            abspath = self.abspath(filename)
1974
2046
            filename = self.relpath(abspath)
1975
2047
            if len(filename) > 0:
1976
 
                new_files.add(filename)
 
2048
                all_files.add(filename)
1977
2049
                recurse_directory_to_add_files(filename)
1978
2050
 
1979
 
        files = list(new_files)
 
2051
        files = list(all_files)
1980
2052
 
1981
2053
        if len(files) == 0:
1982
2054
            return # nothing to do
1986
2058
 
1987
2059
        # Bail out if we are going to delete files we shouldn't
1988
2060
        if not keep_files and not force:
1989
 
            has_changed_files = len(unknown_nested_files) > 0
1990
 
            if not has_changed_files:
1991
 
                for (file_id, path, content_change, versioned, parent_id, name,
1992
 
                     kind, executable) in self.iter_changes(self.basis_tree(),
1993
 
                         include_unchanged=True, require_versioned=False,
1994
 
                         want_unversioned=True, specific_files=files):
1995
 
                    if versioned == (False, False):
1996
 
                        # The record is unknown ...
1997
 
                        if not self.is_ignored(path[1]):
1998
 
                            # ... but not ignored
1999
 
                            has_changed_files = True
2000
 
                            break
2001
 
                    elif content_change and (kind[1] is not None):
2002
 
                        # Versioned and changed, but not deleted
2003
 
                        has_changed_files = True
2004
 
                        break
 
2061
            for (file_id, path, content_change, versioned, parent_id, name,
 
2062
                 kind, executable) in self.iter_changes(self.basis_tree(),
 
2063
                     include_unchanged=True, require_versioned=False,
 
2064
                     want_unversioned=True, specific_files=files):
 
2065
                if versioned[0] == False:
 
2066
                    # The record is unknown or newly added
 
2067
                    files_to_backup.append(path[1])
 
2068
                elif (content_change and (kind[1] is not None) and
 
2069
                        osutils.is_inside_any(files, path[1])):
 
2070
                    # Versioned and changed, but not deleted, and still
 
2071
                    # in one of the dirs to be deleted.
 
2072
                    files_to_backup.append(path[1])
2005
2073
 
2006
 
            if has_changed_files:
2007
 
                # Make delta show ALL applicable changes in error message.
2008
 
                tree_delta = self.changes_from(self.basis_tree(),
2009
 
                    require_versioned=False, want_unversioned=True,
2010
 
                    specific_files=files)
2011
 
                for unknown_file in unknown_nested_files:
2012
 
                    if unknown_file not in tree_delta.unversioned:
2013
 
                        tree_delta.unversioned.extend((unknown_file,))
2014
 
                raise errors.BzrRemoveChangedFilesError(tree_delta)
 
2074
        def backup(file_to_backup):
 
2075
            backup_name = self.bzrdir._available_backup_name(file_to_backup)
 
2076
            osutils.rename(abs_path, self.abspath(backup_name))
 
2077
            return "removed %s (but kept a copy: %s)" % (file_to_backup,
 
2078
                                                         backup_name)
2015
2079
 
2016
2080
        # Build inv_delta and delete files where applicable,
2017
2081
        # do this before any modifications to inventory.
2041
2105
                        len(os.listdir(abs_path)) > 0):
2042
2106
                        if force:
2043
2107
                            osutils.rmtree(abs_path)
 
2108
                            message = "deleted %s" % (f,)
2044
2109
                        else:
2045
 
                            message = "%s is not an empty directory "\
2046
 
                                "and won't be deleted." % (f,)
 
2110
                            message = backup(f)
2047
2111
                    else:
2048
 
                        osutils.delete_any(abs_path)
2049
 
                        message = "deleted %s" % (f,)
 
2112
                        if f in files_to_backup:
 
2113
                            message = backup(f)
 
2114
                        else:
 
2115
                            osutils.delete_any(abs_path)
 
2116
                            message = "deleted %s" % (f,)
2050
2117
                elif message is not None:
2051
2118
                    # Only care if we haven't done anything yet.
2052
2119
                    message = "%s does not exist." % (f,)
2189
2256
    _marker = object()
2190
2257
 
2191
2258
    def update(self, change_reporter=None, possible_transports=None,
2192
 
               revision=None, old_tip=_marker):
 
2259
               revision=None, old_tip=_marker, show_base=False):
2193
2260
        """Update a working tree along its branch.
2194
2261
 
2195
2262
        This will update the branch if its bound too, which means we have
2232
2299
            else:
2233
2300
                if old_tip is self._marker:
2234
2301
                    old_tip = None
2235
 
            return self._update_tree(old_tip, change_reporter, revision)
 
2302
            return self._update_tree(old_tip, change_reporter, revision, show_base)
2236
2303
        finally:
2237
2304
            self.unlock()
2238
2305
 
2239
2306
    @needs_tree_write_lock
2240
 
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None):
 
2307
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None,
 
2308
                     show_base=False):
2241
2309
        """Update a tree to the master branch.
2242
2310
 
2243
2311
        :param old_tip: if supplied, the previous tip revision the branch,
2270
2338
            other_tree = self.branch.repository.revision_tree(old_tip)
2271
2339
            nb_conflicts = merge.merge_inner(self.branch, other_tree,
2272
2340
                                             base_tree, this_tree=self,
2273
 
                                             change_reporter=change_reporter)
 
2341
                                             change_reporter=change_reporter,
 
2342
                                             show_base=show_base)
2274
2343
            if nb_conflicts:
2275
2344
                self.add_parent_tree((old_tip, other_tree))
2276
2345
                trace.note('Rerun update after fixing the conflicts.')
2300
2369
 
2301
2370
            nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
2302
2371
                                             this_tree=self,
2303
 
                                             change_reporter=change_reporter)
 
2372
                                             change_reporter=change_reporter,
 
2373
                                             show_base=show_base)
2304
2374
            self.set_last_revision(revision)
2305
2375
            # TODO - dedup parents list with things merged by pull ?
2306
2376
            # reuse the tree we've updated to to set the basis:
2347
2417
    def add_conflicts(self, arg):
2348
2418
        raise errors.UnsupportedOperation(self.add_conflicts, self)
2349
2419
 
2350
 
    @needs_read_lock
2351
2420
    def conflicts(self):
2352
 
        conflicts = _mod_conflicts.ConflictList()
2353
 
        for conflicted in self._iter_conflicts():
2354
 
            text = True
2355
 
            try:
2356
 
                if file_kind(self.abspath(conflicted)) != "file":
2357
 
                    text = False
2358
 
            except errors.NoSuchFile:
2359
 
                text = False
2360
 
            if text is True:
2361
 
                for suffix in ('.THIS', '.OTHER'):
2362
 
                    try:
2363
 
                        kind = file_kind(self.abspath(conflicted+suffix))
2364
 
                        if kind != "file":
2365
 
                            text = False
2366
 
                    except errors.NoSuchFile:
2367
 
                        text = False
2368
 
                    if text == False:
2369
 
                        break
2370
 
            ctype = {True: 'text conflict', False: 'contents conflict'}[text]
2371
 
            conflicts.append(_mod_conflicts.Conflict.factory(ctype,
2372
 
                             path=conflicted,
2373
 
                             file_id=self.path2id(conflicted)))
2374
 
        return conflicts
 
2421
        raise NotImplementedError(self.conflicts)
2375
2422
 
2376
2423
    def walkdirs(self, prefix=""):
2377
2424
        """Walk the directories of this tree.
2595
2642
        """
2596
2643
        return
2597
2644
 
 
2645
    @needs_read_lock
 
2646
    def check_state(self):
 
2647
        """Check that the working state is/isn't valid."""
 
2648
        check_refs = self._get_check_refs()
 
2649
        refs = {}
 
2650
        for ref in check_refs:
 
2651
            kind, value = ref
 
2652
            if kind == 'trees':
 
2653
                refs[ref] = self.branch.repository.revision_tree(value)
 
2654
        self._check(refs)
 
2655
 
 
2656
    @needs_tree_write_lock
 
2657
    def reset_state(self, revision_ids=None):
 
2658
        """Reset the state of the working tree.
 
2659
 
 
2660
        This does a hard-reset to a last-known-good state. This is a way to
 
2661
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
 
2662
        """
 
2663
        if revision_ids is None:
 
2664
            revision_ids = self.get_parent_ids()
 
2665
        if not revision_ids:
 
2666
            rt = self.branch.repository.revision_tree(
 
2667
                _mod_revision.NULL_REVISION)
 
2668
        else:
 
2669
            rt = self.branch.repository.revision_tree(revision_ids[0])
 
2670
        self._write_inventory(rt.inventory)
 
2671
        self.set_parent_ids(revision_ids)
 
2672
 
2598
2673
    def _get_rules_searcher(self, default_searcher):
2599
2674
        """See Tree._get_rules_searcher."""
2600
2675
        if self._rules_searcher is None:
2608
2683
        return ShelfManager(self, self._transport)
2609
2684
 
2610
2685
 
2611
 
class WorkingTree2(WorkingTree):
2612
 
    """This is the Format 2 working tree.
2613
 
 
2614
 
    This was the first weave based working tree.
2615
 
     - uses os locks for locking.
2616
 
     - uses the branch last-revision.
2617
 
    """
2618
 
 
2619
 
    def __init__(self, *args, **kwargs):
2620
 
        super(WorkingTree2, self).__init__(*args, **kwargs)
2621
 
        # WorkingTree2 has more of a constraint that self._inventory must
2622
 
        # exist. Because this is an older format, we don't mind the overhead
2623
 
        # caused by the extra computation here.
2624
 
 
2625
 
        # Newer WorkingTree's should only have self._inventory set when they
2626
 
        # have a read lock.
2627
 
        if self._inventory is None:
2628
 
            self.read_working_inventory()
2629
 
 
2630
 
    def _get_check_refs(self):
2631
 
        """Return the references needed to perform a check of this tree."""
2632
 
        return [('trees', self.last_revision())]
2633
 
 
2634
 
    def lock_tree_write(self):
2635
 
        """See WorkingTree.lock_tree_write().
2636
 
 
2637
 
        In Format2 WorkingTrees we have a single lock for the branch and tree
2638
 
        so lock_tree_write() degrades to lock_write().
2639
 
        """
2640
 
        self.branch.lock_write()
2641
 
        try:
2642
 
            return self._control_files.lock_write()
2643
 
        except:
2644
 
            self.branch.unlock()
2645
 
            raise
2646
 
 
2647
 
    def unlock(self):
2648
 
        # do non-implementation specific cleanup
2649
 
        self._cleanup()
2650
 
 
2651
 
        # we share control files:
2652
 
        if self._control_files._lock_count == 3:
2653
 
            # _inventory_is_modified is always False during a read lock.
2654
 
            if self._inventory_is_modified:
2655
 
                self.flush()
2656
 
            self._write_hashcache_if_dirty()
2657
 
 
2658
 
        # reverse order of locking.
2659
 
        try:
2660
 
            return self._control_files.unlock()
2661
 
        finally:
2662
 
            self.branch.unlock()
2663
 
 
2664
 
 
2665
2686
class WorkingTree3(WorkingTree):
2666
2687
    """This is the Format 3 working tree.
2667
2688
 
2740
2761
            self.branch.unlock()
2741
2762
 
2742
2763
 
2743
 
def get_conflicted_stem(path):
2744
 
    for suffix in _mod_conflicts.CONFLICT_SUFFIXES:
2745
 
        if path.endswith(suffix):
2746
 
            return path[:-len(suffix)]
2747
 
 
2748
 
 
2749
 
class WorkingTreeFormat(object):
 
2764
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
 
2765
    """Registry for working tree formats."""
 
2766
 
 
2767
    def __init__(self, other_registry=None):
 
2768
        super(WorkingTreeFormatRegistry, self).__init__(other_registry)
 
2769
        self._default_format = None
 
2770
 
 
2771
    def get_default(self):
 
2772
        """Return the current default format."""
 
2773
        return self._default_format
 
2774
 
 
2775
    def set_default(self, format):
 
2776
        self._default_format = format
 
2777
 
 
2778
 
 
2779
format_registry = WorkingTreeFormatRegistry()
 
2780
 
 
2781
 
 
2782
class WorkingTreeFormat(controldir.ControlComponentFormat):
2750
2783
    """An encapsulation of the initialization and open routines for a format.
2751
2784
 
2752
2785
    Formats provide three things:
2764
2797
    object will be created every time regardless.
2765
2798
    """
2766
2799
 
2767
 
    _default_format = None
2768
 
    """The default format used for new trees."""
2769
 
 
2770
 
    _formats = {}
2771
 
    """The known formats."""
2772
 
 
2773
2800
    requires_rich_root = False
2774
2801
 
2775
2802
    upgrade_recommended = False
2776
2803
 
 
2804
    requires_normalized_unicode_filenames = False
 
2805
 
 
2806
    case_sensitive_filename = "FoRMaT"
 
2807
 
 
2808
    missing_parent_conflicts = False
 
2809
    """If this format supports missing parent conflicts."""
 
2810
 
2777
2811
    @classmethod
2778
2812
    def find_format(klass, a_bzrdir):
2779
2813
        """Return the format for the working tree object in a_bzrdir."""
2780
2814
        try:
2781
2815
            transport = a_bzrdir.get_workingtree_transport(None)
2782
2816
            format_string = transport.get_bytes("format")
2783
 
            return klass._formats[format_string]
 
2817
            return format_registry.get(format_string)
2784
2818
        except errors.NoSuchFile:
2785
2819
            raise errors.NoWorkingTree(base=transport.base)
2786
2820
        except KeyError:
2787
2821
            raise errors.UnknownFormatError(format=format_string,
2788
2822
                                            kind="working tree")
2789
2823
 
 
2824
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
2825
                   accelerator_tree=None, hardlink=False):
 
2826
        """Initialize a new working tree in a_bzrdir.
 
2827
 
 
2828
        :param a_bzrdir: BzrDir to initialize the working tree in.
 
2829
        :param revision_id: allows creating a working tree at a different
 
2830
            revision than the branch is at.
 
2831
        :param from_branch: Branch to checkout
 
2832
        :param accelerator_tree: A tree which can be used for retrieving file
 
2833
            contents more quickly than the revision tree, i.e. a workingtree.
 
2834
            The revision tree will be used for cases where accelerator_tree's
 
2835
            content is different.
 
2836
        :param hardlink: If true, hard-link files from accelerator_tree,
 
2837
            where possible.
 
2838
        """
 
2839
        raise NotImplementedError(self.initialize)
 
2840
 
2790
2841
    def __eq__(self, other):
2791
2842
        return self.__class__ is other.__class__
2792
2843
 
2794
2845
        return not (self == other)
2795
2846
 
2796
2847
    @classmethod
 
2848
    @symbol_versioning.deprecated_method(
 
2849
        symbol_versioning.deprecated_in((2, 4, 0)))
2797
2850
    def get_default_format(klass):
2798
2851
        """Return the current default format."""
2799
 
        return klass._default_format
 
2852
        return format_registry.get_default()
2800
2853
 
2801
2854
    def get_format_string(self):
2802
2855
        """Return the ASCII format string that identifies this format."""
2824
2877
        return False
2825
2878
 
2826
2879
    @classmethod
 
2880
    @symbol_versioning.deprecated_method(
 
2881
        symbol_versioning.deprecated_in((2, 4, 0)))
2827
2882
    def register_format(klass, format):
2828
 
        klass._formats[format.get_format_string()] = format
2829
 
 
2830
 
    @classmethod
 
2883
        format_registry.register(format)
 
2884
 
 
2885
    @classmethod
 
2886
    @symbol_versioning.deprecated_method(
 
2887
        symbol_versioning.deprecated_in((2, 4, 0)))
 
2888
    def register_extra_format(klass, format):
 
2889
        format_registry.register_extra(format)
 
2890
 
 
2891
    @classmethod
 
2892
    @symbol_versioning.deprecated_method(
 
2893
        symbol_versioning.deprecated_in((2, 4, 0)))
 
2894
    def unregister_extra_format(klass, format):
 
2895
        format_registry.unregister_extra(format)
 
2896
 
 
2897
    @classmethod
 
2898
    @symbol_versioning.deprecated_method(
 
2899
        symbol_versioning.deprecated_in((2, 4, 0)))
 
2900
    def get_formats(klass):
 
2901
        return format_registry._get_all()
 
2902
 
 
2903
    @classmethod
 
2904
    @symbol_versioning.deprecated_method(
 
2905
        symbol_versioning.deprecated_in((2, 4, 0)))
2831
2906
    def set_default_format(klass, format):
2832
 
        klass._default_format = format
 
2907
        format_registry.set_default(format)
2833
2908
 
2834
2909
    @classmethod
 
2910
    @symbol_versioning.deprecated_method(
 
2911
        symbol_versioning.deprecated_in((2, 4, 0)))
2835
2912
    def unregister_format(klass, format):
2836
 
        del klass._formats[format.get_format_string()]
2837
 
 
2838
 
 
2839
 
class WorkingTreeFormat2(WorkingTreeFormat):
2840
 
    """The second working tree format.
2841
 
 
2842
 
    This format modified the hash cache from the format 1 hash cache.
2843
 
    """
2844
 
 
2845
 
    upgrade_recommended = True
2846
 
 
2847
 
    def get_format_description(self):
2848
 
        """See WorkingTreeFormat.get_format_description()."""
2849
 
        return "Working tree format 2"
2850
 
 
2851
 
    def _stub_initialize_on_transport(self, transport, file_mode):
2852
 
        """Workaround: create control files for a remote working tree.
2853
 
 
2854
 
        This ensures that it can later be updated and dealt with locally,
2855
 
        since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with
2856
 
        no working tree.  (See bug #43064).
2857
 
        """
2858
 
        sio = StringIO()
2859
 
        inv = inventory.Inventory()
2860
 
        xml5.serializer_v5.write_inventory(inv, sio, working=True)
2861
 
        sio.seek(0)
2862
 
        transport.put_file('inventory', sio, file_mode)
2863
 
        transport.put_bytes('pending-merges', '', file_mode)
2864
 
 
2865
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
2866
 
                   accelerator_tree=None, hardlink=False):
2867
 
        """See WorkingTreeFormat.initialize()."""
2868
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
2869
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
2870
 
        if from_branch is not None:
2871
 
            branch = from_branch
2872
 
        else:
2873
 
            branch = a_bzrdir.open_branch()
2874
 
        if revision_id is None:
2875
 
            revision_id = _mod_revision.ensure_null(branch.last_revision())
2876
 
        branch.lock_write()
2877
 
        try:
2878
 
            branch.generate_revision_history(revision_id)
2879
 
        finally:
2880
 
            branch.unlock()
2881
 
        inv = inventory.Inventory()
2882
 
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2883
 
                         branch,
2884
 
                         inv,
2885
 
                         _internal=True,
2886
 
                         _format=self,
2887
 
                         _bzrdir=a_bzrdir)
2888
 
        basis_tree = branch.repository.revision_tree(revision_id)
2889
 
        if basis_tree.inventory.root is not None:
2890
 
            wt.set_root_id(basis_tree.get_root_id())
2891
 
        # set the parent list and cache the basis tree.
2892
 
        if _mod_revision.is_null(revision_id):
2893
 
            parent_trees = []
2894
 
        else:
2895
 
            parent_trees = [(revision_id, basis_tree)]
2896
 
        wt.set_parent_trees(parent_trees)
2897
 
        transform.build_tree(basis_tree, wt)
2898
 
        return wt
2899
 
 
2900
 
    def __init__(self):
2901
 
        super(WorkingTreeFormat2, self).__init__()
2902
 
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
2903
 
 
2904
 
    def open(self, a_bzrdir, _found=False):
2905
 
        """Return the WorkingTree object for a_bzrdir
2906
 
 
2907
 
        _found is a private parameter, do not use it. It is used to indicate
2908
 
               if format probing has already been done.
2909
 
        """
2910
 
        if not _found:
2911
 
            # we are being called directly and must probe.
2912
 
            raise NotImplementedError
2913
 
        if not isinstance(a_bzrdir.transport, LocalTransport):
2914
 
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
2915
 
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2916
 
                           _internal=True,
2917
 
                           _format=self,
2918
 
                           _bzrdir=a_bzrdir)
2919
 
        return wt
 
2913
        format_registry.remove(format)
 
2914
 
2920
2915
 
2921
2916
class WorkingTreeFormat3(WorkingTreeFormat):
2922
2917
    """The second working tree format updated to record a format marker.
2932
2927
 
2933
2928
    upgrade_recommended = True
2934
2929
 
 
2930
    missing_parent_conflicts = True
 
2931
 
2935
2932
    def get_format_string(self):
2936
2933
        """See WorkingTreeFormat.get_format_string()."""
2937
2934
        return "Bazaar-NG Working Tree format 3"
3050
3047
 
3051
3048
 
3052
3049
__default_format = WorkingTreeFormat6()
3053
 
WorkingTreeFormat.register_format(__default_format)
3054
 
WorkingTreeFormat.register_format(WorkingTreeFormat5())
3055
 
WorkingTreeFormat.register_format(WorkingTreeFormat4())
3056
 
WorkingTreeFormat.register_format(WorkingTreeFormat3())
3057
 
WorkingTreeFormat.set_default_format(__default_format)
3058
 
# formats which have no format string are not discoverable
3059
 
# and not independently creatable, so are not registered.
3060
 
_legacy_formats = [WorkingTreeFormat2(),
3061
 
                   ]
 
3050
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
 
3051
    "bzrlib.workingtree_4", "WorkingTreeFormat4")
 
3052
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
 
3053
    "bzrlib.workingtree_4", "WorkingTreeFormat5")
 
3054
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
 
3055
    "bzrlib.workingtree_4", "WorkingTreeFormat6")
 
3056
format_registry.register(WorkingTreeFormat3())
 
3057
format_registry.set_default(__default_format)
 
3058
# Register extra formats which have no format string are not discoverable
 
3059
# and not independently creatable. They are implicitly created as part of
 
3060
# e.g. older Bazaar formats or foreign formats.
 
3061
format_registry.register_extra_lazy("bzrlib.workingtree_2",
 
3062
    "WorkingTreeFormat2")