~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-05-11 10:14:09 UTC
  • Revision ID: mbp@sourcefrog.net-20050511101409-25634506a9caacfd
- move commit code into its own module
- remove some doctest tests in favour of black-box tests
- specific-file parameters for diff and status now cover all
  files inside a directory

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
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
def commit(branch, message, timestamp=None, timezone=None,
 
20
           committer=None,
 
21
           verbose=False):
 
22
    """Commit working copy as a new revision.
 
23
 
 
24
    The basic approach is to add all the file texts into the
 
25
    store, then the inventory, then make a new revision pointing
 
26
    to that inventory and store that.
 
27
 
 
28
    This is not quite safe if the working copy changes during the
 
29
    commit; for the moment that is simply not allowed.  A better
 
30
    approach is to make a temporary copy of the files before
 
31
    computing their hashes, and then add those hashes in turn to
 
32
    the inventory.  This should mean at least that there are no
 
33
    broken hash pointers.  There is no way we can get a snapshot
 
34
    of the whole directory at an instant.  This would also have to
 
35
    be robust against files disappearing, moving, etc.  So the
 
36
    whole thing is a bit hard.
 
37
 
 
38
    timestamp -- if not None, seconds-since-epoch for a
 
39
         postdated/predated commit.
 
40
    """
 
41
 
 
42
    import os, time, tempfile
 
43
 
 
44
    from inventory import Inventory
 
45
    from osutils import isdir, isfile, sha_string, quotefn, \
 
46
         local_time_offset, username
 
47
    
 
48
    from branch import gen_file_id
 
49
    from errors import BzrError
 
50
    from revision import Revision
 
51
    from textui import show_status
 
52
    from trace import mutter, note
 
53
 
 
54
    branch._need_writelock()
 
55
 
 
56
    ## TODO: Show branch names
 
57
 
 
58
    # TODO: Don't commit if there are no changes, unless forced?
 
59
 
 
60
    # First walk over the working inventory; and both update that
 
61
    # and also build a new revision inventory.  The revision
 
62
    # inventory needs to hold the text-id, sha1 and size of the
 
63
    # actual file versions committed in the revision.  (These are
 
64
    # not present in the working inventory.)  We also need to
 
65
    # detect missing/deleted files, and remove them from the
 
66
    # working inventory.
 
67
 
 
68
    work_inv = branch.read_working_inventory()
 
69
    inv = Inventory()
 
70
    basis = branch.basis_tree()
 
71
    basis_inv = basis.inventory
 
72
    missing_ids = []
 
73
    for path, entry in work_inv.iter_entries():
 
74
        ## TODO: Cope with files that have gone missing.
 
75
 
 
76
        ## TODO: Check that the file kind has not changed from the previous
 
77
        ## revision of this file (if any).
 
78
 
 
79
        entry = entry.copy()
 
80
 
 
81
        p = branch.abspath(path)
 
82
        file_id = entry.file_id
 
83
        mutter('commit prep file %s, id %r ' % (p, file_id))
 
84
 
 
85
        if not os.path.exists(p):
 
86
            mutter("    file is missing, removing from inventory")
 
87
            if verbose:
 
88
                show_status('D', entry.kind, quotefn(path))
 
89
            missing_ids.append(file_id)
 
90
            continue
 
91
 
 
92
        # TODO: Handle files that have been deleted
 
93
 
 
94
        # TODO: Maybe a special case for empty files?  Seems a
 
95
        # waste to store them many times.
 
96
 
 
97
        inv.add(entry)
 
98
 
 
99
        if basis_inv.has_id(file_id):
 
100
            old_kind = basis_inv[file_id].kind
 
101
            if old_kind != entry.kind:
 
102
                raise BzrError("entry %r changed kind from %r to %r"
 
103
                        % (file_id, old_kind, entry.kind))
 
104
 
 
105
        if entry.kind == 'directory':
 
106
            if not isdir(p):
 
107
                raise BzrError("%s is entered as directory but not a directory" % quotefn(p))
 
108
        elif entry.kind == 'file':
 
109
            if not isfile(p):
 
110
                raise BzrError("%s is entered as file but is not a file" % quotefn(p))
 
