~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Martin Pool
  • Date: 2005-07-07 10:31:36 UTC
  • Revision ID: mbp@sourcefrog.net-20050707103135-9b4d911d8df6e880
- fix pwk help

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
 
from sets import Set
19
 
 
20
18
from trace import mutter
21
19
from errors import BzrError
22
20
 
23
21
 
24
 
def diff_trees(old_tree, new_tree):
25
 
    """Compute diff between two trees.
26
 
 
27
 
    They may be in different branches and may be working or historical
28
 
    trees.
29
 
 
30
 
    This only compares the versioned files, paying no attention to
31
 
    files which are ignored or unknown.  Those can only be present in
32
 
    working trees and can be reported on separately.
33
 
 
34
 
    Yields a sequence of (state, id, old_name, new_name, kind).
35
 
    Each filename and each id is listed only once.
 
22
# TODO: Rather than building a changeset object, we should probably
 
23
# invoke callbacks on an object.  That object can either accumulate a
 
24
# list, write them out directly, etc etc.
 
25
 
 
26
def internal_diff(old_label, oldlines, new_label, newlines, to_file):
 
27
    import difflib
 
28
    
 
29
    # FIXME: difflib is wrong if there is no trailing newline.
 
30
    # The syntax used by patch seems to be "\ No newline at
 
31
    # end of file" following the last diff line from that
 
32
    # file.  This is not trivial to insert into the
 
33
    # unified_diff output and it might be better to just fix
 
34
    # or replace that function.
 
35
 
 
36
    # In the meantime we at least make sure the patch isn't
 
37
    # mangled.
 
38
 
 
39
 
 
40
    # Special workaround for Python2.3, where difflib fails if
 
41
    # both sequences are empty.
 
42
    if not oldlines and not newlines:
 
43
        return
 
44
 
 
45
    nonl = False
 
46
 
 
47
    if oldlines and (oldlines[-1][-1] != '\n'):
 
48
        oldlines[-1] += '\n'
 
49
        nonl = True
 
50
    if newlines and (newlines[-1][-1] != '\n'):
 
51
        newlines[-1] += '\n'
 
52
        nonl = True
 
53
 
 
54
    ud = difflib.unified_diff(oldlines, newlines,
 
55
                              fromfile=old_label, tofile=new_label)
 
56
 
 
57
    # work-around for difflib being too smart for its own good
 
58
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
 
59
    if not oldlines:
 
60
        ud = list(ud)
 
61
        ud[2] = ud[2].replace('-1,0', '-0,0')
 
62
    elif not newlines:
 
63
        ud = list(ud)
 
64
        ud[2] = ud[2].replace('+1,0', '+0,0')
 
65
 
 
66
    for line in ud:
 
67
        to_file.write(line)
 
68
    if nonl:
 
69
        print >>to_file, "\\ No newline at end of file"
 
70
    print >>to_file
 
71
 
 
72
 
 
73
 
 
74
 
 
75
def external_diff(old_label, oldlines, new_label, newlines, to_file,
 
76
                  diff_opts):
 
77
    """Display a diff by calling out to the external diff program."""
 
78
    import sys
 
79
    
 
80
    if to_file != sys.stdout:
 
81
        raise NotImplementedError("sorry, can't send external diff other than to stdout yet",
 
82
                                  to_file)
 
83
 
 
84
    # make sure our own output is properly ordered before the diff
 
85
    to_file.flush()
 
86
 
 
87
    from tempfile import NamedTemporaryFile
 
88
    import os
 
89
 
 
90
    oldtmpf = NamedTemporaryFile()
 
91
    newtmpf = NamedTemporaryFile()
 
92
 
 
93
    try:
 
94
        # TODO: perhaps a special case for comparing to or from the empty
 
95
        # sequence; can just use /dev/null on Unix
 
96
 
 
97
        # TODO: if either of the files being compared already exists as a
 
98
        # regular named file (e.g. in the working directory) then we can
 
99
        # compare directly to that, rather than copying it.
 
100
 
 
101
        oldtmpf.writelines(oldlines)
 
102
        newtmpf.writelines(newlines)
 
103
 
 
104
        oldtmpf.flush()
 
105
        newtmpf.flush()
 
106
 
 
107
        if not diff_opts:
 
108
            diff_opts = []
 
109
        diffcmd = ['diff',
 
110
                   '--label', old_label,
 
111
                   oldtmpf.name,
 
112
                   '--label', new_label,
 
113
                   newtmpf.name]
 
114
 
 
115
        # diff only allows one style to be specified; they don't override.
 
116
        # note that some of these take optargs, and the optargs can be
 
117
        # directly appended to the options.
 
118
        # this is only an approximate parser; it doesn't properly understand
 
119
        # the grammar.
 
120
        for s in ['-c', '-u', '-C', '-U',
 
121
                  '-e', '--ed',
 
122
                  '-q', '--brief',
 
123
                  '--normal',
 
124
                  '-n', '--rcs',
 
125
                  '-y', '--side-by-side',
 
126
                  '-D', '--ifdef']:
 
127
            for j in diff_opts:
 
128
                if j.startswith(s):
 
129
                    break
 
130
            else:
 
131
                continue
 
132
            break
 
133
        else:
 
134
            diffcmd.append('-u')
 
135
                  
 
136
        if diff_opts:
 
137
            diffcmd.extend(diff_opts)
 
138
 
 
139
        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)
 
140
        
 
141
        if rc != 0 and rc != 1:
 
142
            # returns 1 if files differ; that's OK
 
143
            if rc < 0:
 
144
                msg = 'signal %d' % (-rc)
 
145
            else:
 
146
                msg = 'exit code %d' % rc
 
147
                
 
148
            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))
 
149
    finally:
 
150
        oldtmpf.close()                 # and delete
 
151
        newtmpf.close()
 
152
    
 
153
 
 
154
 
 
155
def show_diff(b, revision, specific_files, external_diff_options=None):
 
156
    """Shortcut for showing the diff to the working tree.
 
