~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Jelmer Vernooij
  • Date: 2010-12-20 02:23:31 UTC
  • mto: This revision was merged to the branch mainline in revision 5577.
  • Revision ID: jelmer@samba.org-20101220022331-hbm91o1ps9gjrlns
Add testr magic for bzr selftest --list

Show diffs side-by-side

added added

removed removed

Lines of Context:
49
49
    branch,
50
50
    bzrdir,
51
51
    conflicts as _mod_conflicts,
 
52
    controldir,
52
53
    errors,
53
54
    generate_ids,
54
55
    globbing,
168
169
 
169
170
 
170
171
class WorkingTree(bzrlib.mutabletree.MutableTree,
171
 
    bzrdir.ControlComponent):
 
172
    controldir.ControlComponent):
172
173
    """Working copy tree.
173
174
 
174
175
    The inventory is held in the `Branch` working-inventory, and the
349
350
        if path is None:
350
351
            path = osutils.getcwd()
351
352
        control, relpath = bzrdir.BzrDir.open_containing(path)
352
 
 
353
353
        return control.open_workingtree(), relpath
354
354
 
355
355
    @staticmethod
 
356
    def open_containing_paths(file_list, default_directory=None,
 
357
                              canonicalize=True, apply_view=True):
 
358
        """Open the WorkingTree that contains a set of paths.
 
359
 
 
360
        Fail if the paths given are not all in a single tree.
 
361
 
 
362
        This is used for the many command-line interfaces that take a list of
 
363
        any number of files and that require they all be in the same tree.
 
364
        """
 
365
        if default_directory is None:
 
366
            default_directory = u'.'
 
367
        # recommended replacement for builtins.internal_tree_files
 
368
        if file_list is None or len(file_list) == 0:
 
369
            tree = WorkingTree.open_containing(default_directory)[0]
 
370
            # XXX: doesn't really belong here, and seems to have the strange
 
371
            # side effect of making it return a bunch of files, not the whole
 
372
            # tree -- mbp 20100716
 
373
            if tree.supports_views() and apply_view:
 
374
                view_files = tree.views.lookup_view()
 
375
                if view_files:
 
376
                    file_list = view_files
 
377
                    view_str = views.view_display_str(view_files)
 
378
                    note("Ignoring files outside view. View is %s" % view_str)
 
379
            return tree, file_list
 
380
        if default_directory == u'.':
 
381
            seed = file_list[0]
 
382
        else:
 
383
            seed = default_directory
 
384
            file_list = [osutils.pathjoin(default_directory, f)
 
385
                         for f in file_list]
 
386
        tree = WorkingTree.open_containing(seed)[0]
 
387
        return tree, tree.safe_relpath_files(file_list, canonicalize,
 
388
                                             apply_view=apply_view)
 
389
 
 
390
    def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):
 
391
        """Convert file_list into a list of relpaths in tree.
 
392
 
 
393
        :param self: A tree to operate on.
 
394
        :param file_list: A list of user provided paths or None.
 
395
        :param apply_view: if True and a view is set, apply it or check that
 
396
            specified files are within it
 
397
        :return: A list of relative paths.
 
398
        :raises errors.PathNotChild: When a provided path is in a different self
 
399
            than self.
 
400
        """
 
401
        if file_list is None:
 
402
            return None
 
403
        if self.supports_views() and apply_view:
 
404
            view_files = self.views.lookup_view()
 
405
        else:
 
406
            view_files = []
 
407
        new_list = []
 
408
        # self.relpath exists as a "thunk" to osutils, but canonical_relpath
 
409
        # doesn't - fix that up here before we enter the loop.
 
410
        if canonicalize:
 
411
            fixer = lambda p: osutils.canonical_relpath(self.basedir, p)
 
412
        else:
 
413
            fixer = self.relpath
 
414
        for filename in file_list:
 
415
            relpath = fixer(osutils.dereference_path(filename))
 
416
            if view_files and not osutils.is_inside_any(view_files, relpath):
 
417
                raise errors.FileOutsideView(filename, view_files)
 
418
            new_list.append(relpath)
 
419
        return new_list
 
420
 
 
421
    @staticmethod
356
422
    def open_downlevel(path=None):
357
423
        """Open an unsupported working tree.
358
424
 
1269
1335
                stack.pop()
1270
1336
 
1271
1337
    @needs_tree_write_lock
1272
 
    def move(self, from_paths, to_dir=None, after=False, **kwargs):
 
1338
    def move(self, from_paths, to_dir=None, after=False):
