~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

Merge John Meinels patch to support trees with fifo/socket/block files present in the tree

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Copyright (C) 2005 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
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
 
# XXX: Can we do any better about making interrupted commits change
19
 
# nothing?  Perhaps the best approach is to integrate commit of
20
 
# AtomicFiles with releasing the lock on the Branch.
21
 
 
22
 
# TODO: Separate 'prepare' phase where we find a list of potentially
23
 
# committed files.  We then can then pause the commit to prompt for a
24
 
# commit message, knowing the summary will be the same as what's
25
 
# actually used for the commit.  (But perhaps simpler to simply get
26
 
# the tree status, then use that for a selective commit?)
27
 
 
28
 
# The newly committed revision is going to have a shape corresponding
29
 
# to that of the working inventory.  Files that are not in the
30
 
# working tree and that were in the predecessor are reported as
31
 
# removed --- this can include files that were either removed from the
32
 
# inventory or deleted in the working tree.  If they were only
33
 
# deleted from disk, they are removed from the working inventory.
34
 
 
35
 
# We then consider the remaining entries, which will be in the new
36
 
# version.  Directory entries are simply copied across.  File entries
37
 
# must be checked to see if a new version of the file should be
38
 
# recorded.  For each parent revision inventory, we check to see what
39
 
# version of the file was present.  If the file was present in at
40
 
# least one tree, and if it was the same version in all the trees,
41
 
# then we can just refer to that version.  Otherwise, a new version
42
 
# representing the merger of the file versions must be added.
43
 
 
44
 
# TODO: Update hashcache before and after - or does the WorkingTree
45
 
# look after that?
46
 
 
47
 
# TODO: Rather than mashing together the ancestry and storing it back,
48
 
# perhaps the weave should have single method which does it all in one
49
 
# go, avoiding a lot of redundant work.
50
 
 
51
 
# TODO: Perhaps give a warning if one of the revisions marked as
52
 
# merged is already in the ancestry, and then don't record it as a
53
 
# distinct parent.
54
 
 
55
 
# TODO: If the file is newly merged but unchanged from the version it
56
 
# merges from, then it should still be reported as newly added
57
 
# relative to the basis revision.
58
 
 
59
 
# TODO: Do checks that the tree can be committed *before* running the 
60
 
# editor; this should include checks for a pointless commit and for 
61
 
# unknown or missing files.
62
 
 
63
 
# TODO: If commit fails, leave the message in a file somewhere.
64
 
 
65
 
 
66
 
import os
67
 
import re
68
 
import sys
69
 
import time
70
 
import pdb
71
 
 
72
 
from binascii import hexlify
73
 
from cStringIO import StringIO
74
 
 
75
 
from bzrlib.atomicfile import AtomicFile
76
 
from bzrlib.osutils import (local_time_offset,
77
 
                            rand_bytes, compact_date,
78
 
                            kind_marker, is_inside_any, quotefn,
79
 
                            sha_string, sha_strings, sha_file, isdir, isfile,
80
 
                            split_lines)
81
 
import bzrlib.config
82
 
from bzrlib.errors import (BzrError, PointlessCommit,
83
 
                           HistoryMissing,
84
 
                           ConflictsInTree,
85
 
                           StrictCommitFailed
86
 
                           )
87
 
import bzrlib.gpg as gpg
88
 
from bzrlib.revision import Revision
89
 
from bzrlib.testament import Testament
90
 
from bzrlib.trace import mutter, note, warning
91
 
from bzrlib.xml5 import serializer_v5
92
 
from bzrlib.inventory import Inventory, ROOT_ID
93
 
from bzrlib.weave import Weave
94
 
from bzrlib.weavefile import read_weave, write_weave_v5
95
 
from bzrlib.workingtree import WorkingTree
96
 
 
97
 
 
98
 
def commit(*args, **kwargs):
99
 
    """Commit a new revision to a branch.
100
 
 
101
 
    Function-style interface for convenience of old callers.
102
 
 
103
 
    New code should use the Commit class instead.
104
 
    """
