~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Martin Pool
  • Date: 2010-06-02 04:50:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5279.
  • Revision ID: mbp@canonical.com-20100602045035-sccetnnwizmu01us
Don't say 'Linux' except when specifically talking about the kernel

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,
53
52
    errors,
54
53
    generate_ids,
55
54
    globbing,
62
61
    revisiontree,
63
62
    trace,
64
63
    transform,
65
 
    transport,
66
64
    ui,
67
65
    views,
68
66
    xml5,
69
67
    xml7,
70
68
    )
 
69
import bzrlib.branch
 
70
from bzrlib.transport import get_transport
71
71
from bzrlib.workingtree_4 import (
72
72
    WorkingTreeFormat4,
73
73
    WorkingTreeFormat5,
169
169
 
170
170
 
171
171
class WorkingTree(bzrlib.mutabletree.MutableTree,
172
 
    controldir.ControlComponent):
 
172
    bzrdir.ControlComponent):
173
173
    """Working copy tree.
174
174
 
175
175
    The inventory is held in the `Branch` working-inventory, and the
177
177
 
178
178
    It is possible for a `WorkingTree` to have a filename which is
179
179
    not listed in the Inventory and vice versa.
180
 
 
181
 
    :ivar basedir: The root of the tree on disk. This is a unicode path object
182
 
        (as opposed to a URL).
183
180
    """
184
181
 
185
182
    # override this to set the strategy for storing views
350
347
        if path is None:
351
348
            path = osutils.getcwd()
352
349
        control, relpath = bzrdir.BzrDir.open_containing(path)
 
350
 
353
351
        return control.open_workingtree(), relpath
354
352
 
355
353
    @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
414
354
    def open_downlevel(path=None):
415
355
        """Open an unsupported working tree.
416
356
 
429
369
                return True, None
430
370
            else:
431
371
                return True, tree
432
 
        t = transport.get_transport(location)
433
 
        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
 
372
        transport = get_transport(location)
 
373
        iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
434
374
                                              list_current=list_current)
435
 
        return [tr for tr in iterator if tr is not None]
 
375
        return [t for t in iterator if t is not None]
436
376
 
437
377
    # should be deprecated - this is slow and in any case treating them as a
438
378
    # container is (we now know) bad style -- mbp 20070302
1267
1207
                # absolute path
1268
1208
                fap = from_dir_abspath + '/' + f
1269
1209
 
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
 
1210
                f_ie = inv.get_child(from_dir_id, f)
1275
1211
                if f_ie:
1276
1212
                    c = 'V'
1277
1213
                elif self.is_ignored(fp[1:]):
1278
1214
                    c = 'I'
1279
1215
                else:
1280
 
                    # we may not have found this file, because of a unicode
1281
 
                    # issue, or because the directory was actually a symlink.
 
1216
                    # we may not have found this file, because of a unicode issue
1282
1217
                    f_norm, can_access = osutils.normalized_filename(f)
1283
1218
                    if f == f_norm or not can_access:
1284
1219
                        # No change, so treat this file normally
1327
1262
                stack.pop()
1328
1263
 
1329
1264
    @needs_tree_write_lock
1330
 
    def move(self, from_paths, to_dir=None, after=False):
 
1265
    def move(self, from_paths, to_dir=None, after=False, **kwargs):
1331
1266
        """Rename files.
1332
1267
 
1333
1268
        to_dir must exist in the inventory.
1367
1302
 
1368
1303
        # check for deprecated use of signature
1369
1304
        if to_dir is None:
1370
 
            raise TypeError('You must supply a target directory')
 
1305
            to_dir = kwargs.get('to_name', None)
 
1306
            if to_dir is None:
 
1307
                raise TypeError('You must supply a target directory')
 
1308
            else:
 
1309
                symbol_versioning.warn('The parameter to_name was deprecated'
 
1310
                                       ' in version 0.13. Use to_dir instead',
 
1311
                                       DeprecationWarning)
 
1312
 
1371
1313
        # check destination directory
1372
1314
        if isinstance(from_paths, basestring):
1373
1315
            raise ValueError()
2025
1967
 
2026
1968
        inv_delta = []
2027
1969
 
2028
 
        all_files = set() # specified and nested files 
 
1970
        new_files=set()
2029
1971
        unknown_nested_files=set()
2030
1972
        if to_file is None:
