← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-04-09 23:12:55 UTC
  • mfrom: (3920.2.37 dpush)
  • Revision ID: pqm@pqm.ubuntu.com-20090409231255-o8w1g2q3igiyf8b2
(Jelmer) Add the dpush command.

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
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
    symbol_versioning,
 
32
    )
 
33
from bzrlib.osutils import dirname
 
34
from bzrlib.revisiontree import RevisionTree
 
35
from bzrlib.trace import mutter, warning
 
36
""")
 
37
 
 
38
from bzrlib import (
31
39
    errors,
32
 
    hooks,
33
40
    osutils,
34
 
    revisiontree,
35
 
    symbol_versioning,
36
 
    trace,
37
41
    tree,
38
42
    )
39
 
""")
40
 
 
41
43
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
44
from bzrlib.osutils import splitpath
42
45
 
43
46
 
44
47
def needs_tree_write_lock(unbound):
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)
 
132
            fp = splitpath(f)
130
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
        #
182
185
               **kwargs):
183
186
        # avoid circular imports
184
187
        from bzrlib import commit
 
188
        if revprops is None:
 
189
            revprops = {}
185
190
        possible_master_transports=[]
186
 
        revprops = commit.Commit.update_revprops(
187
 
                revprops,
188
 
                self.branch,
189
 
                kwargs.pop('authors', None),
190
 
                kwargs.pop('author', None),
 
191
        if not 'branch-nick' in revprops:
 
192
            revprops['branch-nick'] = self.branch._get_nick(
191
193
                kwargs.get('local', False),
192
194
                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
193
221
        # args for wt.commit start at message from the Commit.commit method,
194
222
        args = (message, ) + args
195
223
        for hook in MutableTree.hooks['start_commit']:
198
226
            revprops=revprops,
199
227
            possible_master_transports=possible_master_transports,
200
228
            *args, **kwargs)
201
 
        post_hook_params = PostCommitHookParams(self)
202
 
        for hook in MutableTree.hooks['post_commit']:
203
 
            hook(post_hook_params)
204
229
        return committed_id
205
230
 
206
231
    def _gather_kinds(self, files, kinds):
207
232
        """Helper function for add - sets the entries of kinds."""
208
233
        raise NotImplementedError(self._gather_kinds)
209
234
 
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
 
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)
272
248
 
273
249
    @needs_read_lock
274
250
    def last_revision(self):
393
369
 
394
370
        if not file_list:
395
371
            # no paths supplied: add the entire tree.
396
 
            # FIXME: this assumes we are running in a working tree subdir :-/
397
 
            # -- vila 20100208
398
372
            file_list = [u'.']
399
373
        # mutter("smart add of %r")
400
374
        inv = self.inventory
402
376
        ignored = {}
403
377
        dirs_to_add = []
404
378
        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())
413
379
 
414
380
        # validate user file paths and convert all paths to tree
415
381
        # relative : it's cheaper to make a tree relative path an abspath
417
383
        # perform the canonicalization in bulk.
418
384
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
419
385
            rf = _FastPath(filepath)
420
 
            # validate user parameters. Our recursive code avoids adding new
421
 
            # files that need such validation
 
386
            # validate user parameters. Our recursive code avoids adding new files
 
387
            # that need such validation
422
388
            if self.is_control_filename(rf.raw_path):
423
389
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
424
390
 
430
396
            else:
431
397
                if not InventoryEntry.versionable_kind(kind):
432
398
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
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
 
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
437
403
            versioned = inv.has_filename(rf.raw_path)
438
404
            if versioned:
439
405
                continue
455
421
                dirs_to_add.append((path, None))
456
422
            prev_dir = path.raw_path
457
423
 
458
 
        illegalpath_re = re.compile(r'[\r\n]')
459
424
        # dirs_to_add is initialised to a list of directories, but as we scan
460
425
        # directories we append files to it.
461
426
        # XXX: We should determine kind of files when we scan them rather than
470
435
            kind = osutils.file_kind(abspath)
471
436
 
472
437
            if not InventoryEntry.versionable_kind(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)
 
438
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
485
439
                continue
486
440
 
487
441
            if parent_ie is not None:
510
464
                pass
511
465
                # mutter("%r is already versioned", abspath)
512
466
            elif sub_tree:
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)
 
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)
522
475
            else:
523
476
                _add_one(self, inv, parent_ie, directory, kind, action)
524
477
                added.append(directory.raw_path)
531
484
                    # without the parent ie, use the relatively slower inventory
532
485
                    # probing method
533
486
                    this_id = inv.path2id(
534
 
                        self._fix_case_of_inventory_path(directory.raw_path))
 
487
                            self._fix_case_of_inventory_path(directory.raw_path))
535
488
                    if this_id is None:
536
489
                        this_ie = None
537
490
                    else:
546
499
                    # faster - its impossible for a non root dir to have a
547
500
                    # control file.
548
501
                    if self.is_control_filename(subp):
549
 
                        trace.mutter("skip control directory %r", subp)
 
502
                        mutter("skip control directory %r", subp)
550
503
                    elif subf in this_ie.children:
551
504
                        # recurse into this already versioned subdir.
552
505
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
584
537
        for commit which is not required to handle situations that do not arise
585
538
        outside of commit.
586
539
 
587
 
        See the inventory developers documentation for the theory behind
588
 
        inventory deltas.
589
 
 
590
540
        :param new_revid: The new revision id for the trees parent.
591
541
        :param delta: An inventory delta (see apply_inventory_delta) describing
592
542
            the changes from the current left most parent revision to new_revid.
608
558
        inventory = basis.inventory._get_mutable_inventory()
609
559
        basis.unlock()
610
560
        inventory.apply_delta(delta)
611
 
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
612
 
                                             inventory, new_revid)
 
561
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
613
562
        self.set_parent_trees([(new_revid, rev_tree)])
614
563
 
615
564
 
626
575
        self.create_hook(hooks.HookPoint('start_commit',
627
576
            "Called before a commit is performed on a tree. The start commit "
628
577
            "hook is able to change the tree before the commit takes place. "
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))
 
578
            "start_commit is called with the bzrlib.tree.MutableTree that the "
 
579
            "commit is being performed on.", (1, 4), None))
636
580
 
637
581
 
638
582
# install the default hooks into the MutableTree class.
639
583
MutableTree.hooks = MutableTreeHooks()
640
584
 
641
585
 
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
 
 
655
586
class _FastPath(object):
656
587
    """A path object with fast accessors for things like basename."""
657
588
 
698
629
        # there are a limited number of dirs we can be nested under, it should
699
630
        # generally find it very fast and not recurse after that.
700
631
        added = _add_one_and_parent(tree, inv, None,
701
 
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
702
 
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
 
632
            _FastPath(dirname(path.raw_path)), 'directory', action)
 
633
        parent_id = inv.path2id(dirname(path.raw_path))
703
634
        parent_ie = inv[parent_id]
704
635
    _add_one(tree, inv, parent_ie, path, kind, action)
705
636
    return added + [path.raw_path]