~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Martin Pool
  • Date: 2005-04-28 07:24:55 UTC
  • Revision ID: mbp@sourcefrog.net-20050428072453-7b99afa993a1e549
todo

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2014 Canonical Ltd.
2
 
#
 
1
#! /usr/bin/env python
 
2
# -*- coding: UTF-8 -*-
 
3
 
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
7
 
#
 
8
 
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
12
# GNU General Public License for more details.
12
 
#
 
13
 
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
from __future__ import absolute_import
18
 
 
19
 
import difflib
20
 
import os
21
 
import re
22
 
import string
23
 
import sys
24
 
 
25
 
from bzrlib.lazy_import import lazy_import
26
 
lazy_import(globals(), """
27
 
import errno
28
 
import subprocess
29
 
import tempfile
30
 
 
31
 
from bzrlib import (
32
 
    cleanup,
33
 
    cmdline,
34
 
    controldir,
35
 
    errors,
36
 
    osutils,
37
 
    patiencediff,
38
 
    textfile,
39
 
    timestamp,
40
 
    views,
41
 
    )
42
 
 
43
 
from bzrlib.workingtree import WorkingTree
44
 
from bzrlib.i18n import gettext
45
 
""")
46
 
 
47
 
from bzrlib.registry import (
48
 
    Registry,
49
 
    )
50
 
from bzrlib.trace import mutter, note, warning
51
 
 
52
 
DEFAULT_CONTEXT_AMOUNT = 3
53
 
 
54
 
class AtTemplate(string.Template):
55
 
    """Templating class that uses @ instead of $."""
56
 
 
57
 
    delimiter = '@'
58
 
 
59
 
 
60
 
# TODO: Rather than building a changeset object, we should probably
61
 
# invoke callbacks on an object.  That object can either accumulate a
62
 
# list, write them out directly, etc etc.
63
 
 
64
 
 
65
 
class _PrematchedMatcher(difflib.SequenceMatcher):
66
 
    """Allow SequenceMatcher operations to use predetermined blocks"""
67
 
 
68
 
    def __init__(self, matching_blocks):
69
 
        difflib.SequenceMatcher(self, None, None)
70
 
        self.matching_blocks = matching_blocks
71
 
        self.opcodes = None
72
 
 
73
 
 
74
 
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
75
 
                  allow_binary=False, sequence_matcher=None,
76
 
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
77
 
    # FIXME: difflib is wrong if there is no trailing newline.
78
 
    # The syntax used by patch seems to be "\ No newline at
79
 
    # end of file" following the last diff line from that
80
 
    # file.  This is not trivial to insert into the
81
 
    # unified_diff output and it might be better to just fix
82
 
    # or replace that function.
83
 
 
84
 
    # In the meantime we at least make sure the patch isn't
85
 
    # mangled.
86
 
 
87
 
 
88
 
    # Special workaround for Python2.3, where difflib fails if
89
 
    # both sequences are empty.
90
 
    if not oldlines and not newlines:
91
 
        return
92
 
 
93
 
    if allow_binary is False:
94
 
        textfile.check_text_lines(oldlines)
95
 
        textfile.check_text_lines(newlines)
96
 
 
97
 
    if sequence_matcher is None:
98
 
        sequence_matcher = patiencediff.PatienceSequenceMatcher
99
 
    ud = patiencediff.unified_diff(oldlines, newlines,
100
 
                      fromfile=old_filename.encode(path_encoding, 'replace'),
101
 
                      tofile=new_filename.encode(path_encoding, 'replace'),
102
 
                      n=context_lines, sequencematcher=sequence_matcher)
103
 
 
104
 
    ud = list(ud)
105
 
    if len(ud) == 0: # Identical contents, nothing to do
106
 
        return
107
 
    # work-around for difflib being too smart for its own good
108
 
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
109
 
    if not oldlines:
110
 
        ud[2] = ud[2].replace('-1,0', '-0,0')
111
 
    elif not newlines:
112
 
        ud[2] = ud[2].replace('+1,0', '+0,0')
113
 
 
114
 
    for line in ud:
115
 
        to_file.write(line)
116
 
        if not line.endswith('\n'):
117
 
            to_file.write("\n\\ No newline at end of file\n")
118
 
    to_file.write('\n')
119
 
 
120
 
 
121
 
def _spawn_external_diff(diffcmd, capture_errors=True):
122
 
    """Spawn the external diff process, and return the child handle.
123
 
 
124
 
    :param diffcmd: The command list to spawn
125
 
    :param capture_errors: Capture stderr as well as setting LANG=C
126
 
        and LC_ALL=C. This lets us read and understand the output of diff,
127
 
        and respond to any errors.
128
 
    :return: A Popen object.
129
 
    """
130
 
    if capture_errors:
131
 
        # construct minimal environment
132
 
        env = {}
133
 
        path = os.environ.get('PATH')
134
 
        if path is not None:
135
 
            env['PATH'] = path
136
 
        env['LANGUAGE'] = 'C'   # on win32 only LANGUAGE has effect
137
 
        env['LANG'] = 'C'
138
 
        env['LC_ALL'] = 'C'
139
 
        stderr = subprocess.PIPE
140
 
    else:
141
 
        env = None
142
 
        stderr = None
143
 
 
144
 
    try:
145
 
        pipe = subprocess.Popen(diffcmd,
146
 
                                stdin=subprocess.PIPE,
147
 
                                stdout=subprocess.PIPE,
148
 
                                stderr=stderr,
149
 
                                env=env)
150
 
    except OSError, e:
151
 
        if e.errno == errno.ENOENT:
152
 
            raise errors.NoDiff(str(e))
153
 
        raise
154
 
 
155
 
    return pipe
156
 
 
157
 
# diff style options as of GNU diff v3.2
158
 
style_option_list = ['-c', '-C', '--context',
159
 
                     '-e', '--ed',
160
 
                     '-f', '--forward-ed',
161
 
                     '-q', '--brief',
162
 
                     '--normal',
163
 
                     '-n', '--rcs',
164
 
                     '-u', '-U', '--unified',
165
 
                     '-y', '--side-by-side',
166
 
                     '-D', '--ifdef']