2031
1973
            to_file = sys.stdout
2032
1974
 
2033
 
        files_to_backup = []
2034
 
 
2035
1975
        def recurse_directory_to_add_files(directory):
2036
1976
            # Recurse directory and add all files
2037
1977
            # so we can check if they have changed.
2038
1978
            for parent_info, file_infos in self.walkdirs(directory):
2039
1979
                for relpath, basename, kind, lstat, fileid, kind in file_infos:
2040
1980
                    # Is it versioned or ignored?
2041
 
                    if self.path2id(relpath):
 
1981
                    if self.path2id(relpath) or self.is_ignored(relpath):
2042
1982
                        # Add nested content for deletion.
2043
 
                        all_files.add(relpath)
 
1983
                        new_files.add(relpath)
2044
1984
                    else:
2045
 
                        # Files which are not versioned
 
1985
                        # Files which are not versioned and not ignored
2046
1986
                        # should be treated as unknown.
2047
 
                        files_to_backup.append(relpath)
 
1987
                        unknown_nested_files.add((relpath, None, kind))
2048
1988
 
2049
1989
        for filename in files:
2050
1990
            # Get file name into canonical form.
2051
1991
            abspath = self.abspath(filename)
2052
1992
            filename = self.relpath(abspath)
2053
1993
            if len(filename) > 0:
2054
 
                all_files.add(filename)
 
1994
                new_files.add(filename)
2055
1995
                recurse_directory_to_add_files(filename)
2056
1996
 
2057
 
        files = list(all_files)
 
1997
        files = list(new_files)
2058
1998
 
2059
1999
        if len(files) == 0:
2060
2000
            return # nothing to do
2064
2004
 
2065
2005
        # Bail out if we are going to delete files we shouldn't
2066
2006
        if not keep_files and not force:
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])
 
2007
            has_changed_files = len(unknown_nested_files) > 0
 
2008
            if not has_changed_files:
 
2009
                for (file_id, path, content_change, versioned, parent_id, name,
 
2010
                     kind, executable) in self.iter_changes(self.basis_tree(),
 
2011
                         include_unchanged=True, require_versioned=False,
 
2012
                         want_unversioned=True, specific_files=files):
 
2013
                    if versioned == (False, False):
 
2014
                        # The record is unknown ...
 
2015
                        if not self.is_ignored(path[1]):
 
2016
                            # ... but not ignored
 
2017
                            has_changed_files = True
 
2018
                            break
 
2019
                    elif (content_change and (kind[1] is not None) and
 
2020
                            osutils.is_inside_any(files, path[1])):
 
2021
                        # Versioned and changed, but not deleted, and still
 
2022
                        # in one of the dirs to be deleted.
 
2023
                        has_changed_files = True
 
2024
                        break
2079
2025
 
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)
 
2026
            if has_changed_files:
 
2027
                # Make delta show ALL applicable changes in error message.
 
2028
                tree_delta = self.changes_from(self.basis_tree(),
 
2029
                    require_versioned=False, want_unversioned=True,
 
2030
                    specific_files=files)
 
2031
                for unknown_file in unknown_nested_files:
 
2032
                    if unknown_file not in tree_delta.unversioned:
 
2033
                        tree_delta.unversioned.extend((unknown_file,))
 
2034
                raise errors.BzrRemoveChangedFilesError(tree_delta)
2084
2035
 
2085
2036
        # Build inv_delta and delete files where applicable,
2086
2037
        # do this before any modifications to inventory.
2110
2061
                        len(os.listdir(abs_path)) > 0):
2111
2062
                        if force:
2112
2063
                            osutils.rmtree(abs_path)
2113
 
                            message = "deleted %s" % (f,)
2114
2064
                        else:
2115
 
                            message = backup(f)
 
2065
                            message = "%s is not an empty directory "\
 
2066
                                "and won't be deleted." % (f,)
2116
2067
                    else:
2117
 
                        if f in files_to_backup:
2118
 
                            message = backup(f)
2119
 
                        else:
2120
 
                            osutils.delete_any(abs_path)
2121
 
                            message = "deleted %s" % (f,)
 
2068
                        osutils.delete_any(abs_path)
 
2069
                        message = "deleted %s" % (f,)
2122
2070
                elif message is not None:
2123
2071
                    # Only care if we haven't done anything yet.
2124
2072
                    message = "%s does not exist." % (f,)