← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: John Arbash Meinel
  • Date: 2009-02-23 15:29:35 UTC
  • mfrom: (3943.7.7 bzr.code_style_cleanup)
  • mto: This revision was merged to the branch mainline in revision 4033.
  • Revision ID: john@arbash-meinel.com-20090223152935-oel9m92mwcc6nb4h
Merge the removal of all trailing whitespace, and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
17
17
"""WorkingTree object and friends.
18
18
 
19
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 
 
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
23
new revision based on the workingtree and its inventory.
24
24
 
25
25
At the moment every WorkingTree has its own branch.  Remote
124
124
class TreeEntry(object):
125
125
    """An entry that implements the minimum interface used by commands.
126
126
 
127
 
    This needs further inspection, it may be better to have 
 
127
    This needs further inspection, it may be better to have
128
128
    InventoryEntries without ids - though that seems wrong. For now,
129
129
    this is a parallel hierarchy to InventoryEntry, and needs to become
130
130
    one of several things: decorates to that hierarchy, children of, or
133
133
    no InventoryEntry available - i.e. for unversioned objects.
134
134
    Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
135
135
    """
136
 
 
 
136
 
137
137
    def __eq__(self, other):
138
138
        # yes, this us ugly, TODO: best practice __eq__ style.
139
139
        return (isinstance(other, TreeEntry)
140
140
                and other.__class__ == self.__class__)
141
 
 
 
141
 
142
142
    def kind_character(self):
143
143
        return "???"
144
144
 
389
389
 
390
390
    def basis_tree(self):
391
391
        """Return RevisionTree for the current last revision.
392
 
        
 
392
 
393
393
        If the left most parent is a ghost then the returned tree will be an
394
 
        empty tree - one obtained by calling 
 
394
        empty tree - one obtained by calling
395
395
        repository.revision_tree(NULL_REVISION).
396
396
        """
397
397
        try:
426
426
 
427
427
    def relpath(self, path):
428
428
        """Return the local path portion from a given path.
429
 
        
430
 
        The path may be absolute or relative. If its a relative path it is 
 
429
 
 
430
        The path may be absolute or relative. If its a relative path it is
431
431
        interpreted relative to the python current working directory.
432
432
        """
433
433
        return osutils.relpath(self.basedir, path)
502
502
 
503
503
    def get_parent_ids(self):
504
504
        """See Tree.get_parent_ids.
505
 
        
 
505
 
506
506
        This implementation reads the pending merges list and last_revision
507
507
        value and uses that to decide what the parents list should be.
508
508
        """
525
525
    def get_root_id(self):
526
526
        """Return the id of this trees root"""
527
527
        return self._inventory.root.file_id
528
 
        
 
528
 
529
529
    def _get_store_filename(self, file_id):
530
530
        ## XXX: badly named; this is not in the store at all
531
531
        return self.abspath(self.id2path(file_id))
533
533
    @needs_read_lock
534
534
    def clone(self, to_bzrdir, revision_id=None):
535
535
        """Duplicate this working tree into to_bzr, including all state.
536
 
        
 
536
 
537
537
        Specifically modified files are kept as modified, but
538
538
        ignored and unknown files are discarded.
539
539
 
540
540
        If you want to make a new line of development, see bzrdir.sprout()
541
541
 
542
542
        revision
543
 
            If not None, the cloned tree will have its last revision set to 
 
543
            If not None, the cloned tree will have its last revision set to
544
544
            revision, and and difference between the source trees last revision
545
545
            and this one merged in.
546
546
        """
629
629
        """See MutableTree._add."""
630
630
        # TODO: Re-adding a file that is removed in the working copy
631
631
        # should probably put it back with the previous ID.
632
 
        # the read and write working inventory should not occur in this 
 
632
        # the read and write working inventory should not occur in this
633
633
        # function - they should be part of lock_write and unlock.
634
634
        inv = self.inventory
635
635
        for f, file_id, kind in zip(files, ids, kinds):
754
754
        """Check that all merged revisions are proper 'heads'.
755
755
 
756
756
        This will always return the first revision_id, and any merged revisions
757
 
        which are 
 
757
        which are
758
758
        """
759
759
        if len(revision_ids) == 0:
760
760
            return revision_ids
772
772
    @needs_tree_write_lock
773
773
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
774
774
        """Set the parent ids to revision_ids.
775
 
        
 
775
 
776
776
        See also set_parent_trees. This api will try to retrieve the tree data
777
777
        for each element of revision_ids from the trees repository. If you have
778
778
        tree data already available, it is more efficient to use
