/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 breezy/commit.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/commit.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
# XXX: Can we do any better about making interrupted commits change
19
 
# nothing?  Perhaps the best approach is to integrate commit of
20
 
# AtomicFiles with releasing the lock on the Branch.
21
 
 
22
 
# TODO: Separate 'prepare' phase where we find a list of potentially
23
 
# committed files.  We then can then pause the commit to prompt for a
24
 
# commit message, knowing the summary will be the same as what's
25
 
# actually used for the commit.  (But perhaps simpler to simply get
26
 
# the tree status, then use that for a selective commit?)
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from __future__ import absolute_import
27
18
 
28
19
# The newly committed revision is going to have a shape corresponding
29
 
# to that of the working inventory.  Files that are not in the
 
20
# to that of the working tree.  Files that are not in the
30
21
# working tree and that were in the predecessor are reported as
31
22
# removed --- this can include files that were either removed from the
32
23
# inventory or deleted in the working tree.  If they were only
35
26
# We then consider the remaining entries, which will be in the new
36
27
# version.  Directory entries are simply copied across.  File entries
37
28
# must be checked to see if a new version of the file should be
38
 
# recorded.  For each parent revision inventory, we check to see what
 
29
# recorded.  For each parent revision tree, we check to see what
39
30
# version of the file was present.  If the file was present in at
40
31
# least one tree, and if it was the same version in all the trees,
41
32
# then we can just refer to that version.  Otherwise, a new version
56
47
# merges from, then it should still be reported as newly added
57
48
# relative to the basis revision.
58
49
 
59
 
# TODO: Do checks that the tree can be committed *before* running the 
60
 
# editor; this should include checks for a pointless commit and for 
61
 
# unknown or missing files.
62
 
 
63
 
# TODO: If commit fails, leave the message in a file somewhere.
64
 
 
65
 
 
66
 
import os
67
 
import re
68
 
import sys
69
 
import time
70
 
import pdb
71
 
 
72
 
from binascii import hexlify
73
 
from cStringIO import StringIO
74
 
 
75
 
from bzrlib.osutils import (local_time_offset,
76
 
                            rand_bytes, compact_date,
77
 
                            kind_marker, is_inside_any, quotefn,
78
 
                            sha_string, sha_strings, sha_file, isdir, isfile,
79
 
                            split_lines)
80
 
from bzrlib.branch import gen_file_id
81
 
import bzrlib.config
82
 
from bzrlib.errors import (BzrError, PointlessCommit,
83
 
                           HistoryMissing,
84
 
                           ConflictsInTree,
85
 
                           StrictCommitFailed
86
 
                           )
87
 
import bzrlib.gpg as gpg
88
 
from bzrlib.revision import Revision
89
 
from bzrlib.testament import Testament
90
 
from bzrlib.trace import mutter, note, warning
91
 
from bzrlib.xml5 import serializer_v5
92
 
from bzrlib.inventory import Inventory, ROOT_ID
93
 
from bzrlib.weave import Weave
94
 
from bzrlib.weavefile import read_weave, write_weave_v5
95
 
from bzrlib.atomicfile import AtomicFile
96
 
 
97
 
 
98
 
def commit(*args, **kwargs):
99
 
    """Commit a new revision to a branch.
100
 
 
101
 
    Function-style interface for convenience of old callers.
102
 
 
103
 
    New code should use the Commit class instead.
 
50
# TODO: Change the parameter 'rev_id' to 'revision_id' to be consistent with
 
51
# the rest of the code; add a deprecation of the old name.
 
52
 
 
53
from . import (
 
54
    debug,
 
55
    errors,
 
56
    trace,
 
57
    ui,
 
58
    )
 
59
from .branch import Branch
 
60
from .cleanup import ExitStack
 
61
import breezy.config
 
62
from .errors import (BzrError,
 
63
                     ConflictsInTree,
 
64
                     StrictCommitFailed
 
65
                     )
 
66
from .osutils import (get_user_encoding,
 
67
                      has_symlinks,
 
68
                      is_inside_any,
 
69
                      minimum_path_selection,
 
70
                      )
 
71
from .trace import mutter, note, is_quiet
 
72
from .tree import TreeChange
 
73
from .urlutils import unescape_for_display
 
74
from .i18n import gettext
 
75
 
 
76
 
 
77
class PointlessCommit(BzrError):
 
78
 
 
79
    _fmt = "No changes to commit"
 
80
 
 
81
 
 
82
class CannotCommitSelectedFileMerge(BzrError):
 
83
 
 
84
    _fmt = 'Selected-file commit of merges is not supported yet:'\
 
85
        ' files %(files_str)s'
 
86
 
 
87
    def __init__(self, files):
 
88
        files_str = ', '.join(files)
 
89
        BzrError.__init__(self, files=files, files_str=files_str)
 
90
 
 
91
 
 
92
def filter_excluded(iter_changes, exclude):
 
93
    """Filter exclude filenames.
 
94
 
 
95
    :param iter_changes: iter_changes function
 
96
    :param exclude: List of paths to exclude
 
97
    :return: iter_changes function
