/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 exporter.py

Bundle bzr-fastimport.

Show diffs side-by-side

added added

removed removed

Lines of Context:
exporter.py
 
1
# -*- coding: utf-8 -*-
 
2
 
 
3
# Copyright (C) 2008 Canonical Ltd
 
4
#
 
5
# This program is free software; you can redistribute it and/or modify
 
6
# it under the terms of the GNU General Public License as published by
 
7
# the Free Software Foundation; either version 2 of the License, or
 
8
# (at your option) any later version.
 
9
#
 
10
# This program is distributed in the hope that it will be useful,
 
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
# GNU General Public License for more details.
 
14
#
 
15
# You should have received a copy of the GNU General Public License
 
16
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
17
#
 
18
# Based on bzr-fast-export
 
19
# Copyright (c) 2008 Adeodato Simó
 
20
#
 
21
# Permission is hereby granted, free of charge, to any person obtaining
 
22
# a copy of this software and associated documentation files (the
 
23
# "Software"), to deal in the Software without restriction, including
 
24
# without limitation the rights to use, copy, modify, merge, publish,
 
25
# distribute, sublicense, and/or sell copies of the Software, and to
 
26
# permit persons to whom the Software is furnished to do so, subject to
 
27
# the following conditions:
 
28
#
 
29
# The above copyright notice and this permission notice shall be included
 
30
# in all copies or substantial portions of the Software.
 
31
#
 
32
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
33
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
34
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 
35
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 
36
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 
37
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 
38
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
39
#
 
40
# vim: fileencoding=utf-8
 
41
 
 
42
"""Core engine for the fast-export command."""
 
43
 
 
44
# TODO: if a new_git_branch below gets merged repeatedly, the tip of the branch
 
45
# is not updated (because the parent of commit is already merged, so we don't
 
46
# set new_git_branch to the previously used name)
 
47
 
 
48
from email.Utils import parseaddr
 
49
import sys, time, re
 
50
 
 
51
import bzrlib.branch
 
52
import bzrlib.revision
 
53
from bzrlib import (
 
54
    builtins,
 
55
    errors as bazErrors,
 
56
    osutils,
 
57
    progress,
 
58
    trace,
 
59
    )
 
60
 
 
61
from bzrlib.plugins.fastimport import (
 
62
    helpers,
 
63
    marks_file,
 
64
    )
 
65
 
 
66
from fastimport import commands
 
67
from bzrlib.plugins.fastimport.helpers import (
 
68
    binary_stream,
 
69
    single_plural,
 
70
    )
 
71
 
 
72
 
 
73
def _get_output_stream(destination):
 
74
    if destination is None or destination == '-':
 
75
        return binary_stream(sys.stdout)
 
76
    elif destination.endswith('gz'):
 
77
        import gzip
 
78
        return gzip.open(destination, 'wb')
 
79
    else:
 
80
        return open(destination, 'wb')
 
81
 
 
82
# from dulwich.repo:
 
83
def check_ref_format(refname):
 
84
    """Check if a refname is correctly formatted.
 
85
 
 
86
    Implements all the same rules as git-check-ref-format[1].
 
87
 
 
88
    [1] http://www.kernel.org/pub/software/scm/git/docs/git-check-ref-format.html
 
89
 
 
90
    :param refname: The refname to check
 
91
    :return: True if refname is valid, False otherwise
 
92
    """
 
93
    # These could be combined into one big expression, but are listed separately
 
94
    # to parallel [1].
 
95
    if '/.' in refname or refname.startswith('.'):
 
96
        return False
 
97
    if '/' not in refname:
 
98
        return False
 
99
    if '..' in refname:
 
100
        return False
 
101
    for c in refname:
 
102
        if ord(c) < 040 or c in '\177 ~^:?*[':
 
103
            return False
 
104
    if refname[-1] in '/.':
 
105
        return False
 
106
    if refname.endswith('.lock'):
 
107
        return False
 
108
    if '@{' in refname:
 
109
        return False
 
110
    if '\\' in refname:
 
111
        return False
 
112
    return True
 
