/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: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
61
61
    revisiontree,
62
62
    trace,
63
63
    transform,
 
64
    transport,
64
65
    ui,
65
66
    views,
66
67
    xml5,
67
68
    xml7,
68
69
    )
69
 
import bzrlib.branch
70
 
from bzrlib.transport import get_transport
71
70
from bzrlib.workingtree_4 import (
72
71
    WorkingTreeFormat4,
73
72
    WorkingTreeFormat5,
77
76
 
78
77
from bzrlib import symbol_versioning
79
78
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
79
from bzrlib.lock import LogicalLockResult
80
80
from bzrlib.lockable_files import LockableFiles
81
81
from bzrlib.lockdir import LockDir
82
82
import bzrlib.mutabletree
176
176
 
177
177
    It is possible for a `WorkingTree` to have a filename which is
178
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).
179
182
    """
180
183
 
181
184
    # override this to set the strategy for storing views
368
371
                return True, None
369
372
            else:
370
373
                return True, tree
371
 
        transport = get_transport(location)
372
 
        iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
 
374
        t = transport.get_transport(location)
 
375
        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
373
376
                                              list_current=list_current)
374
 
        return [t for t in iterator if t is not None]
 
377
        return [tr for tr in iterator if tr is not None]
375
378
 
376
379
    # should be deprecated - this is slow and in any case treating them as a
377
380
    # container is (we now know) bad style -- mbp 20070302
462
465
        return (file_obj, stat_value)
463
466
 
464
467
    def get_file_text(self, file_id, path=None, filtered=True):
465
 
        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()
466
473
 
467
474
    def get_file_byname(self, filename, filtered=True):
468
475
        path = self.abspath(filename)
522
529
 
523
530
        # Now we have the parents of this content
524
531
        annotator = self.branch.repository.texts.get_annotator()
525
 
        text = self.get_file(file_id).read()
 
532
        text = self.get_file_text(file_id)
526
533
        this_key =(file_id, default_revision)
527
534
        annotator.add_special_text(this_key, file_parent_keys, text)
528
535
        annotations = [(key[-1], line)
1798
1805
            raise errors.ObjectNotLocked(self)
1799
1806
 
1800
1807
    def lock_read(self):
1801
 
        """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
        """
1802
1814
        if not self.is_locked():
1803
1815
            self._reset_data()
1804
1816
        self.branch.lock_read()
1805
1817
        try:
1806
 
            return self._control_files.lock_read()
 
1818
            self._control_files.lock_read()
 
1819
            return LogicalLockResult(self.unlock)
1807
1820
        except:
1808
1821
            self.branch.unlock()
1809
1822
            raise
1810
1823
 
1811
1824
    def lock_tree_write(self):
1812
 
        """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
        """
1813
1829
        if not self.is_locked():
1814
1830
            self._reset_data()
1815
1831
        self.branch.lock_read()
1816
1832
        try:
1817
 
            return self._control_files.lock_write()
 
1833
            self._control_files.lock_write()
 
1834
            return LogicalLockResult(self.unlock)
1818
1835
        except:
1819
1836
            self.branch.unlock()
1820
1837
            raise
1821
1838
 
1822
1839
    def lock_write(self):
1823
 
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
1840
        """See MutableTree.lock_write, and WorkingTree.unlock.
 
1841
 
 
1842
        :return: A bzrlib.lock.LogicalLockResult.
 
