~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-05-12 02:18:48 UTC
  • Revision ID: mbp@sourcefrog.net-20050512021848-d1a727373aee2c85
- WorkingTree loads statcache in constructor and holds
  it permanently

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
# The newly committed revision is going to have a shape corresponding
19
 
# to that of the working inventory.  Files that are not in the
20
 
# working tree and that were in the predecessor are reported as
21
 
# removed --- this can include files that were either removed from the
22
 
# inventory or deleted in the working tree.  If they were only
23
 
# deleted from disk, they are removed from the working inventory.
24
 
 
25
 
# We then consider the remaining entries, which will be in the new
26
 
# version.  Directory entries are simply copied across.  File entries
27
 
# must be checked to see if a new version of the file should be
28
 
# recorded.  For each parent revision inventory, we check to see what
29
 
# version of the file was present.  If the file was present in at
30
 
# least one tree, and if it was the same version in all the trees,
31
 
# then we can just refer to that version.  Otherwise, a new version
32
 
# representing the merger of the file versions must be added.
33
 
 
34
 
# TODO: Update hashcache before and after - or does the WorkingTree
35
 
# look after that?
36
 
 
37
 
# TODO: Rather than mashing together the ancestry and storing it back,
38
 
# perhaps the weave should have single method which does it all in one
39
 
# go, avoiding a lot of redundant work.
40
 
 
41
 
# TODO: Perhaps give a warning if one of the revisions marked as
42
 
# merged is already in the ancestry, and then don't record it as a
43
 
# distinct parent.
44
 
 
45
 
# TODO: If the file is newly merged but unchanged from the version it
46
 
# merges from, then it should still be reported as newly added
47
 
# relative to the basis revision.
48
 
 
49
 
# TODO: Change the parameter 'rev_id' to 'revision_id' to be consistent with
50
 
# the rest of the code; add a deprecation of the old name.
51
 
 
52
 
import os
53
 
import re
54
 
import sys
55
 
import time
56
 
 
57
 
from cStringIO import StringIO
58
 
 
59
 
from bzrlib import (
60
 
    errors,
61
 
    inventory,
62
 
    tree,
63
 
    )
64
 
from bzrlib.branch import Branch
65
 
import bzrlib.config
66
 
from bzrlib.errors import (BzrError, PointlessCommit,
67
 
                           ConflictsInTree,
68
 
                           StrictCommitFailed
69
 
                           )
70
 
from bzrlib.osutils import (kind_marker, isdir,isfile, is_inside_any, 
71
 
                            is_inside_or_parent_of_any,
72
 
                            quotefn, sha_file, split_lines)
73
 
from bzrlib.testament import Testament
74
 
from bzrlib.trace import mutter, note, warning
75
 
from bzrlib.xml5 import serializer_v5
76
 
from bzrlib.inventory import Inventory, InventoryEntry
77
 
from bzrlib import symbol_versioning
78
 
from bzrlib.symbol_versioning import (deprecated_passed,
79
 
        deprecated_function,
80
 
        DEPRECATED_PARAMETER)
81
 
from bzrlib.workingtree import WorkingTree
82
 
import bzrlib.ui
83
 
 
84
 
 
85
 
class NullCommitReporter(object):
86
 
    """I report on progress of a commit."""
87
 
 
88
 
    def snapshot_change(self, change, path):
89
 
        pass
90
 
 
91
 
    def completed(self, revno, rev_id):
92
 
        pass
93
 
 
94
 
    def deleted(self, file_id):
95
 
        pass
96
 
 
97
 
    def escaped(self, escape_count, message):
98
 
        pass
99
 
 
100
 
    def missing(self, path):
101
 
        pass
102
 
 
103
 
    def renamed(self, change, old_path, new_path):
104
 
        pass
105
 
 
106
 
 
107
 
class ReportCommitToLog(NullCommitReporter):
108
 
 
109
 
    # this may be more useful if 'note' was replaced by an overridable
110
 
    # method on self, which would allow more trivial subclassing.
111
 
    # alternative, a callable could be passed in, allowing really trivial
112
 
    # reuse for some uis. RBC 20060511
113
 
 
114
 
    def snapshot_change(self, change, path):
115
 
        if change == 'unchanged':
116
 
            return
117
 
        if change == 'added' and path == '':
118
 
            return
119
 
        note("%s %s", change, path)
120
 
 
121
 
    def completed(self, revno, rev_id):
122
 
        note('Committed revision %d.', revno)
 
18
 
 
19
def commit(branch, message, timestamp=None, timezone=None,
 
20
           committer=None,
 
21
           verbose=False):
 