105
 
    ## XXX: Remove this in favor of Branch.commit?
106
 
    Commit().commit(*args, **kwargs)
107
 
 
108
 
 
109
 
class NullCommitReporter(object):
110
 
    """I report on progress of a commit."""
111
 
 
112
 
    def snapshot_change(self, change, path):
113
 
        pass
114
 
 
115
 
    def completed(self, revno, rev_id):
116
 
        pass
117
 
 
118
 
    def deleted(self, file_id):
119
 
        pass
120
 
 
121
 
    def escaped(self, escape_count, message):
122
 
        pass
123
 
 
124
 
    def missing(self, path):
125
 
        pass
126
 
 
127
 
 
128
 
class ReportCommitToLog(NullCommitReporter):
129
 
 
130
 
    def snapshot_change(self, change, path):
131
 
        note("%s %s", change, path)
132
 
 
133
 
    def completed(self, revno, rev_id):
134
 
        note('committed r%d {%s}', revno, rev_id)
135
 
    
136
 
    def deleted(self, file_id):
137
 
        note('deleted %s', file_id)
138
 
 
139
 
    def escaped(self, escape_count, message):
140
 
        note("replaced %d control characters in message", escape_count)
141
 
 
142
 
    def missing(self, path):
143
 
        note('missing %s', path)
144
 
 
145
 
 
146
 
class Commit(object):
147
 
    """Task of committing a new revision.
148
 
 
149
 
    This is a MethodObject: it accumulates state as the commit is
150
 
    prepared, and then it is discarded.  It doesn't represent
151
 
    historical revisions, just the act of recording a new one.
152
 
 
153
 
            missing_ids
154
 
            Modified to hold a list of files that have been deleted from
155
 
            the working directory; these should be removed from the
156
 
            working inventory.
157
 
    """
158
 
    def __init__(self,
159
 
                 reporter=None,
160
 
                 config=None):
161
 
        if reporter is not None:
162
 
            self.reporter = reporter
163
 
        else:
164
 
            self.reporter = NullCommitReporter()
165
 
        if config is not None:
166
 
            self.config = config
167
 
        else:
168
 
            self.config = None
169
 
        
170
 
    def commit(self,
171
 
               branch, message,
172
 
               timestamp=None,
173
 
               timezone=None,
174
 
               committer=None,
175
 
               specific_files=None,
176
 
               rev_id=None,
177
 
               allow_pointless=True,
178
 
               strict=False,
179
 
               verbose=False,
180
 
               revprops=None):
181
 
        """Commit working copy as a new revision.
182
 
 
183
 
        timestamp -- if not None, seconds-since-epoch for a
184
 
             postdated/predated commit.
185
 
 
186
 
        specific_files -- If true, commit only those files.
187
 
 
188
 
        rev_id -- If set, use this as the new revision id.
189
 
            Useful for test or import commands that need to tightly
190
 
            control what revisions are assigned.  If you duplicate
191
 
            a revision id that exists elsewhere it is your own fault.
192
 
            If null (default), a time/random revision id is generated.
193
 
 
194
 
        allow_pointless -- If true (default), commit even if nothing
195
 
            has changed and no merges are recorded.
196
 
 
197
 
        strict -- If true, don't allow a commit if the working tree
198
 
            contains unknown files.
199
 
 
200
 
        revprops -- Properties for new revision
201
 
        """
202
 
        mutter('preparing to commit')
203
 
 
204
 
        self.branch = branch
205
 
        self.weave_store = branch.repository.weave_store
206
 
        self.rev_id = rev_id
207
 
        self.specific_files = specific_files
208
 
        self.allow_pointless = allow_pointless
209
 
        self.revprops = {'branch-nick': branch.nick}
210
 
        if revprops:
211
 
            self.revprops.update(revprops)
212
 
        self.work_tree = WorkingTree(branch.base, branch)
213
 
 
214
 
        if strict:
215
 
            # raise an exception as soon as we find a single unknown.
216
 
            for unknown in self.work_tree.unknowns():
217
 
                raise StrictCommitFailed()
218
 
 
219
 
        if timestamp is None:
220
 
            self.timestamp = time.time()
221
 
        else:
222
 
            self.timestamp = long(timestamp)
223
 
            
224
 
        if self.config is None:
225
 
            self.config = bzrlib.config.BranchConfig(self.branch)
 
18
 
 
19
def commit(branch, message,
 
20
           timestamp=None,
 
21
           timezone=None,
 
22
           committer=None,
 
23
           verbose=True,
 
24
           specific_files=None,
 
25
           rev_id=None,
 
26
           allow_pointless=True):
 
27
    """Commit working copy as a new revision.
 
28
 
 
29
    The basic approach is to add all the file texts into the
 
30
    store, then the inventory, then make a new revision pointing
 
31
    to that inventory and store that.
 
32
 
 
33
    This is not quite safe if the working copy changes during the
 
34
    commit; for the moment that is simply not allowed.  A better
 
35
    approach is to make a temporary copy of the files before
 
36
    computing their hashes, and then add those hashes in turn to
 
37
    the inventory.  This should mean at least that there are no
 
38
    broken hash pointers.  There is no way we can get a snapshot
 
39
    of the whole directory at an instant.  This would also have to
 
40
    be robust against files disappearing, moving, etc.  So the
 
41
    whole thing is a bit hard.
 
42
 
 
43
    This raises PointlessCommit if there are no changes, no new merges,
 
44
    and allow_pointless  is false.
 
45
 
 
46
    timestamp -- if not None, seconds-since-epoch for a
 
47
         postdated/predated commit.
 
48
 
 
49
    specific_files
 
50
        If true, commit only those files.
 
51
 
 
52
    rev_id
 
53
        If set, use this as the new revision id.
 
54
        Useful for test or import commands that need to tightly
 
55
        control what revisions are assigned.  If you duplicate
 
56
        a revision id that exists elsewhere it is your own fault.
 
57
        If null (default), a time/random revision id is generated.
 
58
    """
 
59
 
 
60
    import time, tempfile, re
 
61
 
 
62
    from bzrlib.osutils import local_time_offset, username
 
63
    from bzrlib.branch import gen_file_id
 
64
    from bzrlib.errors import BzrError, PointlessCommit
 
65
    from bzrlib.revision import Revision, RevisionReference
 
66
    from bzrlib.trace import mutter, note
 
67
    from bzrlib.xml import serializer_v4
 
68
 
 
69
    branch.lock_write()
 
70
 
 
71
    try:
 
72
        # First walk over the working inventory; and both update that
 
73
        # and also build a new revision inventory.  The revision
 
74
        # inventory needs to hold the text-id, sha1 and size of the
 
75
        # actual file versions committed in the revision.  (These are
 
76
        # not present in the working inventory.)  We also need to
 
77
        # detect missing/deleted files, and remove them from the
 
78
        # working inventory.
 
79
 
 
80
        work_tree = branch.working_tree()
 
81
        work_inv = work_tree.inventory
 
82
        basis = branch.basis_tree()
 
83
        basis_inv = basis.inventory
 
84
 
 
85
        if verbose:
 
86
            # note('looking for changes...')
 
87
            # print 'looking for changes...'
 
88
            # disabled; should be done at a higher level
 
89
            pass
 
90
 
 
91
        pending_merges = branch.pending_merges()
 
92
 
 
93
        missing_ids, new_inv, any_changes = \
 
94
                     _gather_commit(branch,
 
95
                                    work_tree,
 
96
                                    work_inv,
 
97
                                    basis_inv,
 
98
                                    specific_files,
 
99
                                    verbose)
 
100
 
 
101
        if not (any_changes or allow_pointless or pending_merges):
 
102
            raise PointlessCommit()
 
103
 
 
104
        for file_id in missing_ids:
 
105
            # Any files that have been deleted are now removed from the
 
106
            # working inventory.  Files that were not selected for commit
 
107
            # are left as they were in the working inventory and ommitted
 
108
            # from the revision inventory.
 
109
 
 
110
            # have to do this later so we don't mess up the iterator.
 
111
            # since parents may be removed before their children we
 
112
            # have to test.
 
113
 
 
114
            # FIXME: There's probably a better way to do this; perhaps
 
115
            # the workingtree should know how to filter itbranch.
 
116
            if work_inv.has_id(file_id):
 
117
                del work_inv[file_id]
226
118
 
227
119
        if rev_id is None:
228
 
            self.rev_id = _gen_revision_id(self.config, self.timestamp)
229
 
        else:
230
 
            self.rev_id = rev_id
231
 
 
232
 
        if committer is None:
233
 
            self.committer = self.config.username()
234
 
        else:
235
 
            assert isinstance(committer, basestring), type(committer)
236
 
            self.committer = committer
237
 
 
238
 
        if timezone is None:
239
 
            self.timezone = local_time_offset()
240
 
        else:
241
 
            self.timezone = int(timezone)
242
 
 
243
 
        if isinstance(message, str):
244
 
            message = message.decode(bzrlib.user_encoding)
245
 
        assert isinstance(message, unicode), type(message)
246
 
        self.message = message
247
 
        self._escape_commit_message()
248
 
 
249
 
        self.branch.lock_write()
250
 
        try:
251
 
            self.work_inv = self.work_tree.inventory
252
 
            self.basis_tree = self.branch.basis_tree()
253
 
            self.basis_inv = self.basis_tree.inventory
254
 
 
255
 
            self._gather_parents()
256
 
            if len(self.parents) > 1 and self.specific_files:
257
 
                raise NotImplementedError('selected-file commit of merges is not supported yet')
258
 
            self._check_parents_present()
259
 
            
260
 
            self._remove_deleted()
261
 
            self._populate_new_inv()
262
 
            self._store_snapshot()
263
 
            self._report_deletes()
264
 
 
265
 
            if not (self.allow_pointless
266
 
                    or len(self.parents) > 1
267
 
                    or self.new_inv != self.basis_inv):
268
 
                raise PointlessCommit()
269
 
 
270
 
            if len(list(self.work_tree.iter_conflicts()))>0:
271
 
                raise ConflictsInTree
272
 
 
273
 
            self._record_inventory()
274
 
            self._make_revision()
275
 
            self.work_tree.set_pending_merges([])
276
 
            self.branch.append_revision(self.rev_id)
277
 
            self.reporter.completed(self.branch.revno()+1, self.rev_id)
278
 
            if self.config.post_commit() is not None:
279
 
                hooks = self.config.post_commit().split(' ')
280
 
                # this would be nicer with twisted.python.reflect.namedAny
281
 
                for hook in hooks:
282
 
                    result = eval(hook + '(branch, rev_id)',
283
 
                                  {'branch':self.branch,
284
 
                                   'bzrlib':bzrlib,
285
 
                                   'rev_id':self.rev_id})
286
 
        finally:
287
 
            self.branch.unlock()
288
 
 
289
 
    def _record_inventory(self):
290
 
        """Store the inventory for the new revision."""
291
 
        inv_text = serializer_v5.write_inventory_to_string(self.new_inv)
292
 
        self.inv_sha1 = sha_string(inv_text)
293
 
        s = self.branch.repository.control_weaves
294
 
        s.add_text('inventory', self.rev_id,
295
 
                   split_lines(inv_text), self.present_parents,
296
 
                   self.branch.get_transaction())
297
 
 
298
 
    def _escape_commit_message(self):
299
 
        """Replace xml-incompatible control characters."""
 
120
            rev_id = _gen_revision_id(branch, time.time())
 
121
        inv_id = rev_id
 
122
 
 
123
        inv_tmp = tempfile.TemporaryFile()
 
124
        
 
125
        serializer_v4.write_inventory(new_inv, inv_tmp)
 