157
 
 
158
    b
 
159
        Branch.
 
160
 
 
161
    revision
 
162
        None for each, or otherwise the old revision to compare against.
 
163
    
 
164
    The more general form is show_diff_trees(), where the caller
 
165
    supplies any two trees.
36
166
    """
37
 
    ## TODO: Allow specifying a list of files to compare, rather than
38
 
    ## doing the whole tree?  (Not urgent.)
39
 
 
40
 
    ## TODO: Allow diffing any two inventories, not just the
41
 
    ## current one against one.  We mgiht need to specify two
42
 
    ## stores to look for the files if diffing two branches.  That
43
 
    ## might imply this shouldn't be primarily a Branch method.
44
 
 
45
 
    sha_match_cnt = modified_cnt = 0
46
 
 
47
 
    old_it = old_tree.list_files()
48
 
    new_it = new_tree.list_files()
49
 
 
50
 
    def next(it):
51
 
        try:
52
 
            return it.next()
53
 
        except StopIteration:
54
 
            return None
55
 
 
56
 
    old_item = next(old_it)
57
 
    new_item = next(new_it)
58
 
 
59
 
    # We step through the two sorted iterators in parallel, trying to
60
 
    # keep them lined up.
61
 
 
62
 
    while (old_item != None) or (new_item != None):
63
 
        # OK, we still have some remaining on both, but they may be
64
 
        # out of step.        
65
 
        if old_item != None:
66
 
            old_name, old_class, old_kind, old_id = old_item
67
 
        else:
68
 
            old_name = None
69
 
            
70
 
        if new_item != None:
71
 
            new_name, new_class, new_kind, new_id = new_item
72
 
        else:
73
 
            new_name = None
74
 
 
75
 
        if old_item:
76
 
            # can't handle the old tree being a WorkingTree
77
 
            assert old_class == 'V'
78
 
 
79
 
        if new_item and (new_class != 'V'):
80
 
            yield new_class, None, None, new_name, new_kind
81
 
            new_item = next(new_it)
82
 
        elif (not new_item) or (old_item and (old_name < new_name)):
83
 
            if new_tree.has_id(old_id):
84
 
                # will be mentioned as renamed under new name
85
 
                pass
86
 
            else:
87
 
                yield 'D', old_id, old_name, None, old_kind
88
 
            old_item = next(old_it)
89
 
        elif (not old_item) or (new_item and (new_name < old_name)):
90
 
            if old_tree.has_id(new_id):
91
 
                yield 'R', new_id, old_tree.id2path(new_id), new_name, new_kind
92
 
            else:
93
 
                yield 'A', new_id, None, new_name, new_kind
94
 
            new_item = next(new_it)
95
 
        elif old_id != new_id:
96
 
            assert old_name == new_name
97
 
            # both trees have a file of this name, but it is not the
98
 
            # same file.  in other words, the old filename has been
99
 
            # overwritten by either a newly-added or a renamed file.
100
 
            # (should we return something about the overwritten file?)
101
 
            if old_tree.has_id(new_id):
102
 
                # renaming, overlying a deleted file
103
 
                yield 'R', new_id, old_tree.id2path(new_id), new_name, new_kind
104
 
            else:
105
 
                yield 'A', new_id, None, new_name, new_kind
106
 
 
107
 
            new_item = next(new_it)
108
 
            old_item = next(old_it)
109
 
        else:
110
 
            assert old_id == new_id
111
 
            assert old_id != None
112
 
            assert old_name == new_name
113
 
            assert old_kind == new_kind
114
 
 
115
 
            if old_kind == 'directory':
116
 
                yield '.', new_id, old_name, new_name, new_kind
117
 
            elif old_tree.get_file_sha1(old_id) == new_tree.get_file_sha1(old_id):
118
 
                sha_match_cnt += 1
119
 
                yield '.', new_id, old_name, new_name, new_kind
120
 
            else:
121
 
                modified_cnt += 1
122
 
                yield 'M', new_id, old_name, new_name, new_kind
123
 
 
124
 
            new_item = next(new_it)
125
 
            old_item = next(old_it)
126
 
 
127
 
 
128
 
    mutter("diff finished: %d SHA matches, %d modified"
129
 
           % (sha_match_cnt, modified_cnt))
130
 
 
131
 
 
132
 
 
133
 
def show_diff(b, revision, file_list):
134
 
    import difflib, sys, types
135
 
    
 
167
    import sys
 
168
 
136
169
    if revision == None:
137
170
        old_tree = b.basis_tree()
138
171
    else:
140
173
        
141
174
    new_tree = b.working_tree()
142
175
 
 
176
    show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
 
177
                    external_diff_options)
 
178
 
 
179
 
 
180
 
 
181
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
 
182
                    external_diff_options=None):
 
183
    """Show in text form the changes from one tree to another.
 
