/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

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
29
29
WorkingTree.open(dir).
30
30
"""
31
31
 
32
 
# TODO: Give the workingtree sole responsibility for the working inventory;
33
 
# remove the variable and references to it from the branch.  This may require
34
 
# updating the commit code so as to update the inventory within the working
35
 
# copy, and making sure there's only one WorkingTree for any directory on disk.
36
 
# At the moment they may alias the inventory and have old copies of it in
37
 
# memory.  (Now done? -- mbp 20060309)
38
32
 
39
33
from cStringIO import StringIO
40
34
import os
67
61
    revisiontree,
68
62
    trace,
69
63
    transform,
 
64
    transport,
70
65
    ui,
71
66
    views,
72
67
    xml5,
73
68
    xml7,
74
69
    )
75
 
import bzrlib.branch
76
 
from bzrlib.transport import get_transport
77
70
from bzrlib.workingtree_4 import (
78
71
    WorkingTreeFormat4,
79
72
    WorkingTreeFormat5,
83
76
 
84
77
from bzrlib import symbol_versioning
85
78
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
79
from bzrlib.lock import LogicalLockResult
86
80
from bzrlib.lockable_files import LockableFiles
87
81
from bzrlib.lockdir import LockDir
88
82
import bzrlib.mutabletree
101
95
from bzrlib.filters import filtered_input_file
102
96
from bzrlib.trace import mutter, note
103
97
from bzrlib.transport.local import LocalTransport
104
 
from bzrlib.progress import ProgressPhase
105
98
from bzrlib.revision import CURRENT_REVISION
106
99
from bzrlib.rio import RioReader, rio_file, Stanza
107
100
from bzrlib.symbol_versioning import (
174
167
        return ''
175
168
 
176
169
 
177
 
class WorkingTree(bzrlib.mutabletree.MutableTree):
 
170
class WorkingTree(bzrlib.mutabletree.MutableTree,
 
171
    bzrdir.ControlComponent):
178
172
    """Working copy tree.
179
173
 
180
174
    The inventory is held in the `Branch` working-inventory, and the
182
176
 
183
177
    It is possible for a `WorkingTree` to have a filename which is
184
178
    not listed in the Inventory and vice versa.
 
179
 
 
180
    :ivar basedir: The root of the tree on disk. This is a unicode path object
 
181
        (as opposed to a URL).
185
182
    """
186
183
 
187
184
    # override this to set the strategy for storing views
253
250
        self._rules_searcher = None
254
251
        self.views = self._make_views()
255
252
 
 
253
    @property
 
254
    def user_transport(self):
 
255
        return self.bzrdir.user_transport
 
256
 
 
257
    @property
 
258
    def control_transport(self):
 
259
        return self._transport
 
260
 
256
261
    def _detect_case_handling(self):
257
262
        wt_trans = self.bzrdir.get_workingtree_transport(None)
258
263
        try:
366
371
                return True, None
367
372
            else:
368
373
                return True, tree
369
 
        transport = get_transport(location)
370
 
        iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
 
374
        t = transport.get_transport(location)
 
375
        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
371
376
                                              list_current=list_current)
372
 
        return [t for t in iterator if t is not None]
 
377
        return [tr for tr in iterator if tr is not None]
373
378
 
374
379
    # should be deprecated - this is slow and in any case treating them as a
375
380
    # container is (we now know) bad style -- mbp 20070302
460
465
        return (file_obj, stat_value)
461
466
 
462
467
    def get_file_text(self, file_id, path=None, filtered=True):
463
 
        return self.get_file(file_id, path=path, filtered=filtered).read()
 
468
        my_file = self.get_file(file_id, path=path, filtered=filtered)
 
469
        try:
 
470
            return my_file.read()
 
471
        finally:
 
472
            my_file.close()
464
473
 
465
474
    def get_file_byname(self, filename, filtered=True):
466
475
        path = self.abspath(filename)
520
529
 
521
530
        # Now we have the parents of this content
522
531
        annotator = self.branch.repository.texts.get_annotator()
523
 
        text = self.get_file(file_id).read()
 
532
        text = self.get_file_text(file_id)
524
533
        this_key =(file_id, default_revision)
525
534
        annotator.add_special_text(this_key, file_parent_keys, text)
526
535
        annotations = [(key[-1], line)
1796
1805
            raise errors.ObjectNotLocked(self)
1797
1806
 
1798
1807
    def lock_read(self):
1799
 
        """See Branch.lock_read, and WorkingTree.unlock."""
 
1808
        """Lock the tree for reading.
 