911
911
    def merge_modified(self):
912
912
        """Return a dictionary of files modified by a merge.
913
913
 
914
 
        The list is initialized by WorkingTree.set_merge_modified, which is 
 
914
        The list is initialized by WorkingTree.set_merge_modified, which is
915
915
        typically called after we make some automatic updates to the tree
916
916
        because of a merge.
917
917
 
1007
1007
        return False
1008
1008
 
1009
1009
    def _directory_may_be_tree_reference(self, relpath):
1010
 
        # as a special case, if a directory contains control files then 
 
1010
        # as a special case, if a directory contains control files then
1011
1011
        # it's a tree reference, except that the root of the tree is not
1012
1012
        return relpath and osutils.isdir(self.abspath(relpath) + u"/.bzr")
1013
1013
        # TODO: We could ask all the control formats whether they
1024
1024
    @needs_tree_write_lock
1025
1025
    def extract(self, file_id, format=None):
1026
1026
        """Extract a subtree from this tree.
1027
 
        
 
1027
 
1028
1028
        A new branch will be created, relative to the path for this tree.
1029
1029
        """
1030
1030
        self.flush()
1035
1035
                transport = transport.clone(name)
1036
1036
                transport.ensure_base()
1037
1037
            return transport
1038
 
            
 
1038
 
1039
1039
        sub_path = self.id2path(file_id)
1040
1040
        branch_transport = mkdirs(sub_path)
1041
1041
        if format is None:
1123
1123
        # directory file_id, relative path, absolute path, reverse sorted children
1124
1124
        children = os.listdir(self.basedir)
1125
1125
        children.sort()
1126
 
        # jam 20060527 The kernel sized tree seems equivalent whether we 
 
1126
        # jam 20060527 The kernel sized tree seems equivalent whether we
1127
1127
        # use a deque and popleft to keep them sorted, or if we use a plain
1128
1128
        # list and just reverse() them.
1129
1129
        children = collections.deque(children)
1149
1149
 
1150
1150
                # absolute path
1151
1151
                fap = from_dir_abspath + '/' + f
1152
 
                
 
1152
 
1153
1153
                f_ie = inv.get_child(from_dir_id, f)
1154
1154
                if f_ie:
1155
1155
                    c = 'V'
1187
1187
                    except KeyError:
1188
1188
                        yield fp[1:], c, fk, None, TreeEntry()
1189
1189
                    continue
1190
 
                
 
1190
 
1191
1191
                if fk != 'directory':
1192
1192
                    continue
1193
1193
 
1210
1210
        to_dir must exist in the inventory.
1211
1211
 
1212
1212
        If to_dir exists and is a directory, the files are moved into
1213
 
        it, keeping their old names.  
 
1213
        it, keeping their old names.
1214
1214
 
1215
1215
        Note that to_dir is only the last component of the new name;
1216
1216
        this doesn't change the directory.
1493
1493
        These are files in the working directory that are not versioned or
1494
1494
        control files or ignored.
1495
1495
        """
1496
 
        # force the extras method to be fully executed before returning, to 
 
1496
        # force the extras method to be fully executed before returning, to
1497
1497
        # prevent race conditions with the lock
1498
1498
        return iter(
1499
1499
            [subp for subp in self.extras() if not self.is_ignored(subp)])
1514
1514
            else:
1515
1515
                raise errors.NoSuchId(self, file_id)
1516
1516
        if len(file_ids):
1517
 
            # in the future this should just set a dirty bit to wait for the 
 
1517
            # in the future this should just set a dirty bit to wait for the
1518
1518
            # final unlock. However, until all methods of workingtree start
1519
 
            # with the current in -memory inventory rather than triggering 
 
1519
            # with the current in -memory inventory rather than triggering
1520
1520
            # a read, it is more complex - we need to teach read_inventory
1521
1521
            # to know when to read, and when to not read first... and possibly
1522
1522
            # to save first when the in memory one may be corrupted.
1523
1523
            # so for now, we just only write it if it is indeed dirty.
1524
1524
            # - RBC 20060907
1525
1525
            self._write_inventory(self._inventory)
1526
 
    
 
1526
 
1527
1527
    def _iter_conflicts(self):
1528
1528
        conflicted = set()
1529
1529
        for info in self.list_files():
1572
1572
                # reuse the revisiontree we merged against to set the new
1573
1573
                # tree data.
1574
1574
                parent_trees = [(self.branch.last_revision(), new_basis_tree)]
1575
 
                # we have to pull the merge trees out again, because 
1576
 
                # merge_inner has set the ids. - this corner is not yet 
 
