/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

• browse files at revision 5037.2.11
• compare with another revision
• download diff
• download tarball
• view history from revision 5037.2.11

• reverse the comparison (5037.2.11 to 5280)
• stop comparing with revision 5280

Show diffs side-by-side

added

removed

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)

32

38

 

33

39

from cStringIO import StringIO

34

40

import os

77

83

 

78

84

from bzrlib import symbol_versioning

79

85

from bzrlib.decorators import needs_read_lock, needs_write_lock

80

 

from bzrlib.lock import LogicalLockResult

81

86

from bzrlib.lockable_files import LockableFiles

82

87

from bzrlib.lockdir import LockDir

83

88

import bzrlib.mutabletree

96

101

from bzrlib.filters import filtered_input_file

97

102

from bzrlib.trace import mutter, note

98

103

from bzrlib.transport.local import LocalTransport

 

104

from bzrlib.progress import ProgressPhase

99

105

from bzrlib.revision import CURRENT_REVISION

100

106

from bzrlib.rio import RioReader, rio_file, Stanza

101

107

from bzrlib.symbol_versioning import (

168

174

        return ''

169

175

 

170

176

 

171

 

class WorkingTree(bzrlib.mutabletree.MutableTree,

172

 

    bzrdir.ControlComponent):

 

177

class WorkingTree(bzrlib.mutabletree.MutableTree):

173

178

    """Working copy tree.

174

179

 

175

180

    The inventory is held in the `Branch` working-inventory, and the

248

253

        self._rules_searcher = None

249

254

        self.views = self._make_views()

250

255

 

251

 

    @property

252

 

    def user_transport(self):

253

 

        return self.bzrdir.user_transport

254

 

 

255

 

    @property

256

 

    def control_transport(self):

257

 

        return self._transport

258

 

 

259

256

    def _detect_case_handling(self):

260

257

        wt_trans = self.bzrdir.get_workingtree_transport(None)

261

258

        try:

463

460

        return (file_obj, stat_value)

464

461

 

465

462

    def get_file_text(self, file_id, path=None, filtered=True):

466

 

        my_file = self.get_file(file_id, path=path, filtered=filtered)

467

 

        try:

468

 

            return my_file.read()

469

 

        finally:

470

 

            my_file.close()

 

463

        return self.get_file(file_id, path=path, filtered=filtered).read()

471

464

 

472

465

    def get_file_byname(self, filename, filtered=True):

473

466

        path = self.abspath(filename)

527

520

 

528

521

        # Now we have the parents of this content

529

522

        annotator = self.branch.repository.texts.get_annotator()

530

 

        text = self.get_file_text(file_id)

 

523

        text = self.get_file(file_id).read()

531

524

        this_key =(file_id, default_revision)

532

525

        annotator.add_special_text(this_key, file_parent_keys, text)

533

526

        annotations = [(key[-1], line)

1101

1094

        tree_transport = self.bzrdir.root_transport.clone(sub_path)

1102

1095

        if tree_transport.base != branch_transport.base:

1103

1096

            tree_bzrdir = format.initialize_on_transport(tree_transport)

1104

 

            branch.BranchReferenceFormat().initialize(tree_bzrdir,

1105

 

                target_branch=new_branch)

 

1097

            branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)

1106

1098

        else:

1107

1099

            tree_bzrdir = branch_bzrdir

1108

1100

        wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)

1146

1138

        This does not include files that have been deleted in this

1147

1139

        tree. Skips the control directory.

1148

1140

 

1149

 

        :param include_root: if True, return an entry for the root

 

1141

        :param include_root: if True, do not return an entry for the root

1150

1142

        :param from_dir: start from this directory or None for the root

1151

1143

        :param recursive: whether to recurse into subdirectories or not

1152

1144

        """

1803

1795

            raise errors.ObjectNotLocked(self)

1804

1796

 

1805

1797

    def lock_read(self):

1806

 

        """Lock the tree for reading.

1807

 

 

1808

 

        This also locks the branch, and can be unlocked via self.unlock().

1809

 

 

1810

 

        :return: A bzrlib.lock.LogicalLockResult.

1811

 

        """

 

1798

        """See Branch.lock_read, and WorkingTree.unlock."""

1812

1799

        if not self.is_locked():

1813

1800

            self._reset_data()

1814

1801

        self.branch.lock_read()

1815

1802

        try:

1816

 

            self._control_files.lock_read()

1817

 

            return LogicalLockResult(self.unlock)

 

1803

            return self._control_files.lock_read()

1818

1804

        except:

1819

1805

            self.branch.unlock()

1820

1806

            raise

1821

1807

 

1822

1808

    def lock_tree_write(self):

1823

 

        """See MutableTree.lock_tree_write, and WorkingTree.unlock.

1824

 

 

1825

 

        :return: A bzrlib.lock.LogicalLockResult.

1826

 

        """

 

1809

        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""

1827

1810

        if not self.is_locked():

1828

1811

            self._reset_data()

1829

1812

        self.branch.lock_read()

1830

1813

        try:

1831

 

            self._control_files.lock_write()

1832

 

            return LogicalLockResult(self.unlock)

 

1814

            return self._control_files.lock_write()

1833

1815

        except:

1834

1816

            self.branch.unlock()

1835

1817

            raise

1836

1818

 

1837

1819

    def lock_write(self):

1838

 

        """See MutableTree.lock_write, and WorkingTree.unlock.

1839

 

 

1840

 

        :return: A bzrlib.lock.LogicalLockResult.

1841

 

        """

 

1820

        """See MutableTree.lock_write, and WorkingTree.unlock."""

1842

1821

        if not self.is_locked():

1843

1822

            self._reset_data()

1844

1823

        self.branch.lock_write()

1845

1824

        try:

1846

 

            self._control_files.lock_write()

1847

 

            return LogicalLockResult(self.unlock)

 

1825

            return self._control_files.lock_write()

1848

1826

        except:

1849

1827

            self.branch.unlock()

1850

1828

            raise

1975

1953

        def recurse_directory_to_add_files(directory):

1976

1954

            # Recurse directory and add all files

1977

1955

            # so we can check if they have changed.

1978

 

            for parent_info, file_infos in self.walkdirs(directory):

 

1956

            for parent_info, file_infos in\

 

1957

                self.walkdirs(directory):

1979

1958

                for relpath, basename, kind, lstat, fileid, kind in file_infos:

1980

1959

                    # Is it versioned or ignored?

1981

1960

                    if self.path2id(relpath) or self.is_ignored(relpath):

2016

1995

                            # ... but not ignored

2017

1996

                            has_changed_files = True

2018

1997

                            break

2019

 

                    elif (content_change and (kind[1] is not None) and

2020

 

                            osutils.is_inside_any(files, path[1])):

2021

 

                        # Versioned and changed, but not deleted, and still

2022

 

                        # in one of the dirs to be deleted.

 

1998

                    elif content_change and (kind[1] is not None):

 

1999

                        # Versioned and changed, but not deleted

2023

2000

                        has_changed_files = True

2024

2001

                        break

2025

2002

 

2280

2257

            last_rev = _mod_revision.NULL_REVISION

2281

2258

        if revision is None:

2282

2259

            revision = self.branch.last_revision()

 

2260

        else:

 

2261

            if revision not in self.branch.revision_history():

 

2262

                raise errors.NoSuchRevision(self.branch, revision)

2283

2263

 

2284

2264

        old_tip = old_tip or _mod_revision.NULL_REVISION

2285

2265

 

2656

2636

 

2657

2637

        In Format2 WorkingTrees we have a single lock for the branch and tree

2658

2638

        so lock_tree_write() degrades to lock_write().

2659

 

 

2660

 

        :return: An object with an unlock method which will release the lock

2661

 

            obtained.

2662

2639

        """

2663

2640

        self.branch.lock_write()

2664

2641

        try:

2665

 

            self._control_files.lock_write()

2666

 

            return self

 

2642

            return self._control_files.lock_write()

2667

2643

        except:

2668

2644

            self.branch.unlock()

2669

2645

            raise

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0