184
 
 
185
    to_files
 
186
        If set, include only changes to these files.
 
187
 
 
188
    external_diff_options
 
189
        If set, use an external GNU diff and pass these options.
 
190
    """
 
191
 
143
192
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
144
193
    old_label = ''
145
194
    new_label = ''
152
201
    # TODO: Generation of pseudo-diffs for added/deleted files could
153
202
    # be usefully made into a much faster special case.
154
203
 
155
 
    # TODO: Better to return them in sorted order I think.
156
 
 
157
 
    if file_list:
158
 
        file_list = [b.relpath(f) for f in file_list]
159
 
 
160
 
    # FIXME: If given a file list, compare only those files rather
161
 
    # than comparing everything and then throwing stuff away.
 
204
    if external_diff_options:
 
205
        assert isinstance(external_diff_options, basestring)
 
206
        opts = external_diff_options.split()
 
207
        def diff_file(olab, olines, nlab, nlines, to_file):
 
208
            external_diff(olab, olines, nlab, nlines, to_file, opts)
 
209
    else:
 
210
        diff_file = internal_diff
162
211
    
163
 
    for file_state, fid, old_name, new_name, kind in diff_trees(old_tree, new_tree):
164
 
 
165
 
        if file_list and (new_name not in file_list):
166
 
            continue
167
 
        
168
 
        # Don't show this by default; maybe do it if an option is passed
169
 
        # idlabel = '      {%s}' % fid
170
 
        idlabel = ''
171
 
 
172
 
        def diffit(oldlines, newlines, **kw):
173
 
            
174
 
            # FIXME: difflib is wrong if there is no trailing newline.
175
 
            # The syntax used by patch seems to be "\ No newline at
176
 
            # end of file" following the last diff line from that
177
 
            # file.  This is not trivial to insert into the
178
 
            # unified_diff output and it might be better to just fix
179
 
            # or replace that function.
180
 
 
181
 
            # In the meantime we at least make sure the patch isn't
182
 
            # mangled.
183
 
            
184
 
 
185
 
            # Special workaround for Python2.3, where difflib fails if
186
 
            # both sequences are empty.
187
 
            if not oldlines and not newlines:
188
 
                return
189
 
 
190
 
            nonl = False
191
 
 
192
 
            if oldlines and (oldlines[-1][-1] != '\n'):
193
 
                oldlines[-1] += '\n'
194
 
                nonl = True
195
 
            if newlines and (newlines[-1][-1] != '\n'):
196
 
                newlines[-1] += '\n'
197
 
                nonl = True
198
 
 
199
 
            ud = difflib.unified_diff(oldlines, newlines, **kw)
200
 
 
201
 
            # work-around for difflib being too smart for its own good
202
 
            # if /dev/null is "1,0", patch won't recognize it as /dev/null
203
 
            if not oldlines:
204
 
                ud = list(ud)
205
 
                ud[2] = ud[2].replace('-1,0', '-0,0')
206
 
            elif not newlines:
207
 
                ud = list(ud)
208
 
                ud[2] = ud[2].replace('+1,0', '+0,0')
209
 
            
210
 
            sys.stdout.writelines(ud)
211
 
            if nonl:
212
 
                print "\\ No newline at end of file"
213
 
            sys.stdout.write('\n')
214
 
        
215
 
        if file_state in ['.', '?', 'I']:
216
 
            continue
217
 
        elif file_state == 'A':
218
 
            print '*** added %s %r' % (kind, new_name)
219
 
            if kind == 'file':
220
 
                diffit([],
221
 
                       new_tree.get_file(fid).readlines(),
222
 
                       fromfile=DEVNULL,
223
 
                       tofile=new_label + new_name + idlabel)
224
 
        elif file_state == 'D':
225
 
            assert isinstance(old_name, types.StringTypes)
226
 
            print '*** deleted %s %r' % (kind, old_name)
227
 
            if kind == 'file':
228
 
                diffit(old_tree.get_file(fid).readlines(), [],
229
 
                       fromfile=old_label + old_name + idlabel,
230
 
                       tofile=DEVNULL)
231
 
        elif file_state in ['M', 'R']:
232
 
            if file_state == 'M':
233
 
                assert kind == 'file'
234
 
                assert old_name == new_name
235
 
                print '*** modified %s %r' % (kind, new_name)
236
 
            elif file_state == 'R':
237
 
                print '*** renamed %s %r => %r' % (kind, old_name, new_name)
238
 
 
239
 
            if kind == 'file':
240
 
                diffit(old_tree.get_file(fid).readlines(),
241
 
                       new_tree.get_file(fid).readlines(),
242
 
                       fromfile=old_label + old_name + idlabel,
243
 
                       tofile=new_label + new_name)
244
 
        else:
245
 
            raise BzrError("can't represent state %s {%s}" % (file_state, fid))
246
 
 
247
 
 
248
 
 
249
 
class TreeDelta:
 
212
 
 
213
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
 
214
                          specific_files=specific_files)
 
215
 
 
216
    for path, file_id, kind in delta.removed:
 
217
        print >>to_file, '*** removed %s %r' % (kind, path)
 
218
        if kind == 'file':
 
219
            diff_file(old_label + path,
 
220
                      old_tree.get_file(file_id).readlines(),
 
221
                      DEVNULL, 
 
222
                      [],
 
223
                      to_file)
 
224
 
 
225
    for path, file_id, kind in delta.added:
 
226
        print >>to_file, '*** added %s %r' % (kind, path)
 
227
        if kind == 'file':
 
228
            diff_file(DEVNULL,
 
229
                      [],
 
230
                      new_label + path,
 
231
                      new_tree.get_file(file_id).readlines(),
 
232
                      to_file)
 
233
 
 
234
    for old_path, new_path, file_id, kind, text_modified in delta.renamed:
 
235
        print >>to_file, '*** renamed %s %r => %r' % (kind, old_path, new_path)
 
236
        if text_modified:
 
237
            diff_file(old_label + old_path,
 
238
                      old_tree.get_file(file_id).readlines(),
 
239
                      new_label + new_path,
 
240
                      new_tree.get_file(file_id).readlines(),
 
241
                      to_file)
 
242
 
 
243
    for path, file_id, kind in delta.modified:
 
244
        print >>to_file, '*** modified %s %r' % (kind, path)
 
245
        if kind == 'file':
 
246
            diff_file(old_label + path,
 
247
                      old_tree.get_file(file_id).readlines(),
 
248
                      new_label + path,
 
249
                      new_tree.get_file(file_id).readlines(),
 
250
                      to_file)
 
251
 
 
252
 
 
253
 
 
254
class TreeDelta(object):
250
255
    """Describes changes from one tree to another.