1273
1339
        """Rename files.
1274
1340
 
1275
1341
        to_dir must exist in the inventory.
1309
1375
 
1310
1376
        # check for deprecated use of signature
1311
1377
        if to_dir is None:
1312
 
            to_dir = kwargs.get('to_name', None)
1313
 
            if to_dir is None:
1314
 
                raise TypeError('You must supply a target directory')
1315
 
            else:
1316
 
                symbol_versioning.warn('The parameter to_name was deprecated'
1317
 
                                       ' in version 0.13. Use to_dir instead',
1318
 
                                       DeprecationWarning)
1319
 
 
 
1378
            raise TypeError('You must supply a target directory')
1320
1379
        # check destination directory
1321
1380
        if isinstance(from_paths, basestring):
1322
1381
            raise ValueError()
1612
1671
 
1613
1672
    @needs_write_lock
1614
1673
    def pull(self, source, overwrite=False, stop_revision=None,
1615
 
             change_reporter=None, possible_transports=None, local=False):
 
1674
             change_reporter=None, possible_transports=None, local=False,
 
1675
             show_base=False):
1616
1676
        source.lock_read()
1617
1677
        try:
1618
1678
            old_revision_info = self.branch.last_revision_info()
1632
1692
                                basis_tree,
1633
1693
                                this_tree=self,
1634
1694
                                pb=None,
1635
 
                                change_reporter=change_reporter)
 
1695
                                change_reporter=change_reporter,
 
1696
                                show_base=show_base)
1636
1697
                    basis_root_id = basis_tree.get_root_id()
1637
1698
                    new_root_id = new_basis_tree.get_root_id()
1638
1699
                    if basis_root_id != new_root_id:
1974
2035
 
1975
2036
        inv_delta = []
1976
2037
 
1977
 
        new_files=set()
 
2038
        all_files = set() # specified and nested files 
1978
2039
        unknown_nested_files=set()
1979
2040
        if to_file is None:
1980
2041
            to_file = sys.stdout
1981
2042
 
 
2043
        files_to_backup = []
 
2044
 
1982
2045
        def recurse_directory_to_add_files(directory):
1983
2046
            # Recurse directory and add all files
1984
2047
            # so we can check if they have changed.
1985
2048
            for parent_info, file_infos in self.walkdirs(directory):
1986
2049
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1987
2050
                    # Is it versioned or ignored?
1988
 
                    if self.path2id(relpath) or self.is_ignored(relpath):
 
2051
                    if self.path2id(relpath):
1989
2052
                        # Add nested content for deletion.
1990
 
                        new_files.add(relpath)
 
2053
                        all_files.add(relpath)
1991
2054
                    else:
1992
 
                        # Files which are not versioned and not ignored
 
2055
                        # Files which are not versioned
1993
2056
                        # should be treated as unknown.
1994
 
                        unknown_nested_files.add((relpath, None, kind))
 
2057
                        files_to_backup.append(relpath)
1995
2058
 
1996
2059
        for filename in files:
1997
2060
            # Get file name into canonical form.
1998
2061
            abspath = self.abspath(filename)
1999
2062
            filename = self.relpath(abspath)
2000
2063
            if len(filename) > 0:
2001
 
                new_files.add(filename)
 
2064
                all_files.add(filename)
2002
2065
                recurse_directory_to_add_files(filename)
2003
2066
 
2004
 
        files = list(new_files)
 
2067
        files = list(all_files)
2005
2068
 
2006
2069
        if len(files) == 0:
2007
2070
            return # nothing to do
2011
2074
 
2012
2075
        # Bail out if we are going to delete files we shouldn't
2013
2076
        if not keep_files and not force:
2014
 
            has_changed_files = len(unknown_nested_files) > 0
2015
 
            if not has_changed_files:
2016
 
                for (file_id, path, content_change, versioned, parent_id, name,
2017
 
                     kind, executable) in self.iter_changes(self.basis_tree(),
2018
 
                         include_unchanged=True, require_versioned=False,
2019
 
                         want_unversioned=True, specific_files=files):
2020
 
                    if versioned == (False, False):
2021
 
                        # The record is unknown ...
2022
 
                        if not self.is_ignored(path[1]):
2023
 
                            # ... but not ignored
2024
 
                            has_changed_files = True
2025
 
                            break
2026
 
                    elif (content_change and (kind[1] is not None) and
2027
 
                            osutils.is_inside_any(files, path[1])):
2028
 
                        # Versioned and changed, but not deleted, and still
2029
 
                        # in one of the dirs to be deleted.
2030
 
                        has_changed_files = True
2031
 
                        break
 
2077
            for (file_id, path, content_change, versioned, parent_id, name,
 
2078
                 kind, executable) in self.iter_changes(self.basis_tree(),
 
2079
                     include_unchanged=True, require_versioned=False,
 
2080
                     want_unversioned=True, specific_files=files):
 
2081
                if versioned[0] == False:
 
2082
                    # The record is unknown or newly added
 
2083
                    files_to_backup.append(path[1])
 
2084
                elif (content_change and (kind[1] is not None) and
 
2085
                        osutils.is_inside_any(files, path[1])):
 
2086
                    # Versioned and changed, but not deleted, and still
 
2087
                    # in one of the dirs to be deleted.
 
2088
                    files_to_backup.append(path[1])
2032
2089
 
2033
 
            if has_changed_files:
2034
 
                # Make delta show ALL applicable changes in error message.
2035
 
                tree_delta = self.changes_from(self.basis_tree(),
2036
 
                    require_versioned=False, want_unversioned=True,
2037
 
                    specific_files=files)
2038
 
                for unknown_file in unknown_nested_files:
2039
 
                    if unknown_file not in tree_delta.unversioned:
2040
 
                        tree_delta.unversioned.extend((unknown_file,))
2041
 
                raise errors.BzrRemoveChangedFilesError(tree_delta)
 
2090
        def backup(file_to_backup):
 
2091
            backup_name = self.bzrdir._available_backup_name(file_to_backup)
 
2092
            osutils.rename(abs_path, self.abspath(backup_name))
 
2093
            return "removed %s (but kept a copy: %s)" % (file_to_backup,
 
2094
                                                         backup_name)
2042
2095
 
2043
2096
        # Build inv_delta and delete files where applicable,
2044
2097
        # do this before any modifications to inventory.
2068
2121
                        len(os.listdir(abs_path)) > 0):
2069
2122
                        if force:
2070
2123
                            osutils.rmtree(abs_path)
 
2124
                            message = "deleted %s" % (f,)
2071
2125
                        else:
2072
 
                            message = "%s is not an empty directory "\
2073
 
                                "and won't be deleted." % (f,)
 
2126
                            message = backup(f)
2074
2127
                    else:
2075
 
                        osutils.delete_any(abs_path)
2076
 
                        message = "deleted %s" % (f,)
 
2128
                        if f in files_to_backup:
 
2129
                            message = backup(f)
 
2130
                        else:
 
2131
                            osutils.delete_any(abs_path)
 
2132
                            message = "deleted %s" % (f,)
2077
2133
                elif message is not None:
2078
2134
                    # Only care if we haven't done anything yet.
2079
2135
                    message = "%s does not exist." % (f,)
2216
2272
    _marker = object()
2217
2273
 
2218
2274
    def update(self, change_reporter=None, possible_transports=None,
2219
 
               revision=None, old_tip=_marker):
 
2275
               revision=None, old_tip=_marker, show_base=False):
2220
2276
        """Update a working tree along its branch.