104
98
    """
105
 
    ## XXX: Remove this in favor of Branch.commit?
106
 
    Commit().commit(*args, **kwargs)
 
99
    for change in iter_changes:
 
100
        new_excluded = (change.path[1] is not None and
 
101
                        is_inside_any(exclude, change.path[1]))
 
102
 
 
103
        old_excluded = (change.path[0] is not None and
 
104
                        is_inside_any(exclude, change.path[0]))
 
105
 
 
106
        if old_excluded and new_excluded:
 
107
            continue
 
108
 
 
109
        if old_excluded or new_excluded:
 
110
            # TODO(jelmer): Perhaps raise an error here instead?
 
111
            continue
 
112
 
 
113
        yield change
107
114
 
108
115
 
109
116
class NullCommitReporter(object):
110
117
    """I report on progress of a commit."""
111
118
 
 
119
    def started(self, revno, revid, location):
 
120
        pass
 
121
 
112
122
    def snapshot_change(self, change, path):
113
123
        pass
114
124
 
115
125
    def completed(self, revno, rev_id):
116
126
        pass
117
127
 
118
 
    def deleted(self, file_id):
119
 
        pass
120
 
 
121
 
    def escaped(self, escape_count, message):
 
128
    def deleted(self, path):
122
129
        pass
123
130
 
124
131
    def missing(self, path):
125
132
        pass
126
133
 
 
134
    def renamed(self, change, old_path, new_path):
 
135
        pass
 
136
 
 
137
    def is_verbose(self):
 
138
        return False
 
139
 
 
140
 
127
141
class ReportCommitToLog(NullCommitReporter):
128
142
 
 
143
    def _note(self, format, *args):
 
144
        """Output a message.
 
145
 
 
146
        Subclasses may choose to override this method.
 
147
        """
 
148
        note(format, *args)
 
149
 
129
150
    def snapshot_change(self, change, path):
130
 
        note("%s %s", change, path)
 
151
        if path == '' and change in (gettext('added'), gettext('modified')):
 
152
            return
 
153
        self._note("%s %s", change, path)
 
154
 
 
155
    def started(self, revno, rev_id, location):
 
156
        self._note(
 
157
            gettext('Committing to: %s'),
 
158
            unescape_for_display(location, 'utf-8'))
131
159
 
132
160
    def completed(self, revno, rev_id):
133
 
        note('committed r%d {%s}', revno, rev_id)
134
 
    
135
 
    def deleted(self, file_id):
136
 
        note('deleted %s', file_id)
 
161
        if revno is not None:
 
162
            self._note(gettext('Committed revision %d.'), revno)
 
163
            # self._note goes to the console too; so while we want to log the
 
164
            # rev_id, we can't trivially only log it. (See bug 526425). Long
 
165
            # term we should rearrange the reporting structure, but for now
 
166
            # we just mutter seperately. We mutter the revid and revno together
 
167
            # so that concurrent bzr invocations won't lead to confusion.
 
168
            mutter('Committed revid %s as revno %d.', rev_id, revno)
 
169
        else:
 
170
            self._note(gettext('Committed revid %s.'), rev_id)
137
171
 
138
 
    def escaped(self, escape_count, message):
139
 
        note("replaced %d control characters in message", escape_count)
 
172
    def deleted(self, path):
 
173
        self._note(gettext('deleted %s'), path)
140
174
 
141
175
    def missing(self, path):
142
 
        note('missing %s', path)
 
176
        self._note(gettext('missing %s'), path)
 
177
 
 
178
    def renamed(self, change, old_path, new_path):
 
179
        self._note('%s %s => %s', change, old_path, new_path)
 
180
 
 
181
    def is_verbose(self):
 
182
        return True
 
183
 
143
184
 
144
185
class Commit(object):
145
186
    """Task of committing a new revision.
153
194
            the working directory; these should be removed from the
154
195
            working inventory.
155
196
    """
 
197
 
156
198
    def __init__(self,
157
199
                 reporter=None,
158
 
                 config=None):
159
 
        if reporter is not None:
160
 
            self.reporter = reporter
161
 
        else:
162
 
            self.reporter = NullCommitReporter()
163
 
        if config is not None:
164
 
            self.config = config
165
 
        else:
166
 
            self.config = None
167
 
        
 
200
                 config_stack=None):
 
201
        """Create a Commit object.
 
202
 
 
203
        :param reporter: the default reporter to use or None to decide later
 
204
        """
 
205
        self.reporter = reporter
 
206
        self.config_stack = config_stack
 
207
 
 
208
    @staticmethod
 
209
    def update_revprops(revprops, branch, authors=None,
 
210
                        local=False, possible_master_transports=None):
 
211
        if revprops is None:
 
212
            revprops = {}
 
213
        if possible_master_transports is None:
 
214
            possible_master_transports = []
 
215
        if (u'branch-nick' not in revprops and
 
216
                branch.repository._format.supports_storing_branch_nick):
 
217
            revprops[u'branch-nick'] = branch._get_nick(
 
218
                local,
 
219
                possible_master_transports)
 
220
        if authors is not None:
 
221
            if u'author' in revprops or u'authors' in revprops:
 
222
                # XXX: maybe we should just accept one of them?
 
223
                raise AssertionError('author property given twice')
 
224
            if authors:
 
225
                for individual in authors:
 
226
                    if '\n' in individual:
 
227
                        raise AssertionError('\\n is not a valid character '
 
228
                                             'in an author identity')
 
229
                revprops[u'authors'] = '\n'.join(authors)
 
230
        return revprops
 
231
 
168
232
    def commit(self,
169
 
               branch, message,
 
233
               message=None,
170
234
               timestamp=None,
171
235
               timezone=None,
172
236
               committer=None,
175
239
               allow_pointless=True,
176
240
               strict=False,
177
241
               verbose=False,
178
 
               revprops=None):
 
242
               revprops=None,
 
243
               working_tree=None,
 
244
               local=False,
 
245
               reporter=None,
 
246
               config=None,
 
247
               message_callback=None,
 
248
               recursive='down',
 
249
               exclude=None,
 
250
               possible_master_transports=None,
 
251
               lossy=False):
179
252
        """Commit working copy as a new revision.
180
253
 
181
 
        timestamp -- if not None, seconds-since-epoch for a
182
 
             postdated/predated commit.
183
 
 
184
 
        specific_files -- If true, commit only those files.
185
 
 
186
 
        rev_id -- If set, use this as the new revision id.
 
254
        :param message: the commit message (it or message_callback is required)
 
255
        :param message_callback: A callback: message =
 
256
            message_callback(cmt_obj)
 
257
 
 
258
        :param timestamp: if not None, seconds-since-epoch for a
 
