/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Naoki INADA
  • Date: 2009-10-29 10:01:19 UTC
  • mto: (4634.97.3 2.0)
  • mto: This revision was merged to the branch mainline in revision 4798.
  • Revision ID: inada-n@klab.jp-20091029100119-uckv9t7ej2qrghw3
import doc-ja rev90

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
28
28
from bzrlib import (
29
29
    add,
30
30
    bzrdir,
 
31
    hooks,
 
32
    symbol_versioning,
 
33
    )
 
34
from bzrlib.osutils import dirname
 
35
from bzrlib.revisiontree import RevisionTree
 
36
from bzrlib.trace import mutter, warning
 
37
""")
 
38
 
 
39
from bzrlib import (
31
40
    errors,
32
 
    hooks,
33
41
    osutils,
34
 
    revisiontree,
35
 
    symbol_versioning,
36
 
    trace,
37
42
    tree,
38
43
    )
39
 
""")
40
 
 
41
44
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
45
from bzrlib.osutils import splitpath
42
46
 
43
47
 
44
48
def needs_tree_write_lock(unbound):
126
130
            # generic constraint checks:
127
131
            if self.is_control_filename(f):
128
132
                raise errors.ForbiddenControlFileError(filename=f)
129
 
            fp = osutils.splitpath(f)
 
133
            fp = splitpath(f)
130
134
        # fill out file kinds for all files [not needed when we stop
131
135
        # caring about the instantaneous file kind within a uncommmitted tree
132
136
        #
182
186
               **kwargs):
183
187
        # avoid circular imports
184
188
        from bzrlib import commit
 
189
        if revprops is None:
 
190
            revprops = {}
185
191
        possible_master_transports=[]
186
 
        revprops = commit.Commit.update_revprops(
187
 
                revprops,
188
 
                self.branch,
189
 
                kwargs.pop('authors', None),
190
 
                kwargs.pop('author', None),
 
192
        if not 'branch-nick' in revprops:
 
193
            revprops['branch-nick'] = self.branch._get_nick(
191
194
                kwargs.get('local', False),
192
195
                possible_master_transports)
 
196
        authors = kwargs.pop('authors', None)
 
197
        author = kwargs.pop('author', None)
 
198
        if authors is not None:
 
199
            if author is not None:
 
200
                raise AssertionError('Specifying both author and authors '
 
201
                        'is not allowed. Specify just authors instead')
 
202
            if 'author' in revprops or 'authors' in revprops:
 
203
                # XXX: maybe we should just accept one of them?
 
204
                raise AssertionError('author property given twice')
 
205
            if authors:
 
206
                for individual in authors:
 
207
                    if '\n' in individual:
 
208
                        raise AssertionError('\\n is not a valid character '
 
209
                                'in an author identity')
 
210
                revprops['authors'] = '\n'.join(authors)
 
211
        if author is not None:
 
212
            symbol_versioning.warn('The parameter author was deprecated'
 
213
                   ' in version 1.13. Use authors instead',
 
214
                   DeprecationWarning)
 
215
            if 'author' in revprops or 'authors' in revprops:
 
216
                # XXX: maybe we should just accept one of them?
 
217
                raise AssertionError('author property given twice')
 
218
            if '\n' in author:
 
219
                raise AssertionError('\\n is not a valid character '
 
220
                        'in an author identity')
 
221
            revprops['authors'] = author
193
222
        # args for wt.commit start at message from the Commit.commit method,
194
223
        args = (message, ) + args
195
224
        for hook in MutableTree.hooks['start_commit']:
208
237
        raise NotImplementedError(self._gather_kinds)
209
238
 
210
239
    @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).
 
240
    def has_changes(self, from_tree):
 
241
        """Quickly check that the tree contains at least one change.
216
242
 
217
243
        :return: True if a change is found. False otherwise
218
244
        """
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)
 
245
        changes = self.iter_changes(from_tree)
225
246
        try:
226
247
            change = changes.next()
227
248
            # Exclude root (talk about black magic... --vila 20090629)
233
254
            return False
234
255
 
235
256
    @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
272
 
 
273
 
    @needs_read_lock
274
257
    def last_revision(self):