167
 
 
168
 
def default_style_unified(diff_opts):
169
 
    """Default to unified diff style if alternative not specified in diff_opts.
170
 
 
171
 
        diff only allows one style to be specified; they don't override.
172
 
        Note that some of these take optargs, and the optargs can be
173
 
        directly appended to the options.
174
 
        This is only an approximate parser; it doesn't properly understand
175
 
        the grammar.
176
 
 
177
 
    :param diff_opts: List of options for external (GNU) diff.
178
 
    :return: List of options with default style=='unified'.
179
 
    """
180
 
    for s in style_option_list:
181
 
        for j in diff_opts:
182
 
            if j.startswith(s):
183
 
                break
184
 
        else:
185
 
            continue
186
 
        break
187
 
    else:
188
 
        diff_opts.append('-u')
189
 
    return diff_opts
190
 
 
191
 
 
192
 
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
193
 
                  diff_opts):
194
 
    """Display a diff by calling out to the external diff program."""
195
 
    # make sure our own output is properly ordered before the diff
196
 
    to_file.flush()
197
 
 
198
 
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
199
 
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
200
 
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
201
 
    newtmpf = os.fdopen(newtmp_fd, 'wb')
202
 
 
203
 
    try:
204
 
        # TODO: perhaps a special case for comparing to or from the empty
205
 
        # sequence; can just use /dev/null on Unix
206
 
 
207
 
        # TODO: if either of the files being compared already exists as a
208
 
        # regular named file (e.g. in the working directory) then we can
209
 
        # compare directly to that, rather than copying it.
210
 
 
211
 
        oldtmpf.writelines(oldlines)
212
 
        newtmpf.writelines(newlines)
213
 
 
214
 
        oldtmpf.close()
215
 
        newtmpf.close()
216
 
 
217
 
        if not diff_opts:
218
 
            diff_opts = []
219
 
        if sys.platform == 'win32':
220
 
            # Popen doesn't do the proper encoding for external commands
221
 
            # Since we are dealing with an ANSI api, use mbcs encoding
222
 
            old_filename = old_filename.encode('mbcs')
223
 
            new_filename = new_filename.encode('mbcs')
224
 
        diffcmd = ['diff',
225
 
                   '--label', old_filename,
226
 
                   old_abspath,
227
 
                   '--label', new_filename,
228
 
                   new_abspath,
229
 
                   '--binary',
230
 
                  ]
231
 
 
232
 
        diff_opts = default_style_unified(diff_opts)
233
 
 
234
 
        if diff_opts:
235
 
            diffcmd.extend(diff_opts)
236
 
 
237
 
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
238
 
        out,err = pipe.communicate()
239
 
        rc = pipe.returncode
240
 
 
241
 
        # internal_diff() adds a trailing newline, add one here for consistency
242
 
        out += '\n'
243
 
        if rc == 2:
244
 
            # 'diff' gives retcode == 2 for all sorts of errors
245
 
            # one of those is 'Binary files differ'.
246
 
            # Bad options could also be the problem.
247
 
            # 'Binary files' is not a real error, so we suppress that error.
248
 
            lang_c_out = out
249
 
 
250
 
            # Since we got here, we want to make sure to give an i18n error
251
 
            pipe = _spawn_external_diff(diffcmd, capture_errors=False)
252
 
            out, err = pipe.communicate()
253
 
 
254
 
            # Write out the new i18n diff response
255
 
            to_file.write(out+'\n')
256
 
            if pipe.returncode != 2:
257
 
                raise errors.BzrError(
258
 
                               'external diff failed with exit code 2'
259
 
                               ' when run with LANG=C and LC_ALL=C,'
260
 
                               ' but not when run natively: %r' % (diffcmd,))
261
 
 
262
 
            first_line = lang_c_out.split('\n', 1)[0]
263
 
            # Starting with diffutils 2.8.4 the word "binary" was dropped.
264
 
            m = re.match('^(binary )?files.*differ$', first_line, re.I)
265
 
            if m is None:
266
 
                raise errors.BzrError('external diff failed with exit code 2;'
267
 
                                      ' command: %r' % (diffcmd,))
268
 
            else:
269
 
                # Binary files differ, just return
270
 
                return
271
 
 
272
 
        # If we got to here, we haven't written out the output of diff
273
 
        # do so now
274
 
        to_file.write(out)
275
 
        if rc not in (0, 1):
276
 
            # returns 1 if files differ; that's OK
277
 
            if rc < 0:
278
 
                msg = 'signal %d' % (-rc)
279
 
            else:
280
 
                msg = 'exit code %d' % rc
281
 
 
282
 
            raise errors.BzrError('external diff failed with %s; command: %r'
283
 
                                  % (msg, diffcmd))
284
 
 
285
 
 
286
 
    finally:
287
 
        oldtmpf.close()                 # and delete
288
 
        newtmpf.close()
289
 
 
290
 
        def cleanup(path):
291
 
            # Warn in case the file couldn't be deleted (in case windows still
292
 
            # holds the file open, but not if the files have already been
293
 
            # deleted)
294
 
            try:
295
 
                os.remove(path)
296
 
            except OSError, e:
297
 
                if e.errno not in (errno.ENOENT,):
298
 
                    warning('Failed to delete temporary file: %s %s', path, e)
299
 
 
300
 
        cleanup(old_abspath)
301
 
        cleanup(new_abspath)
302
 
 
303
 
 
304
 
