← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Frank Aspell
  • Date: 2009-02-22 16:54:02 UTC
  • mto: This revision was merged to the branch mainline in revision 4256.
  • Revision ID: frankaspell@googlemail.com-20090222165402-2myrucnu7er5w4ha
Fixing various typos

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mutabletree.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""MutableTree object.
18
18
 
23
23
from bzrlib.lazy_import import lazy_import
24
24
lazy_import(globals(), """
25
25
import os
26
 
import re
27
26
 
28
27
from bzrlib import (
29
28
    add,
30
29
    bzrdir,
 
30
    hooks,
 
31
    )
 
32
from bzrlib.osutils import dirname
 
33
from bzrlib.revisiontree import RevisionTree
 
34
from bzrlib.trace import mutter, warning
 
35
""")
 
36
 
 
37
from bzrlib import (
31
38
    errors,
32
 
    hooks,
33
39
    osutils,
34
 
    revisiontree,
35
 
    symbol_versioning,
36
 
    trace,
37
40
    tree,
38
41
    )
39
 
""")
40
 
 
41
42
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
43
from bzrlib.osutils import splitpath
 
44
from bzrlib.symbol_versioning import DEPRECATED_PARAMETER
42
45
 
43
46
 
44
47
def needs_tree_write_lock(unbound):
66
69
    entirely in memory.
67
70
 
68
71
    For now, we are not treating MutableTree as an interface to provide
69
 
    conformance tests for - rather we are testing MemoryTree specifically, and
 
72
    conformance tests for - rather we are testing MemoryTree specifically, and 
70
73
    interface testing implementations of WorkingTree.
71
74
 
72
75
    A mutable tree always has an associated Branch and BzrDir object - the
126
129
            # generic constraint checks:
127
130
            if self.is_control_filename(f):
128
131
                raise errors.ForbiddenControlFileError(filename=f)
129
 
            fp = osutils.splitpath(f)
130
 
        # fill out file kinds for all files [not needed when we stop
 
132
            fp = splitpath(f)
 
133
        # fill out file kinds for all files [not needed when we stop 
131
134
        # caring about the instantaneous file kind within a uncommmitted tree
132
135
        #
133
136
        self._gather_kinds(files, kinds)
189
192
            revprops['branch-nick'] = self.branch._get_nick(
190
193
                kwargs.get('local', False),
191
194
                possible_master_transports)
192
 
        authors = kwargs.pop('authors', None)
193
195
        author = kwargs.pop('author', None)
194
 
        if authors is not None:
195
 
            if author is not None:
196
 
                raise AssertionError('Specifying both author and authors '
197
 
                        'is not allowed. Specify just authors instead')
198
 
            if 'author' in revprops or 'authors' in revprops:
199
 
                # XXX: maybe we should just accept one of them?
200
 
                raise AssertionError('author property given twice')
201
 
            if authors:
202
 
                for individual in authors:
203
 
                    if '\n' in individual:
204
 
                        raise AssertionError('\\n is not a valid character '
205
 
                                'in an author identity')
206
 
                revprops['authors'] = '\n'.join(authors)
207
196
        if author is not None:
208
 
            symbol_versioning.warn('The parameter author was deprecated'
209
 
                   ' in version 1.13. Use authors instead',
210
 
                   DeprecationWarning)
211
 
            if 'author' in revprops or 'authors' in revprops:
 
197
            if 'author' in revprops:
212
198
                # XXX: maybe we should just accept one of them?
213
199
                raise AssertionError('author property given twice')
214
 
            if '\n' in author:
215
 
                raise AssertionError('\\n is not a valid character '
216
 
                        'in an author identity')
217
 
            revprops['authors'] = author
 
200
            revprops['author'] = author
218
201
        # args for wt.commit start at message from the Commit.commit method,
219
202
        args = (message, ) + args
220
203
        for hook in MutableTree.hooks['start_commit']:
223
206
            revprops=revprops,
224
207
            possible_master_transports=possible_master_transports,
225
208
            *args, **kwargs)
226
 
        post_hook_params = PostCommitHookParams(self)
227
 
        for hook in MutableTree.hooks['post_commit']:
228
 
            hook(post_hook_params)
229
209
        return committed_id
230
210
 
231
211
    def _gather_kinds(self, files, kinds):
232
212
        """Helper function for add - sets the entries of kinds."""
233
213
        raise NotImplementedError(self._gather_kinds)
234
214
 
235
 
    @needs_read_lock
236
 
    def has_changes(self, _from_tree=None):
237
 
        """Quickly check that the tree contains at least one commitable change.