259
            postdated/predated commit.
 
260
 
 
261
        :param specific_files: If not None, commit only those files. An empty
 
262
            list means 'commit no files'.
 
263
 
 
264
        :param rev_id: If set, use this as the new revision id.
187
265
            Useful for test or import commands that need to tightly
188
266
            control what revisions are assigned.  If you duplicate
189
267
            a revision id that exists elsewhere it is your own fault.
190
268
            If null (default), a time/random revision id is generated.
191
269
 
192
 
        allow_pointless -- If true (default), commit even if nothing
 
270
        :param allow_pointless: If true (default), commit even if nothing
193
271
            has changed and no merges are recorded.
194
272
 
195
 
        strict -- If true, don't allow a commit if the working tree
 
273
        :param strict: If true, don't allow a commit if the working tree
196
274
            contains unknown files.
197
275
 
198
 
        revprops -- Properties for new revision
 
276
        :param revprops: Properties for new revision
 
277
        :param local: Perform a local only commit.
 
278
        :param reporter: the reporter to use or None for the default
 
279
        :param verbose: if True and the reporter is not None, report everything
 
280
        :param recursive: If set to 'down', commit in any subtrees that have
 
281
            pending changes of any sort during this commit.
 
282
        :param exclude: None or a list of relative paths to exclude from the
 
283
            commit. Pending changes to excluded files will be ignored by the
 
284
            commit.
 
285
        :param lossy: When committing to a foreign VCS, ignore any
 
286
            data that can not be natively represented.