def get_trees_and_branches_to_diff_locked(
305
 
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
306
 
    """Get the trees and specific files to diff given a list of paths.
307
 
 
308
 
    This method works out the trees to be diff'ed and the files of
309
 
    interest within those trees.
310
 
 
311
 
    :param path_list:
312
 
        the list of arguments passed to the diff command
313
 
    :param revision_specs:
314
 
        Zero, one or two RevisionSpecs from the diff command line,
315
 
        saying what revisions to compare.
316
 
    :param old_url:
317
 
        The url of the old branch or tree. If None, the tree to use is
318
 
        taken from the first path, if any, or the current working tree.
319
 
    :param new_url:
320
 
        The url of the new branch or tree. If None, the tree to use is
321
 
        taken from the first path, if any, or the current working tree.
322
 
    :param add_cleanup:
323
 
        a callable like Command.add_cleanup.  get_trees_and_branches_to_diff
324
 
        will register cleanups that must be run to unlock the trees, etc.
325
 
    :param apply_view:
326
 
        if True and a view is set, apply the view or check that the paths
327
 
        are within it
328
 
    :returns:
329
 
        a tuple of (old_tree, new_tree, old_branch, new_branch,
330
 
        specific_files, extra_trees) where extra_trees is a sequence of
331
 
        additional trees to search in for file-ids.  The trees and branches
332
 
        will be read-locked until the cleanups registered via the add_cleanup
333
 
        param are run.
334
 
    """
335
 
    # Get the old and new revision specs
336
 
    old_revision_spec = None
337
 
    new_revision_spec = None
338
 
    if revision_specs is not None:
339
 
        if len(revision_specs) > 0:
340
 
            old_revision_spec = revision_specs[0]
341
 
            if old_url is None:
342
 
                old_url = old_revision_spec.get_branch()
343
 
        if len(revision_specs) > 1:
344
 
            new_revision_spec = revision_specs[1]
345
 
            if new_url is None:
346
 
                new_url = new_revision_spec.get_branch()
347
 
 
348
 
    other_paths = []
349
 
    make_paths_wt_relative = True
350
 
    consider_relpath = True
351
 
    if path_list is None or len(path_list) == 0:
352
 
        # If no path is given, the current working tree is used
353
 
        default_location = u'.'
354
 
        consider_relpath = False
355
 
    elif old_url is not None and new_url is not None:
356
 
        other_paths = path_list
357
 
        make_paths_wt_relative = False
358
 
    else:
359
 
        default_location = path_list[0]
360
 
        other_paths = path_list[1:]
361
 
 
362
 
    def lock_tree_or_branch(wt, br):
363
 
        if wt is not None:
364
 
            wt.lock_read()
365
 
            add_cleanup(wt.unlock)
366
 
        elif br is not None:
367
 
            br.lock_read()
368
 
            add_cleanup(br.unlock)
369
 
 
370
 
    # Get the old location
371
 
    specific_files = []
372
 
    if old_url is None:
373
 
        old_url = default_location
374
 
    working_tree, branch, relpath = \
375
 
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
376
 
    lock_tree_or_branch(working_tree, branch)
377
 
    if consider_relpath and relpath != '':
378
 
        if working_tree is not None and apply_view:
379
 
            views.check_path_in_view(working_tree, relpath)
380
 
        specific_files.append(relpath)
381
 
    old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
382
 
    old_branch = branch
383
 
 
384
 
    # Get the new location
385
 
    if new_url is None:
386
 
        new_url = default_location
387
 
    if new_url != old_url:
388
 
        working_tree, branch, relpath = \
389
 
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
390
 
        lock_tree_or_branch(working_tree, branch)
391
 
        if consider_relpath and relpath != '':
392
 
            if working_tree is not None and apply_view:
393
 
                views.check_path_in_view(working_tree, relpath)
394
 
            specific_files.append(relpath)
395
 
    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
396
 
        basis_is_default=working_tree is None)
397
 
    new_branch = branch
398
 
 
399
 
    # Get the specific files (all files is None, no files is [])
400
 
    if make_paths_wt_relative and working_tree is not None:
401
 
        other_paths = working_tree.safe_relpath_files(
402
 
            other_paths,
403
 
            apply_view=apply_view)
404
 
    specific_files.extend(other_paths)
405
 
    if len(specific_files) == 0:
406
 
        specific_files = None
407
 
        if (working_tree is not None and working_tree.supports_views()
408
 
            and apply_view):
409
 
            view_files = working_tree.views.lookup_view()
410
 
            if view_files:
411
 
                specific_files = view_files
412
 
                view_str = views.view_display_str(view_files)
413
 
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
414
 
 
415
 
    # Get extra trees that ought to be searched for file-ids
416
 
    extra_trees = None
417
 
    if working_tree is not None and working_tree not in (old_tree, new_tree):
418
 
        extra_trees = (working_tree,)
419
 
    return (old_tree, new_tree, old_branch, new_branch,
420
 
            specific_files, extra_trees)
421
 
 
422
 
 
423
 
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
424
 
    if branch is None and tree is not None:
425
 
        branch = tree.branch
426
 
    if spec is None or spec.spec is None:
427
 
        if basis_is_default:
428
 
            if tree is not None:
429
 
                return tree.basis_tree()
430
 
            else:
431
 
                return branch.basis_tree()
432
 
        else:
433
 
            return tree
434
 
    return spec.as_tree(branch)
435
 
 
436
 
 
437
 
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
438
 
                    external_diff_options=None,
439
 
                    old_label='a/', new_label='b/',
440
 
                    extra_trees=None,
441
 
                    path_encoding='utf8',
442
 
                    using=None,
443
 
                    format_cls=None,
444
 
                    context=DEFAULT_CONTEXT_AMOUNT):
445
 
    """Show in text form the changes from one tree to another.
446
 
 
447
 
    :param to_file: The output stream.
448
 
    :param specific_files: Include only changes to these files - None for all
449
 
        changes.
450
 
    :param external_diff_options: If set, use an external GNU diff and pass 
451
 
        these options.
452
 
    :param extra_trees: If set, more Trees to use for looking up file ids
453
 
    :param path_encoding: If set, the path will be encoded as specified, 
454
 
        otherwise is supposed to be utf8
455
 
    :param format_cls: Formatter class (DiffTree subclass)
456
 
    """
457
 
    if context is None:
458
 
        context = DEFAULT_CONTEXT_AMOUNT
459
 
    if format_cls is None:
460
 
        format_cls = DiffTree
461
 
    old_tree.lock_read()
462
 
    try:
463
 
        if extra_trees is not None:
464
 
            for tree in extra_trees:
465
 
                tree.lock_read()
466
 
        new_tree.lock_read()
467
 
        try:
468
 
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
469
 
                                                   path_encoding,