111
 
 
112
            content = file(p, 'rb').read()
 
113
 
 
114
            entry.text_sha1 = sha_string(content)
 
115
            entry.text_size = len(content)
 
116
 
 
117
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
118
            if (old_ie
 
119
                and (old_ie.text_size == entry.text_size)
 
120
                and (old_ie.text_sha1 == entry.text_sha1)):
 
121
                ## assert content == basis.get_file(file_id).read()
 
122
                entry.text_id = basis_inv[file_id].text_id
 
123
                mutter('    unchanged from previous text_id {%s}' %
 
124
                       entry.text_id)
 
125
 
 
126
            else:
 
127
                entry.text_id = gen_file_id(entry.name)
 
128
                branch.text_store.add(content, entry.text_id)
 
129
                mutter('    stored with text_id {%s}' % entry.text_id)
 
130
                if verbose:
 
131
                    if not old_ie:
 
132
                        state = 'A'
 
133
                    elif (old_ie.name == entry.name
 
134
                          and old_ie.parent_id == entry.parent_id):
 
135
                        state = 'M'
 
136
                    else:
 
137
                        state = 'R'
 
138
 
 
139
                    show_status(state, entry.kind, quotefn(path))
 
140
 
 
141
    for file_id in missing_ids:
 
142
        # have to do this later so we don't mess up the iterator.
 
143
        # since parents may be removed before their children we
 
144
        # have to test.
 
145
 
 
146
        # FIXME: There's probably a better way to do this; perhaps
 
147
        # the workingtree should know how to filter itbranch.
 
148
        if work_inv.has_id(file_id):
 
149
            del work_inv[file_id]
 
150
 
 
151
 
 
152
    inv_id = rev_id = _gen_revision_id(time.time())
 
153
 
 
154
    inv_tmp = tempfile.TemporaryFile()
 
155
    inv.write_xml(inv_tmp)
 
156
    inv_tmp.seek(0)
 
157
    branch.inventory_store.add(inv_tmp, inv_id)
 
158
    mutter('new inventory_id is {%s}' % inv_id)
 
159
 
 
160
    branch._write_inventory(work_inv)
 
161
 
 
162
    if timestamp == None:
 
163
        timestamp = time.time()
 
164
 
 
165
    if committer == None:
 
166
        committer = username()
 
167
 
 
168
    if timezone == None:
 
169
        timezone = local_time_offset()
 
170
 
 
171
    mutter("building commit log message")
 
172
    rev = Revision(timestamp=timestamp,
 
173
                   timezone=timezone,
 
174
                   committer=committer,
 
175
                   precursor = branch.last_patch(),
 
176
                   message = message,
 
177
                   inventory_id=inv_id,
 
178
                   revision_id=rev_id)
 
179
 
 
180
    rev_tmp = tempfile.TemporaryFile()
 
181
    rev.write_xml(rev_tmp)
 
182
    rev_tmp.seek(0)
 
183
    branch.revision_store.add(rev_tmp, rev_id)
 
184
    mutter("new revision_id is {%s}" % rev_id)
 
185
 
 
186
    ## XXX: Everything up to here can simply be orphaned if we abort
 
187
    ## the commit; it will leave junk files behind but that doesn't
 
188
    ## matter.
 
189
 
 
190
    ## TODO: Read back the just-generated changeset, and make sure it
 
191
    ## applies and recreates the right state.
 
192
 
 
193
    ## TODO: Also calculate and store the inventory SHA1
 
194
    mutter("committing patch r%d" % (branch.revno() + 1))
 
195
 
 
196
 
 
197
    branch.append_revision(rev_id)
 
198
 
 
199
    if verbose:
 
200
        note("commited r%d" % branch.revno())
 
201
 
 
202
 
 
203
 
 
204
def _gen_revision_id(when):
 
205
    """Return new revision-id."""
 
206
    from binascii import hexlify
 
207
    from osutils import rand_bytes, compact_date, user_email
 
208
 
 
209
    s = '%s-%s-' % (user_email(), compact_date(when))
 
210
    s += hexlify(rand_bytes(8))
 
211
    return s
 
212
 
 
213