1809
 
 
1810
        This also locks the branch, and can be unlocked via self.unlock().
 
1811
 
 
1812
        :return: A bzrlib.lock.LogicalLockResult.
 
1813
        """
1800
1814
        if not self.is_locked():
1801
1815
            self._reset_data()
1802
1816
        self.branch.lock_read()
1803
1817
        try:
1804
 
            return self._control_files.lock_read()
 
1818
            self._control_files.lock_read()
 
1819
            return LogicalLockResult(self.unlock)
1805
1820
        except:
1806
1821
            self.branch.unlock()
1807
1822
            raise
1808
1823
 
1809
1824
    def lock_tree_write(self):
1810
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
 
1825
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
 
1826
 
 
1827
        :return: A bzrlib.lock.LogicalLockResult.
 
1828
        """
1811
1829
        if not self.is_locked():
1812
1830
            self._reset_data()
1813
1831
        self.branch.lock_read()
1814
1832
        try:
1815
 
            return self._control_files.lock_write()
 
1833
            self._control_files.lock_write()
 
1834
            return LogicalLockResult(self.unlock)
1816
1835
        except:
1817
1836
            self.branch.unlock()
1818
1837
            raise
1819
1838
 
1820
1839
    def lock_write(self):
1821
 
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
1840
        """See MutableTree.lock_write, and WorkingTree.unlock.
 
1841
 
 
1842
        :return: A bzrlib.lock.LogicalLockResult.
 
1843
        """
1822
1844
        if not self.is_locked():
1823
1845
            self._reset_data()
1824
1846
        self.branch.lock_write()
1825
1847
        try:
1826
 
            return self._control_files.lock_write()
 
1848
            self._control_files.lock_write()
 
1849
            return LogicalLockResult(self.unlock)
1827
1850
        except:
1828
1851
            self.branch.unlock()
1829
1852
            raise
1954
1977
        def recurse_directory_to_add_files(directory):
1955
1978
            # Recurse directory and add all files
1956
1979
            # so we can check if they have changed.
1957
 
            for parent_info, file_infos in\
1958
 
                self.walkdirs(directory):
 
1980
            for parent_info, file_infos in self.walkdirs(directory):
1959
1981
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1960
1982
                    # Is it versioned or ignored?
1961
1983
                    if self.path2id(relpath) or self.is_ignored(relpath):
1996
2018
                            # ... but not ignored
1997
2019
                            has_changed_files = True
1998
2020
                            break
1999
 
                    elif content_change and (kind[1] is not None):
2000
 
                        # Versioned and changed, but not deleted
 
2021
                    elif (content_change and (kind[1] is not None) and
 
2022
                            osutils.is_inside_any(files, path[1])):
 
2023
                        # Versioned and changed, but not deleted, and still
 
2024
                        # in one of the dirs to be deleted.
2001
2025
                        has_changed_files = True
2002
2026
                        break
2003
2027
 
2634
2658
 
2635
2659
        In Format2 WorkingTrees we have a single lock for the branch and tree
2636
2660
        so lock_tree_write() degrades to lock_write().
 
2661
 
 
2662
        :return: An object with an unlock method which will release the lock
 
2663
            obtained.
2637
2664
        """
2638
2665
        self.branch.lock_write()
2639
2666
        try:
2640
 
            return self._control_files.lock_write()
 
2667
            self._control_files.lock_write()
 
2668
            return self
2641
2669
        except:
2642
2670
            self.branch.unlock()
2643
2671
            raise