/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_4.py

Rework test_script a little bit.


Don't allow someone to request a stdin request to echo.
Echo never reads from stdin, it just echos its arguments.
You use 'cat' if you want to read from stdin.

A few other fixes because the tests were using filenames
that are actually illegal on Windows, rather than just
nonexistant.


Change the exception handling for commands so that
unknown errors don't get silently squashed and then
turn into hard-to-debug errors later.

test_script now passes on Windows.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree_4.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
53
53
from bzrlib.decorators import needs_read_lock, needs_write_lock
54
54
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
55
55
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
 
56
import bzrlib.mutabletree
56
57
from bzrlib.mutabletree import needs_tree_write_lock
57
58
from bzrlib.osutils import (
58
59
    file_kind,
567
568
            return _mod_revision.NULL_REVISION
568
569
 
569
570
    def lock_read(self):
570
 
        """See Branch.lock_read, and WorkingTree.unlock.
571
 
 
572
 
        :return: An object with an unlock method which will release the lock
573
 
            obtained.
574
 
        """
 
571
        """See Branch.lock_read, and WorkingTree.unlock."""
575
572
        self.branch.lock_read()
576
573
        try:
577
574
            self._control_files.lock_read()
590
587
        except:
591
588
            self.branch.unlock()
592
589
            raise
593
 
        return self
594
590
 
595
591
    def _lock_self_write(self):
596
592
        """This should be called after the branch is locked."""
611
607
        except:
612
608
            self.branch.unlock()
613
609
            raise
614
 
        return self
615
610
 
616
611
    def lock_tree_write(self):
617
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
618
 
 
619
 
        :return: An object with an unlock method which will release the lock
620
 
            obtained.
621
 
        """
 
612
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
622
613
        self.branch.lock_read()
623
 
        return self._lock_self_write()
 
614
        self._lock_self_write()
624
615
 
625
616
    def lock_write(self):
626
 
        """See MutableTree.lock_write, and WorkingTree.unlock.
627
 
 
628
 
        :return: An object with an unlock method which will release the lock
629
 
            obtained.
630
 
        """
 
617
        """See MutableTree.lock_write, and WorkingTree.unlock."""
631
618
        self.branch.lock_write()
632
 
        return self._lock_self_write()
 
619
        self._lock_self_write()
633
620
 
634
621
    @needs_tree_write_lock
635
622
    def move(self, from_paths, to_dir, after=False):
1385
1372
 
1386
1373
 
1387
1374
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
1388
 
 
1389
1375
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1390
1376
                   accelerator_tree=None, hardlink=False):
1391
1377
        """See WorkingTreeFormat.initialize().
1461
1447
                if basis_root_id is not None:
1462
1448
                    wt._set_root_id(basis_root_id)
1463
1449
                    wt.flush()
 
1450
                # If content filtering is supported, do not use the accelerator
 
1451
                # tree - the cost of transforming the content both ways and
 
1452
                # checking for changed content can outweight the gains it gives.
 
1453
                # Note: do NOT move this logic up higher - using the basis from
 
1454
                # the accelerator tree is still desirable because that can save
 
1455
                # a minute or more of processing on large trees!
 
1456
                # The original tree may not have the same content filters
 
1457
                # applied so we can't safely build the inventory delta from
 
1458
                # the source tree.
1464
1459
                if wt.supports_content_filtering():
1465
 
                    # The original tree may not have the same content filters
1466
 
                    # applied so we can't safely build the inventory delta from
1467
 
                    # the source tree.
 
1460
                    if hardlink:
 
1461
                        # see https://bugs.edge.launchpad.net/bzr/+bug/408193
 
1462
                        trace.warning("hardlinking working copy files is not currently "
 
1463
                            "supported in %r" % (wt,))
 
1464
                    accelerator_tree = None
1468
1465
                    delta_from_tree = False
1469
1466
                else:
1470
1467
                    delta_from_tree = True
1769
1766
            return None
1770
1767
        parent_index = self._get_parent_index()
1771
1768
        last_changed_revision = entry[1][parent_index][4]
1772
 
        try:
1773
 
            rev = self._repository.get_revision(last_changed_revision)
1774
 
        except errors.NoSuchRevision:
1775
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
1776
 
        return rev.timestamp
 
1769
        return self._repository.get_revision(last_changed_revision).timestamp
1777
1770
 
1778
1771
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1779
1772
        entry = self._get_entry(file_id=file_id, path=path)
1846
1839
        entry = self._get_entry(file_id=file_id)[1]
1847
1840
        if entry is None:
1848
1841
            raise errors.NoSuchId(tree=self, file_id=file_id)
1849
 
        parent_index = self._get_parent_index()
1850
 
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
 
1842
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
1851
1843
 
1852
1844
    def stored_kind(self, file_id):
1853
1845
        """See Tree.stored_kind"""
1873
1865
            return None
1874
1866
        return ie.executable
1875
1867
 
1876
 
    def is_locked(self):
1877
 
        return self._locked
1878
 
 
1879
1868
    def list_files(self, include_root=False, from_dir=None, recursive=True):
1880
1869
        # We use a standard implementation, because DirStateRevisionTree is
1881
1870
        # dealing with one of the parents of the current state
1894
1883
            yield path, 'V', entry.kind, entry.file_id, entry
1895
1884
 
1896
1885
    def lock_read(self):
1897
 
        """Lock the tree for a set of operations.
1898
 
 
1899
 
        :return: An object with an unlock method which will release the lock
1900
 
            obtained.
1901
 
        """
 
1886
        """Lock the tree for a set of operations."""
1902
1887
        if not self._locked:
1903
1888
            self._repository.lock_read()
1904
1889
            if self._dirstate._lock_token is None:
1905
1890
                self._dirstate.lock_read()
1906
1891
                self._dirstate_locked = True
1907
1892
        self._locked += 1
1908
 
        return self
1909
1893
 
1910
1894
    def _must_be_locked(self):
1911
1895
        if not self._locked:
2001
1985
        return result
2002
1986
 
2003
1987
    @classmethod
2004
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
2005
 
                                                  target):
 
1988
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source, target):
2006
1989
        from bzrlib.tests.test__dirstate_helpers import \
2007
 
            compiled_dirstate_helpers_feature
2008
 
        test_case.requireFeature(compiled_dirstate_helpers_feature)
 
1990
            CompiledDirstateHelpersFeature
 
1991
        if not CompiledDirstateHelpersFeature.available():
 
1992
            from bzrlib.tests import UnavailableFeature
 
1993
            raise UnavailableFeature(CompiledDirstateHelpersFeature)
2009
1994
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
2010
1995
        result = klass.make_source_parent_tree(source, target)
2011
1996
        result[1]._iter_changes = ProcessEntryC
2042
2027
            output. An unversioned file is defined as one with (False, False)
2043
2028
            for the versioned pair.
2044
2029
        """
 
2030
        # NB: show_status depends on being able to pass in non-versioned files
 
2031
        # and report them as unknown
2045
2032
        # TODO: handle extra trees in the dirstate.
2046
2033
        if (extra_trees or specific_files == []):
2047
2034
            # we can't fast-path these cases (yet)