199
287
        """
200
 
        mutter('preparing to commit')
201
 
 
202
 
        self.branch = branch
203
 
        self.weave_store = branch.weave_store
204
 
        self.rev_id = rev_id
205
 
        self.specific_files = specific_files
206
 
        self.allow_pointless = allow_pointless
207
 
        self.revprops = revprops
208
 
 
209
 
        if strict and branch.unknowns():
210
 
            raise StrictCommitFailed()
211
 
 
212
 
        if timestamp is None:
213
 
            self.timestamp = time.time()
214
 
        else:
215
 
            self.timestamp = long(timestamp)
216
 
            
217
 
        if self.config is None:
218
 
            self.config = bzrlib.config.BranchConfig(self.branch)
219
 
 
220
 
        if rev_id is None:
221
 
            self.rev_id = _gen_revision_id(self.config, self.timestamp)
222
 
        else:
223
 
            self.rev_id = rev_id
224
 
 
225
 
        if committer is None:
226
 
            self.committer = self.config.username()
227
 
        else:
228
 
            assert isinstance(committer, basestring), type(committer)
 
288
        with ExitStack() as stack:
 
289
            self.revprops = revprops or {}
 
290
            # XXX: Can be set on __init__ or passed in - this is a bit ugly.
 
291
            self.config_stack = config or self.config_stack
 
292
            mutter('preparing to commit')
 
293
 
 
294
            if working_tree is None:
 
295
                raise BzrError("working_tree must be passed into commit().")
 
296
            else:
 
297
                self.work_tree = working_tree
 
298
                self.branch = self.work_tree.branch
 
299
                if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
 
300
                    if not self.branch.repository.supports_rich_root():
 
301
                        raise errors.RootNotRich()
 
302
            if message_callback is None:
 
303
                if message is not None:
 
304
                    if isinstance(message, bytes):
 
305
                        message = message.decode(get_user_encoding())
 
306
 
 
307
                    def message_callback(x):
 
308
                        return message
 
309
                else:
 
310
                    raise BzrError("The message or message_callback keyword"
 
311
                                   " parameter is required for commit().")
 
312
 
 
313
            self.bound_branch = None
 
314
            self.any_entries_deleted = False
 
315
            if exclude is not None:
 
316
                self.exclude = sorted(
 
317
                    minimum_path_selection(exclude))
 
318
            else:
 
319
                self.exclude = []
 
320
            self.local = local
 
321
            self.master_branch = None
 
322
            self.recursive = recursive
 
323
            self.rev_id = None
 
324
            # self.specific_files is None to indicate no filter, or any iterable to
 
325
            # indicate a filter - [] means no files at all, as per iter_changes.
 
326
            if specific_files is not None:
 
327
                self.specific_files = sorted(
 
328
                    minimum_path_selection(specific_files))
 
329
            else:
 
330
                self.specific_files = None
 
331
 
 
332
            self.allow_pointless = allow_pointless
 
333
            self.message_callback = message_callback
 
334
            self.timestamp = timestamp
 
335
            self.timezone = timezone
229
336
            self.committer = committer
230
 
 
231
 
        if timezone is None:
232
 
            self.timezone = local_time_offset()
233
 
        else:
234
 
            self.timezone = int(timezone)
235
 
 
236
 
        assert isinstance(message, basestring), type(message)
237
 
        self.message = message
238
 
        self._escape_commit_message()
239
 
 
240
 
        self.branch.lock_write()
241
 
        try:
242
 
            self.work_tree = self.branch.working_tree()
243
 
            self.work_inv = self.work_tree.inventory
244
 
            self.basis_tree = self.branch.basis_tree()
245
 
            self.basis_inv = self.basis_tree.inventory
246
 
 
247
 
            self._gather_parents()
248
 
            if len(self.parents) > 1 and self.specific_files:
249
 
                raise NotImplementedError('selected-file commit of merges is not supported yet')
250
 
            self._check_parents_present()
251
 
            
252
 
            self._remove_deleted()
253
 
            self._populate_new_inv()
254
 
            self._store_snapshot()
255
 
            self._report_deletes()
256
 
 
257
 
            if not (self.allow_pointless
258
 
                    or len(self.parents) > 1
259
 
                    or self.new_inv != self.basis_inv):
260
 
                raise PointlessCommit()
261
 
 
262
 
            if len(list(self.work_tree.iter_conflicts()))>0:
 
337
            self.strict = strict
 
338
            self.verbose = verbose
 
339
 
 
340
            stack.enter_context(self.work_tree.lock_write())
 
341
            self.parents = self.work_tree.get_parent_ids()
 
342
            self.pb = ui.ui_factory.nested_progress_bar()
 
343
            stack.callback(self.pb.finished)
 
344
            self.basis_revid = self.work_tree.last_revision()
 
345
            self.basis_tree = self.work_tree.basis_tree()
 
346
            stack.enter_context(self.basis_tree.lock_read())
 
347
            # Cannot commit with conflicts present.
 
348
            if len(self.work_tree.conflicts()) > 0:
263
349
                raise ConflictsInTree
264
350
 
265
 
            self._record_inventory()
266
 
            self._make_revision()
267
 
            self.reporter.completed(self.branch.revno()+1, self.rev_id)
268
 
            self.branch.append_revision(self.rev_id)
269
 
            self.branch.set_pending_merges([])
270
 
        finally:
271
 
            self.branch.unlock()
272
 
 
273
 
    def _record_inventory(self):
274
 
        """Store the inventory for the new revision."""
275
 
        inv_text = serializer_v5.write_inventory_to_string(self.new_inv)
276
 
        self.inv_sha1 = sha_string(inv_text)
277
 
        s = self.branch.control_weaves
278
 
        s.add_text('inventory', self.rev_id,
279
 
                   split_lines(inv_text), self.present_parents,
280
 
                   self.branch.get_transaction())
281
 
 
282
 
    def _escape_commit_message(self):
283
 
        """Replace xml-incompatible control characters."""
284
 
        # Python strings can include characters that can't be
285
 
        # represented in well-formed XML; escape characters that
286
 
        # aren't listed in the XML specification
287
 
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
288
 
        if isinstance(self.message, unicode):
289
 
            char_pattern = u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]'
290
 
        else:
291
 
            # Use a regular 'str' as pattern to avoid having re.subn
292
 
            # return 'unicode' results.
293
 
            char_pattern = '[^x09\x0A\x0D\x20-\xFF]'
294
 
        self.message, escape_count = re.subn(
295
 
            char_pattern,
296
 
            lambda match: match.group(0).encode('unicode_escape'),
297
 
            self.message)
298
 
        if escape_count:
299
 
            self.reporter.escaped(escape_count, self.message)
300
 
 
301
 
    def _gather_parents(self):
302
 
        """Record the parents of a merge for merge detection."""
303
 
        pending_merges = self.branch.pending_merges()
304
 
        self.parents = []
305
 
        self.parent_invs = []
306
 
        self.present_parents = []
307
 
        precursor_id = self.branch.last_revision()
308
 
        if precursor_id:
309
 
            self.parents.append(precursor_id)
310
 
        self.parents += pending_merges
311
 
        for revision in self.parents:
312
 
            if self.branch.has_revision(revision):
313
 
                self.parent_invs.append(self.branch.get_inventory(revision))
314
 
                self.present_parents.append(revision)
315
 
 
316
 
    def _check_parents_present(self):
317
 
        for parent_id in self.parents:
318
 
            mutter('commit parent revision {%s}', parent_id)
319
 
            if not self.branch.has_revision(parent_id):
320
 
                if parent_id == self.branch.last_revision():
321
 
                    warning("parent is missing %r", parent_id)
322
 
                    raise HistoryMissing(self.branch, 'revision', parent_id)
 
351
            # Setup the bound branch variables as needed.
 
352
            self._check_bound_branch(stack, possible_master_transports)
 
353
            if self.config_stack is None:
 
354
                self.config_stack = self.work_tree.get_config_stack()
 
355
 
 
356
            # Check that the working tree is up to date
 
357
            old_revno, old_revid, new_revno = self._check_out_of_date_tree()
 
358
 
 
359
            # Complete configuration setup
 
360
            if reporter is not None:
 
361
                self.reporter = reporter
 
362
            elif self.reporter is None:
 
363
                self.reporter = self._select_reporter()
 
364
 
 
365
            # Setup the progress bar. As the number of files that need to be
 
366
            # committed in unknown, progress is reported as stages.
 
367
            # We keep track of entries separately though and include that
 
368
            # information in the progress bar during the relevant stages.
 
369
            self.pb_stage_name = ""
 
370
            self.pb_stage_count = 0
 
371
            self.pb_stage_total = 5
 
372
            if self.bound_branch:
 
373
                # 2 extra stages: "Uploading data to master branch" and "Merging
 
374
                # tags to master branch"
 
375
                self.pb_stage_total += 2
 
376
            self.pb.show_pct = False
 
377
            self.pb.show_spinner = False
 
378
            self.pb.show_eta = False
 
379
            self.pb.show_count = True
 
380
            self.pb.show_bar = True
 
381
 
 
382
            # After a merge, a selected file commit is not supported.
 
383
            # See 'bzr help merge' for an explanation as to why.
 
384
            if len(self.parents) > 1 and self.specific_files is not None:
 
385
                raise CannotCommitSelectedFileMerge(self.specific_files)
 
386
            # Excludes are a form of selected file commit.
 
387
            if len(self.parents) > 1 and self.exclude:
 
388
                raise CannotCommitSelectedFileMerge(self.exclude)
 
389
 
 
390
            # Collect the changes
 
391
            self._set_progress_stage("Collecting changes", counter=True)
 
392
            self._lossy = lossy
 
393
            self.builder = self.branch.get_commit_builder(
 
394
                self.parents, self.config_stack, timestamp, timezone, committer,
 
395
                self.revprops, rev_id, lossy=lossy)
 
396
 
 
397
            if self.builder.updates_branch and self.bound_branch:
 
398
                self.builder.abort()
 
399
                raise AssertionError(
 
400
                    "bound branches not supported for commit builders "
 
401
                    "that update the branch")
 
402
 
 
403
            try:
 
404
                # find the location being committed to
 
405
                if self.bound_branch:
 
406
                    master_location = self.master_branch.base
323
407
                else:
324
 
                    mutter("commit will ghost revision %r", parent_id)
325
 
            
326
 
    def _make_revision(self):
327
 
        """Record a new revision object for this commit."""
328
 
        self.rev = Revision(timestamp=self.timestamp,
329
 
                            timezone=self.timezone,
330
 
                            committer=self.committer,
331
 
                            message=self.message,
332
 
                            inventory_sha1=self.inv_sha1,
333
 
                            revision_id=self.rev_id,
334
 
                            properties=self.revprops)
335
 
        self.rev.parent_ids = self.parents
336
 
        rev_tmp = StringIO()
337
 
        serializer_v5.write_revision(self.rev, rev_tmp)
338
 
        rev_tmp.seek(0)
339
 
        if self.config.signature_needed():
340
 
            plaintext = Testament(self.rev, self.new_inv).as_short_text()
341
 
            self.branch.store_revision_signature(gpg.GPGStrategy(self.config),
342
 
                                                 plaintext, self.rev_id)
343
 
        self.branch.revision_store.add(rev_tmp, self.rev_id)
344
 
        mutter('new revision_id is {%s}', self.rev_id)
345
 
 
346
 
    def _remove_deleted(self):
347
 
        """Remove deleted files from the working inventories.