22
    """Commit working copy as a new revision.
 
23
 
 
24
    The basic approach is to add all the file texts into the
 
25
    store, then the inventory, then make a new revision pointing
 
26
    to that inventory and store that.
 
27
 
 
28
    This is not quite safe if the working copy changes during the
 
29
    commit; for the moment that is simply not allowed.  A better
 
30
    approach is to make a temporary copy of the files before
 
31
    computing their hashes, and then add those hashes in turn to
 
32
    the inventory.  This should mean at least that there are no
 
33
    broken hash pointers.  There is no way we can get a snapshot
 
34
    of the whole directory at an instant.  This would also have to
 
35
    be robust against files disappearing, moving, etc.  So the
 
36
    whole thing is a bit hard.
 
37
 
 
38
    timestamp -- if not None, seconds-since-epoch for a
 
39
         postdated/predated commit.
 
40
    """
 
41
 
 
42
    import os, time, tempfile
 
43
 
 
44
    from inventory import Inventory
 
45
    from osutils import isdir, isfile, sha_string, quotefn, \
 
46
         local_time_offset, username
123
47
    
124
 
    def deleted(self, file_id):
125
 
        note('deleted %s', file_id)
126
 
 
127
 
    def escaped(self, escape_count, message):
128
 
        note("replaced %d control characters in message", escape_count)
129
 
 
130
 
    def missing(self, path):
131
 
        note('missing %s', path)
132
 
 
133
 
    def renamed(self, change, old_path, new_path):
134
 
        note('%s %s => %s', change, old_path, new_path)
135
 
 
136
 
 
137
 
class Commit(object):
138
 
    """Task of committing a new revision.
139
 
 
140
 
    This is a MethodObject: it accumulates state as the commit is
141
 
    prepared, and then it is discarded.  It doesn't represent
142
 
    historical revisions, just the act of recording a new one.
143
 
 
144
 
            missing_ids
145
 
            Modified to hold a list of files that have been deleted from
146
 
            the working directory; these should be removed from the
147
 
            working inventory.
148
 
    """
149
 
    def __init__(self,
150
 
                 reporter=None,
151
 
                 config=None):
152
 
        if reporter is not None:
153
 
            self.reporter = reporter
154
 
        else:
155
 
            self.reporter = NullCommitReporter()
156
 
        if config is not None:
157
 
            self.config = config
158
 
        else:
159
 
            self.config = None
160
 
        
161
 
    def commit(self,
162
 
               message=None,
163
 
               timestamp=None,
164
 
               timezone=None,
165
 
               committer=None,
166
 
               specific_files=None,
167
 
               rev_id=None,
168
 
               allow_pointless=True,
169
 
               strict=False,
170
 
               verbose=False,
171
 
               revprops=None,
172
 
               working_tree=None,
173
 
               local=False,
174
 
               reporter=None,
175
 
               config=None,
176
 
               message_callback=None,
177
 
               recursive='down'):
178
 
        """Commit working copy as a new revision.
179
 
 
180
 
        message -- the commit message (it or message_callback is required)
181
 
 
182
 
        timestamp -- if not None, seconds-since-epoch for a
183
 
             postdated/predated commit.
184
 
 
185
 
        specific_files -- If true, commit only those files.
186
 
 
187
 
        rev_id -- If set, use this as the new revision id.
188
 
            Useful for test or import commands that need to tightly
189
 
            control what revisions are assigned.  If you duplicate
190
 
            a revision id that exists elsewhere it is your own fault.
191
 
            If null (default), a time/random revision id is generated.
192
 
 
193
 
        allow_pointless -- If true (default), commit even if nothing
194
 
            has changed and no merges are recorded.
195
 
 
196
 
        strict -- If true, don't allow a commit if the working tree
197
 
            contains unknown files.
198
 
 
199
 
        revprops -- Properties for new revision
200
 
        :param local: Perform a local only commit.
201
 
        :param recursive: If set to 'down', commit in any subtrees that have
202
 
            pending changes of any sort during this commit.
203
 
        """
204
 
        mutter('preparing to commit')
205
 
 
206
 
        if working_tree is None:
207
 
            raise BzrError("working_tree must be passed into commit().")
208
 
        else:
209
 
            self.work_tree = working_tree
210
 
            self.branch = self.work_tree.branch
211
 
            if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
212
 
                if not self.branch.repository.supports_rich_root():
213
 
                    raise errors.RootNotRich()
214
 
        if message_callback is None:
215
 
            if message is not None:
216
 
                if isinstance(message, str):
217
 
                    message = message.decode(bzrlib.user_encoding)
218
 
                message_callback = lambda x: message
219
 
            else:
220
 
                raise BzrError("The message or message_callback keyword"
221
 
                               " parameter is required for commit().")
222
 
 
223
 
        self.bound_branch = None
224
 
        self.local = local
225
 
        self.master_branch = None
226
 
        self.master_locked = False
227
 
        self.rev_id = None
228
 
        self.specific_files = specific_files
229
 
        self.allow_pointless = allow_pointless
230
 
        self.recursive = recursive
231
 
        self.revprops = revprops
232
 
        self.message_callback = message_callback
233
 
        self.timestamp = timestamp
234
 
        self.timezone = timezone
235
 
        self.committer = committer
236
 
        self.specific_files = specific_files
237
 
        self.strict = strict
238
 
        self.verbose = verbose
239
 
        self.local = local
240
 
 
241
 
        if reporter is None and self.reporter is None:
242
 
            self.reporter = NullCommitReporter()
243
 
        elif reporter is not None:
244
 
            self.reporter = reporter
245
 
 
246
 
        self.work_tree.lock_write()
247
 
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
248
 
        self.basis_tree = self.work_tree.basis_tree()
249
 
        self.basis_tree.lock_read()
250
 
        try:
251
 
            # Cannot commit with conflicts present.
252
 
            if len(self.work_tree.conflicts())>0:
253
 
                raise ConflictsInTree
254
 
 
255
 
            # setup the bound branch variables as needed.
256
 
            self._check_bound_branch()
257
 
 
258
 
            # check for out of date working trees
259
 
            try:
260
 
                first_tree_parent = self.work_tree.get_parent_ids()[0]
261
 
            except IndexError:
262
 
                # if there are no parents, treat our parent as 'None'
263
 
                # this is so that we still consier the master branch
264
 
                # - in a checkout scenario the tree may have no
265
 
                # parents but the branch may do.
266
 
                first_tree_parent = bzrlib.revision.NULL_REVISION
267
 
            old_revno, master_last = self.master_branch.last_revision_info()
268
 
            if master_last != first_tree_parent:
269
 
                if master_last != bzrlib.revision.NULL_REVISION:
270
 
                    raise errors.OutOfDateTree(self.work_tree)
271
 
            if self.branch.repository.has_revision(first_tree_parent):
272
 
                new_revno = old_revno + 1
273
 
            else:
274
 
                # ghost parents never appear in revision history.
275
 
                new_revno = 1
276
 
            if strict:
277
 
                # raise an exception as soon as we find a single unknown.
278
 
                for unknown in self.work_tree.unknowns():
279
 
                    raise StrictCommitFailed()
280
 
                   
281
 
            if self.config is None:
282
 
                self.config = self.branch.get_config()
283
 
 
284
 
            self.work_inv = self.work_tree.inventory
285
 
            self.basis_inv = self.basis_tree.inventory
286
 
            if specific_files is not None:
287
 
                # Ensure specified files are versioned
288
 
                # (We don't actually need the ids here)
289
 
                # XXX: Dont we have filter_unversioned to do this more
290
 
                # cheaply?
291
 
                tree.find_ids_across_trees(specific_files,
292
 
                                           [self.basis_tree, self.work_tree])
293
 
            # one to finish, one for rev and inventory, and one for each
294
 
            # inventory entry, and the same for the new inventory.
295
 
            # note that this estimate is too long when we do a partial tree
296
 
            # commit which excludes some new files from being considered.
297
 
            # The estimate is corrected when we populate the new inv.
298
 
            self.pb_total = len(self.work_inv) + 5
299
 
            self.pb_count = 0
300
 
 
301
 
            self._gather_parents()
302
 
            if len(self.parents) > 1 and self.specific_files:
303
 
                raise NotImplementedError('selected-file commit of merges is not supported yet: files %r',
304
 
                        self.specific_files)
305
 
            
306
 
            self.builder = self.branch.get_commit_builder(self.parents,
307
 
                self.config, timestamp, timezone, committer, revprops, rev_id)
308
 
            
309
 
            self._remove_deleted()
310
 
            self._populate_new_inv()
311
 
            self._report_deletes()
312
 
 
313
 
            self._check_pointless()
314
 
 
315
 
            self._emit_progress_update()
316
 
            # TODO: Now the new inventory is known, check for conflicts and
317
 
            # prompt the user for a commit message.
318
 
            # ADHB 2006-08-08: If this is done, populate_new_inv should not add
319
 
            # weave lines, because nothing should be recorded until it is known
320
 
            # that commit will succeed.
321
 
            self.builder.finish_inventory()
322
 
            self._emit_progress_update()
323
 
            message = message_callback(self)
324
 
            assert isinstance(message, unicode), type(message)