1575
                # we have to pull the merge trees out again, because
 
1576
                # merge_inner has set the ids. - this corner is not yet
1577
1577
                # layered well enough to prevent double handling.
1578
1578
                # XXX TODO: Fix the double handling: telling the tree about
1579
1579
                # the already known parent data is wasteful.
1633
1633
                            fl.append(subf_norm)
1634
1634
                    else:
1635
1635
                        fl.append(subf)
1636
 
            
 
1636
 
1637
1637
            fl.sort()
1638
1638
            for subf in fl:
1639
1639
                subp = pathjoin(path, subf)
1790
1790
 
1791
1791
    def _change_last_revision(self, new_revision):
1792
1792
        """Template method part of set_last_revision to perform the change.
1793
 
        
 
1793
 
1794
1794
        This is used to allow WorkingTree3 instances to not affect branch
1795
1795
        when their last revision is set.
1796
1796
        """
1822
1822
        # as commit already has that ready-to-use [while the format is the
1823
1823
        # same, that is].
1824
1824
        try:
1825
 
            # this double handles the inventory - unpack and repack - 
 
1825
            # this double handles the inventory - unpack and repack -
1826
1826
            # but is easier to understand. We can/should put a conditional
1827
1827
            # in here based on whether the inventory is in the latest format
1828
1828
            # - perhaps we should repack all inventories on a repository
1829
1829
            # upgrade ?
1830
1830
            # the fast path is to copy the raw xml from the repository. If the
1831
 
            # xml contains 'revision_id="', then we assume the right 
 
1831
            # xml contains 'revision_id="', then we assume the right
1832
1832
            # revision_id is set. We must check for this full string, because a
1833
1833
            # root node id can legitimately look like 'revision_id' but cannot
1834
1834
            # contain a '"'.
1835
1835
            xml = self.branch.repository.get_inventory_xml(new_revision)
1836
1836
            firstline = xml.split('\n', 1)[0]
