~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-05-31 07:52:38 UTC
  • Revision ID: mbp@sourcefrog.net-20050531075238-cbe5c652c51d2d8a
- cleanup test code

Show diffs side-by-side

added added

removed removed

Lines of Context:
16
16
 
17
17
 
18
18
 
19
 
# FIXME: "bzr commit doc/format" commits doc/format.txt!
20
 
 
21
19
def commit(branch, message,
22
20
           timestamp=None,
23
21
           timezone=None,
24
22
           committer=None,
25
23
           verbose=True,
26
24
           specific_files=None,
27
 
           rev_id=None,
28
 
           allow_pointless=True):
 
25
           rev_id=None):
29
26
    """Commit working copy as a new revision.
30
27
 
31
28
    The basic approach is to add all the file texts into the
42
39
    be robust against files disappearing, moving, etc.  So the
43
40
    whole thing is a bit hard.
44
41
 
45
 
    This raises PointlessCommit if there are no changes, no new merges,
46
 
    and allow_pointless  is false.
47
 
 
48
42
    timestamp -- if not None, seconds-since-epoch for a
49
43
         postdated/predated commit.
50
44
 
59
53
        If null (default), a time/random revision id is generated.
60
54
    """
61
55
 
62
 
    import time, tempfile
63
 
 
64
 
    from bzrlib.osutils import local_time_offset, username
65
 
    from bzrlib.branch import gen_file_id
66
 
    from bzrlib.errors import BzrError, PointlessCommit
67
 
    from bzrlib.revision import Revision, RevisionReference
68
 
    from bzrlib.trace import mutter, note
69
 
    from bzrlib.xml import pack_xml
70
 
 
71
 
    branch.lock_write()
 
56
    import os, time, tempfile
 
57
 
 
58
    from inventory import Inventory
 
59
    from osutils import isdir, isfile, sha_string, quotefn, \
 
60
         local_time_offset, username, kind_marker, is_inside_any
 
61
    
 
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.lock('w')
72
68
 
73
69
    try:
74
70
        # First walk over the working inventory; and both update that
81
77
 
82
78
        work_tree = branch.working_tree()
83
79
        work_inv = work_tree.inventory
 
80
        inv = Inventory()
84
81
        basis = branch.basis_tree()
85
82
        basis_inv = basis.inventory
 
83
        missing_ids = []
86
84
 
87
85
        if verbose:
88
86
            note('looking for changes...')
89
87
 
90
 
        pending_merges = branch.pending_merges()
91
 
 
92
 
        missing_ids, new_inv, any_changes = \
93
 
                     _gather_commit(branch,
94
 
                                    work_tree,
95
 
                                    work_inv,
96
 
                                    basis_inv,
97
 
                                    specific_files,
98
 
                                    verbose)
99
 
 
100
 
        if not (any_changes or allow_pointless or pending_merges):
101
 
            raise PointlessCommit()
 
88
        for path, entry in work_inv.iter_entries():
 
89
            ## TODO: Check that the file kind has not changed from the previous
 
90
            ## revision of this file (if any).
 
91
 
 
92
            entry = entry.copy()
 
93
 
 
94
            p = branch.abspath(path)
 
95
            file_id = entry.file_id
 
96
            mutter('commit prep file %s, id %r ' % (p, file_id))
 
97
 
 
98
            if specific_files and not is_inside_any(specific_files, path):
 
99
                if basis_inv.has_id(file_id):
 
100
                    # carry over with previous state
 
101
                    inv.add(basis_inv[file_id].copy())
 
102
                else:
 
103
                    # omit this from committed inventory
 
104
                    pass
 
105
                continue
 
106
 
 
107
            if not work_tree.has_id(file_id):
 
108
                if verbose:
 
109
                    print('deleted %s%s' % (path, kind_marker(entry.kind)))
 
110
                mutter("    file is missing, removing from inventory")
 
111
                missing_ids.append(file_id)
 
112
                continue
 
113
 
 
114
            inv.add(entry)
 
115
 
 
116
            if basis_inv.has_id(file_id):
 
117
                old_kind = basis_inv[file_id].kind
 
118
                if old_kind != entry.kind:
 
119
                    raise BzrError("entry %r changed kind from %r to %r"
 
120
                            % (file_id, old_kind, entry.kind))
 
121
 
 
122
            if entry.kind == 'directory':
 
123
                if not isdir(p):
 
124
                    raise BzrError("%s is entered as directory but not a directory"
 
125
                                   % quotefn(p))
 
126
            elif entry.kind == 'file':
 
127
                if not isfile(p):
 
128
                    raise BzrError("%s is entered as file but is not a file" % quotefn(p))
 
129
 
 
130
                new_sha1 = work_tree.get_file_sha1(file_id)
 