126
        inv_tmp.seek(0)
 
127
        branch.inventory_store.add(inv_tmp, inv_id)
 
128
        mutter('new inventory_id is {%s}' % inv_id)
 
129
 
 
130
        # We could also just sha hash the inv_tmp file
 
131
        # however, in the case that branch.inventory_store.add()
 
132
        # ever actually does anything special
 
133
        inv_sha1 = branch.get_inventory_sha1(inv_id)
 
134
 
 
135
        branch._write_inventory(work_inv)
 
136
 
 
137
        if timestamp == None:
 
138
            timestamp = time.time()
 
139
 
 
140
        if committer == None:
 
141
            committer = username(branch)
 
142
 
 
143
        if timezone == None:
 
144
            timezone = local_time_offset()
 
145
 
 
146
        mutter("building commit log message")
300
147
        # Python strings can include characters that can't be
301
148
        # represented in well-formed XML; escape characters that
302
149
        # aren't listed in the XML specification
303
150
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
304
 
        self.message, escape_count = re.subn(
305
 
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
 
151
        if isinstance(message, unicode):
 
152
            char_pattern = u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]'
 
153
        else:
 
154
            # Use a regular 'str' as pattern to avoid having re.subn
 
155
            # return 'unicode' results.
 
156
            char_pattern = '[^x09\x0A\x0D\x20-\xFF]'
 
157
        message, escape_count = re.subn(
 
158
            char_pattern,
306
159
            lambda match: match.group(0).encode('unicode_escape'),
307
 
            self.message)
 
160
            message)
308
161
        if escape_count:
309
 
            self.reporter.escaped(escape_count, self.message)
 
162
            note("replaced %d control characters in message", escape_count)
 
163
        rev = Revision(timestamp=timestamp,
 
164
                       timezone=timezone,
 
165
                       committer=committer,
 
166
                       message = message,
 
167
                       inventory_id=inv_id,
 
168
                       inventory_sha1=inv_sha1,
 
169
                       revision_id=rev_id)
310
170
 
311
 
    def _gather_parents(self):
312
 
        """Record the parents of a merge for merge detection."""
313
 
        pending_merges = self.work_tree.pending_merges()
314
 
        self.parents = []
315
 
        self.parent_invs = []
316
 
        self.present_parents = []
317
 
        precursor_id = self.branch.last_revision()
 
171
        rev.parents = []
 
172
        precursor_id = branch.last_patch()
318
173
        if precursor_id:
319
 
            self.parents.append(precursor_id)
320
 
        self.parents += pending_merges
321
 
        for revision in self.parents:
322
 
            if self.branch.repository.has_revision(revision):
323
 
                inventory = self.branch.repository.get_inventory(revision)
324
 
                self.parent_invs.append(inventory)
325
 
                self.present_parents.append(revision)
 
174
            precursor_sha1 = branch.get_revision_sha1(precursor_id)
 
175
            rev.parents.append(RevisionReference(precursor_id, precursor_sha1))
 
176
        for merge_rev in pending_merges:
 
177
            rev.parents.append(RevisionReference(merge_rev))            
326
178
 
327
 
    def _check_parents_present(self):
328
 
        for parent_id in self.parents:
329
 
            mutter('commit parent revision {%s}', parent_id)
330
 
            if not self.branch.repository.has_revision(parent_id):
331
 
                if parent_id == self.branch.last_revision():
332
 
                    warning("parent is missing %r", parent_id)
333
 
                    raise HistoryMissing(self.branch, 'revision', parent_id)
334
 
                else:
335
 
                    mutter("commit will ghost revision %r", parent_id)
336
 
            
337
 
    def _make_revision(self):
338
 
        """Record a new revision object for this commit."""
339
 
        self.rev = Revision(timestamp=self.timestamp,
340
 
                            timezone=self.timezone,
341
 
                            committer=self.committer,
342
 
                            message=self.message,
343
 
                            inventory_sha1=self.inv_sha1,
344
 
                            revision_id=self.rev_id,
345
 
                            properties=self.revprops)
