~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

Merge up bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
111
111
        deprecated_method,
112
112
        deprecated_function,
113
113
        DEPRECATED_PARAMETER,
114
 
        zero_eight,
115
 
        zero_eleven,
116
 
        zero_thirteen,
117
114
        )
118
115
 
119
116
 
123
120
ERROR_PATH_NOT_FOUND = 3    # WindowsError errno code, equivalent to ENOENT
124
121
 
125
122
 
126
 
@deprecated_function(zero_thirteen)
127
 
def gen_file_id(name):
128
 
    """Return new file id for the basename 'name'.
129
 
 
130
 
    Use bzrlib.generate_ids.gen_file_id() instead
131
 
    """
132
 
    return generate_ids.gen_file_id(name)
133
 
 
134
 
 
135
 
@deprecated_function(zero_thirteen)
136
 
def gen_root_id():
137
 
    """Return a new tree-root file id.
138
 
 
139
 
    This has been deprecated in favor of bzrlib.generate_ids.gen_root_id()
140
 
    """
141
 
    return generate_ids.gen_root_id()
142
 
 
143
 
 
144
123
class TreeEntry(object):
145
124
    """An entry that implements the minimum interface used by commands.
146
125
 
222
201
        if not _internal:
223
202
            raise errors.BzrError("Please use bzrdir.open_workingtree or "
224
203
                "WorkingTree.open() to obtain a WorkingTree.")
225
 
        assert isinstance(basedir, basestring), \
226
 
            "base directory %r is not a string" % basedir
227
204
        basedir = safe_unicode(basedir)
228
205
        mutter("opening working tree %r", basedir)
229
206
        if deprecated_passed(branch):
237
214
            self._control_files = self.branch.control_files
238
215
        else:
239
216
            # assume all other formats have their own control files.
240
 
            assert isinstance(_control_files, LockableFiles), \
241
 
                    "_control_files must be a LockableFiles, not %r" \
242
 
                    % _control_files
243
217
            self._control_files = _control_files
244
218
        # update the whole cache up front and write to disk if anything changed;
245
219
        # in the future we might want to do this more selectively
318
292
            False then the inventory is the same as that on disk and any
319
293
            serialisation would be unneeded overhead.
320
294
        """
321
 
        assert inv.root is not None
322
295
        self._inventory = inv
323
296
        self._inventory_is_modified = dirty
324
297
 
434
407
    def _cleanup(self):
435
408
        self._flush_ignore_list_cache()
436
409
 
437
 
    @staticmethod
438
 
    @deprecated_method(zero_eight)
439
 
    def create(branch, directory):
440
 
        """Create a workingtree for branch at directory.
441
 
 
442
 
        If existing_directory already exists it must have a .bzr directory.
443
 
        If it does not exist, it will be created.
444
 
 
445
 
        This returns a new WorkingTree object for the new checkout.
446
 
 
447
 
        TODO FIXME RBC 20060124 when we have checkout formats in place this
448
 
        should accept an optional revisionid to checkout [and reject this if
449
 
        checking out into the same dir as a pre-checkout-aware branch format.]
450
 
 
451
 
        XXX: When BzrDir is present, these should be created through that 
452
 
        interface instead.
453
 
        """
454
 
        warnings.warn('delete WorkingTree.create', stacklevel=3)
455
 
        transport = get_transport(directory)
456
 
        if branch.bzrdir.root_transport.base == transport.base:
457
 
            # same dir 
458
 
            return branch.bzrdir.create_workingtree()
459
 
        # different directory, 
460
 
        # create a branch reference
461
 
        # and now a working tree.
462
 
        raise NotImplementedError
463
 
 
464
 
    @staticmethod
465
 
    @deprecated_method(zero_eight)
466
 
    def create_standalone(directory):
467
 
        """Create a checkout and a branch and a repo at directory.
468
 
 
469
 
        Directory must exist and be empty.
470
 
 
471
 
        please use BzrDir.create_standalone_workingtree
472
 
        """
473
 
        return bzrdir.BzrDir.create_standalone_workingtree(directory)
474
 
 
475
410
    def relpath(self, path):