251
256
 
252
257
    Contains four lists:
253
258
 
254
259
    added
255
 
        (path, id)
 
260
        (path, id, kind)
256
261
    removed
257
 
        (path, id)
 
262
        (path, id, kind)
258
263
    renamed
259
 
        (oldpath, newpath, id, text_modified)
 
264
        (oldpath, newpath, id, kind, text_modified)
260
265
    modified
261
 
        (path, id)
 
266
        (path, id, kind)
262
267
    unchanged
263
 
        (path, id)
 
268
        (path, id, kind)
264
269
 
265
270
    Each id is listed only once.
266
271
 
267
272
    Files that are both modified and renamed are listed only in
268
273
    renamed, with the text_modified flag true.
269
274
 
 
275
    Files are only considered renamed if their name has changed or
 
276
    their parent directory has changed.  Renaming a directory
 
277
    does not count as renaming all its contents.
 
278
 
270
279
    The lists are normally sorted when the delta is created.
271
280
    """
272
281
    def __init__(self):
276
285
        self.modified = []
277
286
        self.unchanged = []
278
287
 
 
288
    def __eq__(self, other):
 
289
        if not isinstance(other, TreeDelta):
 
290
            return False
 
291
        return self.added == other.added \
 
292
               and self.removed == other.removed \
 
293
               and self.renamed == other.renamed \
 
294
               and self.modified == other.modified \
 
295
               and self.unchanged == other.unchanged
 
296
 
 
297
    def __ne__(self, other):
 
298
        return not (self == other)
 
299
 
 
300
    def __repr__(self):
 
301
        return "TreeDelta(added=%r, removed=%r, renamed=%r, modified=%r," \
 
302
            " unchanged=%r)" % (self.added, self.removed, self.renamed,
 
303
            self.modified, self.unchanged)
 
304
 
 
305
    def has_changed(self):
 
306
        changes = len(self.added) + len(self.removed) + len(self.renamed)
 
307
        changes += len(self.modified) 
 
308
        return (changes != 0)
 
309
 
 
310
    def touches_file_id(self, file_id):
 
311
        """Return True if file_id is modified by this delta."""
 
312
        for l in self.added, self.removed, self.modified:
 
313
            for v in l:
 
314
                if v[1] == file_id:
 
315
                    return True
 
316
        for v in self.renamed:
 
317
            if v[2] == file_id:
 
318
                return True
 
319
        return False
 
320
            
 
321
 
279
322
    def show(self, to_file, show_ids=False, show_unchanged=False):
280
323
        def show_list(files):
281
 
            for path, fid in files:
 
324
            for path, fid, kind in files:
 
325
                if kind == 'directory':
 
326
                    path += '/'
 
327
                elif kind == 'symlink':
 
328
                    path += '@'
 
329
                    
282
330
                if show_ids:
283
331
                    print >>to_file, '  %-30s %s' % (path, fid)
284
332
                else:
285
333
                    print >>to_file, ' ', path
286
334
            
287
335
        if self.removed:
288
 
            print >>to_file, 'removed files:'
 
336
            print >>to_file, 'removed:'
289
337
            show_list(self.removed)
290
338
                
291
339
        if self.added:
292
 
            print >>to_file, 'added files:'
 
340
            print >>to_file, 'added:'
293
341
            show_list(self.added)
294
342
 
295
343
        if self.renamed:
296
 
            print >>to_file, 'renamed files:'
297
 
            for oldpath, newpath, fid, text_modified in self.renamed:
 
344
            print >>to_file, 'renamed:'
 
345
            for oldpath, newpath, fid, kind, text_modified in self.renamed:
298
346
                if show_ids:
299
347
                    print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
300
348
                else:
301
349
                    print >>to_file, '  %s => %s' % (oldpath, newpath)
302
350
                    
303
351
        if self.modified:
304
 
            print >>to_file, 'modified files:'
 
352
            print >>to_file, 'modified:'
305
353
            show_list(self.modified)
306
354
            
307
355
        if show_unchanged and self.unchanged:
308
 
            print >>to_file, 'unchanged files:'
 
356
            print >>to_file, 'unchanged:'
309
357
            show_list(self.unchanged)
310
358
 
311
359
 
312
360
 
313
 
def compare_trees(old_tree, new_tree, want_unchanged):
 
361
def compare_trees(old_tree, new_tree, want_unchanged=False, specific_files=None):
 
362
    """Describe changes from one tree to another.
 