131
 
 
132
                old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
133
                if (old_ie
 
134
                    and old_ie.text_sha1 == new_sha1):
 
135
                    ## assert content == basis.get_file(file_id).read()
 
136
                    entry.text_id = old_ie.text_id
 
137
                    entry.text_sha1 = new_sha1
 
138
                    entry.text_size = old_ie.text_size
 
139
                    mutter('    unchanged from previous text_id {%s}' %
 
140
                           entry.text_id)
 
141
                else:
 
142
                    content = file(p, 'rb').read()
 
143
 
 
144
                    # calculate the sha again, just in case the file contents
 
145
                    # changed since we updated the cache
 
146
                    entry.text_sha1 = sha_string(content)
 
147
                    entry.text_size = len(content)
 
148
 
 
149
                    entry.text_id = gen_file_id(entry.name)
 
150
                    branch.text_store.add(content, entry.text_id)
 
151
                    mutter('    stored with text_id {%s}' % entry.text_id)
 
152
                    if verbose:
 
153
                        if not old_ie:
 
154
                            print('added %s' % path)
 
155
                        elif (old_ie.name == entry.name
 
156
                              and old_ie.parent_id == entry.parent_id):
 
157
                            print('modified %s' % path)
 
158
                        else:
 
159
                            print('renamed %s' % path)
 
160
 
102
161
 
103
162
        for file_id in missing_ids:
104
163
            # Any files that have been deleted are now removed from the
115
174
            if work_inv.has_id(file_id):
116
175
                del work_inv[file_id]
117
176
 
 
177
 
118
178
        if rev_id is None:
119
 
            rev_id = _gen_revision_id(branch, time.time())
 
179
            rev_id = _gen_revision_id(time.time())
120
180
        inv_id = rev_id
121
181
 
122
182
        inv_tmp = tempfile.TemporaryFile()
123
 
        pack_xml(new_inv, inv_tmp)
 
183
        inv.write_xml(inv_tmp)
124
184
        inv_tmp.seek(0)
125
185
        branch.inventory_store.add(inv_tmp, inv_id)
126
186
        mutter('new inventory_id is {%s}' % inv_id)
127
187
 
128
 
        # We could also just sha hash the inv_tmp file
129
 
        # however, in the case that branch.inventory_store.add()
130
 
        # ever actually does anything special
131
 
        inv_sha1 = branch.get_inventory_sha1(inv_id)
132
 
 
133
188
        branch._write_inventory(work_inv)
134
189
 
135
190
        if timestamp == None:
136
191
            timestamp = time.time()
137
192
 
138
193
        if committer == None:
139
 
            committer = username(branch)
 
194
            committer = username()
140
195
 
141
196
        if timezone == None:
142
197
            timezone = local_time_offset()
145
200
        rev = Revision(timestamp=timestamp,
146
201
                       timezone=timezone,
147
202
                       committer=committer,
 
203
                       precursor = branch.last_patch(),
148
204
                       message = message,
149
205
                       inventory_id=inv_id,
150
 
                       inventory_sha1=inv_sha1,
151
206
                       revision_id=rev_id)
152
207
 
153
 
        rev.parents = []
154
 
        precursor_id = branch.last_patch()
155
 
        if precursor_id:
156
 
            precursor_sha1 = branch.get_revision_sha1(precursor_id)
157
 
            rev.parents.append(RevisionReference(precursor_id, precursor_sha1))
158
 
        for merge_rev in pending_merges:
159
 
            rev.parents.append(RevisionReference(merge_rev))            
160
 
 
161
208
        rev_tmp = tempfile.TemporaryFile()
162
 
        pack_xml(rev, rev_tmp)
 
209
        rev.write_xml(rev_tmp)
163
210
        rev_tmp.seek(0)
164
211
        branch.revision_store.add(rev_tmp, rev_id)
165
212
        mutter("new revision_id is {%s}" % rev_id)
176
223
 
177
224
        branch.append_revision(rev_id)
178
225
 
179
 
        branch.set_pending_merges([])
180
 
 
181
226
        if verbose:
182
227
            note("commited r%d" % branch.revno())
183
228
    finally:
185
230
 
186
231
 
187
232
 
188
 
def _gen_revision_id(branch, when):
 
233
def _gen_revision_id(when):
189
234
    """Return new revision-id."""
190
235
    from binascii import hexlify
191
 
    from bzrlib.osutils import rand_bytes, compact_date, user_email
 
236
    from osutils import rand_bytes, compact_date, user_email
192
237
 
193
 
    s = '%s-%s-' % (user_email(branch), compact_date(when))
 
238
    s = '%s-%s-' % (user_email(), compact_date(when))
194
239
    s += hexlify(rand_bytes(8))