348
 
 
349
 
        This is done prior to taking the working inventory as the
350
 
        basis for the new committed inventory.
351
 
 
352
 
        This returns true if any files
353
 
        *that existed in the basis inventory* were deleted.
354
 
        Files that were added and deleted
355
 
        in the working copy don't matter.
356
 
        """
357
 
        specific = self.specific_files
358
 
        deleted_ids = []
359
 
        for path, ie in self.work_inv.iter_entries():
360
 
            if specific and not is_inside_any(specific, path):
361
 
                continue
362
 
            if not self.work_tree.has_filename(path):
363
 
                self.reporter.missing(path)
364
 
                deleted_ids.append((path, ie.file_id))
365
 
        if deleted_ids:
366
 
            deleted_ids.sort(reverse=True)
367
 
            for path, file_id in deleted_ids:
368
 
                del self.work_inv[file_id]
369
 
            self.branch._write_inventory(self.work_inv)
370
 
 
371
 
    def _store_snapshot(self):
372
 
        """Pass over inventory and record a snapshot.
373
 
 
374
 
        Entries get a new revision when they are modified in 
375
 
        any way, which includes a merge with a new set of
376
 
        parents that have the same entry. 
377
 
        """
378
 
        # XXX: Need to think more here about when the user has
379
 
        # made a specific decision on a particular value -- c.f.
380
 
        # mark-merge.  
381
 
        for path, ie in self.new_inv.iter_entries():
382
 
            previous_entries = ie.find_previous_heads(
383
 
                self.parent_invs, 
384
 
                self.weave_store.get_weave_or_empty(ie.file_id,
385
 
                    self.branch.get_transaction()))
386
 
            if ie.revision is None:
387
 
                change = ie.snapshot(self.rev_id, path, previous_entries,
388
 
                                     self.work_tree, self.weave_store,
389
 
                                     self.branch.get_transaction())
390
 
            else:
391
 
                change = "unchanged"
392
 
            self.reporter.snapshot_change(change, path)
393
 
 
394
 
    def _populate_new_inv(self):
395
 
        """Build revision inventory.
396
 
 
397
 
        This creates a new empty inventory. Depending on
398
 
        which files are selected for commit, and what is present in the
399
 
        current tree, the new inventory is populated. inventory entries 
400
 
        which are candidates for modification have their revision set to
401
 
        None; inventory entries that are carried over untouched have their
402
 
        revision set to their prior value.
403
 
        """
404
 
        mutter("Selecting files for commit with filter %s", self.specific_files)
405
 
        self.new_inv = Inventory()
406
 
        for path, new_ie in self.work_inv.iter_entries():
407
 
            file_id = new_ie.file_id
408
 
            mutter('check %s {%s}', path, new_ie.file_id)
409
 
            if self.specific_files:
410
 
                if not is_inside_any(self.specific_files, path):
411
 
                    mutter('%s not selected for commit', path)
412
 
                    self._carry_entry(file_id)
 
408
                    master_location = self.branch.base
 
409
 
 
410
                # report the start of the commit
 
411
                self.reporter.started(new_revno, self.rev_id, master_location)
 
412
 
 
413
                self._update_builder_with_changes()
 
414
                self._check_pointless()
 
415
 
 
416
                # TODO: Now the new inventory is known, check for conflicts.
 
417
                # ADHB 2006-08-08: If this is done, populate_new_inv should not add
 
418
                # weave lines, because nothing should be recorded until it is known
 
419
                # that commit will succeed.
 
420
                self._set_progress_stage("Saving data locally")
 
421
                self.builder.finish_inventory()
 
422
 
 
423
                # Prompt the user for a commit message if none provided
 
424
                message = message_callback(self)
 
425
                self.message = message
 
426
 
 
427
                # Add revision data to the local branch
 
428
                self.rev_id = self.builder.commit(self.message)
 
429
 
 
430
            except Exception:
 
431
                mutter("aborting commit write group because of exception:")
 
432
                trace.log_exception_quietly()
 
433
                self.builder.abort()
 
434
                raise
 
435
 
 
436
            self._update_branches(old_revno, old_revid, new_revno)
 
437
 
 
438
            # Make the working tree be up to date with the branch. This
 
439
            # includes automatic changes scheduled to be made to the tree, such
 
440
            # as updating its basis and unversioning paths that were missing.
 
441
            self.work_tree.unversion(self.deleted_paths)
 
442
            self._set_progress_stage("Updating the working tree")
 
443
            self.work_tree.update_basis_by_delta(self.rev_id,
 
444
                                                 self.builder.get_basis_delta())
 
445
            self.reporter.completed(new_revno, self.rev_id)
 
446
            self._process_post_hooks(old_revno, new_revno)
 
447
            return self.rev_id
 
448
 
 
449
    def _update_branches(self, old_revno, old_revid, new_revno):
 
450
        """Update the master and local branch to the new revision.
 