238
 
 
239
 
        :param _from_tree: tree to compare against to find changes (default to
240
 
            the basis tree and is intended to be used by tests).
241
 
 
242
 
        :return: True if a change is found. False otherwise
243
 
        """
244
 
        # Check pending merges
245
 
        if len(self.get_parent_ids()) > 1:
246
 
            return True
247
 
        if _from_tree is None:
248
 
            _from_tree = self.basis_tree()
249
 
        changes = self.iter_changes(_from_tree)
250
 
        try:
251
 
            change = changes.next()
252
 
            # Exclude root (talk about black magic... --vila 20090629)
253
 
            if change[4] == (None, None):
254
 
                change = changes.next()
255
 
            return True
256
 
        except StopIteration:
257
 
            # No changes
258
 
            return False
259
 
 
260
 
    @needs_read_lock
261
 
    def check_changed_or_out_of_date(self, strict, opt_name,
262
 
                                     more_error, more_warning):
263
 
        """Check the tree for uncommitted changes and branch synchronization.
264
 
 
265
 
        If strict is None and not set in the config files, a warning is issued.
266
 
        If strict is True, an error is raised.
267
 
        If strict is False, no checks are done and no warning is issued.
268
 
 
269
 
        :param strict: True, False or None, searched in branch config if None.
270
 
 
271
 
        :param opt_name: strict option name to search in config file.
272
 
 
273
 
        :param more_error: Details about how to avoid the check.
274
 
 
275
 
        :param more_warning: Details about what is happening.
276
 
        """
277
 
        if strict is None:
278
 
            strict = self.branch.get_config().get_user_option_as_bool(opt_name)
279
 
        if strict is not False:
280
 
            err_class = None
281
 
            if (self.has_changes()):
282
 
                err_class = errors.UncommittedChanges
283
 
            elif self.last_revision() != self.branch.last_revision():
284
 
                # The tree has lost sync with its branch, there is little
285
 
                # chance that the user is aware of it but he can still force
286
 
                # the action with --no-strict
287
 
                err_class = errors.OutOfDateTree
288
 
            if err_class is not None:
289
 
                if strict is None:
290
 
                    err = err_class(self, more=more_warning)
291
 
                    # We don't want to interrupt the user if he expressed no
292
 
                    # preference about strict.
293
 
                    trace.warning('%s', err._format())
294
 
                else:
295
 
                    err = err_class(self, more=more_error)
296
 
                    raise err
 
215
    def get_file_with_stat(self, file_id, path=None):
 
216
        """Get a file handle and stat object for file_id.
 
217
 
 
218
        The default implementation returns (self.get_file, None) for backwards
 
219
        compatibility.
 
220
 
 
221
        :param file_id: The file id to read.
 
222
        :param path: The path of the file, if it is known.
 
223
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
 
224
            no stat facility, or need for a stat cache feedback during commit,
 
225
            it may return None for the second element of the tuple.
 
226
        """
 
227
        return (self.get_file(file_id, path), None)
297
228
 
298
229
    @needs_read_lock
299
230
    def last_revision(self):
302
233
        In early tree formats the result of last_revision is the same as the
303
234
        branch last_revision, but that is no longer the case for modern tree
304
235
        formats.
305
 
 
 
236
        
306
237
        last_revision returns the left most parent id, or None if there are no
307
238
        parents.
308
239
 
325
256
    def lock_write(self):
326
257
        """Lock the tree and its branch. This allows mutating calls to be made.