346
 
        self.rev.parent_ids = self.parents
347
 
        rev_tmp = StringIO()
348
 
        serializer_v5.write_revision(self.rev, rev_tmp)
 
179
        rev_tmp = tempfile.TemporaryFile()
 
180
        serializer_v4.write_revision(rev, rev_tmp)
349
181
        rev_tmp.seek(0)
350
 
        if self.config.signature_needed():
351
 
            plaintext = Testament(self.rev, self.new_inv).as_short_text()
352
 
            self.branch.repository.store_revision_signature(
353
 
                gpg.GPGStrategy(self.config), plaintext, self.rev_id)
354
 
        self.branch.repository.revision_store.add(rev_tmp, self.rev_id)
355
 
        mutter('new revision_id is {%s}', self.rev_id)
356
 
 
357
 
    def _remove_deleted(self):
358
 
        """Remove deleted files from the working inventories.
359
 
 
360
 
        This is done prior to taking the working inventory as the
361
 
        basis for the new committed inventory.
362
 
 
363
 
        This returns true if any files
364
 
        *that existed in the basis inventory* were deleted.
365
 
        Files that were added and deleted
366
 
        in the working copy don't matter.
367
 
        """
368
 
        specific = self.specific_files
369
 
        deleted_ids = []
370
 
        for path, ie in self.work_inv.iter_entries():
371
 
            if specific and not is_inside_any(specific, path):
372
 
                continue
373
 
            if not self.work_tree.has_filename(path):
374
 
                self.reporter.missing(path)
375
 
                deleted_ids.append((path, ie.file_id))
376
 
        if deleted_ids:
377
 
            deleted_ids.sort(reverse=True)
378
 
            for path, file_id in deleted_ids:
379
 
                del self.work_inv[file_id]
380
 
            self.work_tree._write_inventory(self.work_inv)
381
 
 
382
 
    def _store_snapshot(self):
383
 
        """Pass over inventory and record a snapshot.
384
 
 
385
 
        Entries get a new revision when they are modified in 
386
 
        any way, which includes a merge with a new set of
387
 
        parents that have the same entry. 
388
 
        """
389
 
        # XXX: Need to think more here about when the user has
390
 
        # made a specific decision on a particular value -- c.f.
391
 
        # mark-merge.  
392
 
        for path, ie in self.new_inv.iter_entries():
393
 
            previous_entries = ie.find_previous_heads(
394
 
                self.parent_invs, 
395
 
                self.weave_store.get_weave_prelude_or_empty(ie.file_id,
396
 
                    self.branch.get_transaction()))
397
 
            if ie.revision is None:
398
 
                change = ie.snapshot(self.rev_id, path, previous_entries,
399
 
                                     self.work_tree, self.weave_store,
400
 
                                     self.branch.get_transaction())
401
 
            else:
402
 
                change = "unchanged"
403
 
            self.reporter.snapshot_change(change, path)
404
 
 
405
 
    def _populate_new_inv(self):
406
 
        """Build revision inventory.
407
 
 
408
 
        This creates a new empty inventory. Depending on
409
 
        which files are selected for commit, and what is present in the
410
 
        current tree, the new inventory is populated. inventory entries 
411
 
        which are candidates for modification have their revision set to
412
 
        None; inventory entries that are carried over untouched have their
413
 
        revision set to their prior value.
414
 
        """
415
 
        mutter("Selecting files for commit with filter %s", self.specific_files)
416
 
        self.new_inv = Inventory()
417
 
        for path, new_ie in self.work_inv.iter_entries():
418
 
            file_id = new_ie.file_id
419
 
            mutter('check %s {%s}', path, new_ie.file_id)
420
 
            if self.specific_files:
421
 
                if not is_inside_any(self.specific_files, path):
422
 
                    mutter('%s not selected for commit', path)
423
 
                    self._carry_entry(file_id)
424
 
                    continue
425
 
                else:
426
 
                    # this is selected, ensure its parents are too.
427
 
                    parent_id = new_ie.parent_id
428
 
                    while parent_id != ROOT_ID:
429
 
                        if not self.new_inv.has_id(parent_id):
430
 
                            ie = self._select_entry(self.work_inv[parent_id])
431
 
                            mutter('%s selected for commit because of %s',
432
 
                                   self.new_inv.id2path(parent_id), path)
433
 
 
434
 
                        ie = self.new_inv[parent_id]
435
 
                        if ie.revision is not None:
436
 
                            ie.revision = None
437
 
                            mutter('%s selected for commit because of %s',
438
 
                                   self.new_inv.id2path(parent_id), path)
439
 
                        parent_id = ie.parent_id
440
 
            mutter('%s selected for commit', path)
441
 
            self._select_entry(new_ie)
442
 
 
443
 
    def _select_entry(self, new_ie):
444
 
        """Make new_ie be considered for committing."""
445
 
        ie = new_ie.copy()
446
 
        ie.revision = None
447
 
        self.new_inv.add(ie)
448
 
        return ie
449
 
 
450
 
    def _carry_entry(self, file_id):
451
 
        """Carry the file unchanged from the basis revision."""
452
 
        if self.basis_inv.has_id(file_id):
453
 
            self.new_inv.add(self.basis_inv[file_id].copy())
454
 
 
455
 
    def _report_deletes(self):
456
 
        for file_id in self.basis_inv:
457
 
            if file_id not in self.new_inv:
458
 
                self.reporter.deleted(self.basis_inv.id2path(file_id))
459
 
 
460
 
def _gen_revision_id(config, when):
 
182
        branch.revision_store.add(rev_tmp, rev_id)
 
183
        mutter("new revision_id is {%s}" % rev_id)
 
184
 
 
185
        ## XXX: Everything up to here can simply be orphaned if we abort
 
186
        ## the commit; it will leave junk files behind but that doesn't
 
187
        ## matter.
 
188
 
 
189
        ## TODO: Read back the just-generated changeset, and make sure it
 
190
        ## applies and recreates the right state.
 
191
 
 
192
        ## TODO: Also calculate and store the inventory SHA1
 
193
        mutter("committing patch r%d" % (branch.revno() + 1))
 
194
 
 
195
        branch.append_revision(rev_id)
 
196
 
 
197
        branch.set_pending_merges([])
 
198
 
 
199
        if verbose:
 
200
            # disabled; should go through logging
 
201
            # note("commited r%d" % branch.revno())
 
202
            # print ("commited r%d" % branch.revno())
 
203
            pass
 
204
    finally:
 
205
        branch.unlock()
 
206
 
 
207
 
 
208
 
 
209
def _gen_revision_id(branch, when):
461
210
    """Return new revision-id."""
462
 
    s = '%s-%s-' % (config.user_email(), compact_date(when))
 
211
    from binascii import hexlify
 
212
    from bzrlib.osutils import rand_bytes, compact_date, user_email
 
213
 
 
214
    s = '%s-%s-' % (user_email(branch), compact_date(when))
463
215
    s += hexlify(rand_bytes(8))
464
216
    return s
 
217
 
 
218
 
 
219
def _gather_commit(branch, work_tree, work_inv, basis_inv, specific_files,
 
220
                   verbose):
 
221
    """Build inventory preparatory to commit.
 
222
 
 
223
    Returns missing_ids, new_inv, any_changes.
 
224
 
 
225
    This adds any changed files into the text store, and sets their
 
226
    test-id, sha and size in the returned inventory appropriately.
 
227
 
 
228
    missing_ids
 
229
        Modified to hold a list of files that have been deleted from
 
230
        the working directory; these should be removed from the
 
231
        working inventory.
 
232
    """
 
233
    from bzrlib.inventory import Inventory
 
234
    from bzrlib.osutils import isdir, isfile, sha_string, quotefn, \
 