325
 
            self.message = message
326
 
            self._escape_commit_message()
327
 
 
328
 
            self.rev_id = self.builder.commit(self.message)
329
 
            self._emit_progress_update()
330
 
            # revision data is in the local branch now.
331
 
            
332
 
            # upload revision data to the master.
333
 
            # this will propagate merged revisions too if needed.
334
 
            if self.bound_branch:
335
 
                self.master_branch.repository.fetch(self.branch.repository,
336
 
                                                    revision_id=self.rev_id)
337
 
                # now the master has the revision data
338
 
                # 'commit' to the master first so a timeout here causes the local
339
 
                # branch to be out of date
340
 
                self.master_branch.set_last_revision_info(new_revno,
341
 
                                                          self.rev_id)
342
 
 
343
 
            # and now do the commit locally.
344
 
            self.branch.set_last_revision_info(new_revno, self.rev_id)
345
 
 
346
 
            rev_tree = self.builder.revision_tree()
347
 
            self.work_tree.set_parent_trees([(self.rev_id, rev_tree)])
348
 
            # now the work tree is up to date with the branch
349
 
            
350
 
            self.reporter.completed(new_revno, self.rev_id)
351
 
            # old style commit hooks - should be deprecated ? (obsoleted in
352
 
            # 0.15)
353
 
            if self.config.post_commit() is not None:
354
 
                hooks = self.config.post_commit().split(' ')
355
 
                # this would be nicer with twisted.python.reflect.namedAny
356
 
                for hook in hooks:
357
 
                    result = eval(hook + '(branch, rev_id)',
358
 
                                  {'branch':self.branch,
359
 
                                   'bzrlib':bzrlib,
360
 
                                   'rev_id':self.rev_id})
361
 
            # new style commit hooks:
362
 
            if not self.bound_branch:
363
 
                hook_master = self.branch
364
 
                hook_local = None
365
 
            else:
366
 
                hook_master = self.master_branch
367
 
                hook_local = self.branch
368
 
            # With bound branches, when the master is behind the local branch,
369
 
            # the 'old_revno' and old_revid values here are incorrect.
370
 
            # XXX: FIXME ^. RBC 20060206
371
 
            if self.parents:
372
 
                old_revid = self.parents[0]
373
 
            else:
374
 
                old_revid = bzrlib.revision.NULL_REVISION
375
 
            for hook in Branch.hooks['post_commit']:
376
 
                hook(hook_local, hook_master, old_revno, old_revid, new_revno,
377
 
                    self.rev_id)
378
 
            self._emit_progress_update()
379
 
        finally:
380
 
            self._cleanup()
381
 
        return self.rev_id
382
 
 
383
 
    def _any_real_changes(self):
384
 
        """Are there real changes between new_inventory and basis?
385
 
 
386
 
        For trees without rich roots, inv.root.revision changes every commit.
387
 
        But if that is the only change, we want to treat it as though there
388
 
        are *no* changes.
389
 
        """
390
 
        new_entries = self.builder.new_inventory.iter_entries()
391
 
        basis_entries = self.basis_inv.iter_entries()
392
 
        new_path, new_root_ie = new_entries.next()
393
 
        basis_path, basis_root_ie = basis_entries.next()
394
 
 
395
 
        # This is a copy of InventoryEntry.__eq__ only leaving out .revision
396
 
        def ie_equal_no_revision(this, other):
397
 
            return ((this.file_id == other.file_id)
398
 
                    and (this.name == other.name)
399
 
                    and (this.symlink_target == other.symlink_target)
400
 
                    and (this.text_sha1 == other.text_sha1)
401
 
                    and (this.text_size == other.text_size)
402
 
                    and (this.text_id == other.text_id)
403
 
                    and (this.parent_id == other.parent_id)
404
 
                    and (this.kind == other.kind)
405
 
                    and (this.executable == other.executable)
406
 
                    and (this.reference_revision == other.reference_revision)
407
 
                    )
408
 
        if not ie_equal_no_revision(new_root_ie, basis_root_ie):
409
 
            return True
410
 
 
411
 
        for new_ie, basis_ie in zip(new_entries, basis_entries):
412
 
            if new_ie != basis_ie:
413
 
                return True
414
 
 
415
 
        # No actual changes present
416
 
        return False
417
 
 
418
 
    def _check_pointless(self):
419
 
        if self.allow_pointless:
420
 
            return
421
 
        # A merge with no effect on files
422
 
        if len(self.parents) > 1:
423
 
            return
424
 
        # work around the fact that a newly-initted tree does differ from its
425
 
        # basis
426
 
        if len(self.basis_inv) == 0 and len(self.builder.new_inventory) == 1:
427
 
            raise PointlessCommit()
428
 
        # Shortcut, if the number of entries changes, then we obviously have
429
 
        # a change
430
 
        if len(self.builder.new_inventory) != len(self.basis_inv):
431
 
            return
432
 
        # If length == 1, then we only have the root entry. Which means
433
 
        # that there is no real difference (only the root could be different)
434
 
        if (len(self.builder.new_inventory) != 1 and self._any_real_changes()):
435
 
            return
436
 
        raise PointlessCommit()
437
 
 
438
 
    def _check_bound_branch(self):
439
 
        """Check to see if the local branch is bound.
440
 
 
441
 
        If it is bound, then most of the commit will actually be
442
 
        done using the remote branch as the target branch.
443
 
        Only at the end will the local branch be updated.
444
 
        """
445
 
        if self.local and not self.branch.get_bound_location():
446
 
            raise errors.LocalRequiresBoundBranch()
447
 
 
448
 
        if not self.local:
449
 
            self.master_branch = self.branch.get_master_branch()
450
 
 
451
 
        if not self.master_branch:
452
 
            # make this branch the reference branch for out of date checks.
453
 
            self.master_branch = self.branch
454
 
            return
455
 
 
456
 
        # If the master branch is bound, we must fail
457
 
        master_bound_location = self.master_branch.get_bound_location()
458
 
        if master_bound_location:
459
 
            raise errors.CommitToDoubleBoundBranch(self.branch,
460
 
                    self.master_branch, master_bound_location)
461
 
 
462
 
        # TODO: jam 20051230 We could automatically push local
463
 
        #       commits to the remote branch if they would fit.
464
 
        #       But for now, just require remote to be identical
465
 
        #       to local.
466
 
        
467
 
        # Make sure the local branch is identical to the master
468
 
        master_info = self.master_branch.last_revision_info()
469
 
        local_info = self.branch.last_revision_info()
470
 
        if local_info != master_info:
471
 
            raise errors.BoundBranchOutOfDate(self.branch,
472
 
                    self.master_branch)
473
 
 
474
 
        # Now things are ready to change the master branch
475
 
        # so grab the lock
476
 
        self.bound_branch = self.branch
477
 
        self.master_branch.lock_write()
478
 
        self.master_locked = True
479
 
 
480
 
    def _cleanup(self):
481
 
        """Cleanup any open locks, progress bars etc."""
482
 
        cleanups = [self._cleanup_bound_branch,
483
 
                    self.basis_tree.unlock,
484
 
                    self.work_tree.unlock,
485
 
                    self.pb.finished]
486
 
        found_exception = None
487
 
        for cleanup in cleanups:
488
 
            try:
489
 
                cleanup()
490
 
            # we want every cleanup to run no matter what.
491
 
            # so we have a catchall here, but we will raise the
492
 
            # last encountered exception up the stack: and
493
 
            # typically this will be useful enough.
494
 
            except Exception, e:
495
 
                found_exception = e
496
 
        if found_exception is not None: 
497
 
            # don't do a plan raise, because the last exception may have been
498
 
            # trashed, e is our sure-to-work exception even though it loses the
499
 
            # full traceback. XXX: RBC 20060421 perhaps we could check the
500
 
            # exc_info and if its the same one do a plain raise otherwise 
501
 
            # 'raise e' as we do now.
502
 
            raise e
503
 
 
504
 
    def _cleanup_bound_branch(self):
505
 
        """Executed at the end of a try/finally to cleanup a bound branch.
506
 
 
507
 
        If the branch wasn't bound, this is a no-op.
508
 
        If it was, it resents self.branch to the local branch, instead
509
 
        of being the master.
510
 
        """
511
 
        if not self.bound_branch:
512
 
            return
513
 
        if self.master_locked:
514
 
            self.master_branch.unlock()
515
 
 
516
 
    def _escape_commit_message(self):
517
 
        """Replace xml-incompatible control characters."""
518
 
        # FIXME: RBC 20060419 this should be done by the revision
519
 
        # serialiser not by commit. Then we can also add an unescaper
520
 
        # in the deserializer and start roundtripping revision messages
521
 
        # precisely. See repository_implementations/test_repository.py
522
 
        
523
 
        # Python strings can include characters that can't be
524
 
        # represented in well-formed XML; escape characters that
525
 
        # aren't listed in the XML specification
526
 
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
527
 
        self.message, escape_count = re.subn(
528
 
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
529
 
            lambda match: match.group(0).encode('unicode_escape'),
530
 
            self.message)
531
 
        if escape_count:
532
 
            self.reporter.escaped(escape_count, self.message)