2221
2277
 
2222
2278
        This will update the branch if its bound too, which means we have
2259
2315
            else:
2260
2316
                if old_tip is self._marker:
2261
2317
                    old_tip = None
2262
 
            return self._update_tree(old_tip, change_reporter, revision)
 
2318
            return self._update_tree(old_tip, change_reporter, revision, show_base)
2263
2319
        finally:
2264
2320
            self.unlock()
2265
2321
 
2266
2322
    @needs_tree_write_lock
2267
 
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None):
 
2323
    def _update_tree(self, old_tip=None, change_reporter=None, revision=None,
 
2324
                     show_base=False):
2268
2325
        """Update a tree to the master branch.
2269
2326
 
2270
2327
        :param old_tip: if supplied, the previous tip revision the branch,
2297
2354
            other_tree = self.branch.repository.revision_tree(old_tip)
2298
2355
            nb_conflicts = merge.merge_inner(self.branch, other_tree,
2299
2356
                                             base_tree, this_tree=self,
2300
 
                                             change_reporter=change_reporter)
 
2357
                                             change_reporter=change_reporter,
 
2358
                                             show_base=show_base)
2301
2359
            if nb_conflicts:
2302
2360
                self.add_parent_tree((old_tip, other_tree))
2303
2361
                trace.note('Rerun update after fixing the conflicts.')
2327
2385
 
2328
2386
            nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
2329
2387
                                             this_tree=self,
2330
 
                                             change_reporter=change_reporter)
 
2388
                                             change_reporter=change_reporter,
 
2389
                                             show_base=show_base)
2331
2390
            self.set_last_revision(revision)
2332
2391
            # TODO - dedup parents list with things merged by pull ?
2333
2392
            # reuse the tree we've updated to to set the basis: