~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

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='.',
 
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
        # recommended replacement for builtins.internal_tree_files
 
366
        if file_list is None or len(file_list) == 0:
 
367
            tree = WorkingTree.open_containing(default_directory)[0]
 
368
            # XXX: doesn't really belong here, and seems to have the strange
 
369
            # side effect of making it return a bunch of files, not the whole
 
370
            # tree -- mbp 20100716
 
371
            if tree.supports_views() and apply_view:
 
372
                view_files = tree.views.lookup_view()
 
373
                if view_files:
 
374
                    file_list = view_files
 
375
                    view_str = views.view_display_str(view_files)
 
376
                    note("Ignoring files outside view. View is %s" % view_str)
 
377
            return tree, file_list
 
378
        tree = WorkingTree.open_containing(file_list[0])[0]
 
379
        return tree, tree.safe_relpath_files(file_list, canonicalize,
 
380
            apply_view=apply_view)
 
381
 
 
382
    def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):
 
383
        """Convert file_list into a list of relpaths in tree.
 
384
 
 
385
        :param self: A tree to operate on.
 
386
        :param file_list: A list of user provided paths or None.
 
387
        :param apply_view: if True and a view is set, apply it or check that
 
388
            specified files are within it
 
389
        :return: A list of relative paths.
 
390
        :raises errors.PathNotChild: When a provided path is in a different self
 
391
            than self.
 
392
        """
 
393
        if file_list is None:
 
394
            return None
 
395
        if self.supports_views() and apply_view:
 
396
            view_files = self.views.lookup_view()
 
397
        else:
 
398
            view_files = []
 
399
        new_list = []
 
400
        # self.relpath exists as a "thunk" to osutils, but canonical_relpath
 
401
        # doesn't - fix that up here before we enter the loop.
 
402
        if canonicalize:
 
403
            fixer = lambda p: osutils.canonical_relpath(self.basedir, p)
 
404
        else:
 
405
            fixer = self.relpath
 
406
        for filename in file_list:
 
407
            relpath = fixer(osutils.dereference_path(filename))
 
408
            if view_files and not osutils.is_inside_any(view_files, relpath):
 
409
                raise errors.FileOutsideView(filename, view_files)
 
410
            new_list.append(relpath)
 
411
        return new_list
 
412
 
 
413
    @staticmethod
356
414
    def open_downlevel(path=None):
357
415
        """Open an unsupported working tree.
358
416
 
1209
1267
                # absolute path
1210
1268
                fap = from_dir_abspath + '/' + f
1211
1269
 
1212
 
                f_ie = inv.get_child(from_dir_id, f)
 
1270
                dir_ie = inv[from_dir_id]
 
1271
                if dir_ie.kind == 'directory':
 
1272
                    f_ie = dir_ie.children.get(f)
 
1273
                else:
 
1274
                    f_ie = None
1213
1275
                if f_ie:
1214
1276
                    c = 'V'
1215
1277
                elif self.is_ignored(fp[1:]):
1216
1278
                    c = 'I'
1217
1279
                else:
1218
 
                    # we may not have found this file, because of a unicode issue
 
1280
                    # we may not have found this file, because of a unicode
 
1281
                    # issue, or because the directory was actually a symlink.
1219
1282
                    f_norm, can_access = osutils.normalized_filename(f)
1220
1283
                    if f == f_norm or not can_access:
1221
1284
                        # No change, so treat this file normally
1264
1327
                stack.pop()
1265
1328
 
1266
1329
    @needs_tree_write_lock
1267
 
    def move(self, from_paths, to_dir=None, after=False, **kwargs):
 
1330
    def move(self, from_paths, to_dir=None, after=False):
1268
1331
        """Rename files.
1269
1332
 
1270
1333
        to_dir must exist in the inventory.
1304
1367
 
1305
1368
        # check for deprecated use of signature
1306
1369
        if to_dir is None:
1307
 
            to_dir = kwargs.get('to_name', None)
1308
 
            if to_dir is None:
1309
 
                raise TypeError('You must supply a target directory')
1310
 
            else:
1311
 
                symbol_versioning.warn('The parameter to_name was deprecated'
1312
 
                                       ' in version 0.13. Use to_dir instead',
1313
 
                                       DeprecationWarning)
1314
 
 
 
1370
            raise TypeError('You must supply a target directory')
1315
1371
        # check destination directory
1316
1372
        if isinstance(from_paths, basestring):
1317
1373
            raise ValueError()
1969
2025
 
1970
2026
        inv_delta = []
1971
2027
 
1972
 
        new_files=set()
 
2028
        all_files = set() # specified and nested files 
1973
2029
        unknown_nested_files=set()
1974
2030
        if to_file is None:
1975
2031
            to_file = sys.stdout
1976
2032
 
 
2033
        files_to_backup = []
 
2034
 
1977
2035
        def recurse_directory_to_add_files(directory):
1978
2036
            # Recurse directory and add all files
1979
2037
            # so we can check if they have changed.