1837
 
            if (not 'revision_id="' in firstline or 
 
1837
            if (not 'revision_id="' in firstline or
1838
1838
                'format="7"' not in firstline):
1839
1839
                inv = self.branch.repository.deserialise_inventory(
1840
1840
                    new_revision, xml)
1847
1847
        """Read the cached basis inventory."""
1848
1848
        path = self._basis_inventory_name()
1849
1849
        return self._transport.get_bytes(path)
1850
 
        
 
1850
 
1851
1851
    @needs_read_lock
1852
1852
    def read_working_inventory(self):
1853
1853
        """Read the working inventory.
1854
 
        
 
1854
 
1855
1855
        :raises errors.InventoryModified: read_working_inventory will fail
1856
1856
            when the current in memory inventory has been modified.
1857
1857
        """
1858
 
        # conceptually this should be an implementation detail of the tree. 
 
1858
        # conceptually this should be an implementation detail of the tree.
1859
1859
        # XXX: Deprecate this.
1860
1860
        # ElementTree does its own conversion from UTF-8, so open in
1861
1861
        # binary.
2058
2058
            name = os.path.basename(path)
2059
2059
            if name == "":
2060
2060
                continue
2061
 
            # fixme, there should be a factory function inv,add_?? 
 
2061
            # fixme, there should be a factory function inv,add_??
2062
2062
            if kind == 'directory':
2063
2063
                inv.add(InventoryDirectory(file_id, name, parent))
2064
2064
            elif kind == 'file':
2072
2072
    @needs_tree_write_lock
2073
2073
    def set_root_id(self, file_id):
2074
2074
        """Set the root id for this tree."""
2075
 
        # for compatability 
 
2075
        # for compatability
2076
2076
        if file_id is None:
2077
2077
            raise ValueError(
2078
2078
                'WorkingTree.set_root_id with fileid=None')
2082
2082
    def _set_root_id(self, file_id):
2083
2083
        """Set the root id for this tree, in a format specific manner.
2084
2084
 
2085
 
        :param file_id: The file id to assign to the root. It must not be 
 
2085
        :param file_id: The file id to assign to the root. It must not be
2086
2086
            present in the current inventory or an error will occur. It must
2087
2087
            not be None, but rather a valid file id.
2088
2088
        """
2107
2107
 
2108
2108
    def unlock(self):
2109
2109
        """See Branch.unlock.
2110
 
        
 
2110
 
2111
2111
        WorkingTree locking just uses the Branch locking facilities.
2112
2112
        This is current because all working trees have an embedded branch
2113
2113
        within them. IF in the future, we were to make branch data shareable
2114
 
        between multiple working trees, i.e. via shared storage, then we 
 
2114
        between multiple working trees, i.e. via shared storage, then we
2115
2115
        would probably want to lock both the local tree, and the branch.
2116
2116
        """
2117
2117
        raise NotImplementedError(self.unlock)
2169
2169
        # cant set that until we update the working trees last revision to be
2170
2170
        # one from the new branch, because it will just get absorbed by the
2171
2171
        # parent de-duplication logic.
2172
 
        # 
 
2172
        #
2173
2173
        # We MUST save it even if an error occurs, because otherwise the users
2174
2174
        # local work is unreferenced and will appear to have been lost.
2175
 
        # 
 
2175
        #
2176
2176
        result = 0
2177
2177
        try:
2178
2178
            last_rev = self.get_parent_ids()[0]
2530
2530
class WorkingTree2(WorkingTree):
2531
2531
    """This is the Format 2 working tree.
2532
2532
 
2533
 
    This was the first weave based working tree. 
 
2533
    This was the first weave based working tree.
2534
2534
     - uses os locks for locking.
2535
2535
     - uses the branch last-revision.
2536
2536
    """
2569
2569
            if self._inventory_is_modified:
2570
2570
                self.flush()
2571
2571
            self._write_hashcache_if_dirty()
2572
 
                    
 
2572
 
2573
2573
        # reverse order of locking.
2574
2574
        try:
2575
2575
            return self._control_files.unlock()
2610
2610
 
2611
2611
    @needs_tree_write_lock
2612
2612
    def set_conflicts(self, conflicts):
2613
 
        self._put_rio('conflicts', conflicts.to_stanzas(), 
 
2613
        self._put_rio('conflicts', conflicts.to_stanzas(),
2614
2614
                      CONFLICT_HEADER_1)
2615
2615
 
2616
2616
    @needs_tree_write_lock
2665
2665
     * a format string,
2666
2666
     * an open routine.
2667
2667
 
2668
 
    Formats are placed in an dict by their format string for reference 
 
2668
    Formats are placed in an dict by their format string for reference
2669
2669
    during workingtree opening. Its not required that these be instances, they
2670
 
    can be classes themselves with class methods - it simply depends on 
 
2670
    can be classes themselves with class methods - it simply depends on
2671
2671
    whether state is needed for a given format or not.
2672
2672
 
2673
2673
    Once a format is deprecated, just deprecate the initialize and open
2674
 
    methods on the format class. Do not deprecate the object, as the 
 
2674
    methods on the format class. Do not deprecate the object, as the
2675
2675
    object will be created every time regardless.
2676
2676
    """
2677
2677
 
2721
2721
        """Is this format supported?
2722
2722
 
2723
2723
        Supported formats can be initialized and opened.
2724
 
        Unsupported formats may not support initialization or committing or 
 
2724
        Unsupported formats may not support initialization or committing or
2725
2725
        some other features depending on the reason for not being supported.
2726
2726
        """
2727
2727
        return True
2748
2748
 
2749
2749
 
2750
2750
class WorkingTreeFormat2(WorkingTreeFormat):
2751
 
    """The second working tree format. 
 
2751
    """The second working tree format.
2752
2752
 
2753
2753
    This format modified the hash cache from the format 1 hash cache.
2754
2754
    """
2840
2840
        - is new in bzr 0.8
2841
2841
        - uses a LockDir to guard access for writes.
2842
2842
    """
2843
 
    
 
2843
 
2844
2844
    upgrade_recommended = True
2845
2845
 
2846
2846
    def get_format_string(self):
2863
2863
 
2864
2864
    def _open_control_files(self, a_bzrdir):
2865
2865
        transport = a_bzrdir.get_workingtree_transport(None)
2866
 
        return LockableFiles(transport, self._lock_file_name, 
 
2866
        return LockableFiles(transport, self._lock_file_name,
2867
2867
                             self._lock_class)
2868
2868
 
2869
2869
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
2870
2870
                   accelerator_tree=None, hardlink=False):
2871
2871
        """See WorkingTreeFormat.initialize().
2872
 
        
 
2872
 
2873
2873
        :param revision_id: if supplied, create a working tree at a different
2874
2874
            revision than the branch is at.
2875
2875
        :param accelerator_tree: A tree which can be used for retrieving file
2946
2946
 
2947
2947
    def _open(self, a_bzrdir, control_files):
2948
2948
        """Open the tree itself.
2949
 
        
 
2949
 
2950
2950
        :param a_bzrdir: the dir for the tree.
2951
2951
        :param control_files: the control files for the tree.
2952
2952
        """