470
 
                                                   external_diff_options,
471
 
                                                   old_label, new_label, using,
472
 
                                                   context_lines=context)
473
 
            return differ.show_diff(specific_files, extra_trees)
474
 
        finally:
475
 
            new_tree.unlock()
476
 
            if extra_trees is not None:
477
 
                for tree in extra_trees:
478
 
                    tree.unlock()
479
 
    finally:
480
 
        old_tree.unlock()
481
 
 
482
 
 
483
 
def _patch_header_date(tree, file_id, path):
484
 
    """Returns a timestamp suitable for use in a patch header."""
485
 
    try:
486
 
        mtime = tree.get_file_mtime(file_id, path)
487
 
    except errors.FileTimestampUnavailable:
488
 
        mtime = 0
489
 
    return timestamp.format_patch_date(mtime)
490
 
 
491
 
 
492
 
def get_executable_change(old_is_x, new_is_x):
493
 
    descr = { True:"+x", False:"-x", None:"??" }
494
 
    if old_is_x != new_is_x:
495
 
        return ["%s to %s" % (descr[old_is_x], descr[new_is_x],)]
496
 
    else:
497
 
        return []
498
 
 
499
 
 
500
 
class DiffPath(object):
501
 
    """Base type for command object that compare files"""
502
 
 
503
 
    # The type or contents of the file were unsuitable for diffing
504
 
    CANNOT_DIFF = 'CANNOT_DIFF'
505
 
    # The file has changed in a semantic way
506
 
    CHANGED = 'CHANGED'
507
 
    # The file content may have changed, but there is no semantic change
508
 
    UNCHANGED = 'UNCHANGED'
509
 
 
510
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8'):
511
 
        """Constructor.
512
 
 
513
 
        :param old_tree: The tree to show as the old tree in the comparison
514
 
        :param new_tree: The tree to show as new in the comparison
515
 
        :param to_file: The file to write comparison data to
516
 
        :param path_encoding: The character encoding to write paths in
517
 
        """
518
 
        self.old_tree = old_tree
519
 
        self.new_tree = new_tree
520
 
        self.to_file = to_file
521
 
        self.path_encoding = path_encoding
522
 
 
523
 
    def finish(self):
524
 
        pass
525
 
 
526
 
    @classmethod
527
 
    def from_diff_tree(klass, diff_tree):
528
 
        return klass(diff_tree.old_tree, diff_tree.new_tree,
529
 
                     diff_tree.to_file, diff_tree.path_encoding)
530
 
 
531
 
    @staticmethod
532
 
    def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):
533
 
        for file_differ in differs:
534
 
            result = file_differ.diff(file_id, old_path, new_path, old_kind,
535
 
                                      new_kind)
536
 
            if result is not DiffPath.CANNOT_DIFF:
537
 
                return result
538
 
        else:
539
 
            return DiffPath.CANNOT_DIFF
540
 
 
541
 
 
542
 
class DiffKindChange(object):
543
 
    """Special differ for file kind changes.
544
 
 
545
 
    Represents kind change as deletion + creation.  Uses the other differs
546
 
    to do this.
547
 
    """
548
 
    def __init__(self, differs):
549
 
        self.differs = differs
550
 
 
551
 
    def finish(self):
552
 
        pass
553
 
 
554
 
    @classmethod
555
 
    def from_diff_tree(klass, diff_tree):
556
 
        return klass(diff_tree.differs)
557
 
 
558
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
559
 
        """Perform comparison
560
 
 
561
 
        :param file_id: The file_id of the file to compare
562
 
        :param old_path: Path of the file in the old tree
563
 
        :param new_path: Path of the file in the new tree
564
 
        :param old_kind: Old file-kind of the file
565
 
        :param new_kind: New file-kind of the file
566
 
        """
567
 
        if None in (old_kind, new_kind):
568
 
            return DiffPath.CANNOT_DIFF
569
 
        result = DiffPath._diff_many(self.differs, file_id, old_path,
570
 
                                       new_path, old_kind, None)
571
 
        if result is DiffPath.CANNOT_DIFF:
572
 
            return result
573
 
        return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
574
 
                                     None, new_kind)
575
 
 
576
 
 
577
 
class DiffDirectory(DiffPath):
578
 
 
579
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
580
 
        """Perform comparison between two directories.  (dummy)
581
 
 
582
 
        """
583
 
        if 'directory' not in (old_kind, new_kind):
584
 
            return self.CANNOT_DIFF
585
 
        if old_kind not in ('directory', None):
586
 
            return self.CANNOT_DIFF
587
 
        if new_kind not in ('directory', None):
588
 
            return self.CANNOT_DIFF
589
 
        return self.CHANGED
590
 
 
591
 
 
592
 
class DiffSymlink(DiffPath):
593
 
 
594
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
595
 
        """Perform comparison between two symlinks
596
 
 
597
 
        :param file_id: The file_id of the file to compare
598
 
        :param old_path: Path of the file in the old tree
599
 
        :param new_path: Path of the file in the new tree
600
 
        :param old_kind: Old file-kind of the file
601
 
        :param new_kind: New file-kind of the file
602
 
        """
603
 
        if 'symlink' not in (old_kind, new_kind):
604
 
            return self.CANNOT_DIFF
605
 
        if old_kind == 'symlink':
606
 
            old_target = self.old_tree.get_symlink_target(file_id)
607
 
        elif old_kind is None:
608
 
            old_target = None
609
 
        else:
610
 
            return self.CANNOT_DIFF
611
 
        if new_kind == 'symlink':
612
 
            new_target = self.new_tree.get_symlink_target(file_id)
613
 
        elif new_kind is None:
614
 
            new_target = None
615
 
        else:
616
 
            return self.CANNOT_DIFF
617
 
        return self.diff_symlink(old_target, new_target)
618
 
 
619
 
    def diff_symlink(self, old_target, new_target):
620
 
        if old_target is None:
621
 
            self.to_file.write('=== target is %r\n' % new_target)
622
 
        elif new_target is None:
623
 
            self.to_file.write('=== target was %r\n' % old_target)
624
 
        else:
625
 
            self.to_file.write('=== target changed %r => %r\n' %
626
 
                              (old_target, new_target))
627
 
        return self.CHANGED
628
 
 
629
 
 
630
 
class DiffText(DiffPath):
631
 
 
632
 
    # GNU Patch uses the epoch date to detect files that are being added
633
 
    # or removed in a diff.
634
 
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
635
 
 
636
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8', 
637
 
                 old_label='', new_label='', text_differ=internal_diff, 
638
 
                 context_lines=DEFAULT_CONTEXT_AMOUNT):
639
 
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
640
 
        self.text_differ = text_differ
641
 
        self.old_label = old_label
642
 
        self.new_label = new_label
643
 
        self.path_encoding = path_encoding
644
 
        self.context_lines = context_lines
645
 
 
646
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
647
 
        """Compare two files in unified diff format
648
 
 
649
 
        :param file_id: The file_id of the file to compare
650
 
        :param old_path: Path of the file in the old tree
651
 
        :param new_path: Path of the file in the new tree
652
 
        :param old_kind: Old file-kind of the file
653
 
        :param new_kind: New file-kind of the file
654
 
        """
655
 
        if 'file' not in (old_kind, new_kind):
656
 
            return self.CANNOT_DIFF
657
 
        from_file_id = to_file_id = file_id
658
 
        if old_kind == 'file':
659
 
            old_date = _patch_header_date(self.old_tree, file_id, old_path)
660
 
        elif old_kind is None:
661
 
            old_date = self.EPOCH_DATE
662
 
            from_file_id = None
663
 
        else:
664
 
            return self.CANNOT_DIFF
665
 
        if new_kind == 'file':
666
 
            new_date = _patch_header_date(self.new_tree, file_id, new_path)
667
 
        elif new_kind is None:
668
 
            new_date = self.EPOCH_DATE
669
 
            to_file_id = None
670
 
        else:
671
 
            return self.CANNOT_DIFF
672
 
        from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
673
 
        to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
674
 
        return self.diff_text(from_file_id, to_file_id, from_label, to_label,
675
 
            old_path, new_path)
676
 
 
677
 
    def diff_text(self, from_file_id, to_file_id, from_label, to_label,
678
 
        from_path=None, to_path=None):
679
 
        """Diff the content of given files in two trees
680
 
 
681
 
        :param from_file_id: The id of the file in the from tree.  If None,
682
 
            the file is not present in the from tree.
683
 
        :param to_file_id: The id of the file in the to tree.  This may refer
684
 
            to a different file from from_file_id.  If None,
685
 
            the file is not present in the to tree.
686
 
        :param from_path: The path in the from tree or None if unknown.
687
 
        :param to_path: The path in the to tree or None if unknown.
688
 
        """
689
 
        def _get_text(tree, file_id, path):
690
 
            if file_id is not None:
691
 
                return tree.get_file_lines(file_id, path)
692
 
            else:
693
 
                return []
694
 
        try:
695
 
            from_text = _get_text(self.old_tree, from_file_id, from_path)
696
 
            to_text = _get_text(self.new_tree, to_file_id, to_path)
697
 
            self.text_differ(from_label, from_text, to_label, to_text,
698
 
                             self.to_file, path_encoding=self.path_encoding,
699
 
                             context_lines=self.context_lines)
700
 
        except errors.BinaryFile:
701
 
            self.to_file.write(
702
 
                  ("Binary files %s and %s differ\n" %
703
 
                  (from_label, to_label)).encode(self.path_encoding,'replace'))
704
 
        return self.CHANGED
705
 
 
706
 
 
707
 
class DiffFromTool(DiffPath):
708
 
 
709
 
    def __init__(self, command_template, old_tree, new_tree, to_file,
710
 
                 path_encoding='utf-8'):
711
 
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
712
 
        self.command_template = command_template
713
 
        self._root = osutils.mkdtemp(prefix='bzr-diff-')
714
 
 
715
 
    @classmethod
716
 
    def from_string(klass, command_string, old_tree, new_tree, to_file,
717
 
                    path_encoding='utf-8'):
718
 
        command_template = cmdline.split(command_string)
719
 
        if '@' not in command_string:
720
 
            command_template.extend(['@old_path', '@new_path'])
721
 
        return klass(command_template, old_tree, new_tree, to_file,
722
 
                     path_encoding)
723
 
 
724
 
    @classmethod
725
 
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
726
 
        def from_diff_tree(diff_tree):
727
 
            full_command_string = [command_string]
728
 
            if external_diff_options is not None:
729
 
                full_command_string += ' ' + external_diff_options
730
 
            return klass.from_string(full_command_string, diff_tree.old_tree,
731
 
                                     diff_tree.new_tree, diff_tree.to_file)
732
 
        return from_diff_tree
733
 
 
734
 
    def _get_command(self, old_path, new_path):
735
 
        my_map = {'old_path': old_path, 'new_path': new_path}
736
 
        command = [AtTemplate(t).substitute(my_map) for t in
737
 
                   self.command_template]
738
 
        if sys.platform == 'win32': # Popen doesn't accept unicode on win32
739
 
            command_encoded = []
740
 
            for c in command:
741
 
                if isinstance(c, unicode):
742
 
                    command_encoded.append(c.encode('mbcs'))
743
 
                else:
744
 
                    command_encoded.append(c)
745
 
            return command_encoded
746
 
        else:
747
 
            return command
748
 
 
749
 
    def _execute(self, old_path, new_path):
750
 
        command = self._get_command(old_path, new_path)
751
 
        try:
752
 
            proc = subprocess.Popen(command, stdout=subprocess.PIPE,
753
 
                                    cwd=self._root)
754
 
        except OSError, e:
755
 
            if e.errno == errno.ENOENT:
756
 
                raise errors.ExecutableMissing(command[0])
757
 
            else:
758
 
                raise
759
 
        self.to_file.write(proc.stdout.read())
760
 
        return proc.wait()
761
 
 
762
 
    def _try_symlink_root(self, tree, prefix):
763
 
        if (getattr(tree, 'abspath', None) is None
764
 
            or not osutils.host_os_dereferences_symlinks()):