113
 
 
114
 
 
115
def sanitize_ref_name_for_git(refname):
 
116
    """Rewrite refname so that it will be accepted by git-fast-import.
 
117
    For the detailed rules see check_ref_format.
 
118
 
 
119
    By rewriting the refname we are breaking uniqueness guarantees provided by bzr
 
120
    so we have to manually
 
121
    verify that resulting ref names are unique.
 
122
 
 
123
    :param refname: refname to rewrite
 
124
    :return: new refname
 
125
    """
 
126
    new_refname = re.sub(
 
127
        # '/.' in refname or startswith '.'
 
128
        r"/\.|^\."
 
129
        # '..' in refname
 
130
        r"|\.\."
 
131
        # ord(c) < 040
 
132
        r"|[" + "".join([chr(x) for x in range(040)]) + r"]"
 
133
        # c in '\177 ~^:?*['
 
134
        r"|[\177 ~^:?*[]"
 
135
        # last char in "/."
 
136
        r"|[/.]$"
 
137
        # endswith '.lock'
 
138
        r"|.lock$"
 
139
        # "@{" in refname
 
140
        r"|@{"
 
141
        # "\\" in refname
 
142
        r"|\\",
 
143
        "_", refname)
 
144
    return new_refname
 
145
 
 
146
 
 
147
class BzrFastExporter(object):
 
148
 
 
149
    def __init__(self, source, outf, ref=None, checkpoint=-1,
 
150
        import_marks_file=None, export_marks_file=None, revision=None,
 
151
        verbose=False, plain_format=False, rewrite_tags=False,
 
152
        no_tags=False, baseline=False):
 
153
        """Export branch data in fast import format.
 
154
 
 
155
        :param plain_format: if True, 'classic' fast-import format is
 
156
            used without any extended features; if False, the generated
 
157
            data is richer and includes information like multiple
 
158
            authors, revision properties, etc.
 
159
        :param rewrite_tags: if True and if plain_format is set, tag names
 
160
            will be rewritten to be git-compatible.
 
161
            Otherwise tags which aren't valid for git will be skipped if
 
162
            plain_format is set.
 
163
        :param no_tags: if True tags won't be exported at all
 
164
        """
 
165
        self.branch = source
 
166
        self.outf = outf
 
167
        self.ref = ref
 
168
        self.checkpoint = checkpoint
 
169
        self.import_marks_file = import_marks_file
 
170
        self.export_marks_file = export_marks_file
 
171
        self.revision = revision
 
172
        self.excluded_revisions = set()
 
173
        self.plain_format = plain_format
 
174
        self.rewrite_tags = rewrite_tags
 
175
        self.no_tags = no_tags
 
176
        self.baseline = baseline
 
177
        self._multi_author_api_available = hasattr(bzrlib.revision.Revision,
 
178
            'get_apparent_authors')
 
179
        self.properties_to_exclude = ['authors', 'author']
 
180
 
 
181
        # Progress reporting stuff
 
182
        self.verbose = verbose
 
183
        if verbose:
 
184
            self.progress_every = 100
 
185
        else:
 
186
            self.progress_every = 1000
 
187
        self._start_time = time.time()
 
188
        self._commit_total = 0
 
189
 
 
190
        # Load the marks and initialise things accordingly
 
191
        self.revid_to_mark = {}
 
192
        self.branch_names = {}
 
193
        if self.import_marks_file:
 
194
            marks_info = marks_file.import_marks(self.import_marks_file)
 
195
            if marks_info is not None:
 
196
                self.revid_to_mark = dict((r, m) for m, r in
 
197
                    marks_info.items())
 
198
                # These are no longer included in the marks file
 
199
                #self.branch_names = marks_info[1]
 
200
 
 
201
    def interesting_history(self):
 
202
        if self.revision:
 
203
            rev1, rev2 = builtins._get_revision_range(self.revision,
 
204
                self.branch, "fast-export")
 
205
            start_rev_id = rev1.rev_id
 
206
            end_rev_id = rev2.rev_id
 
207
        else:
 
