/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/commit.py

Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit.py
71
71
 
72
72
from cStringIO import StringIO
73
73
 
 
74
from bzrlib import (
 
75
    errors,
 
76
    tree,
 
77
    )
74
78
import bzrlib.config
75
 
import bzrlib.errors as errors
76
79
from bzrlib.errors import (BzrError, PointlessCommit,
77
80
                           ConflictsInTree,
78
81
                           StrictCommitFailed
277
280
            self.work_inv = self.work_tree.inventory
278
281
            self.basis_tree = self.work_tree.basis_tree()
279
282
            self.basis_inv = self.basis_tree.inventory
 
283
            if specific_files is not None:
 
284
                # Ensure specified files are versioned
 
285
                # (We don't actually need the ids here)
 
286
                tree.find_ids_across_trees(specific_files, 
 
287
                                           [self.basis_tree, self.work_tree])
280
288
            # one to finish, one for rev and inventory, and one for each
281
289
            # inventory entry, and the same for the new inventory.
282
290
            # note that this estimate is too long when we do a partial tree
324
332
            # and now do the commit locally.
325
333
            self.branch.append_revision(self.rev_id)
326
334
 
327
 
            # if the builder gave us the revisiontree it created back, we
328
 
            # could use it straight away here.
329
 
            # TODO: implement this.
330
 
            self.work_tree.set_parent_trees([(self.rev_id,
331
 
                self.branch.repository.revision_tree(self.rev_id))])
 
335
            rev_tree = self.builder.revision_tree()
 
336
            self.work_tree.set_parent_trees([(self.rev_id, rev_tree)])
332
337
            # now the work tree is up to date with the branch
333
338
            
334
339
            self.reporter.completed(self.branch.revno(), self.rev_id)
345
350
            self._cleanup()
346
351
        return self.rev_id
347
352
 
 
353
    def _any_real_changes(self):
 
354
        """Are there real changes between new_inventory and basis?
 
355
 
 
356
        For trees without rich roots, inv.root.revision changes every commit.
 
357
        But if that is the only change, we want to treat it as though there
 
358
        are *no* changes.
 
359
        """
 
360
        new_entries = self.builder.new_inventory.iter_entries()
 
361
        basis_entries = self.basis_inv.iter_entries()
 
362
        new_path, new_root_ie = new_entries.next()
 
363
        basis_path, basis_root_ie = basis_entries.next()
 
364
 
 
365
        # This is a copy of InventoryEntry.__eq__ only leaving out .revision
 
366
        def ie_equal_no_revision(this, other):
 
367
            return ((this.file_id == other.file_id)
 
368
                    and (this.name == other.name)
 
369
                    and (this.symlink_target == other.symlink_target)
 
370
                    and (this.text_sha1 == other.text_sha1)
 
371
                    and (this.text_size == other.text_size)
 
372
                    and (this.text_id == other.text_id)
 
373
                    and (this.parent_id == other.parent_id)
 
374
                    and (this.kind == other.kind)
 
375
                    and (this.executable == other.executable)
 
376
                    )
 
377
        if not ie_equal_no_revision(new_root_ie, basis_root_ie):
 
378
            return True
 
379
 
 
380
        for new_ie, basis_ie in zip(new_entries, basis_entries):
 
381
            if new_ie != basis_ie:
 
382
                return True
 
383
 
 
384
        # No actual changes present
 
385
        return False
 
386
 
348
387
    def _check_pointless(self):
349
388
        if self.allow_pointless:
350
389
            return
351
390
        # A merge with no effect on files
352
391
        if len(self.parents) > 1:
353
392
            return
354
 
        # work around the fact that a newly-initted tree does differ from its
355
 
        # basis
 
393
        # Shortcut, if the number of entries changes, then we obviously have
 
394
        # a change
356
395
        if len(self.builder.new_inventory) != len(self.basis_inv):
357
396
            return
358
 
        if (len(self.builder.new_inventory) != 1 and
359
 
            self.builder.new_inventory != self.basis_inv):
 
397
        # If length == 1, then we only have the root entry. Which means
 
398
        # that there is no real difference (only the root could be different)
 
399
        if (len(self.builder.new_inventory) != 1 and self._any_real_changes()):
360
400
            return
361
401
        raise PointlessCommit()
362
402