← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Ian Clatworthy
  • Date: 2010-05-26 04:26:59 UTC
  • mto: (5255.2.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5256.
  • Revision ID: ian.clatworthy@canonical.com-20100526042659-2e3p4qdjr0sby0bt
https://launchpad.net/bugs/486990
Fix PDF generation of User Reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mutabletree.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
23
23
from bzrlib.lazy_import import lazy_import
24
24
lazy_import(globals(), """
25
25
import os
 
26
import re
26
27
 
27
28
from bzrlib import (
28
29
    add,
29
30
    bzrdir,
 
31
    errors,
30
32
    hooks,
 
33
    osutils,
 
34
    revisiontree,
31
35
    symbol_versioning,
 
36
    trace,
 
37
    tree,
32
38
    )
33
 
from bzrlib.osutils import dirname
34
 
from bzrlib.revisiontree import RevisionTree
35
 
from bzrlib.trace import mutter, warning
36
39
""")
37
40
 
38
 
from bzrlib import (
39
 
    errors,
40
 
    osutils,
41
 
    tree,
42
 
    )
43
41
from bzrlib.decorators import needs_read_lock, needs_write_lock
44
 
from bzrlib.osutils import splitpath
45
42
 
46
43
 
47
44
def needs_tree_write_lock(unbound):
129
126
            # generic constraint checks:
130
127
            if self.is_control_filename(f):
131
128
                raise errors.ForbiddenControlFileError(filename=f)
132
 
            fp = splitpath(f)
 
129
            fp = osutils.splitpath(f)
133
130
        # fill out file kinds for all files [not needed when we stop
134
131
        # caring about the instantaneous file kind within a uncommmitted tree
135
132
        #
185
182
               **kwargs):
186
183
        # avoid circular imports
187
184
        from bzrlib import commit
188
 
        if revprops is None:
189
 
            revprops = {}
190
185
        possible_master_transports=[]
191
 
        if not 'branch-nick' in revprops:
192
 
            revprops['branch-nick'] = self.branch._get_nick(
 
186
        revprops = commit.Commit.update_revprops(
 
187
                revprops,
 
188
                self.branch,
 
189
                kwargs.pop('authors', None),
 
190
                kwargs.pop('author', None),
193
191
                kwargs.get('local', False),
194
192
                possible_master_transports)
195
 
        authors = kwargs.pop('authors', None)
196
 
        author = kwargs.pop('author', None)
197
 
        if authors is not None:
198
 
            if author is not None:
199
 
                raise AssertionError('Specifying both author and authors '
200
 
                        'is not allowed. Specify just authors instead')
201
 
            if 'author' in revprops or 'authors' in revprops:
202
 
                # XXX: maybe we should just accept one of them?
203
 
                raise AssertionError('author property given twice')
204
 
            if authors:
205
 
                for individual in authors:
206
 
                    if '\n' in individual:
207
 
                        raise AssertionError('\\n is not a valid character '
208
 
                                'in an author identity')
209
 
                revprops['authors'] = '\n'.join(authors)
210
 
        if author is not None:
211
 
            symbol_versioning.warn('The parameter author was deprecated'
212
 
                   ' in version 1.13. Use authors instead',
213
 
                   DeprecationWarning)
214
 
            if 'author' in revprops or 'authors' in revprops:
215
 
                # XXX: maybe we should just accept one of them?
216
 
                raise AssertionError('author property given twice')
217
 
            if '\n' in author:
218
 
                raise AssertionError('\\n is not a valid character '
219
 
                        'in an author identity')
220
 
            revprops['authors'] = author
221
193
        # args for wt.commit start at message from the Commit.commit method,
222
194
        args = (message, ) + args
223
195
        for hook in MutableTree.hooks['start_commit']:
226
198
            revprops=revprops,
227
199
            possible_master_transports=possible_master_transports,
228
200
            *args, **kwargs)
 
201
        post_hook_params = PostCommitHookParams(self)
 
202
        for hook in MutableTree.hooks['post_commit']:
 
203
            hook(post_hook_params)
229
204
        return committed_id
230
205
 
231
206
    def _gather_kinds(self, files, kinds):
232
207
        """Helper function for add - sets the entries of kinds."""
233
208
        raise NotImplementedError(self._gather_kinds)
234
209
 
235
 
    def get_file_with_stat(self, file_id, path=None):
236
 
        """Get a file handle and stat object for file_id.
237
 
 
238
 
        The default implementation returns (self.get_file, None) for backwards
239
 
        compatibility.
240
 
 
241
 
        :param file_id: The file id to read.
242
 
        :param path: The path of the file, if it is known.
243
 
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
244
 
            no stat facility, or need for a stat cache feedback during commit,
245
 
            it may return None for the second element of the tuple.
246
 
        """
247
 
        return (self.get_file(file_id, path), None)
 
210
    @needs_read_lock
 
211
    def has_changes(self, _from_tree=None):
 
212
        """Quickly check that the tree contains at least one commitable change.
 
213
 
 
214
        :param _from_tree: tree to compare against to find changes (default to
 
215
            the basis tree and is intended to be used by tests).
 
216
 
 
217
        :return: True if a change is found. False otherwise
 
218
        """
 
