~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-05-17 06:56:16 UTC
  • Revision ID: mbp@sourcefrog.net-20050517065616-6f23381d6184a8aa
- add space for un-merged patches

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()
72
 
 
73
 
    try:
74
 
        # First walk over the working inventory; and both update that
75
 
        # and also build a new revision inventory.  The revision
76
 
        # inventory needs to hold the text-id, sha1 and size of the
77
 
        # actual file versions committed in the revision.  (These are
78
 
        # not present in the working inventory.)  We also need to
79
 
        # detect missing/deleted files, and remove them from the
80
 
        # working inventory.
81
 
 
82
 
        work_tree = branch.working_tree()
83
 
        work_inv = work_tree.inventory
84
 
        basis = branch.basis_tree()
85
 
        basis_inv = basis.inventory
86
 
 
87
 
        if verbose:
88
 
            note('looking for changes...')
89
 
 
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()
102
 
 
103
 
        for file_id in missing_ids:
104
 
            # Any files that have been deleted are now removed from the
105
 
            # working inventory.  Files that were not selected for commit
106
 
            # are left as they were in the working inventory and ommitted
107
 
            # from the revision inventory.
108
 
 
109
 
            # have to do this later so we don't mess up the iterator.
110
 
            # since parents may be removed before their children we
111
 
            # have to test.
112
 
 
113
 
            # FIXME: There's probably a better way to do this; perhaps
114
 
            # the workingtree should know how to filter itbranch.
115
 
            if work_inv.has_id(file_id):
116
 
                del work_inv[file_id]
117
 
 
118
 
 
119
 
        if rev_id is None:
120
 
            rev_id = _gen_revision_id(time.time())
121
 
        inv_id = rev_id
122
 
 
123
 
        inv_tmp = tempfile.TemporaryFile()
124
 
        pack_xml(new_inv, inv_tmp)
125
 
        inv_tmp.seek(0)
126
 
        branch.inventory_store.add(inv_tmp, inv_id)
127
 
        mutter('new inventory_id is {%s}' % inv_id)
128
 
 
129
 
        # We could also just sha hash the inv_tmp file
130
 
        # however, in the case that branch.inventory_store.add()
131
 
        # ever actually does anything special
132
 
        inv_sha1 = branch.get_inventory_sha1(inv_id)
133
 
 
134
 
        branch._write_inventory(work_inv)
135
 
 
136
 
        if timestamp == None:
137
 
            timestamp = time.time()
138
 
 
139
 
        if committer == None:
140
 
            committer = username()
141
 
 
142
 
        if timezone == None:
143
 
            timezone = local_time_offset()
144
 
 
145
 
        mutter("building commit log message")
146
 
        rev = Revision(timestamp=timestamp,
147
 
                       timezone=timezone,
148
 
                       committer=committer,
149
 
                       message = message,
150
 
                       inventory_id=inv_id,
151
 
                       inventory_sha1=inv_sha1,
152
 
                       revision_id=rev_id)
153
 
 
154
 
        rev.parents = []
155
 
        precursor_id = branch.last_patch()
156
 
        if precursor_id:
157
 
            precursor_sha1 = branch.get_revision_sha1(precursor_id)
158
 
            rev.parents.append(RevisionReference(precursor_id, precursor_sha1))
159
 
        for merge_rev in pending_merges:
160
 
            rev.parents.append(RevisionReference(merge_rev))            
161
 
 
162
 
        rev_tmp = tempfile.TemporaryFile()
163
 
        pack_xml(rev, rev_tmp)
164
 
        rev_tmp.seek(0)
165
 
        branch.revision_store.add(rev_tmp, rev_id)
166
 
        mutter("new revision_id is {%s}" % rev_id)
167
 
 
168
 
        ## XXX: Everything up to here can simply be orphaned if we abort
169
 
        ## the commit; it will leave junk files behind but that doesn't
170
 
        ## matter.
171
 
 
172
 
        ## TODO: Read back the just-generated changeset, and make sure it
173
 
        ## applies and recreates the right state.
174
 
 
175
 
        ## TODO: Also calculate and store the inventory SHA1
176
 
        mutter("committing patch r%d" % (branch.revno() + 1))
177
 
 
178
 
        branch.append_revision(rev_id)
179
 
 
180
 
        branch.set_pending_merges([])
181
 
 
182
 
        if verbose:
183
 
            note("commited r%d" % branch.revno())