476
411
        """Return the local path portion from a given path.
477
412
        
618
553
    __contains__ = has_id
619
554
 
620
555
    def get_file_size(self, file_id):
621
 
        return os.path.getsize(self.id2abspath(file_id))
 
556
        """See Tree.get_file_size"""
 
557
        try:
 
558
            return os.path.getsize(self.id2abspath(file_id))
 
559
        except OSError, e:
 
560
            if e.errno != errno.ENOENT:
 
561
                raise
 
562
            else:
 
563
                return None
622
564
 
623
565
    @needs_read_lock
624
566
    def get_file_sha1(self, file_id, path=None, stat_value=None):
664
606
        # function - they should be part of lock_write and unlock.
665
607
        inv = self.inventory
666
608
        for f, file_id, kind in zip(files, ids, kinds):
667
 
            assert kind is not None
668
609
            if file_id is None:
669
610
                inv.add_path(f, kind=kind)
670
611
            else:
765
706
        else:
766
707
            return (kind, None, None, None)
767
708
 
768
 
    @deprecated_method(zero_eleven)
769
 
    @needs_read_lock
770
 
    def pending_merges(self):
771
 
        """Return a list of pending merges.
772
 
 
773
 
        These are revisions that have been merged into the working
774
 
        directory but not yet committed.
775
 
 
776
 
        As of 0.11 this is deprecated. Please see WorkingTree.get_parent_ids()
777
 
        instead - which is available on all tree objects.
778
 
        """
779
 
        return self.get_parent_ids()[1:]
780
 
 
781
709
    def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
782
710
        """Common ghost checking functionality from set_parent_*.
783
711
 
1269
1197
                                       DeprecationWarning)
1270
1198
 
1271
1199
        # check destination directory
1272
 
        assert not isinstance(from_paths, basestring)
 
1200
        if isinstance(from_paths, basestring):
 
1201
            raise ValueError()
1273
1202
        inv = self.inventory
1274
1203
        to_abs = self.abspath(to_dir)
1275
1204
        if not isdir(to_abs):
1539
1468
            # - RBC 20060907
1540
1469
            self._write_inventory(self._inventory)
1541
1470
    
1542
 
    @deprecated_method(zero_eight)
1543
 
    def iter_conflicts(self):
1544
 
        """List all files in the tree that have text or content conflicts.
1545
 
        DEPRECATED.  Use conflicts instead."""
1546
 
        return self._iter_conflicts()
1547
 
 
1548
1471
    def _iter_conflicts(self):
1549
1472
        conflicted = set()
1550
1473
        for info in self.list_files():
1820
1743
 
1821
1744
    def _write_basis_inventory(self, xml):
1822
1745
        """Write the basis inventory XML to the basis-inventory file"""
1823
 
        assert isinstance(xml, str), 'serialised xml must be bytestring.'
1824
1746
        path = self._basis_inventory_name()
1825
1747
        sio = StringIO(xml)
1826
1748
        self._control_files.put(path, sio)
1944
1866
                            # ... but not ignored
1945
1867
                            has_changed_files = True
1946
1868
                            break
1947
 
                    elif content_change and (kind[1] != None):
 
1869
                    elif content_change and (kind[1] is not None):
1948
1870
                        # Versioned and changed, but not deleted
1949
1871
                        has_changed_files = True
1950
1872
                        break
2090
2012
        """Set the root id for this tree."""
2091
2013
        # for compatability 
2092
2014
        if file_id is None:
2093
 
            symbol_versioning.warn(symbol_versioning.zero_twelve
2094
 
                % 'WorkingTree.set_root_id with fileid=None',
2095
 
                DeprecationWarning,
2096
 
                stacklevel=3)
2097
 
            file_id = ROOT_ID
2098
 
        else:
2099
 
            file_id = osutils.safe_file_id(file_id)
 
2015
            raise ValueError(
 
2016
                'WorkingTree.set_root_id with fileid=None')
 
2017
        file_id = osutils.safe_file_id(file_id)
2100
2018
        self._set_root_id(file_id)
2101
2019
 
2102
2020
    def _set_root_id(self, file_id):
2644
2562
            return path[:-len(suffix)]
2645
2563
 
2646
2564
 
2647
 
@deprecated_function(zero_eight)
2648
 
def is_control_file(filename):
2649
 
    """See WorkingTree.is_control_filename(filename)."""
2650
 
    ## FIXME: better check
2651
 
    filename = normpath(filename)
2652
 
    while filename != '':
2653
 
        head, tail = os.path.split(filename)
2654
 
        ## mutter('check %r for control file' % ((head, tail),))
2655
 
        if tail == '.bzr':
2656
 
            return True
2657
 
        if filename == head:
2658
 
            break
2659
 
        filename = head
2660
 
    return False
2661
 
 
2662
 
 
2663
2565
class WorkingTreeFormat(object):
2664
2566
    """An encapsulation of the initialization and open routines for a format.
2665
2567
 
2739
2641
 
2740
2642
    @classmethod
2741
2643
    def unregister_format(klass, format):
2742
 
        assert klass._formats[format.get_format_string()] is format
2743
2644
        del klass._formats[format.get_format_string()]
2744
2645
 
2745
2646