~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Robert Collins
  • Date: 2005-08-23 06:52:09 UTC
  • mto: (974.1.50) (1185.1.10) (1092.3.1)
  • mto: This revision was merged to the branch mainline in revision 1139.
  • Revision ID: robertc@robertcollins.net-20050823065209-81cd5962c401751b
move io redirection into each test case from the global runner

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
        if rev_id is None:
 
119
            rev_id = _gen_revision_id(branch, time.time())
 
120
        inv_id = rev_id
 
121
 
 
122
        inv_tmp = tempfile.TemporaryFile()
 
123
        pack_xml(new_inv, inv_tmp)
 
124
        inv_tmp.seek(0)
 
125
        branch.inventory_store.add(inv_tmp, inv_id)
 
126
        mutter('new inventory_id is {%s}' % inv_id)
 
127
 
 
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
        branch._write_inventory(work_inv)
 
134
 
 
135
        if timestamp == None:
 
136
            timestamp = time.time()
 
137
 
 
138
        if committer == None:
 
139
            committer = username(branch)
 
140
 
 
141
        if timezone == None:
 
142
            timezone = local_time_offset()
 
143
 
 
144
        mutter("building commit log message")
 
145
        rev = Revision(timestamp=timestamp,
 
146
                       timezone=timezone,
 
147
                       committer=committer,
 
148
                       message = message,
 
149
                       inventory_id=inv_id,
 
150
                       inventory_sha1=inv_sha1,
 
151
                       revision_id=rev_id)
 
152
 
 
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
        rev_tmp = tempfile.TemporaryFile()
 
162
        pack_xml(rev, rev_tmp)
 
163
        rev_tmp.seek(0)
 
164
        branch.revision_store.add(rev_tmp, rev_id)
 
165
        mutter("new revision_id is {%s}" % rev_id)
 
166
 
 
167
        ## XXX: Everything up to here can simply be orphaned if we abort
 
168
        ## the commit; it will leave junk files behind but that doesn't
 
169
        ## matter.
 
170
 
 
171
        ## TODO: Read back the just-generated changeset, and make sure it
 
172
        ## applies and recreates the right state.
 
173
 
 
174
        ## TODO: Also calculate and store the inventory SHA1
 
175
        mutter("committing patch r%d" % (branch.revno() + 1))
 
176
 
 
177
        branch.append_revision(rev_id)
 
178
 
 
179
        branch.set_pending_merges([])
 
180
 
 
181
        if verbose:
 
182
            note("commited r%d" % branch.revno())
 
183
    finally:
 
184
        branch.unlock()
 
185
 
 
186
 
 
187
 
 
188
def _gen_revision_id(branch, when):
 
189
    """Return new revision-id."""
 
190
    from binascii import hexlify
 
191
    from bzrlib.osutils import rand_bytes, compact_date, user_email
 
192
 
 
193
    s = '%s-%s-' % (user_email(branch), compact_date(when))
 
194
    s += hexlify(rand_bytes(8))
 
195
    return s
 
196
 
 
197
 
 
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, \
60
214
         local_time_offset, username, kind_marker, is_inside_any
61
215
    
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
 
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)
82
223
    missing_ids = []
83
 
 
84
 
    if verbose:
85
 
        note('looking for changes...')
86
 
        
 
224
    
87
225
    for path, entry in work_inv.iter_entries():
88
226
        ## TODO: Check that the file kind has not changed from the previous
89
227
        ## revision of this file (if any).
90
228
 
91
 
        entry = entry.copy()
92
 
 
93
229
        p = branch.abspath(path)
94
230
        file_id = entry.file_id
95
231
        mutter('commit prep file %s, id %r ' % (p, file_id))
96
232
 
97
233
        if specific_files and not is_inside_any(specific_files, path):
 
234
            mutter('  skipping file excluded from commit')
98
235
            if basis_inv.has_id(file_id):
99
236
                # carry over with previous state
100
237
                inv.add(basis_inv[file_id].copy())
106
243
        if not work_tree.has_id(file_id):
107
244
            if verbose:
108
245
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
 
246
                any_changes = True
109
247
            mutter("    file is missing, removing from inventory")
110
248
            missing_ids.append(file_id)
111
249
            continue
112
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()
113
256
        inv.add(entry)
114
257
 
115
 
        if basis_inv.has_id(file_id):
116
 
            old_kind = basis_inv[file_id].kind
 
258
        if old_ie:
 
259
            old_kind = old_ie.kind
117
260
            if old_kind != entry.kind:
118
261
                raise BzrError("entry %r changed kind from %r to %r"
119
262
                        % (file_id, old_kind, entry.kind))
128
271
 
129
272
            new_sha1 = work_tree.get_file_sha1(file_id)
130
273
 
131
 
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
132
274
            if (old_ie
133
275
                and old_ie.text_sha1 == new_sha1):
134
276
                ## assert content == basis.get_file(file_id).read()
148
290
                entry.text_id = gen_file_id(entry.name)
149
291
                branch.text_store.add(content, entry.text_id)
150
292
                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
 
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
238
310
 
239
311