208
            start_rev_id = None
 
209
            end_rev_id = None
 
210
        self.note("Calculating the revisions to include ...")
 
211
        view_revisions = [rev_id for rev_id, _, _, _ in
 
212
            self.branch.iter_merge_sorted_revisions(end_rev_id, start_rev_id)]
 
213
        view_revisions.reverse()
 
214
        # If a starting point was given, we need to later check that we don't
 
215
        # start emitting revisions from before that point. Collect the
 
216
        # revisions to exclude now ...
 
217
        if start_rev_id is not None:
 
218
            self.note("Calculating the revisions to exclude ...")
 
219
            self.excluded_revisions = set([rev_id for rev_id, _, _, _ in
 
220
                self.branch.iter_merge_sorted_revisions(start_rev_id)])
 
221
            if self.baseline:
 
222
                # needed so the first relative commit knows its parent
 
223
                self.excluded_revisions.remove(start_rev_id)
 
224
                view_revisions.insert(0, start_rev_id)
 
225
        return list(view_revisions)
 
226
 
 
227
    def run(self):
 
228
        # Export the data
 
229
        self.branch.repository.lock_read()
 
230
        try:
 
231
            interesting = self.interesting_history()
 
232
            self._commit_total = len(interesting)
 
233
            self.note("Starting export of %d revisions ..." %
 
234
                self._commit_total)
 
235
            if not self.plain_format:
 
236
                self.emit_features()
 
237
            if self.baseline:
 
238
                self.emit_baseline(interesting.pop(0), self.ref)
 
239
            for revid in interesting:
 
240
                self.emit_commit(revid, self.ref)
 
241
            if self.branch.supports_tags() and not self.no_tags:
 
242
                self.emit_tags()
 
243
        finally:
 
244
            self.branch.repository.unlock()
 
245
 
 
246
        # Save the marks if requested
 
247
        self._save_marks()
 
248
        self.dump_stats()
 
249
 
 
250
    def note(self, msg, *args):
 
251
        """Output a note but timestamp it."""
 
252
        msg = "%s %s" % (self._time_of_day(), msg)
 
253
        trace.note(msg, *args)
 
254
 
 
255
    def warning(self, msg, *args):
 
256
        """Output a warning but timestamp it."""
 
257
        msg = "%s WARNING: %s" % (self._time_of_day(), msg)
 
258
        trace.warning(msg, *args)
 
259
 
 
260
    def _time_of_day(self):
 
261
        """Time of day as a string."""
 
262
        # Note: this is a separate method so tests can patch in a fixed value
 
263
        return time.strftime("%H:%M:%S")
 
264
 
 
265
    def report_progress(self, commit_count, details=''):
 
266
        if commit_count and commit_count % self.progress_every == 0:
 
267
            if self._commit_total:
 
268
                counts = "%d/%d" % (commit_count, self._commit_total)
 
269
            else:
 
270
                counts = "%d" % (commit_count,)
 
271
            minutes = (time.time() - self._start_time) / 60
 
272
            rate = commit_count * 1.0 / minutes
 
273
            if rate > 10:
 
274
                rate_str = "at %.0f/minute " % rate
 
275
            else:
 
276
                rate_str = "at %.1f/minute " % rate
 
277
            self.note("%s commits exported %s%s" % (counts, rate_str, details))
 
278
 
 
279
    def dump_stats(self):
 
280
        time_required = progress.str_tdelta(time.time() - self._start_time)
 
281
        rc = len(self.revid_to_mark)
 
282
        self.note("Exported %d %s in %s",
 
283
            rc, single_plural(rc, "revision", "revisions"),
 
284
            time_required)
 
285
 
 
286
    def print_cmd(self, cmd):
 
287
        self.outf.write("%r\n" % cmd)
 
288
 
 
289
    def _save_marks(self):
 
290
        if self.export_marks_file:
 
291
            revision_ids = dict((m, r) for r, m in self.revid_to_mark.items())
 
292
            marks_file.export_marks(self.export_marks_file, revision_ids)
 