327
258
 
328
 
        Some mutating methods will take out implicit write locks, but in
 
259
        Some mutating methods will take out implicit write locks, but in 
329
260
        general you should always obtain a write lock before calling mutating
330
261
        methods on a tree.
331
262
        """
347
278
        The intent of this function is to allow trees that have a hashcache to
348
279
        update the hashcache during commit. If the observed file is too new
349
280
        (based on the stat_value) to be safely hash-cached the tree will ignore
350
 
        it.
 
281
        it. 
351
282
 
352
283
        The default implementation does nothing.
353
284
 
367
298
    @needs_write_lock
368
299
    def put_file_bytes_non_atomic(self, file_id, bytes):
369
300
        """Update the content of a file in the tree.
370
 
 
 
301
        
371
302
        Note that the file is written in-place rather than being
372
303
        written to a temporary location and renamed. As a consequence,
373
304
        readers can potentially see the file half-written.
387
318
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
388
319
        """Set the parents of the working tree.
389
320
 
390
 
        :param parents_list: A list of (revision_id, tree) tuples.
 
321
        :param parents_list: A list of (revision_id, tree) tuples. 
391
322
            If tree is None, then that element is treated as an unreachable
392
323
            parent tree - i.e. a ghost.
393
324
        """
401
332
        For the specific behaviour see the help for cmd_add().
402
333
 
403
334
        :param action: A reporter to be called with the inventory, parent_ie,
404
 
            path and kind of the path being added. It may return a file_id if
 
335
            path and kind of the path being added. It may return a file_id if 
405
336
            a specific one should be used.
406
337
        :param save: Save the inventory after completing the adds. If False
407
338
            this provides dry-run functionality by doing the add and not saving
415
346
        from bzrlib.inventory import InventoryEntry
416
347
        if action is None:
417
348
            action = add.AddAction()
418
 
 
 
349
        
419
350
        if not file_list:
420
351
            # no paths supplied: add the entire tree.
421
 
            # FIXME: this assumes we are running in a working tree subdir :-/
422
 
            # -- vila 20100208
423
352
            file_list = [u'.']
424
353
        # mutter("smart add of %r")
425
354
        inv = self.inventory
427
356
        ignored = {}
428
357
        dirs_to_add = []
429
358
        user_dirs = set()
430
 
        conflicts_related = set()
431
 
        # Not all mutable trees can have conflicts
432
 
        if getattr(self, 'conflicts', None) is not None:
433
 
            # Collect all related files without checking whether they exist or
434
 
            # are versioned. It's cheaper to do that once for all conflicts
435
 
            # than trying to find the relevant conflict for each added file.
436
 
            for c in self.conflicts():
437
 
                conflicts_related.update(c.associated_filenames())
438
359
 
439
 
        # validate user file paths and convert all paths to tree
 
360
        # validate user file paths and convert all paths to tree 
440
361
        # relative : it's cheaper to make a tree relative path an abspath
441
362
        # than to convert an abspath to tree relative, and it's cheaper to
442
363
        # perform the canonicalization in bulk.
443
364
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
444
365
            rf = _FastPath(filepath)
445
 
            # validate user parameters. Our recursive code avoids adding new
446
 
            # files that need such validation
 
366
            # validate user parameters. Our recursive code avoids adding new files
 
367
            # that need such validation 
447
368
            if self.is_control_filename(rf.raw_path):
448
369
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
449
 
 
 
370
            
450
371
            abspath = self.abspath(rf.raw_path)
451
372
            kind = osutils.file_kind(abspath)
452
373
            if kind == 'directory':
455
376
            else:
456
377
                if not InventoryEntry.versionable_kind(kind):
457
378
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
458
 
            # ensure the named path is added, so that ignore rules in the later
459
 
            # directory walk dont skip it.
460
 
            # we dont have a parent ie known yet.: use the relatively slower
461
 
            # inventory probing method
 
379
            # ensure the named path is added, so that ignore rules in the later directory
 
380
            # walk dont skip it.
 