363
 
 
364
    Returns a TreeDelta with details of added, modified, renamed, and
 
365
    deleted entries.
 
366
 
 
367
    The root entry is specifically exempt.
 
368
 
 
369
    This only considers versioned files.
 
370
 
 
371
    want_unchanged
 
372
        If true, also list files unchanged from one version to
 
373
        the next.
 
374
 
 
375
    specific_files
 
376
        If true, only check for changes to specified names or
 
377
        files within them.
 
378
    """
 
379
 
 
380
    from osutils import is_inside_any
 
381
    
314
382
    old_inv = old_tree.inventory
315
383
    new_inv = new_tree.inventory
316
384
    delta = TreeDelta()
 
385
    mutter('start compare_trees')
 
386
 
 
387
    # TODO: match for specific files can be rather smarter by finding
 
388
    # the IDs of those files up front and then considering only that.
 
389
 
317
390
    for file_id in old_tree:
318
391
        if file_id in new_tree:
319
 
            old_path = old_inv.id2path(file_id)
320
 
            new_path = new_inv.id2path(file_id)
321
 
 
322
392
            kind = old_inv.get_file_kind(file_id)
 
393
            assert kind == new_inv.get_file_kind(file_id)
 
394
            
323
395
            assert kind in ('file', 'directory', 'symlink', 'root_directory'), \
324
396
                   'invalid file kind %r' % kind
 
397
 
 
398
            if kind == 'root_directory':
 
399
                continue
 
400
            
 
401
            old_path = old_inv.id2path(file_id)
 
402
            new_path = new_inv.id2path(file_id)
 
403
 
 
404
            old_ie = old_inv[file_id]
 
405
            new_ie = new_inv[file_id]
 
406
 
 
407
            if specific_files:
 
408
                if (not is_inside_any(specific_files, old_path) 
 
409
                    and not is_inside_any(specific_files, new_path)):
 
410
                    continue
 
411
 
325
412
            if kind == 'file':
326
413
                old_sha1 = old_tree.get_file_sha1(file_id)
327
414
                new_sha1 = new_tree.get_file_sha1(file_id)
335
422
            # the same and the parents are unchanged all the way up.
336
423
            # May not be worthwhile.
337
424
            
338
 
            if old_path != new_path:
339
 
                delta.renamed.append((old_path, new_path, file_id, text_modified))
 
425
            if (old_ie.name != new_ie.name
 
426
                or old_ie.parent_id != new_ie.parent_id):
 
427
                delta.renamed.append((old_path, new_path, file_id, kind,
 
428
                                      text_modified))
340
429
            elif text_modified:
341
 
                delta.modified.append((new_path, file_id))
 
430
                delta.modified.append((new_path, file_id, kind))
342
431
            elif want_unchanged:
343
 
                delta.unchanged.append((new_path, file_id))
 
432
                delta.unchanged.append((new_path, file_id, kind))
344
433
        else:
345
 
            delta.removed.append((old_inv.id2path(file_id), file_id))
 
434
            kind = old_inv.get_file_kind(file_id)
 
435
            old_path = old_inv.id2path(file_id)
 
436
            if specific_files:
 
437
                if not is_inside_any(specific_files, old_path):
 
438
                    continue
 
439
            delta.removed.append((old_path, file_id, kind))
 
440
 
 
441
    mutter('start looking for new files')
346
442
    for file_id in new_inv:
347
443
        if file_id in old_inv:
348
444
            continue
349
 
        delta.added.append((new_inv.id2path(file_id), file_id))
 
445
        new_path = new_inv.id2path(file_id)
 
446
        if specific_files:
 
447
            if not is_inside_any(specific_files, new_path):
 
448
                continue
 
449
        kind = new_inv.get_file_kind(file_id)
 
450
        delta.added.append((new_path, file_id, kind))
350
451
            
351
452
    delta.removed.sort()
352
453
    delta.added.sort()
353
454
    delta.renamed.sort()
354
455
    delta.modified.sort()
 
456
    delta.unchanged.sort()
355
457
 
356
458
    return delta