293
 
 
294
    def is_empty_dir(self, tree, path):
 
295
        path_id = tree.path2id(path)
 
296
        if path_id is None:
 
297
            self.warning("Skipping empty_dir detection - no file_id for %s" %
 
298
                (path,))
 
299
            return False
 
300
 
 
301
        # Continue if path is not a directory
 
302
        if tree.kind(path_id) != 'directory':
 
303
            return False
 
304
 
 
305
        # Use treewalk to find the contents of our directory
 
306
        contents = list(tree.walkdirs(prefix=path))[0]
 
307
        if len(contents[1]) == 0:
 
308
            return True
 
309
        else:
 
310
            return False
 
311
 
 
312
    def emit_features(self):
 
313
        for feature in sorted(commands.FEATURE_NAMES):
 
314
            self.print_cmd(commands.FeatureCommand(feature))
 
315
 
 
316
    def emit_baseline(self, revid, ref):
 
317
        # Emit a full source tree of the first commit's parent
 
318
        revobj = self.branch.repository.get_revision(revid)
 
319
        mark = 1
 
320
        self.revid_to_mark[revid] = mark
 
321
        file_cmds = self._get_filecommands(bzrlib.revision.NULL_REVISION, revid)
 
322
        self.print_cmd(self._get_commit_command(ref, mark, revobj, file_cmds))
 
323
 
 
324
    def emit_commit(self, revid, ref):
 
325
        if revid in self.revid_to_mark or revid in self.excluded_revisions:
 
326
            return
 
327
 
 
328
        # Get the Revision object
 
329
        try:
 
330
            revobj = self.branch.repository.get_revision(revid)
 
331
        except bazErrors.NoSuchRevision:
 
332
            # This is a ghost revision. Mark it as not found and next!
 
333
            self.revid_to_mark[revid] = -1
 
334
            return
 
335
 
 
336
        # Get the primary parent
 
337
        # TODO: Consider the excluded revisions when deciding the parents.
 
338
        # Currently, a commit with parents that are excluded ought to be
 
339
        # triggering the ref calculation below (and it is not).
 
340
        # IGC 20090824
 
341
        ncommits = len(self.revid_to_mark)
 
342
        nparents = len(revobj.parent_ids)
 
343
        if nparents == 0:
 
344
            if ncommits:
 
345
                # This is a parentless commit but it's not the first one
 
346
                # output. We need to create a new temporary branch for it
 
347
                # otherwise git-fast-import will assume the previous commit
 
348
                # was this one's parent
 
349
                ref = self._next_tmp_ref()
 
350
            parent = bzrlib.revision.NULL_REVISION
 
351
        else:
 
352
            parent = revobj.parent_ids[0]
 
353
 
 
354
        # Print the commit
 
355
        mark = ncommits + 1
 
356
        self.revid_to_mark[revid] = mark
 
357
        file_cmds = self._get_filecommands(parent, revid)
 
358
        self.print_cmd(self._get_commit_command(ref, mark, revobj, file_cmds))
 
359
 
 
360
        # Report progress and checkpoint if it's time for that
 
361
        self.report_progress(ncommits)
 
362
        if (self.checkpoint > 0 and ncommits
 
363
            and ncommits % self.checkpoint == 0):
 
364
            self.note("Exported %i commits - adding checkpoint to output"
 
365
                % ncommits)
 
366
            self._save_marks()
 
367
            self.print_cmd(commands.CheckpointCommand())
 
368
 
 
369
    def _get_name_email(self, user):
 
370
        if user.find('<') == -1:
 
371
            # If the email isn't inside <>, we need to use it as the name
 
372
            # in order for things to round-trip correctly.
 
373
            # (note: parseaddr('a@b.com') => name:'', email: 'a@b.com')
 
374
            name = user
 
375
            email = ''
 
376
        else:
 
377
            name, email = parseaddr(user)
 
378
        return name.encode("utf-8"), email.encode("utf-8")
 
379
 
 
380
    def _get_commit_command(self, git_ref, mark, revobj, file_cmds):
 
381
        # Get the committer and author info
 