275
258
        """Return the revision id of the last commit performed in this tree.
276
259
 
375
358
        This is designed more towards DWIM for humans than API clarity.
376
359
        For the specific behaviour see the help for cmd_add().
377
360
 
378
 
        :param file_list: List of zero or more paths.  *NB: these are 
379
 
            interpreted relative to the process cwd, not relative to the 
380
 
            tree.*  (Add and most other tree methods use tree-relative
381
 
            paths.)
382
361
        :param action: A reporter to be called with the inventory, parent_ie,
383
362
            path and kind of the path being added. It may return a file_id if
384
363
            a specific one should be used.
397
376
 
398
377
        if not file_list:
399
378
            # no paths supplied: add the entire tree.
400
 
            # FIXME: this assumes we are running in a working tree subdir :-/
401
 
            # -- vila 20100208
402
379
            file_list = [u'.']
403
380
        # mutter("smart add of %r")
404
381
        inv = self.inventory
406
383
        ignored = {}
407
384
        dirs_to_add = []
408
385
        user_dirs = set()
409
 
        conflicts_related = set()
410
 
        # Not all mutable trees can have conflicts
411
 
        if getattr(self, 'conflicts', None) is not None:
412
 
            # Collect all related files without checking whether they exist or
413
 
            # are versioned. It's cheaper to do that once for all conflicts
414
 
            # than trying to find the relevant conflict for each added file.
415
 
            for c in self.conflicts():
416
 
                conflicts_related.update(c.associated_filenames())
417
386
 
418
387
        # validate user file paths and convert all paths to tree
419
388
        # relative : it's cheaper to make a tree relative path an abspath
421
390
        # perform the canonicalization in bulk.
422
391
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
423
392
            rf = _FastPath(filepath)
424
 
            # validate user parameters. Our recursive code avoids adding new
425
 
            # files that need such validation
 
393
            # validate user parameters. Our recursive code avoids adding new files
 
394
            # that need such validation
426
395
            if self.is_control_filename(rf.raw_path):
427
396
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
428
397
 
434
403
            else:
435
404
                if not InventoryEntry.versionable_kind(kind):
436
405
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
437
 
            # ensure the named path is added, so that ignore rules in the later
438
 
            # directory walk dont skip it.
439
 
            # we dont have a parent ie known yet.: use the relatively slower
440
 
            # inventory probing method
 
406
            # ensure the named path is added, so that ignore rules in the later directory
 
407
            # walk dont skip it.
 
408
            # we dont have a parent ie known yet.: use the relatively slower inventory
 
409
            # probing method
441
410
            versioned = inv.has_filename(rf.raw_path)
442
411
            if versioned:
443
412
                continue
474
443
            kind = osutils.file_kind(abspath)
475
444
 
476
445
            if not InventoryEntry.versionable_kind(kind):
477
 
                trace.warning("skipping %s (can't add file of kind '%s')",
478
 
                              abspath, kind)
 
446
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
479
447
                continue
480
448
            if illegalpath_re.search(directory.raw_path):
481
 
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
482
 
                continue
483
 
            if directory.raw_path in conflicts_related:
484
 
                # If the file looks like one generated for a conflict, don't
485
 
                # add it.
486
 
                trace.warning(
487
 
                    'skipping %s (generated to help resolve conflicts)',
488
 
                    abspath)
 
449
                warning("skipping %r (contains \\n or \\r)" % abspath)
489
450
                continue
490
451
 
491
452
            if parent_ie is not None:
514
475
                pass
515
476
                # mutter("%r is already versioned", abspath)
516
477
            elif sub_tree:
517
 
                # XXX: This is wrong; people *might* reasonably be trying to
518
 
                # add subtrees as subtrees.  This should probably only be done
519
 
                # in formats which can represent subtrees, and even then
520
 
                # perhaps only when the user asked to add subtrees.  At the
521
 
                # moment you can add them specially through 'join --reference',
522
 
                # which is perhaps reasonable: adding a new reference is a
523
 
                # special operation and can have a special behaviour.  mbp
524
 
                # 20070306
525
 
                trace.mutter("%r is a nested bzr tree", abspath)
 
478
                # XXX: This is wrong; people *might* reasonably be trying to add
 
479
                # subtrees as subtrees.  This should probably only be done in formats
 
480
                # which can represent subtrees, and even then perhaps only when
 
481
                # the user asked to add subtrees.  At the moment you can add them
 
482
                # specially through 'join --reference', which is perhaps
 
483
                # reasonable: adding a new reference is a special operation and
 
484
                # can have a special behaviour.  mbp 20070306
 
485
                mutter("%r is a nested bzr tree", abspath)
526
486
            else:
527
487
                _add_one(self, inv, parent_ie, directory, kind, action)
528
488
                added.append(directory.raw_path)
535
495
                    # without the parent ie, use the relatively slower inventory
536
496
                    # probing method
537
497
                    this_id = inv.path2id(
538
 
                        self._fix_case_of_inventory_path(directory.raw_path))
 
498
                            self._fix_case_of_inventory_path(directory.raw_path))
539
499
                    if this_id is None:
540
500
                        this_ie = None
541
501
                    else:
550
510
                    # faster - its impossible for a non root dir to have a
551
511
                    # control file.
552
512
                    if self.is_control_filename(subp):
553
 
                        trace.mutter("skip control directory %r", subp)
 
513
                        mutter("skip control directory %r", subp)
554
514
                    elif subf in this_ie.children:
555
515
                        # recurse into this already versioned subdir.
556
516
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
612
572
        inventory = basis.inventory._get_mutable_inventory()
613
573
        basis.unlock()
614
574
        inventory.apply_delta(delta)
615
 
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
616
 
                                             inventory, new_revid)
 
575
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
617
576
        self.set_parent_trees([(new_revid, rev_tree)])
618
577
 
619
578
 
702
661
        # there are a limited number of dirs we can be nested under, it should
703
662
        # generally find it very fast and not recurse after that.
704
663
        added = _add_one_and_parent(tree, inv, None,
705
 
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
706
 
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
 
664
            _FastPath(dirname(path.raw_path)), 'directory', action)
 
665
        parent_id = inv.path2id(dirname(path.raw_path))
707
666
        parent_ie = inv[parent_id]
708
667
    _add_one(tree, inv, parent_ie, path, kind, action)
709
668
    return added + [path.raw_path]