235
         local_time_offset, username, kind_marker, is_inside_any
 
236
    
 
237
    from bzrlib.branch import gen_file_id
 
238
    from bzrlib.errors import BzrError
 
239
    from bzrlib.revision import Revision
 
240
    from bzrlib.trace import mutter, note
 
241
 
 
242
    any_changes = False
 
243
    inv = Inventory(work_inv.root.file_id)
 
244
    missing_ids = []
 
245
    
 
246
    for path, entry in work_inv.iter_entries():
 
247
        ## TODO: Check that the file kind has not changed from the previous
 
248
        ## revision of this file (if any).
 
249
 
 
250
        p = branch.abspath(path)
 
251
        file_id = entry.file_id
 
252
        mutter('commit prep file %s, id %r ' % (p, file_id))
 
253
 
 
254
        if specific_files and not is_inside_any(specific_files, path):
 
255
            mutter('  skipping file excluded from commit')
 
256
            if basis_inv.has_id(file_id):
 
257
                # carry over with previous state
 
258
                inv.add(basis_inv[file_id].copy())
 
259
            else:
 
260
                # omit this from committed inventory
 
261
                pass
 
262
            continue
 
263
 
 
264
        if not work_tree.has_id(file_id):
 
265
            if verbose:
 
266
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
 
267
            any_changes = True
 
268
            mutter("    file is missing, removing from inventory")
 
269
            missing_ids.append(file_id)
 
270
            continue
 
271
 
 
272
        # this is present in the new inventory; may be new, modified or
 
273
        # unchanged.
 
274
        old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
275
        
 
276
        entry = entry.copy()
 
277
        inv.add(entry)
 
278
 
 
279
        if old_ie:
 
280
            old_kind = old_ie.kind
 
281
            if old_kind != entry.kind:
 
282
                raise BzrError("entry %r changed kind from %r to %r"
 
283
                        % (file_id, old_kind, entry.kind))
 
284
 
 
285
        if entry.kind == 'directory':
 
286
            if not isdir(p):
 
287
                raise BzrError("%s is entered as directory but not a directory"
 
288
                               % quotefn(p))
 
289
        elif entry.kind == 'file':
 
290
            if not isfile(p):
 
291
                raise BzrError("%s is entered as file but is not a file" % quotefn(p))
 
292
 
 
293
            new_sha1 = work_tree.get_file_sha1(file_id)
 
294
 
 
295
            if (old_ie
 
296
                and old_ie.text_sha1 == new_sha1):
 
297
                ## assert content == basis.get_file(file_id).read()
 
298
                entry.text_id = old_ie.text_id
 
299
                entry.text_sha1 = new_sha1
 
300
                entry.text_size = old_ie.text_size
 
301
                mutter('    unchanged from previous text_id {%s}' %
 
302
                       entry.text_id)
 
303
            else:
 
304
                content = file(p, 'rb').read()
 
305
 
 
306
                # calculate the sha again, just in case the file contents
 
307
                # changed since we updated the cache
 
308
                entry.text_sha1 = sha_string(content)
 
309
                entry.text_size = len(content)
 
310
 
 
311
                entry.text_id = gen_file_id(entry.name)
 
312
                branch.text_store.add(content, entry.text_id)
 
313
                mutter('    stored with text_id {%s}' % entry.text_id)
 
314
 
 
315
        if verbose:
 
316
            marked = path + kind_marker(entry.kind)
 
317
            if not old_ie:
 
318
                print 'added', marked
 
319
                any_changes = True
 
320
            elif old_ie == entry:
 
321
                pass                    # unchanged
 
322
            elif (old_ie.name == entry.name
 
323
                  and old_ie.parent_id == entry.parent_id):
 
324
                print 'modified', marked
 
325
                any_changes = True
 
326
            else:
 
327
                print 'renamed', marked
 
328
                any_changes = True
 
329
        elif old_ie != entry:
 
330
            any_changes = True
 
331
 
 
332
    return missing_ids, inv, any_changes
 
333
 
 
334