/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 bzrlib/diff.py

More work on roundtrip push support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#! /usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
3
 
 
4
 
# This program is free software; you can redistribute it and/or modify
5
 
# it under the terms of the GNU General Public License as published by
6
 
# the Free Software Foundation; either version 2 of the License, or
7
 
# (at your option) any later version.
8
 
 
9
 
# This program is distributed in the hope that it will be useful,
10
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
# GNU General Public License for more details.
13
 
 
14
 
# You should have received a copy of the GNU General Public License
15
 
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 
18
 
from trace import mutter
19
 
from errors import BzrError
20
 
 
21
 
 
22
 
 
23
 
def _diff_one(oldlines, newlines, to_file, **kw):
24
 
    import difflib
25
 
    
26
 
    # FIXME: difflib is wrong if there is no trailing newline.
27
 
    # The syntax used by patch seems to be "\ No newline at
28
 
    # end of file" following the last diff line from that
29
 
    # file.  This is not trivial to insert into the
30
 
    # unified_diff output and it might be better to just fix
31
 
    # or replace that function.
32
 
 
33
 
    # In the meantime we at least make sure the patch isn't
34
 
    # mangled.
35
 
 
36
 
 
37
 
    # Special workaround for Python2.3, where difflib fails if
38
 
    # both sequences are empty.
39
 
    if not oldlines and not newlines:
40
 
        return
41
 
 
42
 
    nonl = False
43
 
 
44
 
    if oldlines and (oldlines[-1][-1] != '\n'):
45
 
        oldlines[-1] += '\n'
46
 
        nonl = True
47
 
    if newlines and (newlines[-1][-1] != '\n'):
48
 
        newlines[-1] += '\n'
49
 
        nonl = True
50
 
 
51
 
    ud = difflib.unified_diff(oldlines, newlines, **kw)
52
 
 
53
 
    # work-around for difflib being too smart for its own good
54
 
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
55
 
    if not oldlines:
56
 
        ud = list(ud)
57
 
        ud[2] = ud[2].replace('-1,0', '-0,0')
58
 
    elif not newlines:
59
 
        ud = list(ud)
60
 
        ud[2] = ud[2].replace('+1,0', '+0,0')
61
 
 
62
 
    to_file.writelines(ud)
63
 
    if nonl:
64
 
        print >>to_file, "\\ No newline at end of file"
65
 
    print >>to_file
66
 
 
67
 
 
68
 
def show_diff(b, revision, specific_files):
69
 
    import sys
70
 
 
71
 
    if revision == None:
72
 
        old_tree = b.basis_tree()
73
 
    else:
74
 
        old_tree = b.revision_tree(b.lookup_revision(revision))
75
 
        
76
 
    new_tree = b.working_tree()
77
 
 
78
 
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
79
 
    old_label = ''
80
 
    new_label = ''
81
 
 
82
 
    DEVNULL = '/dev/null'
83
 
    # Windows users, don't panic about this filename -- it is a
84
 
    # special signal to GNU patch that the file should be created or
85
 
    # deleted respectively.
86
 
 
87
 
    # TODO: Generation of pseudo-diffs for added/deleted files could
88
 
    # be usefully made into a much faster special case.
89
 
 
90
 
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
91
 
                          specific_files=specific_files)
92
 
 
93
 
    for path, file_id, kind in delta.removed:
94
 
        print '*** removed %s %r' % (kind, path)
95
 
        if kind == 'file':
96
 
            _diff_one(old_tree.get_file(file_id).readlines(),
97
 
                   [],
98
 
                   sys.stdout,
99
 
                   fromfile=old_label + path,
100
 
                   tofile=DEVNULL)
101
 
 
102
 
    for path, file_id, kind in delta.added:
103
 
        print '*** added %s %r' % (kind, path)
104
 
        if kind == 'file':
105
 
            _diff_one([],
106
 
                   new_tree.get_file(file_id).readlines(),
107
 
                   sys.stdout,
108
 
                   fromfile=DEVNULL,
109
 
                   tofile=new_label + path)
110
 
 
111
 
    for old_path, new_path, file_id, kind, text_modified in delta.renamed:
112
 
        print '*** renamed %s %r => %r' % (kind, old_path, new_path)
113
 
        if text_modified:
114
 
            _diff_one(old_tree.get_file(file_id).readlines(),
115
 
                   new_tree.get_file(file_id).readlines(),
116
 
                   sys.stdout,
117
 
                   fromfile=old_label + old_path,
118
 
                   tofile=new_label + new_path)
119
 
 
120
 
    for path, file_id, kind in delta.modified:
121
 
        print '*** modified %s %r' % (kind, path)
122
 
        if kind == 'file':
123
 
            _diff_one(old_tree.get_file(file_id).readlines(),
124
 
                   new_tree.get_file(file_id).readlines(),
125
 
                   sys.stdout,
126
 
                   fromfile=old_label + path,
127
 
                   tofile=new_label + path)
128
 
 
129
 
 
130
 
 
131
 
class TreeDelta:
132
 
    """Describes changes from one tree to another.
133
 
 
134
 
    Contains four lists:
135
 
 
136
 
    added
137
 
        (path, id, kind)
138
 
    removed
139
 
        (path, id, kind)
140
 
    renamed
141
 
        (oldpath, newpath, id, kind, text_modified)
142
 
    modified
143
 
        (path, id, kind)
144
 
    unchanged
145
 
        (path, id, kind)
146
 
 
147
 
    Each id is listed only once.
148
 
 
149
 
    Files that are both modified and renamed are listed only in
150
 
    renamed, with the text_modified flag true.
151
 
 
152
 
    The lists are normally sorted when the delta is created.
153
 
    """
154
 
    def __init__(self):
155
 
        self.added = []