451
 
 
452
        This will try to make sure that the master branch is updated
 
453
        before the local branch.
 
454
 
 
455
        :param old_revno: Revision number of master branch before the
 
456
            commit
 
457
        :param old_revid: Tip of master branch before the commit
 
458
        :param new_revno: Revision number of the new commit
 
459
        """
 
460
        if not self.builder.updates_branch:
 
461
            self._process_pre_hooks(old_revno, new_revno)
 
462
 
 
463
            # Upload revision data to the master.
 
464
            # this will propagate merged revisions too if needed.
 
465
            if self.bound_branch:
 
466
                self._set_progress_stage("Uploading data to master branch")
 
467
                # 'commit' to the master first so a timeout here causes the
 
468
                # local branch to be out of date
 
469
                (new_revno, self.rev_id) = self.master_branch.import_last_revision_info_and_tags(
 
470
                    self.branch, new_revno, self.rev_id, lossy=self._lossy)
 
471
                if self._lossy:
 
472
                    self.branch.fetch(self.master_branch, self.rev_id)
 
473
 
 
474
            # and now do the commit locally.
 
475
            if new_revno is None:
 
476
                # Keep existing behaviour around ghosts
 
477
                new_revno = 1
 
478
            self.branch.set_last_revision_info(new_revno, self.rev_id)
 
479
        else:
 
480
            try:
 
481
                self._process_pre_hooks(old_revno, new_revno)
 
482
            except BaseException:
 
483
                # The commit builder will already have updated the branch,
 
484
                # revert it.
 
485
                self.branch.set_last_revision_info(old_revno, old_revid)
 
486
                raise
 
487
 
 
488
        # Merge local tags to remote
 
489
        if self.bound_branch:
 
490
            self._set_progress_stage("Merging tags to master branch")
 
491
            tag_updates, tag_conflicts = self.branch.tags.merge_to(
 
492
                self.master_branch.tags)
 
493
            if tag_conflicts:
 
494
                warning_lines = ['    ' + name for name, _, _ in tag_conflicts]
 
495
                note(gettext("Conflicting tags in bound branch:\n{0}".format(
 
496
                    "\n".join(warning_lines))))
 
497
 
 
498
    def _select_reporter(self):
 
499
        """Select the CommitReporter to use."""
 
500
        if is_quiet():
 
501
            return NullCommitReporter()
 
502
        return ReportCommitToLog()
 
503
 
 
504
    def _check_pointless(self):
 
505
        if self.allow_pointless:
 
506
            return
 
507
        # A merge with no effect on files
 
508
        if len(self.parents) > 1:
 
509
            return
 
510
        if self.builder.any_changes():
 
511
            return
 
512
        raise PointlessCommit()
 
513
 
 
514
    def _check_bound_branch(self, stack, possible_master_transports=None):
 
515
        """Check to see if the local branch is bound.
 
516
 
 
517
        If it is bound, then most of the commit will actually be
 
518
        done using the remote branch as the target branch.
 
519
        Only at the end will the local branch be updated.
 
520
        """
 
521
        if self.local and not self.branch.get_bound_location():
 
522
            raise errors.LocalRequiresBoundBranch()
 
523
 
 
524
        if not self.local:
 
525
            self.master_branch = self.branch.get_master_branch(
 
526
                possible_master_transports)
 
527
 
 
528
        if not self.master_branch:
 
529
            # make this branch the reference branch for out of date checks.
 
530
            self.master_branch = self.branch
 
531
            return
 
532
 
 
533
        # If the master branch is bound, we must fail
 
534
        master_bound_location = self.master_branch.get_bound_location()
 
535
        if master_bound_location:
 
536
            raise errors.CommitToDoubleBoundBranch(
 
537
                self.branch, self.master_branch, master_bound_location)
 
538
 
 
539
        # TODO: jam 20051230 We could automatically push local
 
540
        #       commits to the remote branch if they would fit.
 
541
        #       But for now, just require remote to be identical
 
542
        #       to local.
 
543
 
 
544
        # Make sure the local branch is identical to the master
 
545
        master_revid = self.master_branch.last_revision()
 
546
        local_revid = self.branch.last_revision()
 
547
        if local_revid != master_revid:
 
548
            raise errors.BoundBranchOutOfDate(self.branch,
 
549
                                              self.master_branch)
 
550
 
 
551
        # Now things are ready to change the master branch
 
552
        # so grab the lock
 
553
        self.bound_branch = self.branch
 
554
        stack.enter_context(self.master_branch.lock_write())
 
555
 
 
556
    def _check_out_of_date_tree(self):
 
557
        """Check that the working tree is up to date.
 
558
 
 
559
        :return: old_revision_number, old_revision_id, new_revision_number
 
560
            tuple
 