381
            # we dont have a parent ie known yet.: use the relatively slower inventory 
 
382
            # probing method
462
383
            versioned = inv.has_filename(rf.raw_path)
463
384
            if versioned:
464
385
                continue
480
401
                dirs_to_add.append((path, None))
481
402
            prev_dir = path.raw_path
482
403
 
483
 
        illegalpath_re = re.compile(r'[\r\n]')
484
404
        # dirs_to_add is initialised to a list of directories, but as we scan
485
405
        # directories we append files to it.
486
406
        # XXX: We should determine kind of files when we scan them rather than
495
415
            kind = osutils.file_kind(abspath)
496
416
 
497
417
            if not InventoryEntry.versionable_kind(kind):
498
 
                trace.warning("skipping %s (can't add file of kind '%s')",
499
 
                              abspath, kind)
500
 
                continue
501
 
            if illegalpath_re.search(directory.raw_path):
502
 
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
503
 
                continue
504
 
            if directory.raw_path in conflicts_related:
505
 
                # If the file looks like one generated for a conflict, don't
506
 
                # add it.
507
 
                trace.warning(
508
 
                    'skipping %s (generated to help resolve conflicts)',
509
 
                    abspath)
 
418
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
510
419
                continue
511
420
 
512
421
            if parent_ie is not None:
513
422
                versioned = directory.base_path in parent_ie.children
514
423
            else:
515
 
                # without the parent ie, use the relatively slower inventory
 
424
                # without the parent ie, use the relatively slower inventory 
516
425
                # probing method
517
426
                versioned = inv.has_filename(
518
427
                        self._fix_case_of_inventory_path(directory.raw_path))
535
444
                pass
536
445
                # mutter("%r is already versioned", abspath)
537
446
            elif sub_tree:
538
 
                # XXX: This is wrong; people *might* reasonably be trying to
539
 
                # add subtrees as subtrees.  This should probably only be done
540
 
                # in formats which can represent subtrees, and even then
541
 
                # perhaps only when the user asked to add subtrees.  At the
542
 
                # moment you can add them specially through 'join --reference',
543
 
                # which is perhaps reasonable: adding a new reference is a
544
 
                # special operation and can have a special behaviour.  mbp
545
 
                # 20070306
546
 
                trace.mutter("%r is a nested bzr tree", abspath)
 
447
                # XXX: This is wrong; people *might* reasonably be trying to add
 
448
                # subtrees as subtrees.  This should probably only be done in formats 
 
449
                # which can represent subtrees, and even then perhaps only when
 
450
                # the user asked to add subtrees.  At the moment you can add them
 
451
                # specially through 'join --reference', which is perhaps
 
452
                # reasonable: adding a new reference is a special operation and
 
453
                # can have a special behaviour.  mbp 20070306
 
454
                mutter("%r is a nested bzr tree", abspath)
547
455
            else:
548
456
                _add_one(self, inv, parent_ie, directory, kind, action)
549
457
                added.append(directory.raw_path)
553
461
                    # must be present:
554
462
                    this_ie = parent_ie.children[directory.base_path]
555
463
                else:
556
 
                    # without the parent ie, use the relatively slower inventory
 
464
                    # without the parent ie, use the relatively slower inventory 
557
465
                    # probing method
558
466
                    this_id = inv.path2id(
559
 
                        self._fix_case_of_inventory_path(directory.raw_path))
 
467
                            self._fix_case_of_inventory_path(directory.raw_path))
560
468
                    if this_id is None:
561
469
                        this_ie = None
562
470
                    else:
563
471
                        this_ie = inv[this_id]
564
472
 
565
473
                for subf in sorted(os.listdir(abspath)):
566
 
                    # here we could use TreeDirectory rather than
 
474
                    # here we could use TreeDirectory rather than 
567
475
                    # string concatenation.
568
476
                    subp = osutils.pathjoin(directory.raw_path, subf)
569
 
                    # TODO: is_control_filename is very slow. Make it faster.
570
 
                    # TreeDirectory.is_control_filename could also make this
