← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-06-10 06:29:35 UTC
  • Revision ID: mbp@sourcefrog.net-20050610062935-cd2fc37ca7ae1e09
- split out proposed progress module

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit.py
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
 
61
55
 
62
56
    import time, tempfile
63
57
 
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
 
58
    from osutils import local_time_offset, username
 
59
    
 
60
    from branch import gen_file_id
 
61
    from errors import BzrError
 
62
    from revision import Revision
 
63
    from trace import mutter, note
70
64
 
71
65
    branch.lock_write()
72
66
 
87
81
        if verbose:
88
82
            note('looking for changes...')
89
83
 
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()
 
84
        missing_ids, new_inv = _gather_commit(branch,
 
85
                                              work_tree,
 
86
                                              work_inv,
 
87
                                              basis_inv,
 
88
                                              specific_files,
 
89
                                              verbose)
102
90
 
103
91
        for file_id in missing_ids:
104
92
            # Any files that have been deleted are now removed from the
121
109
        inv_id = rev_id
122
110
 
123
111
        inv_tmp = tempfile.TemporaryFile()
124
 
        pack_xml(new_inv, inv_tmp)
 
112
        new_inv.write_xml(inv_tmp)
125
113
        inv_tmp.seek(0)
126
114
        branch.inventory_store.add(inv_tmp, inv_id)
127
115
        mutter('new inventory_id is {%s}' % inv_id)
128
116
 
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
117
        branch._write_inventory(work_inv)
135
118
 
136
119
        if timestamp == None:
146
129
        rev = Revision(timestamp=timestamp,
147
130
                       timezone=timezone,
148
131
                       committer=committer,
 
132
                       precursor = branch.last_patch(),
149
133
                       message = message,
150
134
                       inventory_id=inv_id,
151
 
                       inventory_sha1=inv_sha1,
152
135
                       revision_id=rev_id)
153
136
 
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
137
        rev_tmp = tempfile.TemporaryFile()
163
 
        pack_xml(rev, rev_tmp)
 
138
        rev.write_xml(rev_tmp)
164
139
        rev_tmp.seek(0)
165
140
        branch.revision_store.add(rev_tmp, rev_id)
166
141
        mutter("new revision_id is {%s}" % rev_id)
177
152
 
178
153
        branch.append_revision(rev_id)
179
154
 
180
 
        branch.set_pending_merges([])
181
 
 
182
155
        if verbose:
183
156
            note("commited r%d" % branch.revno())
184
157
    finally:
200
173
                   verbose):
201
174
    """Build inventory preparatory to commit.
202
175
 
203
 
    Returns missing_ids, new_inv, any_changes.
204
 
 
205
176
    This adds any changed files into the text store, and sets their
206
177
    test-id, sha and size in the returned inventory appropriately.
207
178
 
211
182
        working inventory.
212
183
    """
213
184
    from bzrlib.inventory import Inventory
214
 
    from bzrlib.osutils import isdir, isfile, sha_string, quotefn, \
 
185
    from osutils import isdir, isfile, sha_string, quotefn, \
215
186
         local_time_offset, username, kind_marker, is_inside_any
216
187
    
217
 
    from bzrlib.branch import gen_file_id
218
 
    from bzrlib.errors import BzrError
219
 
    from bzrlib.revision import Revision
 
188
    from branch import gen_file_id
 
189
    from errors import BzrError
 
190
    from revision import Revision
220
191
    from bzrlib.trace import mutter, note
221
192
 
222
 
    any_changes = False
223
 
    inv = Inventory(work_inv.root.file_id)
 
193
    inv = Inventory()
224
194
    missing_ids = []
225
195
    
226
196
    for path, entry in work_inv.iter_entries():
232
202
        mutter('commit prep file %s, id %r ' % (p, file_id))
233
203
 
234
204
        if specific_files and not is_inside_any(specific_files, path):
235
 
            mutter('  skipping file excluded from commit')
236
205
            if basis_inv.has_id(file_id):
237
206
                # carry over with previous state
238
207
                inv.add(basis_inv[file_id].copy())
244
213
        if not work_tree.has_id(file_id):
245
214
            if verbose:
246
215
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
247
 
                any_changes = True
248
216
            mutter("    file is missing, removing from inventory")
249
217
            missing_ids.append(file_id)
250
218
            continue
296
264
            marked = path + kind_marker(entry.kind)
297
265
            if not old_ie:
298
266
                print 'added', marked
299
 
                any_changes = True
300
267
            elif old_ie == entry:
301
268
                pass                    # unchanged
302
269
            elif (old_ie.name == entry.name
303
270
                  and old_ie.parent_id == entry.parent_id):
304
271
                print 'modified', marked
305
 
                any_changes = True
306
272
            else:
307
273
                print 'renamed', marked
308
 
                any_changes = True
309
274
                        
310
 
    return missing_ids, inv, any_changes
 
275
    return missing_ids, inv
311
276
 
312
277