561
        """
 
562
        try:
 
563
            first_tree_parent = self.work_tree.get_parent_ids()[0]
 
564
        except IndexError:
 
565
            # if there are no parents, treat our parent as 'None'
 
566
            # this is so that we still consider the master branch
 
567
            # - in a checkout scenario the tree may have no
 
568
            # parents but the branch may do.
 
569
            first_tree_parent = breezy.revision.NULL_REVISION
 
570
        if (self.master_branch._format.stores_revno() or
 
571
                self.config_stack.get('calculate_revnos')):
 
572
            try:
 
573
                old_revno, master_last = self.master_branch.last_revision_info()
 
574
            except errors.UnsupportedOperation:
 
575
                master_last = self.master_branch.last_revision()
 
576
                old_revno = self.branch.revision_id_to_revno(master_last)
 
577
        else:
 
578
            master_last = self.master_branch.last_revision()
 
579
            old_revno = None
 
580
        if master_last != first_tree_parent:
 
581
            if master_last != breezy.revision.NULL_REVISION:
 
582
                raise errors.OutOfDateTree(self.work_tree)
 
583
        if (old_revno is not None and
 
584
                self.branch.repository.has_revision(first_tree_parent)):
 
585
            new_revno = old_revno + 1
 
586
        else:
 
587
            # ghost parents never appear in revision history.
 
588
            new_revno = None
 
589
        return old_revno, master_last, new_revno
 
590
 
 
591
    def _process_pre_hooks(self, old_revno, new_revno):
 
592
        """Process any registered pre commit hooks."""
 
593
        self._set_progress_stage("Running pre_commit hooks")
 
594
        self._process_hooks("pre_commit", old_revno, new_revno)
 
595
 
 
596
    def _process_post_hooks(self, old_revno, new_revno):
 
597
        """Process any registered post commit hooks."""
 
598
        # Process the post commit hooks, if any
 
599
        self._set_progress_stage("Running post_commit hooks")
 
600
        # old style commit hooks - should be deprecated ? (obsoleted in
 
601
        # 0.15^H^H^H^H 2.5.0)
 
602
        post_commit = self.config_stack.get('post_commit')
 
603
        if post_commit is not None:
 
604
            hooks = post_commit.split(' ')
 
605
            # this would be nicer with twisted.python.reflect.namedAny
 
606
            for hook in hooks:
 
607
                result = eval(hook + '(branch, rev_id)',
 
608
                              {'branch': self.branch,
 
609
                               'breezy': breezy,
 
610
                               'rev_id': self.rev_id})
 
611
        # process new style post commit hooks
 
612
        self._process_hooks("post_commit", old_revno, new_revno)
 
613
 
 
614
    def _process_hooks(self, hook_name, old_revno, new_revno):
 
615
        if not Branch.hooks[hook_name]:
 
616
            return
 
617
 
 
618
        # new style commit hooks:
 
619
        if not self.bound_branch:
 
620
            hook_master = self.branch
 
621
            hook_local = None
 
622
        else:
 
623
            hook_master = self.master_branch
 
624
            hook_local = self.branch
 
625
        # With bound branches, when the master is behind the local branch,
 
626
        # the 'old_revno' and old_revid values here are incorrect.
 
627
        # XXX: FIXME ^. RBC 20060206
 
628
        if self.parents:
 
629
            old_revid = self.parents[0]
 
630
        else:
 
631
            old_revid = breezy.revision.NULL_REVISION
 
632
 
 
633
        if hook_name == "pre_commit":
 
634
            future_tree = self.builder.revision_tree()
 
635
            tree_delta = future_tree.changes_from(self.basis_tree,
 
636
                                                  include_root=True)
 
637
 
 
638
        for hook in Branch.hooks[hook_name]:
 
639
            # show the running hook in the progress bar. As hooks may
 
640
            # end up doing nothing (e.g. because they are not configured by
 
641
            # the user) this is still showing progress, not showing overall
 
642
            # actions - its up to each plugin to show a UI if it want's to
 
643
            # (such as 'Emailing diff to foo@example.com').
 
644
            self.pb_stage_name = "Running %s hooks [%s]" % \
 
645
                (hook_name, Branch.hooks.get_hook_name(hook))
 
646
            self._emit_progress()
 
647
            if 'hooks' in debug.debug_flags:
 
648
                mutter("Invoking commit hook: %r", hook)
 
649
            if hook_name == "post_commit":
 
650
                hook(hook_local, hook_master, old_revno, old_revid, new_revno,
 
651
                     self.rev_id)
 
652
            elif hook_name == "pre_commit":
 
653
                hook(hook_local, hook_master,
 
654
                     old_revno, old_revid, new_revno, self.rev_id,
 
655
                     tree_delta, future_tree)
 
656
 
 
657
    def _update_builder_with_changes(self):
 
658
        """Update the commit builder with the data about what has changed.
 
659
        """
 
660
        specific_files = self.specific_files
 
661
        mutter("Selecting files for commit with filter %r", specific_files)
 
662
 
 
663
        self._check_strict()
 
664
        iter_changes = self.work_tree.iter_changes(
 
665
            self.basis_tree, specific_files=specific_files)
 
666
        if self.exclude:
 
667
            iter_changes = filter_excluded(iter_changes, self.exclude)
 
668
        iter_changes = self._filter_iter_changes(iter_changes)
 
669
        for path, fs_hash in self.builder.record_iter_changes(
 
670
                self.work_tree, self.basis_revid, iter_changes):
 
671
            self.work_tree._observed_sha1(path, fs_hash)
 
672
 
 
673
    def _filter_iter_changes(self, iter_changes):
 
674
        """Process iter_changes.
 
675
 
 
676
        This method reports on the changes in iter_changes to the user, and
 
677
        converts 'missing' entries in the iter_changes iterator to 'deleted'
 
678
        entries. 'missing' entries have their
 
679
 
 
680
        :param iter_changes: An iter_changes to process.
 
681
        :return: A generator of changes.
 
