~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-05-27 01:50:28 UTC
  • Revision ID: mbp@sourcefrog.net-20050527015028-83638384380101a8
- still use internal diff by default

Show diffs side-by-side

added added

removed removed

Lines of Context:
22
22
           committer=None,
23
23
           verbose=True,
24
24
           specific_files=None,
25
 
           rev_id=None,
26
 
           allow_pointless=True):
 
25
           rev_id=None):
27
26
    """Commit working copy as a new revision.
28
27
 
29
28
    The basic approach is to add all the file texts into the
40
39
    be robust against files disappearing, moving, etc.  So the
41
40
    whole thing is a bit hard.
42
41
 
43
 
    This raises PointlessCommit if there are no changes, no new merges,
44
 
    and allow_pointless  is false.
45
 
 
46
42
    timestamp -- if not None, seconds-since-epoch for a
47
43
         postdated/predated commit.
48
44
 
57
53
        If null (default), a time/random revision id is generated.
58
54
    """
59
55
 
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]
118
 
 
119
 
        if rev_id is None:
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")
147
 
        # Python strings can include characters that can't be
148
 
        # represented in well-formed XML; escape characters that
149
 
        # aren't listed in the XML specification
150
 
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
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,
159
 
            lambda match: match.group(0).encode('unicode_escape'),
160
 
            message)
161
 
        if escape_count:
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)
170
 
 
171
 
        rev.parents = []
172
 
        precursor_id = branch.last_patch()
173
 
        if precursor_id:
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))            
178
 
 
179
 
        rev_tmp = tempfile.TemporaryFile()
180
 
        serializer_v4.write_revision(rev, rev_tmp)
181
 
        rev_tmp.seek(0)
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):
210
 
    """Return new revision-id."""
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))
215
 
    s += hexlify(rand_bytes(8))
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, \
 
56
    import os, time, tempfile
 
57
 
 
58
    from inventory import Inventory
 
59
    from osutils import isdir, isfile, sha_string, quotefn, \
235
60
         local_time_offset, username, kind_marker, is_inside_any
236
61
    
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)
 
62
    from branch import gen_file_id
 
63
    from errors import BzrError
 
64
    from revision import Revision
 
65
    from trace import mutter, note
 
66
 
 
67
    branch._need_writelock()
 
68
 
 
69
    # First walk over the working inventory; and both update that
 
70
    # and also build a new revision inventory.  The revision
 
71
    # inventory needs to hold the text-id, sha1 and size of the
 
72
    # actual file versions committed in the revision.  (These are
 
73
    # not present in the working inventory.)  We also need to
 
74
    # detect missing/deleted files, and remove them from the
 
75
    # working inventory.
 
76
 
 
77
    work_tree = branch.working_tree()
 
78
    work_inv = work_tree.inventory
 
79
    inv = Inventory()
 
80
    basis = branch.basis_tree()
 
81
    basis_inv = basis.inventory
244
82
    missing_ids = []
245
 
    
 
83
 
 
84
    if verbose:
 
85
        note('looking for changes...')
 
86
        
246
87
    for path, entry in work_inv.iter_entries():
247
88
        ## TODO: Check that the file kind has not changed from the previous
248
89
        ## revision of this file (if any).
249
90
 
 
91
        entry = entry.copy()
 
92
 
250
93
        p = branch.abspath(path)
251
94
        file_id = entry.file_id
252
95
        mutter('commit prep file %s, id %r ' % (p, file_id))
253
96
 
254
97
        if specific_files and not is_inside_any(specific_files, path):
255
 
            mutter('  skipping file excluded from commit')
256
98
            if basis_inv.has_id(file_id):
257
99
                # carry over with previous state
258
100
                inv.add(basis_inv[file_id].copy())
264
106
        if not work_tree.has_id(file_id):
265
107
            if verbose:
266
108
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
267
 
            any_changes = True
268
109
            mutter("    file is missing, removing from inventory")
269
110
            missing_ids.append(file_id)
270
111
            continue
271
112
 
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
113
        inv.add(entry)
278
114
 
279
 
        if old_ie:
280
 
            old_kind = old_ie.kind
 
115
        if basis_inv.has_id(file_id):
 
