/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-07-04 12:11:40 UTC
  • Revision ID: mbp@sourcefrog.net-20050704121140-fc4ab493bedc2e2f
- Deferred patch that uses Python ndiff format.

  This highlights the changes within a line, which is rather nice.  But it also
  outputs the entire file, which is less good.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit.py
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
 
 
19
# FIXME: "bzr commit doc/format" commits doc/format.txt!
 
20
 
 
21
def commit(branch, message,
 
22
           timestamp=None,
 
23
           timezone=None,
 
24
           committer=None,
 
25
           verbose=True,
 
26
           specific_files=None,
 
27
           rev_id=None):
 
28
    """Commit working copy as a new revision.
 
29
 
 
30
    The basic approach is to add all the file texts into the
 
31
    store, then the inventory, then make a new revision pointing
 
32
    to that inventory and store that.
 
33
 
 
34
    This is not quite safe if the working copy changes during the
 
35
    commit; for the moment that is simply not allowed.  A better
 
36
    approach is to make a temporary copy of the files before
 
37
    computing their hashes, and then add those hashes in turn to
 
38
    the inventory.  This should mean at least that there are no
 
39
    broken hash pointers.  There is no way we can get a snapshot
 
40
    of the whole directory at an instant.  This would also have to
 
41
    be robust against files disappearing, moving, etc.  So the
 
42
    whole thing is a bit hard.
 
43
 
 
44
    timestamp -- if not None, seconds-since-epoch for a
 
45
         postdated/predated commit.
 
46
 
 
47
    specific_files
 
48
        If true, commit only those files.
 
49
 
 
50
    rev_id
 
51
        If set, use this as the new revision id.
 
52
        Useful for test or import commands that need to tightly
 
53
        control what revisions are assigned.  If you duplicate
 
54
        a revision id that exists elsewhere it is your own fault.
 
55
        If null (default), a time/random revision id is generated.
 
56
    """
 
57
 
 
58
    import time, tempfile
 
59
 
 
60
    from bzrlib.osutils import local_time_offset, username
 
61
    from bzrlib.branch import gen_file_id
 
62
    from bzrlib.errors import BzrError
 
63
    from bzrlib.revision import Revision, RevisionReference
 
64
    from bzrlib.trace import mutter, note
 
65
    from bzrlib.xml import pack_xml
 
66
 
 
67
    branch.lock_write()
 
68
 
 
69
    try:
 
70
        # First walk over the working inventory; and both update that
 
71
        # and also build a new revision inventory.  The revision
 
72
        # inventory needs to hold the text-id, sha1 and size of the
 
73
        # actual file versions committed in the revision.  (These are
 
74
        # not present in the working inventory.)  We also need to
 
75
        # detect missing/deleted files, and remove them from the
 
76
        # working inventory.
 
77
 
 
78
        work_tree = branch.working_tree()
 
79
        work_inv = work_tree.inventory
 
80
        basis = branch.basis_tree()
 
81
        basis_inv = basis.inventory
 
82
 
 
83
        if verbose:
 
84
            note('looking for changes...')
 
85
 
 
86
        pending_merges = branch.pending_merges()
 
87
 
 
88
        missing_ids, new_inv = _gather_commit(branch,
 
89
                                              work_tree,
 
90
                                              work_inv,
 
91
                                              basis_inv,
 
92
                                              specific_files,
 
93
                                              verbose)
 
94
 
 
95
        for file_id in missing_ids:
 
96
            # Any files that have been deleted are now removed from the
 
97
            # working inventory.  Files that were not selected for commit
 
98
            # are left as they were in the working inventory and ommitted
 
99
            # from the revision inventory.
 
100
 
 
101
            # have to do this later so we don't mess up the iterator.
 
102
            # since parents may be removed before their children we
 
103
            # have to test.
 
104
 
 
105
            # FIXME: There's probably a better way to do this; perhaps
 
106
            # the workingtree should know how to filter itbranch.
 
107
            if work_inv.has_id(file_id):
 
108
                del work_inv[file_id]
 
109
 
 
110
 
 
111
        if rev_id is None:
 
112
            rev_id = _gen_revision_id(time.time())
 
113
        inv_id = rev_id
 
114
 
 
115
        inv_tmp = tempfile.TemporaryFile()
 
116
        pack_xml(new_inv, inv_tmp)
 
117
        inv_tmp.seek(0)
 
118
        branch.inventory_store.add(inv_tmp, inv_id)
 
119
        mutter('new inventory_id is {%s}' % inv_id)
 
120
 
 
121
        # We could also just sha hash the inv_tmp file
 
122
        # however, in the case that branch.inventory_store.add()
 
123
        # ever actually does anything special
 
124
        inv_sha1 = branch.get_inventory_sha1(inv_id)
 
125
 
 
126
        branch._write_inventory(work_inv)
 
127
 
 
128
        if timestamp == None:
 
129
            timestamp = time.time()
 
130
 
 
131
        if committer == None:
 
132
            committer = username()
 
133
 
 
134
        if timezone == None:
 
135
            timezone = local_time_offset()
 
136
 
 
137
        mutter("building commit log message")
 
138
        rev = Revision(timestamp=timestamp,
 
139
                       timezone=timezone,
 
140
                       committer=committer,
 
141
                       message = message,
 
142
                       inventory_id=inv_id,
 
143
                       inventory_sha1=inv_sha1,
 
144
                       revision_id=rev_id)
 
145
 
 
146
        rev.parents = []
 
147
        precursor_id = branch.last_patch()
 
148
        if precursor_id:
 
149
            precursor_sha1 = branch.get_revision_sha1(precursor_id)
 
150
            rev.parents.append(RevisionReference(precursor_id, precursor_sha1))
 
151
        for merge_rev in pending_merges:
 