682
        """
 
683
        reporter = self.reporter
 
684
        report_changes = reporter.is_verbose()
 
685
        deleted_paths = []
 
686
        for change in iter_changes:
 
687
            if report_changes:
 
688
                old_path = change.path[0]
 
689
                new_path = change.path[1]
 
690
                versioned = change.versioned[1]
 
691
            kind = change.kind[1]
 
692
            versioned = change.versioned[1]
 
693
            if kind is None and versioned:
 
694
                # 'missing' path
 
695
                if report_changes:
 
696
                    reporter.missing(new_path)
 
697
                if change.kind[0] == 'symlink' and not self.work_tree.supports_symlinks():
 
698
                    trace.warning('Ignoring "%s" as symlinks are not '
 
699
                                  'supported on this filesystem.' % (change.path[0],))
413
700
                    continue
414
 
                else:
415
 
                    # this is selected, ensure its parents are too.
416
 
                    parent_id = new_ie.parent_id
417
 
                    while parent_id != ROOT_ID:
418
 
                        if not self.new_inv.has_id(parent_id):
419
 
                            ie = self._select_entry(self.work_inv[parent_id])
420
 
                            mutter('%s selected for commit because of %s',
421
 
                                   self.new_inv.id2path(parent_id), path)
422
 
 
423
 
                        ie = self.new_inv[parent_id]
424
 
                        if ie.revision is not None:
425
 
                            ie.revision = None
426
 
                            mutter('%s selected for commit because of %s',
427
 
                                   self.new_inv.id2path(parent_id), path)
428
 
                        parent_id = ie.parent_id
429
 
            mutter('%s selected for commit', path)
430
 
            self._select_entry(new_ie)
431
 
 
432
 
    def _select_entry(self, new_ie):
433
 
        """Make new_ie be considered for committing."""
434
 
        ie = new_ie.copy()
435
 
        ie.revision = None
436
 
        self.new_inv.add(ie)
437
 
        return ie
438
 
 
439
 
    def _carry_entry(self, file_id):
440
 
        """Carry the file unchanged from the basis revision."""
441
 
        if self.basis_inv.has_id(file_id):
442
 
            self.new_inv.add(self.basis_inv[file_id].copy())
443
 
 
444
 
    def _report_deletes(self):
445
 
        for file_id in self.basis_inv:
446
 
            if file_id not in self.new_inv:
447
 
                self.reporter.deleted(self.basis_inv.id2path(file_id))
448
 
 
449
 
def _gen_revision_id(config, when):
450
 
    """Return new revision-id."""
451
 
    s = '%s-%s-' % (config.user_email(), compact_date(when))
452
 
    s += hexlify(rand_bytes(8))
453
 
    return s
 
701
                deleted_paths.append(change.path[1])
 
702
                # Reset the new path (None) and new versioned flag (False)
 
703
                change = change.discard_new()
 
704
                new_path = change.path[1]
 
705
                versioned = False
 
706
            elif kind == 'tree-reference':
 
707
                if self.recursive == 'down':
 
708
                    self._commit_nested_tree(change.path[1])
 
709
            if change.versioned[0] or change.versioned[1]:
 
710
                yield change
 
711
                if report_changes:
 
712
                    if new_path is None:
 
713
                        reporter.deleted(old_path)
 
714
                    elif old_path is None:
 
715
                        reporter.snapshot_change(gettext('added'), new_path)
 
716
                    elif old_path != new_path:
 
717
                        reporter.renamed(gettext('renamed'),
 
718
                                         old_path, new_path)
 
719
                    else:
 
720
                        if (new_path
 
721
                                or self.work_tree.branch.repository._format.rich_root_data):
 
722
                            # Don't report on changes to '' in non rich root
 
723
                            # repositories.
 
724
                            reporter.snapshot_change(
 
725
                                gettext('modified'), new_path)
 
726
            self._next_progress_entry()
 
727
        # Unversion files that were found to be deleted
 
728
        self.deleted_paths = deleted_paths
 
729
 
 
730
    def _check_strict(self):
 
731
        # XXX: when we use iter_changes this would likely be faster if
 
732
        # iter_changes would check for us (even in the presence of
 
733
        # selected_files).
 
734
        if self.strict:
 
735
            # raise an exception as soon as we find a single unknown.
 
736
            for unknown in self.work_tree.unknowns():
 
737
                raise StrictCommitFailed()
 
738
 
 
739
    def _commit_nested_tree(self, path):
 
740
        "Commit a nested tree."
 
741
        sub_tree = self.work_tree.get_nested_tree(path)
 
742
        # FIXME: be more comprehensive here:
 
743
        # this works when both trees are in --trees repository,
 
744
        # but when both are bound to a different repository,
 
745
        # it fails; a better way of approaching this is to
 
746
        # finally implement the explicit-caches approach design
 
747
        # a while back - RBC 20070306.
 
748
        if sub_tree.branch.repository.has_same_location(
 
749
                self.work_tree.branch.repository):
 
750
            sub_tree.branch.repository = \
 
751
                self.work_tree.branch.repository
 
752
        try:
 
753
            return sub_tree.commit(message=None, revprops=self.revprops,
 
754
                                   recursive=self.recursive,
 
755
                                   message_callback=self.message_callback,
 
756
                                   timestamp=self.timestamp,
 
757
                                   timezone=self.timezone,
 
758
                                   committer=self.committer,
 
759
                                   allow_pointless=self.allow_pointless,
 
760
                                   strict=self.strict, verbose=self.verbose,
 
761
                                   local=self.local, reporter=self.reporter)
 
762
        except PointlessCommit:
 
763
            return self.work_tree.get_reference_revision(path)
 
764
 
 
765
    def _set_progress_stage(self, name, counter=False):
 
766
        """Set the progress stage and emit an update to the progress bar."""
 
767
        self.pb_stage_name = name
 
768
        self.pb_stage_count += 1
 
769
        if counter:
 
770
            self.pb_entries_count = 0
 
771
        else:
 
772
            self.pb_entries_count = None
 
773
        self._emit_progress()
 
774
 
 
775
    def _next_progress_entry(self):
 
776
        """Emit an update to the progress bar and increment the entry count."""
 
777
        self.pb_entries_count += 1
 
778
        self._emit_progress()
 
779
 
 
780
    def _emit_progress(self):
 
781
        if self.pb_entries_count is not None:
 
782
            text = gettext("{0} [{1}] - Stage").format(self.pb_stage_name,
 
783
                                                       self.pb_entries_count)
 
784
        else:
 
785
            text = gettext("%s - Stage") % (self.pb_stage_name, )
 
786
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)