382
        committer = revobj.committer
 
383
        name, email = self._get_name_email(committer)
 
384
        committer_info = (name, email, revobj.timestamp, revobj.timezone)
 
385
        if self._multi_author_api_available:
 
386
            more_authors = revobj.get_apparent_authors()
 
387
            author = more_authors.pop(0)
 
388
        else:
 
389
            more_authors = []
 
390
            author = revobj.get_apparent_author()
 
391
        if not self.plain_format and more_authors:
 
392
            name, email = self._get_name_email(author)
 
393
            author_info = (name, email, revobj.timestamp, revobj.timezone)
 
394
            more_author_info = []
 
395
            for a in more_authors:
 
396
                name, email = self._get_name_email(a)
 
397
                more_author_info.append(
 
398
                    (name, email, revobj.timestamp, revobj.timezone))
 
399
        elif author != committer:
 
400
            name, email = self._get_name_email(author)
 
401
            author_info = (name, email, revobj.timestamp, revobj.timezone)
 
402
            more_author_info = None
 
403
        else:
 
404
            author_info = None
 
405
            more_author_info = None
 
406
 
 
407
        # Get the parents in terms of marks
 
408
        non_ghost_parents = []
 
409
        for p in revobj.parent_ids:
 
410
            if p in self.excluded_revisions:
 
411
                continue
 
412
            try:
 
413
                parent_mark = self.revid_to_mark[p]
 
414
                non_ghost_parents.append(":%s" % parent_mark)
 
415
            except KeyError:
 
416
                # ghost - ignore
 
417
                continue
 
418
        if non_ghost_parents:
 
419
            from_ = non_ghost_parents[0]
 
420
            merges = non_ghost_parents[1:]
 
421
        else:
 
422
            from_ = None
 
423
            merges = None
 
424
 
 
425
        # Filter the revision properties. Some metadata (like the
 
426
        # author information) is already exposed in other ways so
 
427
        # don't repeat it here.
 
428
        if self.plain_format:
 
429
            properties = None
 
430
        else:
 
431
            properties = revobj.properties
 
432
            for prop in self.properties_to_exclude:
 
433
                try:
 
434
                    del properties[prop]
 
435
                except KeyError:
 
436
                    pass
 
437
 
 
438
        # Build and return the result
 
439
        return commands.CommitCommand(git_ref, mark, author_info,
 
440
            committer_info, revobj.message.encode("utf-8"), from_, merges, iter(file_cmds),
 
441
            more_authors=more_author_info, properties=properties)
 
442
 
 
443
    def _get_revision_trees(self, parent, revision_id):
 
444
        try:
 
445
            tree_old = self.branch.repository.revision_tree(parent)
 
446
        except bazErrors.UnexpectedInventoryFormat:
 
447
            self.warning("Parent is malformed - diffing against previous parent")
 
448
            # We can't find the old parent. Let's diff against his parent
 
449
            pp = self.branch.repository.get_revision(parent)
 
450
            tree_old = self.branch.repository.revision_tree(pp.parent_ids[0])
 
451
        tree_new = None
 
452
        try:
 
453
            tree_new = self.branch.repository.revision_tree(revision_id)
 
454
        except bazErrors.UnexpectedInventoryFormat:
 
455
            # We can't really do anything anymore
 
456
            self.warning("Revision %s is malformed - skipping" % revision_id)
 
457
        return tree_old, tree_new
 
458
 
 
459
    def _get_filecommands(self, parent, revision_id):
 
460
        """Get the list of FileCommands for the changes between two revisions."""
 
461
        tree_old, tree_new = self._get_revision_trees(parent, revision_id)
 
462
        if not(tree_old and tree_new):
 
463
            # Something is wrong with this revision - ignore the filecommands
 
464
            return []
 
465
 
 
466
        changes = tree_new.changes_from(tree_old)
 
467
 
 
468
        # Make "modified" have 3-tuples, as added does
 
469
        my_modified = [ x[0:3] for x in changes.modified ]
 
470
 
 
471
        # The potential interaction between renames and deletes is messy.
 