1980
2038
            for parent_info, file_infos in self.walkdirs(directory):
1981
2039
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
1982
2040
                    # Is it versioned or ignored?
1983
 
                    if self.path2id(relpath) or self.is_ignored(relpath):
 
2041
                    if self.path2id(relpath):
1984
2042
                        # Add nested content for deletion.
1985
 
                        new_files.add(relpath)
 
2043
                        all_files.add(relpath)
1986
2044
                    else:
1987
 
                        # Files which are not versioned and not ignored
 
2045
                        # Files which are not versioned
1988
2046
                        # should be treated as unknown.
1989
 
                        unknown_nested_files.add((relpath, None, kind))
 
2047
                        files_to_backup.append(relpath)
1990
2048
 
1991
2049
        for filename in files:
1992
2050
            # Get file name into canonical form.
1993
2051
            abspath = self.abspath(filename)
1994
2052
            filename = self.relpath(abspath)
1995
2053
            if len(filename) > 0:
1996
 
                new_files.add(filename)
 
2054
                all_files.add(filename)
1997
2055
                recurse_directory_to_add_files(filename)
1998
2056
 
1999
 
        files = list(new_files)
 
2057
        files = list(all_files)
2000
2058
 
2001
2059
        if len(files) == 0:
2002
2060
            return # nothing to do
2006
2064
 
2007
2065
        # Bail out if we are going to delete files we shouldn't
2008
2066
        if not keep_files and not force:
2009
 
            has_changed_files = len(unknown_nested_files) > 0
2010
 
            if not has_changed_files:
2011
 
                for (file_id, path, content_change, versioned, parent_id, name,
2012
 
                     kind, executable) in self.iter_changes(self.basis_tree(),
2013
 
                         include_unchanged=True, require_versioned=False,
2014
 
                         want_unversioned=True, specific_files=files):
2015
 
                    if versioned == (False, False):
2016
 
                        # The record is unknown ...
2017
 
                        if not self.is_ignored(path[1]):
2018
 
                            # ... but not ignored
2019
 
                            has_changed_files = True
2020
 
                            break
2021
 
                    elif (content_change and (kind[1] is not None) and
2022
 
                            osutils.is_inside_any(files, path[1])):
2023
 
                        # Versioned and changed, but not deleted, and still
2024
 
                        # in one of the dirs to be deleted.
2025
 
                        has_changed_files = True
2026
 
                        break
 
2067
            for (file_id, path, content_change, versioned, parent_id, name,
 
2068
                 kind, executable) in self.iter_changes(self.basis_tree(),
 
2069
                     include_unchanged=True, require_versioned=False,
 
2070
                     want_unversioned=True, specific_files=files):
 
2071
                if versioned[0] == False:
 
2072
                    # The record is unknown or newly added
 
2073
                    files_to_backup.append(path[1])
 
2074
                elif (content_change and (kind[1] is not None) and
 
2075
                        osutils.is_inside_any(files, path[1])):
 
2076
                    # Versioned and changed, but not deleted, and still
 
2077
                    # in one of the dirs to be deleted.
 
2078
                    files_to_backup.append(path[1])
2027
2079
 
2028
 
            if has_changed_files:
2029
 
                # Make delta show ALL applicable changes in error message.
2030
 
                tree_delta = self.changes_from(self.basis_tree(),
2031
 
                    require_versioned=False, want_unversioned=True,
2032
 
                    specific_files=files)
2033
 
                for unknown_file in unknown_nested_files:
2034
 
                    if unknown_file not in tree_delta.unversioned:
2035
 
                        tree_delta.unversioned.extend((unknown_file,))
2036
 
                raise errors.BzrRemoveChangedFilesError(tree_delta)
 
2080
        def backup(file_to_backup):
 
2081
            backup_name = self.bzrdir.generate_backup_name(file_to_backup)
 
2082
            osutils.rename(abs_path, self.abspath(backup_name))
 
2083
            return "removed %s (but kept a copy: %s)" % (file_to_backup, backup_name)
2037
2084
 
2038
2085
        # Build inv_delta and delete files where applicable,
2039
2086
        # do this before any modifications to inventory.
2063
2110
                        len(os.listdir(abs_path)) > 0):
2064
2111
                        if force:
2065
2112
                            osutils.rmtree(abs_path)
 
2113
                            message = "deleted %s" % (f,)
2066
2114
                        else:
2067
 
                            message = "%s is not an empty directory "\
2068
 
                                "and won't be deleted." % (f,)
 
2115
                            message = backup(f)
2069
2116
                    else:
2070
 
                        osutils.delete_any(abs_path)
2071
 
                        message = "deleted %s" % (f,)
 
2117
                        if f in files_to_backup:
 
2118
                            message = backup(f)
 
2119
                        else:
 
2120
                            osutils.delete_any(abs_path)
 
2121
                            message = "deleted %s" % (f,)
2072
2122
                elif message is not None:
2073
2123
                    # Only care if we haven't done anything yet.
2074
2124
                    message = "%s does not exist." % (f,)