156
 
        self.removed = []
157
 
        self.renamed = []
158
 
        self.modified = []
159
 
        self.unchanged = []
160
 
 
161
 
 
162
 
    def touches_file_id(self, file_id):
163
 
        """Return True if file_id is modified by this delta."""
164
 
        for l in self.added, self.removed, self.modified:
165
 
            for v in l:
166
 
                if v[1] == file_id:
167
 
                    return True
168
 
        for v in self.renamed:
169
 
            if v[2] == file_id:
170
 
                return True
171
 
        return False
172
 
            
173
 
 
174
 
    def show(self, to_file, show_ids=False, show_unchanged=False):
175
 
        def show_list(files):
176
 
            for path, fid, kind in files:
177
 
                if kind == 'directory':
178
 
                    path += '/'
179
 
                elif kind == 'symlink':
180
 
                    path += '@'
181
 
                    
182
 
                if show_ids:
183
 
                    print >>to_file, '  %-30s %s' % (path, fid)
184
 
                else:
185
 
                    print >>to_file, ' ', path
186
 
            
187
 
        if self.removed:
188
 
            print >>to_file, 'removed:'
189
 
            show_list(self.removed)
190
 
                
191
 
        if self.added:
192
 
            print >>to_file, 'added:'
193
 
            show_list(self.added)
194
 
 
195
 
        if self.renamed:
196
 
            print >>to_file, 'renamed:'
197
 
            for oldpath, newpath, fid, kind, text_modified in self.renamed:
198
 
                if show_ids:
199
 
                    print >>to_file, '  %s => %s %s' % (oldpath, newpath, fid)
200
 
                else:
201
 
                    print >>to_file, '  %s => %s' % (oldpath, newpath)
202
 
                    
203
 
        if self.modified:
204
 
            print >>to_file, 'modified:'
205
 
            show_list(self.modified)
206
 
            
207
 
        if show_unchanged and self.unchanged:
208
 
            print >>to_file, 'unchanged:'
209
 
            show_list(self.unchanged)
210
 
 
211
 
 
212
 
 
213
 
def compare_trees(old_tree, new_tree, want_unchanged, specific_files=None):
214
 
    """Describe changes from one tree to another.
215
 
 
216
 
    Returns a TreeDelta with details of added, modified, renamed, and
217
 
    deleted entries.
218
 
 
219
 
    The root entry is specifically exempt.
220
 
 
221
 
    This only considers versioned files.
222
 
 
223
 
    want_unchanged
224
 
        If true, also list files unchanged from one version to
225
 
        the next.
226
 
 
227
 
    specific_files
228
 
        If true, only check for changes to specified names or
229
 
        files within them.
230
 
    """
231
 
 
232
 
    from osutils import is_inside_any
233
 
    
234
 
    old_inv = old_tree.inventory
235
 
    new_inv = new_tree.inventory
236
 
    delta = TreeDelta()
237
 
    mutter('start compare_trees')
238
 
 
239
 
    # TODO: match for specific files can be rather smarter by finding
240
 
    # the IDs of those files up front and then considering only that.
241
 
 
242
 
    for file_id in old_tree:
243
 
        if file_id in new_tree:
244
 
            kind = old_inv.get_file_kind(file_id)
245
 
            assert kind == new_inv.get_file_kind(file_id)
246
 
            
247
 
            assert kind in ('file', 'directory', 'symlink', 'root_directory'), \
248
 
                   'invalid file kind %r' % kind
249
 
 
250
 
            if kind == 'root_directory':
251
 
                continue
252
 
            
253
 
            old_path = old_inv.id2path(file_id)
254
 
            new_path = new_inv.id2path(file_id)
255
 
 
256
 
            if specific_files:
257
 
                if (not is_inside_any(specific_files, old_path) 
258
 
                    and not is_inside_any(specific_files, new_path)):
259
 
                    continue
260
 
 
261
 
            if kind == 'file':
262
 
                old_sha1 = old_tree.get_file_sha1(file_id)
263
 
                new_sha1 = new_tree.get_file_sha1(file_id)
264
 
                text_modified = (old_sha1 != new_sha1)
265
 
            else:
266
 
                ## mutter("no text to check for %r %r" % (file_id, kind))
267
 
                text_modified = False
268
 
 
269
 
            # TODO: Can possibly avoid calculating path strings if the
270
 
            # two files are unchanged and their names and parents are
271
 
            # the same and the parents are unchanged all the way up.
272
 
            # May not be worthwhile.
273
 
            
274
 
            if old_path != new_path:
275
 
                delta.renamed.append((old_path, new_path, file_id, kind,
276
 
                                      text_modified))
277
 
            elif text_modified:
278
 
                delta.modified.append((new_path, file_id, kind))
279
 
            elif want_unchanged:
280
 
                delta.unchanged.append((new_path, file_id, kind))
281
 
        else:
282
 
            old_path = old_inv.id2path(file_id)
283
 
            if specific_files:
284
 
                if not is_inside_any(specific_files, old_path):
285
 
                    continue
286
 
            delta.removed.append((old_path, file_id, kind))
287
 
 
288
 
    mutter('start looking for new files')
289
 
    for file_id in new_inv:
290
 
        if file_id in old_inv:
291
 
            continue
292
 
        new_path = new_inv.id2path(file_id)
293
 
        if specific_files:
294
 
            if not is_inside_any(specific_files, new_path):
295
 
                continue
296
 
        kind = new_inv.get_file_kind(file_id)
297
 
        delta.added.append((new_path, file_id, kind))
298
 
            
299
 
    delta.removed.sort()
300
 
    delta.added.sort()
301
 
    delta.renamed.sort()
302
 
    delta.modified.sort()
303
 
    delta.unchanged.sort()
304
 
 
305
 
    return delta