765
 
            return False
766
 
        try:
767
 
            os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
768
 
        except OSError, e:
769
 
            if e.errno != errno.EEXIST:
770
 
                raise
771
 
        return True
772
 
 
773
 
    @staticmethod
774
 
    def _fenc():
775
 
        """Returns safe encoding for passing file path to diff tool"""
776
 
        if sys.platform == 'win32':
777
 
            return 'mbcs'
778
 
        else:
779
 
            # Don't fallback to 'utf-8' because subprocess may not be able to
780
 
            # handle utf-8 correctly when locale is not utf-8.
781
 
            return sys.getfilesystemencoding() or 'ascii'
782
 
 
783
 
    def _is_safepath(self, path):
784
 
        """Return true if `path` may be able to pass to subprocess."""
785
 
        fenc = self._fenc()
786
 
        try:
787
 
            return path == path.encode(fenc).decode(fenc)
788
 
        except UnicodeError:
789
 
            return False
790
 
 
791
 
    def _safe_filename(self, prefix, relpath):
792
 
        """Replace unsafe character in `relpath` then join `self._root`,
793
 
        `prefix` and `relpath`."""
794
 
        fenc = self._fenc()
795
 
        # encoded_str.replace('?', '_') may break multibyte char.
796
 
        # So we should encode, decode, then replace(u'?', u'_')
797
 
        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
798
 
        relpath_tmp = relpath_tmp.replace(u'?', u'_')
799
 
        return osutils.pathjoin(self._root, prefix, relpath_tmp)
800
 
 
801
 
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
802
 
                    allow_write=False):
803
 
        if not force_temp and isinstance(tree, WorkingTree):
804
 
            full_path = tree.abspath(tree.id2path(file_id))
805
 
            if self._is_safepath(full_path):
806
 
                return full_path
807
 
 
808
 
        full_path = self._safe_filename(prefix, relpath)
809
 
        if not force_temp and self._try_symlink_root(tree, prefix):
810
 
            return full_path
811
 
        parent_dir = osutils.dirname(full_path)
812
 
        try:
813
 
            os.makedirs(parent_dir)
814
 
        except OSError, e:
815
 
            if e.errno != errno.EEXIST:
816
 
                raise
817
 
        source = tree.get_file(file_id, relpath)
818
 
        try:
819
 
            target = open(full_path, 'wb')
820
 
            try:
821
 
                osutils.pumpfile(source, target)
822
 
            finally:
823
 
                target.close()
824
 
        finally:
825
 
            source.close()
826
 
        try:
827
 
            mtime = tree.get_file_mtime(file_id)
828
 
        except errors.FileTimestampUnavailable:
829
 
            pass
830
 
        else:
831
 
            os.utime(full_path, (mtime, mtime))
832
 
        if not allow_write:
833
 
            osutils.make_readonly(full_path)
834
 
        return full_path
835
 
 
836
 
    def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
837
 
                       allow_write_new=False):
838
 
        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
839
 
                                         old_path, force_temp)
840
 
        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
841
 
                                         new_path, force_temp,
842
 
                                         allow_write=allow_write_new)
843
 
        return old_disk_path, new_disk_path
844
 
 
845
 
    def finish(self):
846
 
        try:
847
 
            osutils.rmtree(self._root)
848
 
        except OSError, e:
849
 
            if e.errno != errno.ENOENT:
850
 
                mutter("The temporary directory \"%s\" was not "
851
 
                        "cleanly removed: %s." % (self._root, e))
852
 
 
853
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
854
 
        if (old_kind, new_kind) != ('file', 'file'):
855
 
            return DiffPath.CANNOT_DIFF
856
 
        (old_disk_path, new_disk_path) = self._prepare_files(
857
 
                                                file_id, old_path, new_path)
858
 
        self._execute(old_disk_path, new_disk_path)
859
 
 
860
 
    def edit_file(self, file_id):
861
 
        """Use this tool to edit a file.
862
 
 
863
 
        A temporary copy will be edited, and the new contents will be
864
 
        returned.
865
 
 
866
 
        :param file_id: The id of the file to edit.
867
 
        :return: The new contents of the file.
868
 
        """
869
 
        old_path = self.old_tree.id2path(file_id)
870
 
        new_path = self.new_tree.id2path(file_id)
871
 
        old_abs_path, new_abs_path = self._prepare_files(
872
 
                                            file_id, old_path, new_path,
873
 
                                            allow_write_new=True,
874
 
                                            force_temp=True)
875
 
        command = self._get_command(old_abs_path, new_abs_path)
876
 
        subprocess.call(command, cwd=self._root)
877
 
        new_file = open(new_abs_path, 'rb')
878
 
        try:
879
 
            return new_file.read()
880
 
        finally:
881
 
            new_file.close()
882
 
 
883
 
 
884
 
class DiffTree(object):
885
 
    """Provides textual representations of the difference between two trees.
886
 
 
887
 
    A DiffTree examines two trees and where a file-id has altered
888
 
    between them, generates a textual representation of the difference.
889
 
    DiffTree uses a sequence of DiffPath objects which are each
890
 
    given the opportunity to handle a given altered fileid. The list
891
 
    of DiffPath objects can be extended globally by appending to
892
 
    DiffTree.diff_factories, or for a specific diff operation by
893
 
    supplying the extra_factories option to the appropriate method.
894
 
    """
895
 
 
896
 
    # list of factories that can provide instances of DiffPath objects
897
 
    # may be extended by plugins.
898
 
    diff_factories = [DiffSymlink.from_diff_tree,
899
 
                      DiffDirectory.from_diff_tree]
900
 
 
901
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
902
 
                 diff_text=None, extra_factories=None):
903
 
        """Constructor
904
 
 
905
 
        :param old_tree: Tree to show as old in the comparison
906
 
        :param new_tree: Tree to show as new in the comparison
907
 
        :param to_file: File to write comparision to
908
 
        :param path_encoding: Character encoding to write paths in
909
 
        :param diff_text: DiffPath-type object to use as a last resort for
910
 
            diffing text files.
911
 
        :param extra_factories: Factories of DiffPaths to try before any other
912
 
            DiffPaths"""