472
        # Handle it here ...
 
473
        file_cmds, rd_modifies, renamed = self._process_renames_and_deletes(
 
474
            changes.renamed, changes.removed, revision_id, tree_old)
 
475
 
 
476
        # Map kind changes to a delete followed by an add
 
477
        for path, id_, kind1, kind2 in changes.kind_changed:
 
478
            path = self._adjust_path_for_renames(path, renamed, revision_id)
 
479
            # IGC: I don't understand why a delete is needed here.
 
480
            # In fact, it seems harmful? If you uncomment this line,
 
481
            # please file a bug explaining why you needed to.
 
482
            #file_cmds.append(commands.FileDeleteCommand(path))
 
483
            my_modified.append((path, id_, kind2))
 
484
 
 
485
        # Record modifications
 
486
        for path, id_, kind in changes.added + my_modified + rd_modifies:
 
487
            if kind == 'file':
 
488
                text = tree_new.get_file_text(id_)
 
489
                file_cmds.append(commands.FileModifyCommand(path.encode("utf-8"),
 
490
                    helpers.kind_to_mode('file', tree_new.is_executable(id_)),
 
491
                    None, text))
 
492
            elif kind == 'symlink':
 
493
                file_cmds.append(commands.FileModifyCommand(path.encode("utf-8"),
 
494
                    helpers.kind_to_mode('symlink', False),
 
495
                    None, tree_new.get_symlink_target(id_)))
 
496
            elif kind == 'directory':
 
497
                if not self.plain_format:
 
498
                    file_cmds.append(commands.FileModifyCommand(path.encode("utf-8"),
 
499
                        helpers.kind_to_mode('directory', False),
 
500
                        None, None))
 
501
            else:
 
502
                self.warning("cannot export '%s' of kind %s yet - ignoring" %
 
503
                    (path, kind))
 
504
        return file_cmds
 
505
 
 
506
    def _process_renames_and_deletes(self, renames, deletes,
 
507
        revision_id, tree_old):
 
508
        file_cmds = []
 
509
        modifies = []
 
510
        renamed = []
 
511
 
 
512
        # See https://bugs.edge.launchpad.net/bzr-fastimport/+bug/268933.
 
513
        # In a nutshell, there are several nasty cases:
 
514
        #
 
515
        # 1) bzr rm a; bzr mv b a; bzr commit
 
516
        # 2) bzr mv x/y z; bzr rm x; commmit
 
517
        #
 
518
        # The first must come out with the delete first like this:
 
519
        #
 
520
        # D a
 
521
        # R b a
 
522
        #
 
523
        # The second case must come out with the rename first like this:
 
524
        #
 
525
        # R x/y z
 
526
        # D x
 
527
        #
 
528
        # So outputting all deletes first or all renames first won't work.
 
529
        # Instead, we need to make multiple passes over the various lists to
 
530
        # get the ordering right.
 
531
 
 
532
        must_be_renamed = {}
 
533
        old_to_new = {}
 
534
        deleted_paths = set([p for p, _, _ in deletes])
 
535
        for (oldpath, newpath, id_, kind,
 
536
                text_modified, meta_modified) in renames:
 
537
            emit = kind != 'directory' or not self.plain_format
 
538
            if newpath in deleted_paths:
 
539
                if emit:
 
540
                    file_cmds.append(commands.FileDeleteCommand(newpath.encode("utf-8")))
 
541
                deleted_paths.remove(newpath)
 
542
            if (self.is_empty_dir(tree_old, oldpath)):
 
543
                self.note("Skipping empty dir %s in rev %s" % (oldpath,
 
544
                    revision_id))
 
545
                continue
 
546
            #oldpath = self._adjust_path_for_renames(oldpath, renamed,
 
547
            #    revision_id)
 
548
            renamed.append([oldpath, newpath])
 
549
            old_to_new[oldpath] = newpath
 
550
            if emit:
 
551
                file_cmds.append(
 
552
                    commands.FileRenameCommand(oldpath.encode("utf-8"), newpath.encode("utf-8")))
 