533
 
 
534
 
    def _gather_parents(self):
535
 
        """Record the parents of a merge for merge detection."""
536
 
        # TODO: Make sure that this list doesn't contain duplicate 
537
 
        # entries and the order is preserved when doing this.
538
 
        self.parents = self.work_tree.get_parent_ids()
539
 
        self.parent_invs = [self.basis_inv]
540
 
        for revision in self.parents[1:]:
541
 
            if self.branch.repository.has_revision(revision):
542
 
                mutter('commit parent revision {%s}', revision)
543
 
                inventory = self.branch.repository.get_inventory(revision)
544
 
                self.parent_invs.append(inventory)
545
 
            else:
546
 
                mutter('commit parent ghost revision {%s}', revision)
547
 
 
548
 
    def _remove_deleted(self):
549
 
        """Remove deleted files from the working inventories.
550
 
 
551
 
        This is done prior to taking the working inventory as the
552
 
        basis for the new committed inventory.
553
 
 
554
 
        This returns true if any files
555
 
        *that existed in the basis inventory* were deleted.
556
 
        Files that were added and deleted
557
 
        in the working copy don't matter.
558
 
        """
559
 
        specific = self.specific_files
560
 
        deleted_ids = []
561
 
        deleted_paths = set()
562
 
        for path, ie in self.work_inv.iter_entries():
563
 
            if is_inside_any(deleted_paths, path):
564
 
                # The tree will delete the required ids recursively.
565
 
                continue
566
 
            if specific and not is_inside_any(specific, path):
567
 
                continue
568
 
            if not self.work_tree.has_filename(path):
569
 
                deleted_paths.add(path)
570
 
                self.reporter.missing(path)
571
 
                deleted_ids.append(ie.file_id)
572
 
        self.work_tree.unversion(deleted_ids)
573
 
 
574
 
    def _populate_new_inv(self):
575
 
        """Build revision inventory.
576
 
 
577
 
        This creates a new empty inventory. Depending on
578
 
        which files are selected for commit, and what is present in the
579
 
        current tree, the new inventory is populated. inventory entries 
580
 
        which are candidates for modification have their revision set to
581
 
        None; inventory entries that are carried over untouched have their
582
 
        revision set to their prior value.
583
 
        """
584
 
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
585
 
        # results to create a new inventory at the same time, which results
586
 
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
587
 
        # ADHB 11-07-2006
588
 
        mutter("Selecting files for commit with filter %s", self.specific_files)
589
 
        assert self.work_inv.root is not None
590
 
        entries = self.work_inv.iter_entries()
591
 
        if not self.builder.record_root_entry:
592
 
            symbol_versioning.warn('CommitBuilders should support recording'
593
 
                ' the root entry as of bzr 0.10.', DeprecationWarning, 
594
 
                stacklevel=1)
595
 
            self.builder.new_inventory.add(self.basis_inv.root.copy())
596
 
            entries.next()
597
 
            self._emit_progress_update()
598
 
        for path, new_ie in entries:
599
 
            self._emit_progress_update()
600
 
            file_id = new_ie.file_id
601
 
            try:
602
 
                kind = self.work_tree.kind(file_id)
603
 
                if kind == 'tree-reference' and self.recursive == 'down':
604
 
                    # nested tree: commit in it
605
 
                    sub_tree = WorkingTree.open(self.work_tree.abspath(path))
606
 
                    # FIXME: be more comprehensive here:
607
 
                    # this works when both trees are in --trees repository,
608
 
                    # but when both are bound to a different repository,
609
 
                    # it fails; a better way of approaching this is to 
610
 
                    # finally implement the explicit-caches approach design
611
 
                    # a while back - RBC 20070306.
612
 
                    if (sub_tree.branch.repository.bzrdir.root_transport.base
613
 
                        ==
614
 
                        self.work_tree.branch.repository.bzrdir.root_transport.base):
615
 
                        sub_tree.branch.repository = \
616
 
                            self.work_tree.branch.repository
617
 
                    try:
618
 
                        sub_tree.commit(message=None, revprops=self.revprops,
619
 
                            recursive=self.recursive,
620
 
                            message_callback=self.message_callback,
621
 
                            timestamp=self.timestamp, timezone=self.timezone,
622
 
                            committer=self.committer,
623
 
                            allow_pointless=self.allow_pointless,
624
 
                            strict=self.strict, verbose=self.verbose,
625
 
                            local=self.local, reporter=self.reporter)
626
 
                    except errors.PointlessCommit:
627
 
                        pass
628
 
                if kind != new_ie.kind:
629
 
                    new_ie = inventory.make_entry(kind, new_ie.name,
630
 
                                                  new_ie.parent_id, file_id)