184
 
    finally:
185
 
        branch.unlock()
186
 
 
187
 
 
188
 
 
189
 
def _gen_revision_id(when):
190
 
    """Return new revision-id."""
191
 
    from binascii import hexlify
192
 
    from osutils import rand_bytes, compact_date, user_email
193
 
 
194
 
    s = '%s-%s-' % (user_email(), compact_date(when))
195
 
    s += hexlify(rand_bytes(8))
196
 
    return s
197
 
 
198
 
 
199
 
def _gather_commit(branch, work_tree, work_inv, basis_inv, specific_files,
200
 
                   verbose):
201
 
    """Build inventory preparatory to commit.
202
 
 
203
 
    Returns missing_ids, new_inv, any_changes.
204
 
 
205
 
    This adds any changed files into the text store, and sets their
206
 
    test-id, sha and size in the returned inventory appropriately.
207
 
 
208
 
    missing_ids
209
 
        Modified to hold a list of files that have been deleted from
210
 
        the working directory; these should be removed from the
211
 
        working inventory.
212
 
    """
213
 
    from bzrlib.inventory import Inventory
 
56
    import os, time, tempfile
 
57
 
 
58
    from inventory import Inventory
214
59
    from osutils import isdir, isfile, sha_string, quotefn, \
215
60
         local_time_offset, username, kind_marker, is_inside_any
216
61
    
217
62
    from branch import gen_file_id
218
63
    from errors import BzrError
219
64
    from revision import Revision
220
 
    from bzrlib.trace import mutter, note
221
 
 
222
 
    any_changes = False
223
 
    inv = Inventory(work_inv.root.file_id)
 
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
224
82
    missing_ids = []
225
 
    
 
83
 
 
84
    if verbose:
 
85
        note('looking for changes...')
 
86
        
226
87
    for path, entry in work_inv.iter_entries():
227
88
        ## TODO: Check that the file kind has not changed from the previous
228
89
        ## revision of this file (if any).
229
90
 
 
91
        entry = entry.copy()
 
92
 
230
93
        p = branch.abspath(path)
231
94
        file_id = entry.file_id
232
95
        mutter('commit prep file %s, id %r ' % (p, file_id))
233
96
 
234
97
        if specific_files and not is_inside_any(specific_files, path):
235
 
            mutter('  skipping file excluded from commit')
236
98
            if basis_inv.has_id(file_id):
237
99
                # carry over with previous state
238
100
                inv.add(basis_inv[file_id].copy())
244
106
        if not work_tree.has_id(file_id):
245
107
            if verbose:
246
108
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
247
 
                any_changes = True
248
109
            mutter("    file is missing, removing from inventory")
249
110
            missing_ids.append(file_id)
250
111
            continue
251
112
 
252
 
        # this is present in the new inventory; may be new, modified or
253
 
        # unchanged.
254
 
        old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
255
 
        
256
 
        entry = entry.copy()
257
113
        inv.add(entry)
258
114
 
259
 
        if old_ie:
260
 
            old_kind = old_ie.kind
 
115
        if basis_inv.has_id(file_id):
 
116
            old_kind = basis_inv[file_id].kind
261
117
            if old_kind != entry.kind:
262
118
                raise BzrError("entry %r changed kind from %r to %r"
263
119
                        % (file_id, old_kind, entry.kind))
272
128
 
273
129
            new_sha1 = work_tree.get_file_sha1(file_id)
274
130
 
 
131
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
275
132
            if (old_ie
276
133
                and old_ie.text_sha1 == new_sha1):
277
134
                ## assert content == basis.get_file(file_id).read()
291
148
                entry.text_id = gen_file_id(entry.name)
292
149
                branch.text_store.add(content, entry.text_id)
293
150
                mutter('    stored with text_id {%s}' % entry.text_id)
294
 
 
295
 
        if verbose:
296
 
            marked = path + kind_marker(entry.kind)
297
 
            if not old_ie:
298
 
                print 'added', marked
299
 
                any_changes = True
300
 
            elif old_ie == entry:
301
 
                pass                    # unchanged
302
 
            elif (old_ie.name == entry.name
303
 
                  and old_ie.parent_id == entry.parent_id):
304
 
                print 'modified', marked
305
 
                any_changes = True
306
 
            else:
307
 
                print 'renamed', marked
308
 
                any_changes = True
309
 
                        
310
 
    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
311
238
 
312
239