219
        # Check pending merges
 
220
        if len(self.get_parent_ids()) > 1:
 
221
            return True
 
222
        if _from_tree is None:
 
223
            _from_tree = self.basis_tree()
 
224
        changes = self.iter_changes(_from_tree)
 
225
        try:
 
226
            change = changes.next()
 
227
            # Exclude root (talk about black magic... --vila 20090629)
 
228
            if change[4] == (None, None):
 
229
                change = changes.next()
 
230
            return True
 
231
        except StopIteration:
 
232
            # No changes
 
233
            return False
 
234
 
 
235
    @needs_read_lock
 
236
    def check_changed_or_out_of_date(self, strict, opt_name,
 
237
                                     more_error, more_warning):
 
238
        """Check the tree for uncommitted changes and branch synchronization.
 
239
 
 
240
        If strict is None and not set in the config files, a warning is issued.
 
241
        If strict is True, an error is raised.
 
242
        If strict is False, no checks are done and no warning is issued.
 
243
 
 
244
        :param strict: True, False or None, searched in branch config if None.
 
245
 
 
246
        :param opt_name: strict option name to search in config file.
 
247
 
 
248
        :param more_error: Details about how to avoid the check.
 
249
 
 
250
        :param more_warning: Details about what is happening.
 
251
        """
 
252
        if strict is None:
 
253
            strict = self.branch.get_config().get_user_option_as_bool(opt_name)
 
254
        if strict is not False:
 
255
            err_class = None
 
256
            if (self.has_changes()):
 
257
                err_class = errors.UncommittedChanges
 
258
            elif self.last_revision() != self.branch.last_revision():
 
259
                # The tree has lost sync with its branch, there is little
 
260
                # chance that the user is aware of it but he can still force
 
261
                # the action with --no-strict
 
262
                err_class = errors.OutOfDateTree
 
263
            if err_class is not None:
 
264
                if strict is None:
 
265
                    err = err_class(self, more=more_warning)
 
266
                    # We don't want to interrupt the user if he expressed no
 
267
                    # preference about strict.
 
268
                    trace.warning('%s', err._format())
 
269
                else:
 
270
                    err = err_class(self, more=more_error)
 
271
                    raise err
248
272
 
249
273
    @needs_read_lock
250
274
    def last_revision(self):
369
393
 
370
394
        if not file_list:
371
395
            # no paths supplied: add the entire tree.
 
396
            # FIXME: this assumes we are running in a working tree subdir :-/
 
397
            # -- vila 20100208
372
398
            file_list = [u'.']
373
399
        # mutter("smart add of %r")
374
400
        inv = self.inventory
376
402
        ignored = {}
377
403
        dirs_to_add = []
378
404
        user_dirs = set()
 
405
        conflicts_related = set()
 
406
        # Not all mutable trees can have conflicts
 
407
        if getattr(self, 'conflicts', None) is not None:
 
408
            # Collect all related files without checking whether they exist or
 
409
            # are versioned. It's cheaper to do that once for all conflicts
 
410
            # than trying to find the relevant conflict for each added file.
 
411
            for c in self.conflicts():
 
412
                conflicts_related.update(c.associated_filenames())
379
413
 
380
414
        # validate user file paths and convert all paths to tree
381
415
        # relative : it's cheaper to make a tree relative path an abspath
383
417
        # perform the canonicalization in bulk.
384
418
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
385
419
            rf = _FastPath(filepath)
386
 
            # validate user parameters. Our recursive code avoids adding new files
387
 
            # that need such validation
 
420
            # validate user parameters. Our recursive code avoids adding new
 
421
            # files that need such validation
388
422
            if self.is_control_filename(rf.raw_path):
389
423
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
390
424
 
396
430
            else:
397
431
                if not InventoryEntry.versionable_kind(kind):
398
432
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
399
 
            # ensure the named path is added, so that ignore rules in the later directory
400
 
            # walk dont skip it.
401
 
            # we dont have a parent ie known yet.: use the relatively slower inventory
402
 
            # probing method
 
433
            # ensure the named path is added, so that ignore rules in the later
 
434
            # directory walk dont skip it.
 
435
            # we dont have a parent ie known yet.: use the relatively slower
 
436
            # inventory probing method
403
437
            versioned = inv.has_filename(rf.raw_path)
404
438
            if versioned:
405
439
                continue
421
455
                dirs_to_add.append((path, None))
422
456
            prev_dir = path.raw_path
423
457
 
 
458
        illegalpath_re = re.compile(r'[\r\n]')
424
459
        # dirs_to_add is initialised to a list of directories, but as we scan
425
460
        # directories we append files to it.
426
461
        # XXX: We should determine kind of files when we scan them rather than
435
470
            kind = osutils.file_kind(abspath)
436
471
 
437
472
            if not InventoryEntry.versionable_kind(kind):
438
 
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
 
473
                trace.warning("skipping %s (can't add file of kind '%s')",
 
474
                              abspath, kind)
 
475
                continue
 
476
            if illegalpath_re.search(directory.raw_path):
 
477
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
 