631
 
            except errors.NoSuchFile:
632
 
                pass
633
 
            # mutter('check %s {%s}', path, file_id)
634
 
            if (not self.specific_files or 
635
 
                is_inside_or_parent_of_any(self.specific_files, path)):
636
 
                    # mutter('%s selected for commit', path)
637
 
                    ie = new_ie.copy()
638
 
                    ie.revision = None
639
 
            else:
640
 
                # mutter('%s not selected for commit', path)
641
 
                if self.basis_inv.has_id(file_id):
642
 
                    ie = self.basis_inv[file_id].copy()
643
 
                else:
644
 
                    # this entry is new and not being committed
645
 
                    continue
646
 
            self.builder.record_entry_contents(ie, self.parent_invs, 
647
 
                path, self.work_tree)
648
 
            # describe the nature of the change that has occurred relative to
649
 
            # the basis inventory.
650
 
            if (self.basis_inv.has_id(ie.file_id)):
651
 
                basis_ie = self.basis_inv[ie.file_id]
652
 
            else:
653
 
                basis_ie = None
654
 
            change = ie.describe_change(basis_ie, ie)
655
 
            if change in (InventoryEntry.RENAMED, 
656
 
                InventoryEntry.MODIFIED_AND_RENAMED):
657
 
                old_path = self.basis_inv.id2path(ie.file_id)
658
 
                self.reporter.renamed(change, old_path, path)
659
 
            else:
660
 
                self.reporter.snapshot_change(change, path)
661
 
 
662
 
        if not self.specific_files:
663
 
            return
664
 
 
665
 
        # ignore removals that don't match filespec
666
 
        for path, new_ie in self.basis_inv.iter_entries():
667
 
            if new_ie.file_id in self.work_inv:
668
 
                continue
669
 
            if is_inside_any(self.specific_files, path):
670
 
                continue
671
 
            ie = new_ie.copy()
672
 
            ie.revision = None
673
 
            self.builder.record_entry_contents(ie, self.parent_invs, path,
674
 
                                               self.basis_tree)
675
 
 
676
 
    def _emit_progress_update(self):
677
 
        """Emit an update to the progress bar."""
678
 
        self.pb.update("Committing", self.pb_count, self.pb_total)
679
 
        self.pb_count += 1
680
 
 
681
 
    def _report_deletes(self):
682
 
        for path, ie in self.basis_inv.iter_entries():
683
 
            if ie.file_id not in self.builder.new_inventory:
684
 
                self.reporter.deleted(path)
 
48
    from branch import gen_file_id
 
49
    from errors import BzrError
 
50
    from revision import Revision
 
51
    from textui import show_status
 
52
    from trace import mutter, note
 
53
 
 
54
    branch._need_writelock()
 
55
 
 
56
    ## TODO: Show branch names
 
57
 
 
58
    # TODO: Don't commit if there are no changes, unless forced?
 
59
 
 
60
    # First walk over the working inventory; and both update that
 
61
    # and also build a new revision inventory.  The revision
 
62
    # inventory needs to hold the text-id, sha1 and size of the
 
63
    # actual file versions committed in the revision.  (These are
 
64
    # not present in the working inventory.)  We also need to
 
65
    # detect missing/deleted files, and remove them from the
 
66
    # working inventory.
 
67
 
 
68
    work_inv = branch.read_working_inventory()
 
69
    inv = Inventory()
 
70
    basis = branch.basis_tree()
 
71
    basis_inv = basis.inventory
 
72
    missing_ids = []
 
73
    for path, entry in work_inv.iter_entries():
 
74
        ## TODO: Cope with files that have gone missing.
 
75
 
 
76
        ## TODO: Check that the file kind has not changed from the previous
 
77
        ## revision of this file (if any).
 
78
 
 
79
        entry = entry.copy()
 
80
 
 
81
        p = branch.abspath(path)
 
82
        file_id = entry.file_id
 
83
        mutter('commit prep file %s, id %r ' % (p, file_id))
 
84
 
 
85
        if not os.path.exists(p):
 
86
            mutter("    file is missing, removing from inventory")
 
87
            if verbose:
 
88
                show_status('D', entry.kind, quotefn(path))
 
89
            missing_ids.append(file_id)
 
90
            continue
 
91
 
 
92
        # TODO: Handle files that have been deleted
 
93
 
 
94
        # TODO: Maybe a special case for empty files?  Seems a
 
95
        # waste to store them many times.
 
96
 
 
97
        inv.add(entry)
 
98
 
 
99
        if basis_inv.has_id(file_id):
 
100
            old_kind = basis_inv[file_id].kind
 
