← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« 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
279
282
            self.work_inv = self.work_tree.inventory
280
283
            self.basis_tree = self.work_tree.basis_tree()
281
284
            self.basis_inv = self.basis_tree.inventory
 
285
            if specific_files is not None:
 
286
                # Ensure specified files are versioned
 
287
                # (We don't actually need the ids here)
 
288
                tree.find_ids_across_trees(specific_files, 
 
289
                                           [self.basis_tree, self.work_tree])
282
290
            # one to finish, one for rev and inventory, and one for each
283
291
            # inventory entry, and the same for the new inventory.
284
292
            # note that this estimate is too long when we do a partial tree
326
334
            # and now do the commit locally.
327
335
            self.branch.append_revision(self.rev_id)
328
336
 
329
 
            # if the builder gave us the revisiontree it created back, we
330
 
            # could use it straight away here.
331
 
            # TODO: implement this.
332
 
            self.work_tree.set_parent_trees([(self.rev_id,
333
 
                self.branch.repository.revision_tree(self.rev_id))])
 
337
            rev_tree = self.builder.revision_tree()
 
338
            self.work_tree.set_parent_trees([(self.rev_id, rev_tree)])
334
339
            # now the work tree is up to date with the branch
335
340
            
336
341
            self.reporter.completed(self.branch.revno(), self.rev_id)
347
352
            self._cleanup()
348
353
        return self.rev_id
349
354
 
 
355
    def _any_real_changes(self):
 
356
        """Are there real changes between new_inventory and basis?
 
357
 
 
358
        For trees without rich roots, inv.root.revision changes every commit.
 
359
        But if that is the only change, we want to treat it as though there
 
360
        are *no* changes.
 
361
        """
 
362
        new_entries = self.builder.new_inventory.iter_entries()
 
363
        basis_entries = self.basis_inv.iter_entries()
 
364
        new_path, new_root_ie = new_entries.next()
 
365
        basis_path, basis_root_ie = basis_entries.next()
 
366
 
 
367
        # This is a copy of InventoryEntry.__eq__ only leaving out .revision
 
368
        def ie_equal_no_revision(this, other):
 
369
            return ((this.file_id == other.file_id)
 
370
                    and (this.name == other.name)
 
371
                    and (this.symlink_target == other.symlink_target)
 
372
                    and (this.text_sha1 == other.text_sha1)
 
373
                    and (this.text_size == other.text_size)
 
374
                    and (this.text_id == other.text_id)
 
375
                    and (this.parent_id == other.parent_id)
 
376
                    and (this.kind == other.kind)
 
377
                    and (this.executable == other.executable)
 
378
                    )
 
379
        if not ie_equal_no_revision(new_root_ie, basis_root_ie):
 
380
            return True
 
381
 
 
382
        for new_ie, basis_ie in zip(new_entries, basis_entries):
 
383
            if new_ie != basis_ie:
 
384
                return True
 
385
 
 
386
        # No actual changes present
 
387
        return False
 
388
 
350
389
    def _check_pointless(self):
351
390
        if self.allow_pointless:
352
391
            return
357
396
        # basis
358
397
        if len(self.basis_inv) == 0 and len(self.builder.new_inventory) == 1:
359
398
            raise PointlessCommit()
 
399
        # Shortcut, if the number of entries changes, then we obviously have
 
400
        # a change
360
401
        if len(self.builder.new_inventory) != len(self.basis_inv):
361
402
            return
362
 
        if (len(self.builder.new_inventory) != 1 and
363
 
            self.builder.new_inventory != self.basis_inv):
 
403
        # If length == 1, then we only have the root entry. Which means
 
404
        # that there is no real difference (only the root could be different)
 
405
        if (len(self.builder.new_inventory) != 1 and self._any_real_changes()):
364
406
            return
365
407
        raise PointlessCommit()
366
408