116
            old_kind = basis_inv[file_id].kind
281
117
            if old_kind != entry.kind:
282
118
                raise BzrError("entry %r changed kind from %r to %r"
283
119
                        % (file_id, old_kind, entry.kind))
292
128
 
293
129
            new_sha1 = work_tree.get_file_sha1(file_id)
294
130
 
 
131
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
295
132
            if (old_ie
296
133
                and old_ie.text_sha1 == new_sha1):
297
134
                ## assert content == basis.get_file(file_id).read()
311
148
                entry.text_id = gen_file_id(entry.name)
312
149
                branch.text_store.add(content, entry.text_id)
313
150
                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
 
151
                if verbose:
 
152
                    if not old_ie:
 
153
                        print('added %s' % path)
 
154
                    elif (old_ie.name == entry.name
 
155
                          and old_ie.parent_id == entry.parent_id):
 
156
                        print('modified %s' % path)
 
157
                    else:
 
158
                        print('renamed %s' % path)
 
159
 
 
160
 
 
161
    for file_id in missing_ids:
 
162
        # Any files that have been deleted are now removed from the
 
163
        # working inventory.  Files that were not selected for commit
 
164
        # are left as they were in the working inventory and ommitted
 
165
        # from the revision inventory.
 
166
        
 
167
        # have to do this later so we don't mess up the iterator.
 
168
        # since parents may be removed before their children we
 
169
        # have to test.
 
170
 
 
171
        # FIXME: There's probably a better way to do this; perhaps
 
172
        # the workingtree should know how to filter itbranch.
 
173
        if work_inv.has_id(file_id):
 
174
            del work_inv[file_id]
 
175
 
 
176
 
 
177
    if rev_id is None:
 
178
        rev_id = _gen_revision_id(time.time())
 
179
    inv_id = rev_id
 
180
 
 
181
    inv_tmp = tempfile.TemporaryFile()
 
182
    inv.write_xml(inv_tmp)
 
183
    inv_tmp.seek(0)
 
184
    branch.inventory_store.add(inv_tmp, inv_id)
 
185
    mutter('new inventory_id is {%s}' % inv_id)
 
186
 
 
187
    branch._write_inventory(work_inv)
 
188
 
 
189
    if timestamp == None:
 
190
        timestamp = time.time()
 
191
 
 
192
    if committer == None:
 
193
        committer = username()
 
194
 
 
195
    if timezone == None:
 
196
        timezone = local_time_offset()
 
197
 
 
198
    mutter("building commit log message")
 
199
    rev = Revision(timestamp=timestamp,
 
200
                   timezone=timezone,
 
201
                   committer=committer,
 
202
                   precursor = branch.last_patch(),
 
203
                   message = message,
 
204
                   inventory_id=inv_id,
 
205
                   revision_id=rev_id)
 
206
 
 
207
    rev_tmp = tempfile.TemporaryFile()
 
208
    rev.write_xml(rev_tmp)
 
209
    rev_tmp.seek(0)
 
210
    branch.revision_store.add(rev_tmp, rev_id)
 
211
    mutter("new revision_id is {%s}" % rev_id)
 
212
 
 
213
    ## XXX: Everything up to here can simply be orphaned if we abort
 
214
    ## the commit; it will leave junk files behind but that doesn't
 
215
    ## matter.
 
216
 
 
217
    ## TODO: Read back the just-generated changeset, and make sure it
 
218
    ## applies and recreates the right state.
 
219
 
 
220
    ## TODO: Also calculate and store the inventory SHA1
 
221
    mutter("committing patch r%d" % (branch.revno() + 1))
 
222
 
 
223
    branch.append_revision(rev_id)
 
224
 
 
225
    if verbose:
 
226
        note("commited r%d" % branch.revno())
 
227
 
 
228
 
 
229
 
 
230
def _gen_revision_id(when):
 
231
    """Return new revision-id."""
 
232
    from binascii import hexlify
 
233
    from osutils import rand_bytes, compact_date, user_email
 
234
 
 
235
    s = '%s-%s-' % (user_email(), compact_date(when))
 
236
    s += hexlify(rand_bytes(8))
 
237
    return s
333
238
 
334
239