~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Aaron Bentley
  • Date: 2005-07-29 17:19:16 UTC
  • mto: (1092.1.41) (1185.3.4) (974.1.47)
  • mto: This revision was merged to the branch mainline in revision 1020.
  • Revision ID: abentley@panoramicfeedback.com-20050729171916-322fd81b451d2e3e
Added merge-type parameter to merge.

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
 
19
21
def commit(branch, message,
20
22
           timestamp=None,
21
23
           timezone=None,
22
24
           committer=None,
23
25
           verbose=True,
24
26
           specific_files=None,
25
 
           rev_id=None):
 
27
           rev_id=None,
 
28
           allow_pointless=True):
26
29
    """Commit working copy as a new revision.
27
30
 
28
31
    The basic approach is to add all the file texts into the
39
42
    be robust against files disappearing, moving, etc.  So the
40
43
    whole thing is a bit hard.
41
44
 
 
45
    This raises PointlessCommit if there are no changes, no new merges,
 
46
    and allow_pointless  is false.
 
47
 
42
48
    timestamp -- if not None, seconds-since-epoch for a
43
49
         postdated/predated commit.
44
50
 
53
59
        If null (default), a time/random revision id is generated.
54
60
    """
55
61
 
56
 
    import os, time, tempfile
57
 
 
58
 
    from inventory import Inventory
59
 
    from osutils import isdir, isfile, sha_string, quotefn, \
 
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
 
214
    from bzrlib.osutils import isdir, isfile, sha_string, quotefn, \
60
215
         local_time_offset, username, kind_marker, is_inside_any
61
216
    
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
 
217
    from bzrlib.branch import gen_file_id
 
218
    from bzrlib.errors import BzrError
 
219
    from bzrlib.revision import Revision
 
220
    from bzrlib.trace import mutter, note
 
221
 
 
222
    any_changes = False
 
223
    inv = Inventory(work_inv.root.file_id)
82
224
    missing_ids = []
83
 
 
84
 
    if verbose:
85
 
        note('looking for changes...')
86
 
        
 
225
    
87
226
    for path, entry in work_inv.iter_entries():
88
227
        ## TODO: Check that the file kind has not changed from the previous
89
228
        ## revision of this file (if any).
90
229
 
91
 
        entry = entry.copy()
92
 
 
93
230
        p = branch.abspath(path)
94
231
        file_id = entry.file_id
95
232
        mutter('commit prep file %s, id %r ' % (p, file_id))
96
233
 
97
234
        if specific_files and not is_inside_any(specific_files, path):
 
235
            mutter('  skipping file excluded from commit')
98
236
            if basis_inv.has_id(file_id):
99
237
                # carry over with previous state
100
238
                inv.add(basis_inv[file_id].copy())
106
244
        if not work_tree.has_id(file_id):
107
245
            if verbose:
108
246
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
 
247
                any_changes = True
109
248
            mutter("    file is missing, removing from inventory")
110
249
            missing_ids.append(file_id)
111
250
            continue
112
251
 
 
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()
113
257
        inv.add(entry)
114
258
 
115
 
        if basis_inv.has_id(file_id):
116
 
            old_kind = basis_inv[file_id].kind
 
259
        if old_ie:
 
260
            old_kind = old_ie.kind
117
261
            if old_kind != entry.kind:
118
262
                raise BzrError("entry %r changed kind from %r to %r"
119
263
                        % (file_id, old_kind, entry.kind))
128
272
 
129
273
            new_sha1 = work_tree.get_file_sha1(file_id)
130
274
 
131
 
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
132
275
            if (old_ie
133
276
                and old_ie.text_sha1 == new_sha1):
134
277
                ## assert content == basis.get_file(file_id).read()
148
291
                entry.text_id = gen_file_id(entry.name)
149
292
                branch.text_store.add(content, entry.text_id)
150
293
                mutter('    stored with text_id {%s}' % entry.text_id)
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
 
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
238
311
 
239
312