1843
        """
1824
1844
        if not self.is_locked():
1825
1845
            self._reset_data()
1826
1846
        self.branch.lock_write()
1827
1847
        try:
1828
 
            return self._control_files.lock_write()
 
1848
            self._control_files.lock_write()
 
1849
            return LogicalLockResult(self.unlock)
1829
1850
        except:
1830
1851
            self.branch.unlock()
1831
1852
            raise
1948
1969
 
1949
1970
        inv_delta = []
1950
1971
 
1951
 
        new_files=set()
 
1972
        all_files = set() # specified and nested files 
1952
1973
        unknown_nested_files=set()
1953
1974
        if to_file is None:
1954
1975
            to_file = sys.stdout
1955
1976
 
 
1977
        files_to_backup = []
 
1978
 
1956
1979
        def recurse_directory_to_add_files(directory):
1957
1980
            # Recurse directory and add all files
1958
1981
            # so we can check if they have changed.
1959
 
            for parent_info, file_infos in\
1960
 
                self.walkdirs(directory):
 
1982
            for parent_info, file_infos in self.walkdirs(directory):
1961
1983
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1962
1984
                    # Is it versioned or ignored?
1963
 
                    if self.path2id(relpath) or self.is_ignored(relpath):
 
1985
                    if self.path2id(relpath):
1964
1986
                        # Add nested content for deletion.
1965
 
                        new_files.add(relpath)
 
1987
                        all_files.add(relpath)
1966
1988
                    else:
1967
 
                        # Files which are not versioned and not ignored
 
1989
                        # Files which are not versioned
1968
1990
                        # should be treated as unknown.
1969
 
                        unknown_nested_files.add((relpath, None, kind))
 
1991
                        files_to_backup.append(relpath)
1970
1992
 
1971
1993
        for filename in files:
1972
1994
            # Get file name into canonical form.
1973
1995
            abspath = self.abspath(filename)
1974
1996
            filename = self.relpath(abspath)
1975
1997
            if len(filename) > 0:
1976
 
                new_files.add(filename)
 
1998
                all_files.add(filename)
1977
1999
                recurse_directory_to_add_files(filename)
1978
2000
 
1979
 
        files = list(new_files)
 
2001
        files = list(all_files)
1980
2002
 
1981
2003
        if len(files) == 0:
1982
2004
            return # nothing to do
1986
2008
 
1987
2009
        # Bail out if we are going to delete files we shouldn't
1988
2010
        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
 
2011
            for (file_id, path, content_change, versioned, parent_id, name,
 
2012
                 kind, executable) in self.iter_changes(self.basis_tree(),
 
2013
                     include_unchanged=True, require_versioned=False,
 
2014
                     want_unversioned=True, specific_files=files):
 
2015
                if versioned[0] == False:
 
2016
                    # The record is unknown or newly added
 
2017
                    files_to_backup.append(path[1])
 
2018
                elif (content_change and (kind[1] is not None) and
 
2019
                        osutils.is_inside_any(files, path[1])):
 
2020
                    # Versioned and changed, but not deleted, and still
 
2021
                    # in one of the dirs to be deleted.
 
2022
                    files_to_backup.append(path[1])
2005
2023
 
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)
 
2024
        def backup(file_to_backup):
 
2025
            backup_name = self.bzrdir.generate_backup_name(file_to_backup)
 
2026
            osutils.rename(abs_path, self.abspath(backup_name))
 
2027
            return "removed %s (but kept a copy: %s)" % (file_to_backup, backup_name)
2015
2028
 
2016
2029
        # Build inv_delta and delete files where applicable,
2017
2030
        # do this before any modifications to inventory.
2041
2054
                        len(os.listdir(abs_path)) > 0):
2042
2055
                        if force:
2043
2056
                            osutils.rmtree(abs_path)
 
2057
                            message = "deleted %s" % (f,)
2044
2058
                        else:
2045
 
                            message = "%s is not an empty directory "\
2046
 
                                "and won't be deleted." % (f,)
 
2059
                            message = backup(f)
2047
2060
                    else:
2048
 
                        osutils.delete_any(abs_path)
2049
 
                        message = "deleted %s" % (f,)
 
2061
                        if f in files_to_backup:
 
2062
                            message = backup(f)
 
2063
                        else:
 
2064
                            osutils.delete_any(abs_path)
 
2065
                            message = "deleted %s" % (f,)
2050
2066
                elif message is not None:
2051
2067
                    # Only care if we haven't done anything yet.
2052
2068
                    message = "%s does not exist." % (f,)
2636
2652
 
2637
2653
        In Format2 WorkingTrees we have a single lock for the branch and tree
2638
2654
        so lock_tree_write() degrades to lock_write().
 
2655
 
 
2656
        :return: An object with an unlock method which will release the lock
 
2657
            obtained.
2639
2658
        """
2640
2659
        self.branch.lock_write()
2641
2660
        try:
2642
 
            return self._control_files.lock_write()
 
2661
            self._control_files.lock_write()
 
2662
            return self
2643
2663
        except:
2644
2664
            self.branch.unlock()
2645
2665
            raise