553
            if text_modified or meta_modified:
 
554
                modifies.append((newpath, id_, kind))
 
555
 
 
556
            # Renaming a directory implies all children must be renamed.
 
557
            # Note: changes_from() doesn't handle this
 
558
            if kind == 'directory' and tree_old.kind(id_) == 'directory':
 
559
                for p, e in tree_old.inventory.iter_entries_by_dir(from_dir=id_):
 
560
                    if e.kind == 'directory' and self.plain_format:
 
561
                        continue
 
562
                    old_child_path = osutils.pathjoin(oldpath, p)
 
563
                    new_child_path = osutils.pathjoin(newpath, p)
 
564
                    must_be_renamed[old_child_path] = new_child_path
 
565
 
 
566
        # Add children not already renamed
 
567
        if must_be_renamed:
 
568
            renamed_already = set(old_to_new.keys())
 
569
            still_to_be_renamed = set(must_be_renamed.keys()) - renamed_already
 
570
            for old_child_path in sorted(still_to_be_renamed):
 
571
                new_child_path = must_be_renamed[old_child_path]
 
572
                if self.verbose:
 
573
                    self.note("implicitly renaming %s => %s" % (old_child_path,
 
574
                        new_child_path))
 
575
                file_cmds.append(commands.FileRenameCommand(old_child_path.encode("utf-8"),
 
576
                    new_child_path.encode("utf-8")))
 
577
 
 
578
        # Record remaining deletes
 
579
        for path, id_, kind in deletes:
 
580
            if path not in deleted_paths:
 
581
                continue
 
582
            if kind == 'directory' and self.plain_format:
 
583
                continue
 
584
            #path = self._adjust_path_for_renames(path, renamed, revision_id)
 
585
            file_cmds.append(commands.FileDeleteCommand(path.encode("utf-8")))
 
586
        return file_cmds, modifies, renamed
 
587
 
 
588
    def _adjust_path_for_renames(self, path, renamed, revision_id):
 
589
        # If a previous rename is found, we should adjust the path
 
590
        for old, new in renamed:
 
591
            if path == old:
 
592
                self.note("Changing path %s given rename to %s in revision %s"
 
593
                    % (path, new, revision_id))
 
594
                path = new
 
595
            elif path.startswith(old + '/'):
 
596
                self.note(
 
597
                    "Adjusting path %s given rename of %s to %s in revision %s"
 
598
                    % (path, old, new, revision_id))
 
599
                path = path.replace(old + "/", new + "/")
 
600
        return path
 
601
 
 
602
    def emit_tags(self):
 
603
        for tag, revid in self.branch.tags.get_tag_dict().items():
 
604
            try:
 
605
                mark = self.revid_to_mark[revid]
 
606
            except KeyError:
 
607
                self.warning('not creating tag %r pointing to non-existent '
 
608
                    'revision %s' % (tag, revid))
 
609
            else:
 
610
                git_ref = 'refs/tags/%s' % tag.encode("utf-8")
 
611
                if self.plain_format and not check_ref_format(git_ref):
 
612
                    if self.rewrite_tags:
 
613
                        new_ref = sanitize_ref_name_for_git(git_ref)
 
614
                        self.warning('tag %r is exported as %r to be valid in git.',
 
615
                                     git_ref, new_ref)
 
616
                        git_ref = new_ref
 
617
                    else:
 
618
                        self.warning('not creating tag %r as its name would not be '
 
619
                                     'valid in git.', git_ref)
 
620
                        continue
 
621
                self.print_cmd(commands.ResetCommand(git_ref, ":" + str(mark)))
 
622
 
 
623
    def _next_tmp_ref(self):
 
624
        """Return a unique branch name. The name will start with "tmp"."""
 
625
        prefix = 'tmp'
 
626
        if prefix not in self.branch_names:
 
627
            self.branch_names[prefix] = 0
 
628
        else:
 
629
            self.branch_names[prefix] += 1
 
630
            prefix = '%s.%d' % (prefix, self.branch_names[prefix])
 
631
        return 'refs/heads/%s' % prefix