195
240
    return s
196
241
 
197
242
 
198
 
def _gather_commit(branch, work_tree, work_inv, basis_inv, specific_files,
199
 
                   verbose):
200
 
    """Build inventory preparatory to commit.
201
 
 
202
 
    Returns missing_ids, new_inv, any_changes.
203
 
 
204
 
    This adds any changed files into the text store, and sets their
205
 
    test-id, sha and size in the returned inventory appropriately.
206
 
 
207
 
    missing_ids
208
 
        Modified to hold a list of files that have been deleted from
209
 
        the working directory; these should be removed from the
210
 
        working inventory.
211
 
    """
212
 
    from bzrlib.inventory import Inventory
213
 
    from bzrlib.osutils import isdir, isfile, sha_string, quotefn, \
214
 
         local_time_offset, username, kind_marker, is_inside_any
215
 
    
216
 
    from bzrlib.branch import gen_file_id
217
 
    from bzrlib.errors import BzrError
218
 
    from bzrlib.revision import Revision
219
 
    from bzrlib.trace import mutter, note
220
 
 
221
 
    any_changes = False
222
 
    inv = Inventory(work_inv.root.file_id)
223
 
    missing_ids = []
224
 
    
225
 
    for path, entry in work_inv.iter_entries():
226
 
        ## TODO: Check that the file kind has not changed from the previous
227
 
        ## revision of this file (if any).
228
 
 
229
 
        p = branch.abspath(path)
230
 
        file_id = entry.file_id
231
 
        mutter('commit prep file %s, id %r ' % (p, file_id))
232
 
 
233
 
        if specific_files and not is_inside_any(specific_files, path):
234
 
            mutter('  skipping file excluded from commit')
235
 
            if basis_inv.has_id(file_id):
236
 
                # carry over with previous state
237
 
                inv.add(basis_inv[file_id].copy())
238
 
            else:
239
 
                # omit this from committed inventory
240
 
                pass
241
 
            continue
242
 
 
243
 
        if not work_tree.has_id(file_id):
244
 
            if verbose:
245
 
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
246
 
                any_changes = True
247
 
            mutter("    file is missing, removing from inventory")
248
 
            missing_ids.append(file_id)
249
 
            continue
250
 
 
251
 
        # this is present in the new inventory; may be new, modified or
252
 
        # unchanged.
253
 
        old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
254
 
        
255
 
        entry = entry.copy()
256
 
        inv.add(entry)
257
 
 
258
 
        if old_ie:
259
 
            old_kind = old_ie.kind
260
 
            if old_kind != entry.kind:
261
 
                raise BzrError("entry %r changed kind from %r to %r"
262
 
                        % (file_id, old_kind, entry.kind))
263
 
 
264
 
        if entry.kind == 'directory':
265
 
            if not isdir(p):
266
 
                raise BzrError("%s is entered as directory but not a directory"
267
 
                               % quotefn(p))
268
 
        elif entry.kind == 'file':
269
 
            if not isfile(p):
270
 
                raise BzrError("%s is entered as file but is not a file" % quotefn(p))
271
 
 
272
 
            new_sha1 = work_tree.get_file_sha1(file_id)
273
 
 
274
 
            if (old_ie
275
 
                and old_ie.text_sha1 == new_sha1):
276
 
                ## assert content == basis.get_file(file_id).read()
277
 
                entry.text_id = old_ie.text_id
278
 
                entry.text_sha1 = new_sha1
279
 
                entry.text_size = old_ie.text_size
280
 
                mutter('    unchanged from previous text_id {%s}' %
281
 
                       entry.text_id)
282
 
            else:
283
 
                content = file(p, 'rb').read()
284
 
 
285
 
                # calculate the sha again, just in case the file contents
286
 
                # changed since we updated the cache
287
 
                entry.text_sha1 = sha_string(content)
288
 
                entry.text_size = len(content)
289
 
 
290
 
                entry.text_id = gen_file_id(entry.name)
291
 
                branch.text_store.add(content, entry.text_id)
292
 
                mutter('    stored with text_id {%s}' % entry.text_id)
293
 
 
294
 
        if verbose:
295
 
            marked = path + kind_marker(entry.kind)
296
 
            if not old_ie:
297
 
                print 'added', marked
298
 
                any_changes = True
299
 
            elif old_ie == entry:
300
 
                pass                    # unchanged
301
 
            elif (old_ie.name == entry.name
302
 
                  and old_ie.parent_id == entry.parent_id):
303
 
                print 'modified', marked
304
 
                any_changes = True
305
 
            else:
306
 
                print 'renamed', marked
307
 
                any_changes = True
308
 
                        
309
 
    return missing_ids, inv, any_changes
310
 
 
311