913
 
        if diff_text is None:
914
 
            diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
915
 
                                 '', '',  internal_diff)
916
 
        self.old_tree = old_tree
917
 
        self.new_tree = new_tree
918
 
        self.to_file = to_file
919
 
        self.path_encoding = path_encoding
920
 
        self.differs = []
921
 
        if extra_factories is not None:
922
 
            self.differs.extend(f(self) for f in extra_factories)
923
 
        self.differs.extend(f(self) for f in self.diff_factories)
924
 
        self.differs.extend([diff_text, DiffKindChange.from_diff_tree(self)])
925
 
 
926
 
    @classmethod
927
 
    def from_trees_options(klass, old_tree, new_tree, to_file,
928
 
                           path_encoding, external_diff_options, old_label,
929
 
                           new_label, using, context_lines):
930
 
        """Factory for producing a DiffTree.
931
 
 
932
 
        Designed to accept options used by show_diff_trees.
933
 
 
934
 
        :param old_tree: The tree to show as old in the comparison
935
 
        :param new_tree: The tree to show as new in the comparison
936
 
        :param to_file: File to write comparisons to
937
 
        :param path_encoding: Character encoding to use for writing paths
938
 
        :param external_diff_options: If supplied, use the installed diff
939
 
            binary to perform file comparison, using supplied options.
940
 
        :param old_label: Prefix to use for old file labels
941
 
        :param new_label: Prefix to use for new file labels
942
 
        :param using: Commandline to use to invoke an external diff tool
943
 
        """
944
 
        if using is not None:
945
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
946
 
        else:
947
 
            extra_factories = []
948
 
        if external_diff_options:
949
 
            opts = external_diff_options.split()
950
 
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
951
 
                """:param path_encoding: not used but required
952
 
                        to match the signature of internal_diff.
953
 
                """
954
 
                external_diff(olab, olines, nlab, nlines, to_file, opts)
955
 
        else:
956
 
            diff_file = internal_diff
957
 
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
958
 
                             old_label, new_label, diff_file, context_lines=context_lines)
959
 
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
960
 
                     extra_factories)
961
 
 
962
 
    def show_diff(self, specific_files, extra_trees=None):
963
 
        """Write tree diff to self.to_file
964
 
 
965
 
        :param specific_files: the specific files to compare (recursive)
966
 
        :param extra_trees: extra trees to use for mapping paths to file_ids
967
 
        """
968
 
        try:
969
 
            return self._show_diff(specific_files, extra_trees)
970
 
        finally:
971
 
            for differ in self.differs:
972
 
                differ.finish()
973
 
 
974
 
    def _show_diff(self, specific_files, extra_trees):
975
 
        # TODO: Generation of pseudo-diffs for added/deleted files could
976
 
        # be usefully made into a much faster special case.
977
 
        iterator = self.new_tree.iter_changes(self.old_tree,
978
 
                                               specific_files=specific_files,
979
 
                                               extra_trees=extra_trees,
980
 
                                               require_versioned=True)
981
 
        has_changes = 0
982
 
        def changes_key(change):
983
 
            old_path, new_path = change[1]
984
 
            path = new_path
985
 
            if path is None:
986
 
                path = old_path
987
 
            return path
988
 
        def get_encoded_path(path):
989
 
            if path is not None:
990
 
                return path.encode(self.path_encoding, "replace")
991
 
        for (file_id, paths, changed_content, versioned, parent, name, kind,
992
 
             executable) in sorted(iterator, key=changes_key):
993
 
            # The root does not get diffed, and items with no known kind (that
994
 
            # is, missing) in both trees are skipped as well.
995
 
            if parent == (None, None) or kind == (None, None):
996
 
                continue
997
 
            oldpath, newpath = paths
998
 
            oldpath_encoded = get_encoded_path(paths[0])
999
 
            newpath_encoded = get_encoded_path(paths[1])
1000
 
            old_present = (kind[0] is not None and versioned[0])
1001
 
            new_present = (kind[1] is not None and versioned[1])
1002
 
            renamed = (parent[0], name[0]) != (parent[1], name[1])
1003
 
 
1004
 
            properties_changed = []
1005
 
            properties_changed.extend(get_executable_change(executable[0], executable[1]))
1006
 
 
1007
 
            if properties_changed:
1008
 
                prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)
1009
 
            else:
1010
 
                prop_str = ""
1011
 
 
1012
 
            if (old_present, new_present) == (True, False):
1013
 
                self.to_file.write("=== removed %s '%s'\n" %
1014
 
                                   (kind[0], oldpath_encoded))
1015
 
                newpath = oldpath
1016
 
            elif (old_present, new_present) == (False, True):
1017
 
                self.to_file.write("=== added %s '%s'\n" %
1018
 
                                   (kind[1], newpath_encoded))
1019
 
                oldpath = newpath
1020
 
            elif renamed:
1021
 
                self.to_file.write("=== renamed %s '%s' => '%s'%s\n" %
1022
 
                    (kind[0], oldpath_encoded, newpath_encoded, prop_str))
1023
 
            else:
1024
 
                # if it was produced by iter_changes, it must be
1025
 
                # modified *somehow*, either content or execute bit.
1026
 
                self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
1027
 
                                   newpath_encoded, prop_str))
1028
 
            if changed_content:
1029
 
                self._diff(file_id, oldpath, newpath, kind[0], kind[1])
1030
 
                has_changes = 1
1031
 
            if renamed:
1032
 
                has_changes = 1
1033
 
        return has_changes
1034
 
 
1035
 
    def diff(self, file_id, old_path, new_path):
1036
 
        """Perform a diff of a single file
1037
 
 
1038
 
        :param file_id: file-id of the file
1039
 
        :param old_path: The path of the file in the old tree
1040
 
        :param new_path: The path of the file in the new tree
1041
 
        """
1042
 
        try:
1043
 
            old_kind = self.old_tree.kind(file_id)
1044
 
        except (errors.NoSuchId, errors.NoSuchFile):
1045
 
            old_kind = None
1046
 
        try:
1047
 
            new_kind = self.new_tree.kind(file_id)
1048
 
        except (errors.NoSuchId, errors.NoSuchFile):
1049
 
            new_kind = None
1050
 
        self._diff(file_id, old_path, new_path, old_kind, new_kind)
1051
 
 
1052
 
 
1053
 
    def _diff(self, file_id, old_path, new_path, old_kind, new_kind):
1054
 
        result = DiffPath._diff_many(self.differs, file_id, old_path,
1055
 
                                       new_path, old_kind, new_kind)
1056
 
        if result is DiffPath.CANNOT_DIFF:
1057
 
            error_path = new_path
1058
 
            if error_path is None:
1059
 
                error_path = old_path
1060
 
            raise errors.NoDiffFound(error_path)
1061
 
 
1062
 
 
1063
 
format_registry = Registry()
1064
 
format_registry.register('default', DiffTree)
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
from sets import Set
 
19
 
 
20
from trace import mutter
 
21
 
 
22
 
 
23
 
 
24
 
 
25
 
 
26
 
 
27
def diff_trees(old_tree, new_tree):
 
28
    """Compute diff between two trees.
 
29
 
 
30
    They may be in different branches and may be working or historical
 
31
    trees.
 
32
 
 
33
    Yields a sequence of (state, id, old_name, new_name, kind).
 
34
    Each filename and each id is listed only once.
 
35
    """
 
36
 
 
37
    ## TODO: Compare files before diffing; only mention those that have changed
 
38
 
 
39
    ## TODO: Set nice names in the headers, maybe include diffstat
 
40
 
 
41
    ## TODO: Perhaps make this a generator rather than using
 
42
    ## a callback object?
 
43
 
 
44
    ## TODO: Allow specifying a list of files to compare, rather than
 
45
    ## doing the whole tree?  (Not urgent.)
 
46
 
 
47
    ## TODO: Allow diffing any two inventories, not just the
 
48
    ## current one against one.  We mgiht need to specify two
 
49
    ## stores to look for the files if diffing two branches.  That
 
50
    ## might imply this shouldn't be primarily a Branch method.
 
51
 
 
52
    ## XXX: This doesn't report on unknown files; that can be done
 
53
    ## from a separate method.
 
54
 
 
55
    old_it = old_tree.list_files()
 
56
    new_it = new_tree.list_files()
 
57
 
 
58
    def next(it):
 
59
        try:
 
60
            return it.next()
 
61
        except StopIteration:
 
62
            return None
 
63
 
 
64
    old_item = next(old_it)
 
65
    new_item = next(new_it)
 
66
 
 
67
    # We step through the two sorted iterators in parallel, trying to
 
68
    # keep them lined up.
 
69
 
 
70
    while (old_item != None) or (new_item != None):
 
71
        # OK, we still have some remaining on both, but they may be
 
72
        # out of step.        
 
73
        if old_item != None:
 
74
            old_name, old_class, old_kind, old_id = old_item
 
75
        else:
 
76
            old_name = None
 
77
            
 
78
        if new_item != None:
 
79
            new_name, new_class, new_kind, new_id = new_item
 
80
        else:
 
81
            new_name = None
 
82
 
 
83
        mutter("   diff pairwise %r" % (old_item,))
 
84
        mutter("                 %r" % (new_item,))
 
85
 
 
86
        if old_item:
 
87
            # can't handle the old tree being a WorkingTree
 
88
            assert old_class == 'V'
 
89
 
 
90
        if new_item and (new_class != 'V'):
 
91
            yield new_class, None, None, new_name, new_kind
 
92
            new_item = next(new_it)
 
93
        elif (not new_item) or (old_item and (old_name < new_name)):
 
94
            mutter("     extra entry in old-tree sequence")
 
95
            if new_tree.has_id(old_id):
 
96
                # will be mentioned as renamed under new name
 
97
                pass
 
98
            else:
 
99
                yield 'D', old_id, old_name, None, old_kind
 
100
            old_item = next(old_it)
 
101
        elif (not old_item) or (new_item and (new_name < old_name)):
 
102
            mutter("     extra entry in new-tree sequence")
 
103
            if old_tree.has_id(new_id):
 
104
                yield 'R', new_id, old_tree.id2path(new_id), new_name, new_kind
 
105
            else:
 
106
                yield 'A', new_id, None, new_name, new_kind
 
107
            new_item = next(new_it)
 
108
        elif old_id != new_id:
 
109
            assert old_name == new_name
 
110
            # both trees have a file of this name, but it is not the
 
111
            # same file.  in other words, the old filename has been
 
112
            # overwritten by either a newly-added or a renamed file.
 
113
            # (should we return something about the overwritten file?)
 
114
            if old_tree.has_id(new_id):
 
115
                # renaming, overlying a deleted file
 
116
                yield 'R', new_id, old_tree.id2path(new_id), new_name, new_kind
 
117
            else:
 
118
                yield 'A', new_id, None, new_name, new_kind
 
119
 
 
120
            new_item = next(new_it)
 
121
            old_item = next(old_it)
 
122
        else:
 
123
            assert old_id == new_id
 
124
            assert old_id != None
 
125
            assert old_name == new_name
 
126
            assert old_kind == new_kind
 
127
 
 
128
            if old_kind == 'directory':
 
129
                yield '.', new_id, old_name, new_name, new_kind
 
130
            elif old_tree.get_file_size(old_id) != new_tree.get_file_size(old_id):
 
131
                mutter("    file size has changed, must be different")
 
132
                yield 'M', new_id, old_name, new_name, new_kind
 
133
            elif old_tree.get_file_sha1(old_id) == new_tree.get_file_sha1(old_id):
 
134
                mutter("      SHA1 indicates they're identical")
 
135
                ## assert compare_files(old_tree.get_file(i), new_tree.get_file(i))
 
136
                yield '.', new_id, old_name, new_name, new_kind
 
137
            else:
 
138
                mutter("      quick compare shows different")
 
139
                yield 'M', new_id, old_name, new_name, new_kind
 
140
 
 
141
            new_item = next(new_it)
 
142
            old_item = next(old_it)
 
143
 
 
144