101
            if old_kind != entry.kind:
 
102
                raise BzrError("entry %r changed kind from %r to %r"
 
103
                        % (file_id, old_kind, entry.kind))
 
104
 
 
105
        if entry.kind == 'directory':
 
106
            if not isdir(p):
 
107
                raise BzrError("%s is entered as directory but not a directory" % quotefn(p))
 
108
        elif entry.kind == 'file':
 
109
            if not isfile(p):
 
110
                raise BzrError("%s is entered as file but is not a file" % quotefn(p))
 
111
 
 
112
            content = file(p, 'rb').read()
 
113
 
 
114
            entry.text_sha1 = sha_string(content)
 
115
            entry.text_size = len(content)
 
116
 
 
117
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
118
            if (old_ie
 
119
                and (old_ie.text_size == entry.text_size)
 
120
                and (old_ie.text_sha1 == entry.text_sha1)):
 
121
                ## assert content == basis.get_file(file_id).read()
 
122
                entry.text_id = basis_inv[file_id].text_id
 
123
                mutter('    unchanged from previous text_id {%s}' %
 
124
                       entry.text_id)
 
125
 
 
126
            else:
 
127
                entry.text_id = gen_file_id(entry.name)
 
128
                branch.text_store.add(content, entry.text_id)
 
129
                mutter('    stored with text_id {%s}' % entry.text_id)
 
130
                if verbose:
 
131
                    if not old_ie:
 
132
                        state = 'A'
 
133
                    elif (old_ie.name == entry.name
 
134
                          and old_ie.parent_id == entry.parent_id):
 
135
                        state = 'M'
 
136
                    else:
 
137
                        state = 'R'
 
138
 
 
139
                    show_status(state, entry.kind, quotefn(path))
 
140
 
 
141
    for file_id in missing_ids:
 
142
        # have to do this later so we don't mess up the iterator.
 
143
        # since parents may be removed before their children we
 
144
        # have to test.
 
145
 
 
146
        # FIXME: There's probably a better way to do this; perhaps
 
147
        # the workingtree should know how to filter itbranch.
 
148
        if work_inv.has_id(file_id):
 
149
            del work_inv[file_id]
 
150
 
 
151
 
 
152
    inv_id = rev_id = _gen_revision_id(time.time())
 
153
 
 
154
    inv_tmp = tempfile.TemporaryFile()
 
155
    inv.write_xml(inv_tmp)
 
156
    inv_tmp.seek(0)
 
157
    branch.inventory_store.add(inv_tmp, inv_id)
 
158
    mutter('new inventory_id is {%s}' % inv_id)
 
159
 
 
160
    branch._write_inventory(work_inv)
 
161
 
 
162
    if timestamp == None:
 
163
        timestamp = time.time()
 
164
 
 
165
    if committer == None:
 
166
        committer = username()
 
167
 
 
168
    if timezone == None:
 
169
        timezone = local_time_offset()
 
170
 
 
171
    mutter("building commit log message")
 
172
    rev = Revision(timestamp=timestamp,
 
173
                   timezone=timezone,
 
174
                   committer=committer,
 
175
                   precursor = branch.last_patch(),
 
176
                   message = message,
 
177
                   inventory_id=inv_id,
 
178
                   revision_id=rev_id)
 
179
 
 
180
    rev_tmp = tempfile.TemporaryFile()
 
181
    rev.write_xml(rev_tmp)
 
182
    rev_tmp.seek(0)
 
183
    branch.revision_store.add(rev_tmp, rev_id)
 
184
    mutter("new revision_id is {%s}" % rev_id)
 
185
 
 
186
    ## XXX: Everything up to here can simply be orphaned if we abort
 
187
    ## the commit; it will leave junk files behind but that doesn't
 
188
    ## matter.
 
189
 
 
190
    ## TODO: Read back the just-generated changeset, and make sure it
 
191
    ## applies and recreates the right state.
 
192
 
 
193
    ## TODO: Also calculate and store the inventory SHA1
 
194
    mutter("committing patch r%d" % (branch.revno() + 1))
 
195
 
 
196
 
 
197
    branch.append_revision(rev_id)
 
198
 
 
199
    if verbose:
 
200
        note("commited r%d" % branch.revno())
 
201
 
 
202
 
 
203
 
 
204
def _gen_revision_id(when):
 
205
    """Return new revision-id."""
 
206
    from binascii import hexlify
 
207
    from osutils import rand_bytes, compact_date, user_email
 
208
 
 
209
    s = '%s-%s-' % (user_email(), compact_date(when))
 
210
    s += hexlify(rand_bytes(8))
 
211
    return s
685
212
 
686
213