152
            rev.parents.append(RevisionReference(merge_rev))            
 
153
 
 
154
        rev_tmp = tempfile.TemporaryFile()
 
155
        pack_xml(rev, rev_tmp)
 
156
        rev_tmp.seek(0)
 
157
        branch.revision_store.add(rev_tmp, rev_id)
 
158
        mutter("new revision_id is {%s}" % rev_id)
 
159
 
 
160
        ## XXX: Everything up to here can simply be orphaned if we abort
 
161
        ## the commit; it will leave junk files behind but that doesn't
 
162
        ## matter.
 
163
 
 
164
        ## TODO: Read back the just-generated changeset, and make sure it
 
165
        ## applies and recreates the right state.
 
166
 
 
167
        ## TODO: Also calculate and store the inventory SHA1
 
168
        mutter("committing patch r%d" % (branch.revno() + 1))
 
169
 
 
170
        branch.append_revision(rev_id)
 
171
 
 
172
        if verbose:
 
173
            note("commited r%d" % branch.revno())
 
174
    finally:
 
175
        branch.unlock()
 
176
 
 
177
 
 
178
 
 
179
def _gen_revision_id(when):
 
180
    """Return new revision-id."""
 
181
    from binascii import hexlify
 
182
    from osutils import rand_bytes, compact_date, user_email
 
183
 
 
184
    s = '%s-%s-' % (user_email(), compact_date(when))
 
185
    s += hexlify(rand_bytes(8))
 
186
    return s
 
187
 
 
188
 
 
189
def _gather_commit(branch, work_tree, work_inv, basis_inv, specific_files,
 
190
                   verbose):
 
191
    """Build inventory preparatory to commit.
 
192
 
 
193
    This adds any changed files into the text store, and sets their
 
194
    test-id, sha and size in the returned inventory appropriately.
 
195
 
 
196
    missing_ids
 
197
        Modified to hold a list of files that have been deleted from
 
198
        the working directory; these should be removed from the
 
199
        working inventory.
 
200
    """
 
201
    from bzrlib.inventory import Inventory
 
202
    from osutils import isdir, isfile, sha_string, quotefn, \
 
203
         local_time_offset, username, kind_marker, is_inside_any
 
204
    
 
205
    from branch import gen_file_id
 
206
    from errors import BzrError
 
207
    from revision import Revision
 
208
    from bzrlib.trace import mutter, note
 
209
 
 
210
    inv = Inventory()
 
211
    missing_ids = []
 
212
    
 
213
    for path, entry in work_inv.iter_entries():
 
214
        ## TODO: Check that the file kind has not changed from the previous
 
215
        ## revision of this file (if any).
 
216
 
 
217
        p = branch.abspath(path)
 
218
        file_id = entry.file_id
 
219
        mutter('commit prep file %s, id %r ' % (p, file_id))
 
220
 
 
221
        if specific_files and not is_inside_any(specific_files, path):
 
222
            if basis_inv.has_id(file_id):
 
223
                # carry over with previous state
 
224
                inv.add(basis_inv[file_id].copy())
 
225
            else:
 
226
                # omit this from committed inventory
 
227
                pass
 
228
            continue
 
229
 
 
230
        if not work_tree.has_id(file_id):
 
231
            if verbose:
 
232
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
 
233
            mutter("    file is missing, removing from inventory")
 
234
            missing_ids.append(file_id)
 
235
            continue
 
236
 
 
237
        # this is present in the new inventory; may be new, modified or
 
238
        # unchanged.
 
239
        old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
240
        
 
241
        entry = entry.copy()
 
242
        inv.add(entry)
 
243
 
 
244
        if old_ie:
 
245
            old_kind = old_ie.kind
 
246
            if old_kind != entry.kind:
 
247
                raise BzrError("entry %r changed kind from %r to %r"
 
248
                        % (file_id, old_kind, entry.kind))
 
249
 
 
250
        if entry.kind == 'directory':
 
251
            if not isdir(p):
 
252
                raise BzrError("%s is entered as directory but not a directory"
 
253
                               % quotefn(p))
 
254
        elif entry.kind == 'file':
 
255
            if not isfile(p):
 
256
                raise BzrError("%s is entered as file but is not a file" % quotefn(p))
 
257
 
 
258
            new_sha1 = work_tree.get_file_sha1(file_id)
 
259
 
 
260
            if (old_ie
 
261
                and old_ie.text_sha1 == new_sha1):
 
262
                ## assert content == basis.get_file(file_id).read()
 
263
                entry.text_id = old_ie.text_id
 
264
                entry.text_sha1 = new_sha1
 
265
                entry.text_size = old_ie.text_size
 
266
                mutter('    unchanged from previous text_id {%s}' %
 
267
                       entry.text_id)
 
268
            else:
 
269
                content = file(p, 'rb').read()
 
270
 
 
271
                # calculate the sha again, just in case the file contents
 
272
                # changed since we updated the cache
 
273
                entry.text_sha1 = sha_string(content)
 
274
                entry.text_size = len(content)
 
275
 
 
276
                entry.text_id = gen_file_id(entry.name)
 
277
                branch.text_store.add(content, entry.text_id)
 
278
                mutter('    stored with text_id {%s}' % entry.text_id)
 
279
 
 
280
        if verbose:
 
281
            marked = path + kind_marker(entry.kind)
 
282
            if not old_ie:
 
283
                print 'added', marked
 
284
            elif old_ie == entry:
 
285
                pass                    # unchanged
 
286
            elif (old_ie.name == entry.name
 
287
                  and old_ie.parent_id == entry.parent_id):
 
288
                print 'modified', marked
 
289
            else:
 
290
                print 'renamed', marked
 
291
                        
 
292
    return missing_ids, inv
 
293
 
 
294