478
                continue
 
479
            if directory.raw_path in conflicts_related:
 
480
                # If the file looks like one generated for a conflict, don't
 
481
                # add it.
 
482
                trace.warning(
 
483
                    'skipping %s (generated to help resolve conflicts)',
 
484
                    abspath)
439
485
                continue
440
486
 
441
487
            if parent_ie is not None:
464
510
                pass
465
511
                # mutter("%r is already versioned", abspath)
466
512
            elif sub_tree:
467
 
                # XXX: This is wrong; people *might* reasonably be trying to add
468
 
                # subtrees as subtrees.  This should probably only be done in formats
469
 
                # which can represent subtrees, and even then perhaps only when
470
 
                # the user asked to add subtrees.  At the moment you can add them
471
 
                # specially through 'join --reference', which is perhaps
472
 
                # reasonable: adding a new reference is a special operation and
473
 
                # can have a special behaviour.  mbp 20070306
474
 
                mutter("%r is a nested bzr tree", abspath)
 
513
                # XXX: This is wrong; people *might* reasonably be trying to
 
514
                # add subtrees as subtrees.  This should probably only be done
 
515
                # in formats which can represent subtrees, and even then
 
516
                # perhaps only when the user asked to add subtrees.  At the
 
517
                # moment you can add them specially through 'join --reference',
 
518
                # which is perhaps reasonable: adding a new reference is a
 
519
                # special operation and can have a special behaviour.  mbp
 
520
                # 20070306
 
521
                trace.mutter("%r is a nested bzr tree", abspath)
475
522
            else:
476
523
                _add_one(self, inv, parent_ie, directory, kind, action)
477
524
                added.append(directory.raw_path)
484
531
                    # without the parent ie, use the relatively slower inventory
485
532
                    # probing method
486
533
                    this_id = inv.path2id(
487
 
                            self._fix_case_of_inventory_path(directory.raw_path))
 
534
                        self._fix_case_of_inventory_path(directory.raw_path))
488
535
                    if this_id is None:
489
536
                        this_ie = None
490
537
                    else:
499
546
                    # faster - its impossible for a non root dir to have a
500
547
                    # control file.
501
548
                    if self.is_control_filename(subp):
502
 
                        mutter("skip control directory %r", subp)
 
549
                        trace.mutter("skip control directory %r", subp)
503
550
                    elif subf in this_ie.children:
504
551
                        # recurse into this already versioned subdir.
505
552
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
537
584
        for commit which is not required to handle situations that do not arise
538
585
        outside of commit.
539
586
 
 
587
        See the inventory developers documentation for the theory behind
 
588
        inventory deltas.
 
589
 
540
590
        :param new_revid: The new revision id for the trees parent.
541
591
        :param delta: An inventory delta (see apply_inventory_delta) describing
542
592
            the changes from the current left most parent revision to new_revid.
558
608
        inventory = basis.inventory._get_mutable_inventory()
559
609
        basis.unlock()
560
610
        inventory.apply_delta(delta)
561
 
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
 
611
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
 
612
                                             inventory, new_revid)
562
613
        self.set_parent_trees([(new_revid, rev_tree)])
563
614
 
564
615
 
575
626
        self.create_hook(hooks.HookPoint('start_commit',
576
627
            "Called before a commit is performed on a tree. The start commit "
577
628
            "hook is able to change the tree before the commit takes place. "
578
 
            "start_commit is called with the bzrlib.tree.MutableTree that the "
579
 
            "commit is being performed on.", (1, 4), None))
 
629
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
 
630
            "that the commit is being performed on.", (1, 4), None))
 
631
        self.create_hook(hooks.HookPoint('post_commit',
 
632
            "Called after a commit is performed on a tree. The hook is "
 
633
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
 
634
            "The mutable tree the commit was performed on is available via "
 
635
            "the mutable_tree attribute of that object.", (2, 0), None))
580
636
 
581
637
 
582
638
# install the default hooks into the MutableTree class.
583
639
MutableTree.hooks = MutableTreeHooks()
584
640
 
585
641
 
 
642
class PostCommitHookParams(object):
 
643
    """Parameters for the post_commit hook.
 
644
 
 
645
    To access the parameters, use the following attributes:
 
646
 
 
647
    * mutable_tree - the MutableTree object
 
648
    """
 
649
 
 
650
    def __init__(self, mutable_tree):
 
651
        """Create the parameters for the post_commit hook."""
 
652
        self.mutable_tree = mutable_tree
 
653
 
 
654
 
586
655
class _FastPath(object):
587
656
    """A path object with fast accessors for things like basename."""
588
657
 
629
698
        # there are a limited number of dirs we can be nested under, it should
630
699
        # generally find it very fast and not recurse after that.
631
700
        added = _add_one_and_parent(tree, inv, None,
632
 
            _FastPath(dirname(path.raw_path)), 'directory', action)
633
 
        parent_id = inv.path2id(dirname(path.raw_path))
 
701
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
 
702
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
634
703
        parent_ie = inv[parent_id]
635
704
    _add_one(tree, inv, parent_ie, path, kind, action)
636
705
    return added + [path.raw_path]