571
 
                    # faster - its impossible for a non root dir to have a
 
477
                    # TODO: is_control_filename is very slow. Make it faster. 
 
478
                    # TreeDirectory.is_control_filename could also make this 
 
479
                    # faster - its impossible for a non root dir to have a 
572
480
                    # control file.
573
481
                    if self.is_control_filename(subp):
574
 
                        trace.mutter("skip control directory %r", subp)
 
482
                        mutter("skip control directory %r", subp)
575
483
                    elif subf in this_ie.children:
576
484
                        # recurse into this already versioned subdir.
577
485
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
609
517
        for commit which is not required to handle situations that do not arise
610
518
        outside of commit.
611
519
 
612
 
        See the inventory developers documentation for the theory behind
613
 
        inventory deltas.
614
 
 
615
520
        :param new_revid: The new revision id for the trees parent.
616
521
        :param delta: An inventory delta (see apply_inventory_delta) describing
617
522
            the changes from the current left most parent revision to new_revid.
627
532
        # WorkingTree classes for optimised versions for specific format trees.
628
533
        basis = self.basis_tree()
629
534
        basis.lock_read()
630
 
        # TODO: Consider re-evaluating the need for this with CHKInventory
631
 
        # we don't strictly need to mutate an inventory for this
632
 
        # it only makes sense when apply_delta is cheaper than get_inventory()
633
 
        inventory = basis.inventory._get_mutable_inventory()
 
535
        inventory = basis.inventory
634
536
        basis.unlock()
635
537
        inventory.apply_delta(delta)
636
 
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
637
 
                                             inventory, new_revid)
 
538
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
638
539
        self.set_parent_trees([(new_revid, rev_tree)])
639
540
 
640
541
 
641
542
class MutableTreeHooks(hooks.Hooks):
642
 
    """A dictionary mapping a hook name to a list of callables for mutabletree
 
543
    """A dictionary mapping a hook name to a list of callables for mutabletree 
643
544
    hooks.
644
545
    """
645
546
 
648
549
 
649
550
        """
650
551
        hooks.Hooks.__init__(self)
651
 
        self.create_hook(hooks.HookPoint('start_commit',
652
 
            "Called before a commit is performed on a tree. The start commit "
653
 
            "hook is able to change the tree before the commit takes place. "
654
 
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
655
 
            "that the commit is being performed on.", (1, 4), None))
656
 
        self.create_hook(hooks.HookPoint('post_commit',
657
 
            "Called after a commit is performed on a tree. The hook is "
658
 
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
659
 
            "The mutable tree the commit was performed on is available via "
660
 
            "the mutable_tree attribute of that object.", (2, 0), None))
 
552
        # Invoked before a commit is done in a tree. New in 1.4
 
553
        self['start_commit'] = []
661
554
 
662
555
 
663
556
# install the default hooks into the MutableTree class.
664
557
MutableTree.hooks = MutableTreeHooks()
665
558
 
666
559
 
667
 
class PostCommitHookParams(object):
668
 
    """Parameters for the post_commit hook.
669
 
 
670
 
    To access the parameters, use the following attributes:
671
 
 
672
 
    * mutable_tree - the MutableTree object
673
 
    """
674
 
 
675
 
    def __init__(self, mutable_tree):
676
 
        """Create the parameters for the post_commit hook."""
677
 
        self.mutable_tree = mutable_tree
678
 
 
679
 
 
680
560
class _FastPath(object):
681
561
    """A path object with fast accessors for things like basename."""
682
562
 
723
603
        # there are a limited number of dirs we can be nested under, it should
724
604
        # generally find it very fast and not recurse after that.
725
605
        added = _add_one_and_parent(tree, inv, None,
726
 
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
727
 
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
 
606
            _FastPath(dirname(path.raw_path)), 'directory', action)
 
607
        parent_id = inv.path2id(dirname(path.raw_path))
728
608
        parent_ie = inv[parent_id]
729
609
    _add_one(tree, inv, parent_ie, path, kind, action)
730
610
    return added + [path.raw_path]