~bzr-pqm/bzr/bzr.dev

1658.1.9 by Martin Pool
Give an error for bzr diff on an nonexistent file (Malone #3619)
1
# Copyright (C) 2004, 2005, 2006 Canonical Ltd.
1711.2.54 by John Arbash Meinel
Use mkstemp instead of NamedTemporary file for external diff.
2
#
1 by mbp at sourcefrog
import from baz patch-364
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
1711.2.54 by John Arbash Meinel
Use mkstemp instead of NamedTemporary file for external diff.
7
#
1 by mbp at sourcefrog
import from baz patch-364
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
# GNU General Public License for more details.
1711.2.54 by John Arbash Meinel
Use mkstemp instead of NamedTemporary file for external diff.
12
#
1 by mbp at sourcefrog
import from baz patch-364
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
2520.4.140 by Aaron Bentley
Use matching blocks from mpdiff for knit delta creation
17
import difflib
1711.2.54 by John Arbash Meinel
Use mkstemp instead of NamedTemporary file for external diff.
18
import os
1899.1.5 by John Arbash Meinel
Always buffer the output of diff, so we can check if retcode==2 is because of Binary files
19
import re
3123.6.2 by Aaron Bentley
Implement diff --using natively
20
import shutil
1996.3.9 by John Arbash Meinel
lazy_import diff.py
21
import sys
22
23
from bzrlib.lazy_import import lazy_import
24
lazy_import(globals(), """
25
import errno
1692.8.7 by James Henstridge
changes suggested by John Meinel
26
import subprocess
1711.2.54 by John Arbash Meinel
Use mkstemp instead of NamedTemporary file for external diff.
27
import tempfile
1740.2.5 by Aaron Bentley
Merge from bzr.dev
28
import time
29
1955.2.10 by John Arbash Meinel
Unset a few other LANG type variables when spawning diff
30
from bzrlib import (
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
31
    bzrdir,
3123.6.2 by Aaron Bentley
Implement diff --using natively
32
    commands,
1955.2.10 by John Arbash Meinel
Unset a few other LANG type variables when spawning diff
33
    errors,
34
    osutils,
1996.3.9 by John Arbash Meinel
lazy_import diff.py
35
    patiencediff,
36
    textfile,
1551.12.29 by Aaron Bentley
Copy and extend patch date formatting code, add patch-date parsing
37
    timestamp,
1955.2.10 by John Arbash Meinel
Unset a few other LANG type variables when spawning diff
38
    )
1996.3.9 by John Arbash Meinel
lazy_import diff.py
39
""")
40
41
from bzrlib.symbol_versioning import (
42
        deprecated_function,
3123.1.1 by John Arbash Meinel
Update from deprecating 0.93 to 1.0, and add a 1.1 deprecation.
43
        one_zero,
3268.1.1 by C Miller
Describe the property changes in diffs. Currently, this is the executable-bit
44
        one_three
1996.3.9 by John Arbash Meinel
lazy_import diff.py
45
        )
1711.2.54 by John Arbash Meinel
Use mkstemp instead of NamedTemporary file for external diff.
46
from bzrlib.trace import mutter, warning
1 by mbp at sourcefrog
import from baz patch-364
47
1711.2.24 by John Arbash Meinel
Late bind to PatienceSequenceMatcher to allow plugin to override.
48
767 by Martin Pool
- files are only reported as modified if their name or parent has changed,
49
# TODO: Rather than building a changeset object, we should probably
50
# invoke callbacks on an object.  That object can either accumulate a
51
# list, write them out directly, etc etc.
52
2520.4.140 by Aaron Bentley
Use matching blocks from mpdiff for knit delta creation
53
54
class _PrematchedMatcher(difflib.SequenceMatcher):
55
    """Allow SequenceMatcher operations to use predetermined blocks"""
56
57
    def __init__(self, matching_blocks):
58
        difflib.SequenceMatcher(self, None, None)
59
        self.matching_blocks = matching_blocks
60
        self.opcodes = None
61
62
1558.15.11 by Aaron Bentley
Apply merge review suggestions
63
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
1711.2.30 by John Arbash Meinel
Fix bug in internal_diff handling of unicode paths
64
                  allow_binary=False, sequence_matcher=None,
65
                  path_encoding='utf8'):
475 by Martin Pool
- rewrite diff using compare_trees()
66
    # FIXME: difflib is wrong if there is no trailing newline.
67
    # The syntax used by patch seems to be "\ No newline at
68
    # end of file" following the last diff line from that
69
    # file.  This is not trivial to insert into the
70
    # unified_diff output and it might be better to just fix
71
    # or replace that function.
72
73
    # In the meantime we at least make sure the patch isn't
74
    # mangled.
75
76
77
    # Special workaround for Python2.3, where difflib fails if
78
    # both sequences are empty.
79
    if not oldlines and not newlines:
80
        return
1558.15.2 by Aaron Bentley
Implemented binary file handling for diff
81
    
1558.15.11 by Aaron Bentley
Apply merge review suggestions
82
    if allow_binary is False:
1996.3.9 by John Arbash Meinel
lazy_import diff.py
83
        textfile.check_text_lines(oldlines)
84
        textfile.check_text_lines(newlines)
475 by Martin Pool
- rewrite diff using compare_trees()
85
1185.81.8 by John Arbash Meinel
Updating unified_diff to take a factory, using the new diff algorithm in the code.
86
    if sequence_matcher is None:
1996.3.9 by John Arbash Meinel
lazy_import diff.py
87
        sequence_matcher = patiencediff.PatienceSequenceMatcher
88
    ud = patiencediff.unified_diff(oldlines, newlines,
1740.2.5 by Aaron Bentley
Merge from bzr.dev
89
                      fromfile=old_filename.encode(path_encoding),
90
                      tofile=new_filename.encode(path_encoding),
1185.81.8 by John Arbash Meinel
Updating unified_diff to take a factory, using the new diff algorithm in the code.
91
                      sequencematcher=sequence_matcher)
475 by Martin Pool
- rewrite diff using compare_trees()
92
1092.1.50 by Robert Collins
make diff lsdiff/filterdiff friendly
93
    ud = list(ud)
3085.1.1 by John Arbash Meinel
Fix internal_diff to not fail when the texts are identical.
94
    if len(ud) == 0: # Identical contents, nothing to do
95
        return
475 by Martin Pool
- rewrite diff using compare_trees()
96
    # work-around for difflib being too smart for its own good
97
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
98
    if not oldlines:
99
        ud[2] = ud[2].replace('-1,0', '-0,0')
100
    elif not newlines:
101
        ud[2] = ud[2].replace('+1,0', '+0,0')
1092.1.50 by Robert Collins
make diff lsdiff/filterdiff friendly
102
    # work around for difflib emitting random spaces after the label
103
    ud[0] = ud[0][:-2] + '\n'
104
    ud[1] = ud[1][:-2] + '\n'
475 by Martin Pool
- rewrite diff using compare_trees()
105
804 by Martin Pool
Patch from John:
106
    for line in ud:
107
        to_file.write(line)
974.1.5 by Aaron Bentley
Fixed handling of missing newlines in udiffs
108
        if not line.endswith('\n'):
109
            to_file.write("\n\\ No newline at end of file\n")
2911.6.1 by Blake Winton
Change 'print >> f,'s to 'f.write('s.
110
    to_file.write('\n')
475 by Martin Pool
- rewrite diff using compare_trees()
111
112
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
113
def _spawn_external_diff(diffcmd, capture_errors=True):
114
    """Spawn the externall diff process, and return the child handle.
115
116
    :param diffcmd: The command list to spawn
2138.1.1 by Wouter van Heyst
Robuster external diff output handling.
117
    :param capture_errors: Capture stderr as well as setting LANG=C
118
        and LC_ALL=C. This lets us read and understand the output of diff,
119
        and respond to any errors.
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
120
    :return: A Popen object.
121
    """
122
    if capture_errors:
2321.2.2 by Alexander Belchenko
win32 fixes for test_external_diff_binary (gettext on win32 rely on $LANGUAGE)
123
        # construct minimal environment
124
        env = {}
125
        path = os.environ.get('PATH')
126
        if path is not None:
127
            env['PATH'] = path
2321.2.5 by Alexander Belchenko
external diff: no need for special code path for win32 (suggested by John Meinel)
128
        env['LANGUAGE'] = 'C'   # on win32 only LANGUAGE has effect
129
        env['LANG'] = 'C'
130
        env['LC_ALL'] = 'C'
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
131
        stderr = subprocess.PIPE
132
    else:
2321.2.2 by Alexander Belchenko
win32 fixes for test_external_diff_binary (gettext on win32 rely on $LANGUAGE)
133
        env = None
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
134
        stderr = None
135
136
    try:
137
        pipe = subprocess.Popen(diffcmd,
138
                                stdin=subprocess.PIPE,
139
                                stdout=subprocess.PIPE,
140
                                stderr=stderr,
2321.2.2 by Alexander Belchenko
win32 fixes for test_external_diff_binary (gettext on win32 rely on $LANGUAGE)
141
                                env=env)
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
142
    except OSError, e:
143
        if e.errno == errno.ENOENT:
144
            raise errors.NoDiff(str(e))
145
        raise
146
147
    return pipe
148
149
1185.35.29 by Aaron Bentley
Support whitespace in diff filenames
150
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
571 by Martin Pool
- new --diff-options to pass options through to external
151
                  diff_opts):
568 by Martin Pool
- start adding support for showing diffs by calling out to
152
    """Display a diff by calling out to the external diff program."""
581 by Martin Pool
- make sure any bzr output is flushed before
153
    # make sure our own output is properly ordered before the diff
154
    to_file.flush()
155
1711.2.54 by John Arbash Meinel
Use mkstemp instead of NamedTemporary file for external diff.
156
    oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
157
    newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
158
    oldtmpf = os.fdopen(oldtmp_fd, 'wb')
159
    newtmpf = os.fdopen(newtmp_fd, 'wb')
568 by Martin Pool
- start adding support for showing diffs by calling out to
160
161
    try:
162
        # TODO: perhaps a special case for comparing to or from the empty
163
        # sequence; can just use /dev/null on Unix
164
165
        # TODO: if either of the files being compared already exists as a
166
        # regular named file (e.g. in the working directory) then we can
167
        # compare directly to that, rather than copying it.
168
169
        oldtmpf.writelines(oldlines)
170
        newtmpf.writelines(newlines)
171
1711.2.54 by John Arbash Meinel
Use mkstemp instead of NamedTemporary file for external diff.
172
        oldtmpf.close()
173
        newtmpf.close()
568 by Martin Pool
- start adding support for showing diffs by calling out to
174
571 by Martin Pool
- new --diff-options to pass options through to external
175
        if not diff_opts:
176
            diff_opts = []
177
        diffcmd = ['diff',
1740.2.5 by Aaron Bentley
Merge from bzr.dev
178
                   '--label', old_filename,
1711.2.54 by John Arbash Meinel
Use mkstemp instead of NamedTemporary file for external diff.
179
                   old_abspath,
1740.2.5 by Aaron Bentley
Merge from bzr.dev
180
                   '--label', new_filename,
1711.2.56 by John Arbash Meinel
Raise NoDiff if 'diff' not present.
181
                   new_abspath,
182
                   '--binary',
183
                  ]
571 by Martin Pool
- new --diff-options to pass options through to external
184
185
        # diff only allows one style to be specified; they don't override.
186
        # note that some of these take optargs, and the optargs can be
187
        # directly appended to the options.
188
        # this is only an approximate parser; it doesn't properly understand
189
        # the grammar.
190
        for s in ['-c', '-u', '-C', '-U',
191
                  '-e', '--ed',
192
                  '-q', '--brief',
193
                  '--normal',
194
                  '-n', '--rcs',
195
                  '-y', '--side-by-side',
196
                  '-D', '--ifdef']:
197
            for j in diff_opts:
198
                if j.startswith(s):
199
                    break
200
            else:
201
                continue
202
            break
203
        else:
204
            diffcmd.append('-u')
205
                  
206
        if diff_opts:
207
            diffcmd.extend(diff_opts)
208
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
209
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
210
        out,err = pipe.communicate()
211
        rc = pipe.returncode
571 by Martin Pool
- new --diff-options to pass options through to external
212
        
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
213
        # internal_diff() adds a trailing newline, add one here for consistency
214
        out += '\n'
1899.1.5 by John Arbash Meinel
Always buffer the output of diff, so we can check if retcode==2 is because of Binary files
215
        if rc == 2:
216
            # 'diff' gives retcode == 2 for all sorts of errors
217
            # one of those is 'Binary files differ'.
218
            # Bad options could also be the problem.
1904.1.4 by Marien Zwart
Make external diff in binary mode work with recent versions of diffutils.
219
            # 'Binary files' is not a real error, so we suppress that error.
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
220
            lang_c_out = out
221
222
            # Since we got here, we want to make sure to give an i18n error
223
            pipe = _spawn_external_diff(diffcmd, capture_errors=False)
224
            out, err = pipe.communicate()
225
226
            # Write out the new i18n diff response
227
            to_file.write(out+'\n')
228
            if pipe.returncode != 2:
1996.3.9 by John Arbash Meinel
lazy_import diff.py
229
                raise errors.BzrError(
230
                               'external diff failed with exit code 2'
2138.1.1 by Wouter van Heyst
Robuster external diff output handling.
231
                               ' when run with LANG=C and LC_ALL=C,'
232
                               ' but not when run natively: %r' % (diffcmd,))
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
233
234
            first_line = lang_c_out.split('\n', 1)[0]
1904.1.4 by Marien Zwart
Make external diff in binary mode work with recent versions of diffutils.
235
            # Starting with diffutils 2.8.4 the word "binary" was dropped.
236
            m = re.match('^(binary )?files.*differ$', first_line, re.I)
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
237
            if m is None:
1996.3.9 by John Arbash Meinel
lazy_import diff.py
238
                raise errors.BzrError('external diff failed with exit code 2;'
239
                                      ' command: %r' % (diffcmd,))
1920.1.1 by John Arbash Meinel
fix bug #56307, handle binary files even when LANG is not english
240
            else:
241
                # Binary files differ, just return
242
                return
243
244
        # If we got to here, we haven't written out the output of diff
245
        # do so now
246
        to_file.write(out)
247
        if rc not in (0, 1):
571 by Martin Pool
- new --diff-options to pass options through to external
248
            # returns 1 if files differ; that's OK
249
            if rc < 0:
250
                msg = 'signal %d' % (-rc)
251
            else:
252
                msg = 'exit code %d' % rc
253
                
1996.3.9 by John Arbash Meinel
lazy_import diff.py
254
            raise errors.BzrError('external diff failed with %s; command: %r' 
255
                                  % (rc, diffcmd))
1899.1.6 by John Arbash Meinel
internal_diff always adds a trailing \n, make sure external_diff does too
256
257
568 by Martin Pool
- start adding support for showing diffs by calling out to
258
    finally:
259
        oldtmpf.close()                 # and delete
260
        newtmpf.close()
1711.2.54 by John Arbash Meinel
Use mkstemp instead of NamedTemporary file for external diff.
261
        # Clean up. Warn in case the files couldn't be deleted
262
        # (in case windows still holds the file open, but not
263
        # if the files have already been deleted)
264
        try:
265
            os.remove(old_abspath)
266
        except OSError, e:
267
            if e.errno not in (errno.ENOENT,):
268
                warning('Failed to delete temporary file: %s %s',
269
                        old_abspath, e)
270
        try:
271
            os.remove(new_abspath)
272
        except OSError:
273
            if e.errno not in (errno.ENOENT,):
274
                warning('Failed to delete temporary file: %s %s',
275
                        new_abspath, e)
568 by Martin Pool
- start adding support for showing diffs by calling out to
276
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
277
3123.1.1 by John Arbash Meinel
Update from deprecating 0.93 to 1.0, and add a 1.1 deprecation.
278
@deprecated_function(one_zero)
1551.2.15 by Aaron Bentley
Rename cmd_show_diff to diff_cmd_helper
279
def diff_cmd_helper(tree, specific_files, external_diff_options, 
1684.1.6 by Martin Pool
(patch) --diff-prefix option (goffredo, alexander)
280
                    old_revision_spec=None, new_revision_spec=None,
2197.2.1 by Martin Pool
Refactor cmd_diff
281
                    revision_specs=None,
1684.1.6 by Martin Pool
(patch) --diff-prefix option (goffredo, alexander)
282
                    old_label='a/', new_label='b/'):
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
283
    """Helper for cmd_diff.
284
2197.2.1 by Martin Pool
Refactor cmd_diff
285
    :param tree:
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
286
        A WorkingTree
287
2197.2.1 by Martin Pool
Refactor cmd_diff
288
    :param specific_files:
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
289
        The specific files to compare, or None
290
2197.2.1 by Martin Pool
Refactor cmd_diff
291
    :param external_diff_options:
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
292
        If non-None, run an external diff, and pass it these options
293
2197.2.1 by Martin Pool
Refactor cmd_diff
294
    :param old_revision_spec:
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
295
        If None, use basis tree as old revision, otherwise use the tree for
296
        the specified revision. 
297
2197.2.1 by Martin Pool
Refactor cmd_diff
298
    :param new_revision_spec:
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
299
        If None, use working tree as new revision, otherwise use the tree for
300
        the specified revision.
301
    
2197.2.1 by Martin Pool
Refactor cmd_diff
302
    :param revision_specs: 
303
        Zero, one or two RevisionSpecs from the command line, saying what revisions 
304
        to compare.  This can be passed as an alternative to the old_revision_spec 
305
        and new_revision_spec parameters.
306
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
307
    The more general form is show_diff_trees(), where the caller
308
    supplies any two trees.
309
    """
2197.2.2 by Martin Pool
merge bzr.dev, reconcile with option changes
310
311
    # TODO: perhaps remove the old parameters old_revision_spec and
312
    # new_revision_spec, since this is only really for use from cmd_diff and
313
    # it now always passes through a sequence of revision_specs -- mbp
314
    # 20061221
315
1551.2.14 by Aaron Bentley
Updated argument names, DRY fixes.
316
    def spec_tree(spec):
1732.3.1 by Matthieu Moy
Implementation of -r revno:N:/path/to/branch
317
        if tree:
3298.2.18 by Aaron Bentley
Restore original diff revision spec handling
318
            revision = spec.in_store(tree.branch)
1732.3.1 by Matthieu Moy
Implementation of -r revno:N:/path/to/branch
319
        else:
3298.2.18 by Aaron Bentley
Restore original diff revision spec handling
320
            revision = spec.in_store(None)
1732.3.1 by Matthieu Moy
Implementation of -r revno:N:/path/to/branch
321
        revision_id = revision.rev_id
322
        branch = revision.branch
323
        return branch.repository.revision_tree(revision_id)
2197.2.1 by Martin Pool
Refactor cmd_diff
324
325
    if revision_specs is not None:
326
        if len(revision_specs) > 0:
327
            old_revision_spec = revision_specs[0]
328
        if len(revision_specs) > 1:
329
            new_revision_spec = revision_specs[1]
330
1551.2.14 by Aaron Bentley
Updated argument names, DRY fixes.
331
    if old_revision_spec is None:
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
332
        old_tree = tree.basis_tree()
333
    else:
1551.2.14 by Aaron Bentley
Updated argument names, DRY fixes.
334
        old_tree = spec_tree(old_revision_spec)
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
335
2197.2.1 by Martin Pool
Refactor cmd_diff
336
    if (new_revision_spec is None
337
        or new_revision_spec.spec is None):
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
338
        new_tree = tree
339
    else:
1551.2.14 by Aaron Bentley
Updated argument names, DRY fixes.
340
        new_tree = spec_tree(new_revision_spec)
2197.2.1 by Martin Pool
Refactor cmd_diff
341
1551.7.19 by Aaron Bentley
Always include working tree when calculating file ids for diff
342
    if new_tree is not tree:
343
        extra_trees = (tree,)
344
    else:
345
        extra_trees = None
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
346
1551.2.14 by Aaron Bentley
Updated argument names, DRY fixes.
347
    return show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
1684.1.6 by Martin Pool
(patch) --diff-prefix option (goffredo, alexander)
348
                           external_diff_options,
1551.7.19 by Aaron Bentley
Always include working tree when calculating file ids for diff
349
                           old_label=old_label, new_label=new_label,
350
                           extra_trees=extra_trees)
1551.2.13 by Aaron Bentley
Got diff working properly with checkouts
351
571 by Martin Pool
- new --diff-options to pass options through to external
352
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
353
def _get_trees_to_diff(path_list, revision_specs, old_url, new_url):
354
    """Get the trees and specific files to diff given a list of paths.
355
356
    This method works out the trees to be diff'ed and the files of
357
    interest within those trees.
358
359
    :param path_list:
360
        the list of arguments passed to the diff command
361
    :param revision_specs:
362
        Zero, one or two RevisionSpecs from the diff command line,
363
        saying what revisions to compare.
364
    :param old_url:
365
        The url of the old branch or tree. If None, the tree to use is
366
        taken from the first path, if any, or the current working tree.
367
    :param new_url:
368
        The url of the new branch or tree. If None, the tree to use is
369
        taken from the first path, if any, or the current working tree.
370
    :returns:
371
        a tuple of (old_tree, new_tree, specific_files, extra_trees) where
372
        extra_trees is a sequence of additional trees to search in for
373
        file-ids.
374
    """
375
    # Get the old and new revision specs
376
    old_revision_spec = None
377
    new_revision_spec = None
378
    if revision_specs is not None:
379
        if len(revision_specs) > 0:
380
            old_revision_spec = revision_specs[0]
3072.1.5 by Ian Clatworthy
more good ideas from abentley
381
            if old_url is None:
382
                old_url = old_revision_spec.get_branch()
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
383
        if len(revision_specs) > 1:
384
            new_revision_spec = revision_specs[1]
3072.1.5 by Ian Clatworthy
more good ideas from abentley
385
            if new_url is None:
386
                new_url = new_revision_spec.get_branch()
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
387
3072.1.5 by Ian Clatworthy
more good ideas from abentley
388
    other_paths = []
389
    make_paths_wt_relative = True
3164.1.1 by Ian Clatworthy
diff without arguments means the current tree, not the current directory
390
    consider_relpath = True
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
391
    if path_list is None or len(path_list) == 0:
3164.1.1 by Ian Clatworthy
diff without arguments means the current tree, not the current directory
392
        # If no path is given, the current working tree is used
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
393
        default_location = u'.'
3164.1.1 by Ian Clatworthy
diff without arguments means the current tree, not the current directory
394
        consider_relpath = False
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
395
    elif old_url is not None and new_url is not None:
396
        other_paths = path_list
3072.1.5 by Ian Clatworthy
more good ideas from abentley
397
        make_paths_wt_relative = False
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
398
    else:
399
        default_location = path_list[0]
400
        other_paths = path_list[1:]
401
402
    # Get the old location
3072.1.2 by Ian Clatworthy
Test various --old and --new combinations
403
    specific_files = []
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
404
    if old_url is None:
405
        old_url = default_location
406
    working_tree, branch, relpath = \
407
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
3164.1.1 by Ian Clatworthy
diff without arguments means the current tree, not the current directory
408
    if consider_relpath and relpath != '':
3072.1.2 by Ian Clatworthy
Test various --old and --new combinations
409
        specific_files.append(relpath)
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
410
    old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
411
412
    # Get the new location
413
    if new_url is None:
414
        new_url = default_location
415
    if new_url != old_url:
416
        working_tree, branch, relpath = \
417
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
3164.1.1 by Ian Clatworthy
diff without arguments means the current tree, not the current directory
418
        if consider_relpath and relpath != '':
3072.1.2 by Ian Clatworthy
Test various --old and --new combinations
419
            specific_files.append(relpath)
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
420
    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
421
        basis_is_default=working_tree is None)
422
3072.1.2 by Ian Clatworthy
Test various --old and --new combinations
423
    # Get the specific files (all files is None, no files is [])
3072.1.5 by Ian Clatworthy
more good ideas from abentley
424
    if make_paths_wt_relative and working_tree is not None:
3072.1.2 by Ian Clatworthy
Test various --old and --new combinations
425
        other_paths = _relative_paths_in_tree(working_tree, other_paths)
426
    specific_files.extend(other_paths)
427
    if len(specific_files) == 0:
428
        specific_files = None
429
430
    # Get extra trees that ought to be searched for file-ids
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
431
    extra_trees = None
3072.1.5 by Ian Clatworthy
more good ideas from abentley
432
    if working_tree is not None and working_tree not in (old_tree, new_tree):
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
433
        extra_trees = (working_tree,)
434
    return old_tree, new_tree, specific_files, extra_trees
435
436
437
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
438
    if branch is None and tree is not None:
439
        branch = tree.branch
440
    if spec is None or spec.spec is None:
441
        if basis_is_default:
3072.1.5 by Ian Clatworthy
more good ideas from abentley
442
            if tree is not None:
443
                return tree.basis_tree()
444
            else:
445
                return branch.basis_tree()
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
446
        else:
447
            return tree
448
    revision = spec.in_store(branch)
449
    revision_id = revision.rev_id
450
    rev_branch = revision.branch
451
    return rev_branch.repository.revision_tree(revision_id)
452
453
3072.1.2 by Ian Clatworthy
Test various --old and --new combinations
454
def _relative_paths_in_tree(tree, paths):
455
    """Get the relative paths within a working tree.
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
456
3072.1.6 by Ian Clatworthy
Fix docstring for _relative_paths_in_tree
457
    Each path may be either an absolute path or a path relative to the
458
    current working directory.
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
459
    """
3072.1.2 by Ian Clatworthy
Test various --old and --new combinations
460
    result = []
461
    for filename in paths:
462
        try:
463
            result.append(tree.relpath(osutils.dereference_path(filename)))
464
        except errors.PathNotChild:
465
            raise errors.BzrCommandError("Files are in different branches")
466
    return result
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
467
468
571 by Martin Pool
- new --diff-options to pass options through to external
469
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
1684.1.6 by Martin Pool
(patch) --diff-prefix option (goffredo, alexander)
470
                    external_diff_options=None,
1551.7.17 by Aaron Bentley
Switch to PathsNotVersioned, accept extra_trees
471
                    old_label='a/', new_label='b/',
2598.6.12 by ghigo
Move the encoding of the commit message at the command line level
472
                    extra_trees=None,
3123.6.2 by Aaron Bentley
Implement diff --using natively
473
                    path_encoding='utf8',
474
                    using=None):
550 by Martin Pool
- Refactor diff code into one that works purely on
475
    """Show in text form the changes from one tree to another.
476
3072.1.1 by Ian Clatworthy
Improved diff based on feedback from abentley
477
    to_file
478
        The output stream.
479
480
    specific_files
481
        Include only changes to these files - None for all changes.
571 by Martin Pool
- new --diff-options to pass options through to external
482
483
    external_diff_options
484
        If set, use an external GNU diff and pass these options.
1551.7.18 by Aaron Bentley
Indentation and documentation fixes
485
486
    extra_trees
487
        If set, more Trees to use for looking up file ids
2598.6.12 by ghigo
Move the encoding of the commit message at the command line level
488
489
    path_encoding
2598.6.24 by ghigo
update on the basis of Aaron suggestions
490
        If set, the path will be encoded as specified, otherwise is supposed
491
        to be utf8
550 by Martin Pool
- Refactor diff code into one that works purely on
492
    """
1543.1.1 by Denys Duchier
lock operations for trees - use them for diff
493
    old_tree.lock_read()
494
    try:
2255.7.38 by John Arbash Meinel
show_diff_trees() should lock any extra trees it is passed.
495
        if extra_trees is not None:
496
            for tree in extra_trees:
497
                tree.lock_read()
1543.1.1 by Denys Duchier
lock operations for trees - use them for diff
498
        new_tree.lock_read()
499
        try:
3009.2.22 by Aaron Bentley
Update names & docstring
500
            differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
3123.6.2 by Aaron Bentley
Implement diff --using natively
501
                                                 path_encoding,
502
                                                 external_diff_options,
503
                                                 old_label, new_label, using)
3009.2.12 by Aaron Bentley
Associate labels with text diffing only
504
            return differ.show_diff(specific_files, extra_trees)
1543.1.1 by Denys Duchier
lock operations for trees - use them for diff
505
        finally:
506
            new_tree.unlock()
2255.7.38 by John Arbash Meinel
show_diff_trees() should lock any extra trees it is passed.
507
            if extra_trees is not None:
508
                for tree in extra_trees:
509
                    tree.unlock()
1543.1.1 by Denys Duchier
lock operations for trees - use them for diff
510
    finally:
511
        old_tree.unlock()
512
513
1740.2.5 by Aaron Bentley
Merge from bzr.dev
514
def _patch_header_date(tree, file_id, path):
515
    """Returns a timestamp suitable for use in a patch header."""
2405.1.2 by John Arbash Meinel
Fix bug #103870 by passing None instead of a (sometimes wrong) path
516
    mtime = tree.get_file_mtime(file_id, path)
517
    return timestamp.format_patch_date(mtime)
1740.2.5 by Aaron Bentley
Merge from bzr.dev
518
519
1662.1.9 by Martin Pool
Give a clear error for bzr status of an unversioned, nonexistent file. (Malone #3619)
520
def _raise_if_nonexistent(paths, old_tree, new_tree):
521
    """Complain if paths are not in either inventory or tree.
522
523
    It's OK with the files exist in either tree's inventory, or 
524
    if they exist in the tree but are not versioned.
525
    
526
    This can be used by operations such as bzr status that can accept
527
    unknown or ignored files.
528
    """
529
    mutter("check paths: %r", paths)
530
    if not paths:
531
        return
532
    s = old_tree.filter_unversioned_files(paths)
533
    s = new_tree.filter_unversioned_files(s)
534
    s = [path for path in s if not new_tree.has_filename(path)]
535
    if s:
536
        raise errors.PathsDoNotExist(sorted(s))
537
538
3268.1.1 by C Miller
Describe the property changes in diffs. Currently, this is the executable-bit
539
@deprecated_function(one_three)
1398 by Robert Collins
integrate in Gustavos x-bit patch
540
def get_prop_change(meta_modified):
541
    if meta_modified:
542
        return " (properties changed)"
543
    else:
544
        return  ""
545
3268.1.1 by C Miller
Describe the property changes in diffs. Currently, this is the executable-bit
546
def get_executable_change(old_is_x, new_is_x):
547
    descr = { True:"+x", False:"-x", None:"??" }
548
    if old_is_x != new_is_x:
549
        return ["%s to %s" % (descr[old_is_x], descr[new_is_x],)]
550
    else:
551
        return []
552
1398 by Robert Collins
integrate in Gustavos x-bit patch
553
3009.2.22 by Aaron Bentley
Update names & docstring
554
class DiffPath(object):
3009.2.14 by Aaron Bentley
Update return type handling
555
    """Base type for command object that compare files"""
3009.2.17 by Aaron Bentley
Update docs
556
3009.2.14 by Aaron Bentley
Update return type handling
557
    # The type or contents of the file were unsuitable for diffing
3009.2.29 by Aaron Bentley
Change constants to strings
558
    CANNOT_DIFF = 'CANNOT_DIFF'
3009.2.14 by Aaron Bentley
Update return type handling
559
    # The file has changed in a semantic way
3009.2.29 by Aaron Bentley
Change constants to strings
560
    CHANGED = 'CHANGED'
561
    # The file content may have changed, but there is no semantic change
562
    UNCHANGED = 'UNCHANGED'
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
563
3009.2.13 by Aaron Bentley
Refactor differ to support registering differ factories
564
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8'):
3009.2.17 by Aaron Bentley
Update docs
565
        """Constructor.
566
567
        :param old_tree: The tree to show as the old tree in the comparison
568
        :param new_tree: The tree to show as new in the comparison
569
        :param to_file: The file to write comparison data to
570
        :param path_encoding: The character encoding to write paths in
571
        """
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
572
        self.old_tree = old_tree
573
        self.new_tree = new_tree
574
        self.to_file = to_file
3009.2.13 by Aaron Bentley
Refactor differ to support registering differ factories
575
        self.path_encoding = path_encoding
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
576
3123.6.2 by Aaron Bentley
Implement diff --using natively
577
    def finish(self):
578
        pass
579
3009.2.28 by Aaron Bentley
Add from_diff_tree factories
580
    @classmethod
581
    def from_diff_tree(klass, diff_tree):
582
        return klass(diff_tree.old_tree, diff_tree.new_tree,
583
                     diff_tree.to_file, diff_tree.path_encoding)
584
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
585
    @staticmethod
586
    def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):
587
        for file_differ in differs:
588
            result = file_differ.diff(file_id, old_path, new_path, old_kind,
589
                                      new_kind)
3009.2.22 by Aaron Bentley
Update names & docstring
590
            if result is not DiffPath.CANNOT_DIFF:
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
591
                return result
592
        else:
3009.2.22 by Aaron Bentley
Update names & docstring
593
            return DiffPath.CANNOT_DIFF
594
595
596
class DiffKindChange(object):
3009.2.17 by Aaron Bentley
Update docs
597
    """Special differ for file kind changes.
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
598
3009.2.17 by Aaron Bentley
Update docs
599
    Represents kind change as deletion + creation.  Uses the other differs
600
    to do this.
601
    """
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
602
    def __init__(self, differs):
603
        self.differs = differs
604
3123.6.2 by Aaron Bentley
Implement diff --using natively
605
    def finish(self):
606
        pass
607
3009.2.28 by Aaron Bentley
Add from_diff_tree factories
608
    @classmethod
609
    def from_diff_tree(klass, diff_tree):
610
        return klass(diff_tree.differs)
611
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
612
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
3009.2.17 by Aaron Bentley
Update docs
613
        """Perform comparison
614
615
        :param file_id: The file_id of the file to compare
616
        :param old_path: Path of the file in the old tree
617
        :param new_path: Path of the file in the new tree
618
        :param old_kind: Old file-kind of the file
619
        :param new_kind: New file-kind of the file
620
        """
3009.2.18 by Aaron Bentley
Change KindChangeDiffer's anti-recursion to avoid kind pairs with None
621
        if None in (old_kind, new_kind):
3009.2.22 by Aaron Bentley
Update names & docstring
622
            return DiffPath.CANNOT_DIFF
623
        result = DiffPath._diff_many(self.differs, file_id, old_path,
3009.2.18 by Aaron Bentley
Change KindChangeDiffer's anti-recursion to avoid kind pairs with None
624
                                       new_path, old_kind, None)
3009.2.22 by Aaron Bentley
Update names & docstring
625
        if result is DiffPath.CANNOT_DIFF:
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
626
            return result
3009.2.22 by Aaron Bentley
Update names & docstring
627
        return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
628
                                     None, new_kind)
629
630
3009.2.22 by Aaron Bentley
Update names & docstring
631
class DiffDirectory(DiffPath):
3009.2.19 by Aaron Bentley
Implement directory diffing
632
633
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
634
        """Perform comparison between two directories.  (dummy)
635
636
        """
637
        if 'directory' not in (old_kind, new_kind):
638
            return self.CANNOT_DIFF
639
        if old_kind not in ('directory', None):
640
            return self.CANNOT_DIFF
641
        if new_kind not in ('directory', None):
642
            return self.CANNOT_DIFF
643
        return self.CHANGED
644
3009.2.20 by Aaron Bentley
PEP8
645
3009.2.22 by Aaron Bentley
Update names & docstring
646
class DiffSymlink(DiffPath):
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
647
648
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
3009.2.17 by Aaron Bentley
Update docs
649
        """Perform comparison between two symlinks
650
651
        :param file_id: The file_id of the file to compare
652
        :param old_path: Path of the file in the old tree
653
        :param new_path: Path of the file in the new tree
654
        :param old_kind: Old file-kind of the file
655
        :param new_kind: New file-kind of the file
656
        """
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
657
        if 'symlink' not in (old_kind, new_kind):
3009.2.14 by Aaron Bentley
Update return type handling
658
            return self.CANNOT_DIFF
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
659
        if old_kind == 'symlink':
660
            old_target = self.old_tree.get_symlink_target(file_id)
661
        elif old_kind is None:
662
            old_target = None
663
        else:
3009.2.14 by Aaron Bentley
Update return type handling
664
            return self.CANNOT_DIFF
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
665
        if new_kind == 'symlink':
666
            new_target = self.new_tree.get_symlink_target(file_id)
667
        elif new_kind is None:
668
            new_target = None
669
        else:
3009.2.14 by Aaron Bentley
Update return type handling
670
            return self.CANNOT_DIFF
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
671
        return self.diff_symlink(old_target, new_target)
672
673
    def diff_symlink(self, old_target, new_target):
674
        if old_target is None:
675
            self.to_file.write('=== target is %r\n' % new_target)
676
        elif new_target is None:
677
            self.to_file.write('=== target was %r\n' % old_target)
678
        else:
679
            self.to_file.write('=== target changed %r => %r\n' %
680
                              (old_target, new_target))
3009.2.14 by Aaron Bentley
Update return type handling
681
        return self.CHANGED
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
682
683
3009.2.22 by Aaron Bentley
Update names & docstring
684
class DiffText(DiffPath):
3009.2.2 by Aaron Bentley
Implement Differ object for abstracting diffing
685
3009.2.7 by Aaron Bentley
Move responsibility for generating diff labels into Differ.diff
686
    # GNU Patch uses the epoch date to detect files that are being added
687
    # or removed in a diff.
688
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
689
3009.2.13 by Aaron Bentley
Refactor differ to support registering differ factories
690
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
691
                 old_label='', new_label='', text_differ=internal_diff):
3009.2.22 by Aaron Bentley
Update names & docstring
692
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
693
        self.text_differ = text_differ
694
        self.old_label = old_label
695
        self.new_label = new_label
3009.2.12 by Aaron Bentley
Associate labels with text diffing only
696
        self.path_encoding = path_encoding
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
697
698
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
3009.2.17 by Aaron Bentley
Update docs
699
        """Compare two files in unified diff format
700
701
        :param file_id: The file_id of the file to compare
702
        :param old_path: Path of the file in the old tree
703
        :param new_path: Path of the file in the new tree
704
        :param old_kind: Old file-kind of the file
705
        :param new_kind: New file-kind of the file
706
        """
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
707
        if 'file' not in (old_kind, new_kind):
3009.2.14 by Aaron Bentley
Update return type handling
708
            return self.CANNOT_DIFF
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
709
        from_file_id = to_file_id = file_id
710
        if old_kind == 'file':
711
            old_date = _patch_header_date(self.old_tree, file_id, old_path)
712
        elif old_kind is None:
713
            old_date = self.EPOCH_DATE
3009.2.12 by Aaron Bentley
Associate labels with text diffing only
714
            from_file_id = None
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
715
        else:
3009.2.14 by Aaron Bentley
Update return type handling
716
            return self.CANNOT_DIFF
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
717
        if new_kind == 'file':
718
            new_date = _patch_header_date(self.new_tree, file_id, new_path)
719
        elif new_kind is None:
720
            new_date = self.EPOCH_DATE
721
            to_file_id = None
722
        else:
3009.2.14 by Aaron Bentley
Update return type handling
723
            return self.CANNOT_DIFF
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
724
        from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
725
        to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
726
        return self.diff_text(from_file_id, to_file_id, from_label, to_label)
727
728
    def diff_text(self, from_file_id, to_file_id, from_label, to_label):
729
        """Diff the content of given files in two trees
730
731
        :param from_file_id: The id of the file in the from tree.  If None,
732
            the file is not present in the from tree.
733
        :param to_file_id: The id of the file in the to tree.  This may refer
734
            to a different file from from_file_id.  If None,
735
            the file is not present in the to tree.
736
        """
737
        def _get_text(tree, file_id):
738
            if file_id is not None:
739
                return tree.get_file(file_id).readlines()
740
            else:
741
                return []
742
        try:
743
            from_text = _get_text(self.old_tree, from_file_id)
744
            to_text = _get_text(self.new_tree, to_file_id)
745
            self.text_differ(from_label, from_text, to_label, to_text,
746
                             self.to_file)
747
        except errors.BinaryFile:
748
            self.to_file.write(
749
                  ("Binary files %s and %s differ\n" %
750
                  (from_label, to_label)).encode(self.path_encoding))
3009.2.14 by Aaron Bentley
Update return type handling
751
        return self.CHANGED
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
752
753
3123.6.2 by Aaron Bentley
Implement diff --using natively
754
class DiffFromTool(DiffPath):
755
756
    def __init__(self, command_template, old_tree, new_tree, to_file,
757
                 path_encoding='utf-8'):
758
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
759
        self.command_template = command_template
760
        self._root = tempfile.mkdtemp(prefix='bzr-diff-')
761
762
    @classmethod
763
    def from_string(klass, command_string, old_tree, new_tree, to_file,
764
                    path_encoding='utf-8'):
765
        command_template = commands.shlex_split_unicode(command_string)
766
        command_template.extend(['%(old_path)s', '%(new_path)s'])
767
        return klass(command_template, old_tree, new_tree, to_file,
768
                     path_encoding)
769
770
    @classmethod
771
    def make_from_diff_tree(klass, command_string):
772
        def from_diff_tree(diff_tree):
773
            return klass.from_string(command_string, diff_tree.old_tree,
774
                                     diff_tree.new_tree, diff_tree.to_file)
775
        return from_diff_tree
776
777
    def _get_command(self, old_path, new_path):
778
        my_map = {'old_path': old_path, 'new_path': new_path}
779
        return [t % my_map for t in self.command_template]
780
781
    def _execute(self, old_path, new_path):
3145.1.1 by Aaron Bentley
Handle missing tools gracefully in diff --using
782
        command = self._get_command(old_path, new_path)
783
        try:
784
            proc = subprocess.Popen(command, stdout=subprocess.PIPE,
785
                                    cwd=self._root)
786
        except OSError, e:
787
            if e.errno == errno.ENOENT:
788
                raise errors.ExecutableMissing(command[0])
3145.1.2 by Aaron Bentley
Don't swallow other OSErrors
789
            else:
790
                raise
3123.6.2 by Aaron Bentley
Implement diff --using natively
791
        self.to_file.write(proc.stdout.read())
792
        return proc.wait()
793
3123.6.5 by Aaron Bentley
Symlink to real files if possible
794
    def _try_symlink_root(self, tree, prefix):
795
        if not (getattr(tree, 'abspath', None) is not None
796
                and osutils.has_symlinks()):
797
            return False
798
        try:
799
            os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
800
        except OSError, e:
801
            if e.errno != errno.EEXIST:
802
                raise
803
        return True
804
3123.6.4 by Aaron Bentley
Set mtime (and atime) on files for --using
805
    def _write_file(self, file_id, tree, prefix, relpath):
806
        full_path = osutils.pathjoin(self._root, prefix, relpath)
3123.6.5 by Aaron Bentley
Symlink to real files if possible
807
        if self._try_symlink_root(tree, prefix):
808
            return full_path
3123.6.4 by Aaron Bentley
Set mtime (and atime) on files for --using
809
        parent_dir = osutils.dirname(full_path)
3123.6.2 by Aaron Bentley
Implement diff --using natively
810
        try:
811
            os.makedirs(parent_dir)
812
        except OSError, e:
813
            if e.errno != errno.EEXIST:
814
                raise
3123.6.6 by Aaron Bentley
Use relpath for get_file
815
        source = tree.get_file(file_id, relpath)
3123.6.2 by Aaron Bentley
Implement diff --using natively
816
        try:
3123.6.4 by Aaron Bentley
Set mtime (and atime) on files for --using
817
            target = open(full_path, 'wb')
3123.6.2 by Aaron Bentley
Implement diff --using natively
818
            try:
819
                osutils.pumpfile(source, target)
820
            finally:
821
                target.close()
822
        finally:
823
            source.close()
3123.6.7 by Aaron Bentley
Mark temporary files read-only
824
        osutils.make_readonly(full_path)
3123.6.4 by Aaron Bentley
Set mtime (and atime) on files for --using
825
        mtime = tree.get_file_mtime(file_id)
826
        os.utime(full_path, (mtime, mtime))
827
        return full_path
3123.6.2 by Aaron Bentley
Implement diff --using natively
828
829
    def _prepare_files(self, file_id, old_path, new_path):
830
        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
831
                                         old_path)
832
        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
833
                                         new_path)
834
        return old_disk_path, new_disk_path
835
836
    def finish(self):
3123.6.8 by Aaron Bentley
Us osutils.rmtree instead of shutil.rmtree, now that some files are readonly
837
        osutils.rmtree(self._root)
3123.6.2 by Aaron Bentley
Implement diff --using natively
838
839
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
840
        if (old_kind, new_kind) != ('file', 'file'):
841
            return DiffPath.CANNOT_DIFF
842
        self._prepare_files(file_id, old_path, new_path)
843
        self._execute(osutils.pathjoin('old', old_path),
844
                      osutils.pathjoin('new', new_path))
845
846
3009.2.22 by Aaron Bentley
Update names & docstring
847
class DiffTree(object):
848
    """Provides textual representations of the difference between two trees.
849
850
    A DiffTree examines two trees and where a file-id has altered
851
    between them, generates a textual representation of the difference.
852
    DiffTree uses a sequence of DiffPath objects which are each
853
    given the opportunity to handle a given altered fileid. The list
854
    of DiffPath objects can be extended globally by appending to
855
    DiffTree.diff_factories, or for a specific diff operation by
3009.2.27 by Aaron Bentley
Use extra_factories instead of extra_diffs
856
    supplying the extra_factories option to the appropriate method.
3009.2.22 by Aaron Bentley
Update names & docstring
857
    """
858
859
    # list of factories that can provide instances of DiffPath objects
3009.2.17 by Aaron Bentley
Update docs
860
    # may be extended by plugins.
3009.2.28 by Aaron Bentley
Add from_diff_tree factories
861
    diff_factories = [DiffSymlink.from_diff_tree,
862
                      DiffDirectory.from_diff_tree]
3009.2.13 by Aaron Bentley
Refactor differ to support registering differ factories
863
3009.2.12 by Aaron Bentley
Associate labels with text diffing only
864
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
3009.2.28 by Aaron Bentley
Add from_diff_tree factories
865
                 diff_text=None, extra_factories=None):
3009.2.17 by Aaron Bentley
Update docs
866
        """Constructor
867
868
        :param old_tree: Tree to show as old in the comparison
869
        :param new_tree: Tree to show as new in the comparison
870
        :param to_file: File to write comparision to
871
        :param path_encoding: Character encoding to write paths in
3009.2.28 by Aaron Bentley
Add from_diff_tree factories
872
        :param diff_text: DiffPath-type object to use as a last resort for
3009.2.17 by Aaron Bentley
Update docs
873
            diffing text files.
3009.2.27 by Aaron Bentley
Use extra_factories instead of extra_diffs
874
        :param extra_factories: Factories of DiffPaths to try before any other
875
            DiffPaths"""
3009.2.28 by Aaron Bentley
Add from_diff_tree factories
876
        if diff_text is None:
877
            diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
878
                                 '', '',  internal_diff)
3009.2.4 by Aaron Bentley
Make old_tree/new_tree construction parameters of Differ
879
        self.old_tree = old_tree
880
        self.new_tree = new_tree
3009.2.2 by Aaron Bentley
Implement Differ object for abstracting diffing
881
        self.to_file = to_file
3009.2.28 by Aaron Bentley
Add from_diff_tree factories
882
        self.path_encoding = path_encoding
3009.2.13 by Aaron Bentley
Refactor differ to support registering differ factories
883
        self.differs = []
3009.2.27 by Aaron Bentley
Use extra_factories instead of extra_diffs
884
        if extra_factories is not None:
3009.2.28 by Aaron Bentley
Add from_diff_tree factories
885
            self.differs.extend(f(self) for f in extra_factories)
886
        self.differs.extend(f(self) for f in self.diff_factories)
887
        self.differs.extend([diff_text, DiffKindChange.from_diff_tree(self)])
3009.2.6 by Aaron Bentley
Convert show_diff_trees into a Differ method
888
889
    @classmethod
890
    def from_trees_options(klass, old_tree, new_tree, to_file,
3009.2.17 by Aaron Bentley
Update docs
891
                           path_encoding, external_diff_options, old_label,
3123.6.2 by Aaron Bentley
Implement diff --using natively
892
                           new_label, using):
3009.2.22 by Aaron Bentley
Update names & docstring
893
        """Factory for producing a DiffTree.
3009.2.17 by Aaron Bentley
Update docs
894
895
        Designed to accept options used by show_diff_trees.
896
        :param old_tree: The tree to show as old in the comparison
897
        :param new_tree: The tree to show as new in the comparison
898
        :param to_file: File to write comparisons to
899
        :param path_encoding: Character encoding to use for writing paths
900
        :param external_diff_options: If supplied, use the installed diff
901
            binary to perform file comparison, using supplied options.
902
        :param old_label: Prefix to use for old file labels
903
        :param new_label: Prefix to use for new file labels
3123.6.2 by Aaron Bentley
Implement diff --using natively
904
        :param using: Commandline to use to invoke an external diff tool
3009.2.17 by Aaron Bentley
Update docs
905
        """
3123.6.2 by Aaron Bentley
Implement diff --using natively
906
        if using is not None:
907
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
908
        else:
909
            extra_factories = []
3009.2.6 by Aaron Bentley
Convert show_diff_trees into a Differ method
910
        if external_diff_options:
911
            opts = external_diff_options.split()
912
            def diff_file(olab, olines, nlab, nlines, to_file):
913
                external_diff(olab, olines, nlab, nlines, to_file, opts)
914
        else:
915
            diff_file = internal_diff
3009.2.28 by Aaron Bentley
Add from_diff_tree factories
916
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
917
                             old_label, new_label, diff_file)
3123.6.2 by Aaron Bentley
Implement diff --using natively
918
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
919
                     extra_factories)
3009.2.6 by Aaron Bentley
Convert show_diff_trees into a Differ method
920
3009.2.12 by Aaron Bentley
Associate labels with text diffing only
921
    def show_diff(self, specific_files, extra_trees=None):
3009.2.17 by Aaron Bentley
Update docs
922
        """Write tree diff to self.to_file
923
924
        :param sepecific_files: the specific files to compare (recursive)
925
        :param extra_trees: extra trees to use for mapping paths to file_ids
926
        """
3123.6.2 by Aaron Bentley
Implement diff --using natively
927
        try:
928
            return self._show_diff(specific_files, extra_trees)
929
        finally:
930
            for differ in self.differs:
931
                differ.finish()
932
933
    def _show_diff(self, specific_files, extra_trees):
3009.2.6 by Aaron Bentley
Convert show_diff_trees into a Differ method
934
        # TODO: Generation of pseudo-diffs for added/deleted files could
935
        # be usefully made into a much faster special case.
3254.1.1 by Aaron Bentley
Make Tree.iter_changes a public method
936
        iterator = self.new_tree.iter_changes(self.old_tree,
3123.4.1 by Aaron Bentley
Diff sorts files in alphabetical order
937
                                               specific_files=specific_files,
938
                                               extra_trees=extra_trees,
939
                                               require_versioned=True)
3009.2.6 by Aaron Bentley
Convert show_diff_trees into a Differ method
940
        has_changes = 0
3123.4.1 by Aaron Bentley
Diff sorts files in alphabetical order
941
        def changes_key(change):
942
            old_path, new_path = change[1]
943
            path = new_path
944
            if path is None:
945
                path = old_path
946
            return path
947
        def get_encoded_path(path):
948
            if path is not None:
949
                return path.encode(self.path_encoding, "replace")
950
        for (file_id, paths, changed_content, versioned, parent, name, kind,
951
             executable) in sorted(iterator, key=changes_key):
3123.4.3 by Aaron Bentley
Tweak path handling
952
            if parent == (None, None):
953
                continue
954
            oldpath, newpath = paths
3123.4.1 by Aaron Bentley
Diff sorts files in alphabetical order
955
            oldpath_encoded = get_encoded_path(paths[0])
956
            newpath_encoded = get_encoded_path(paths[1])
957
            old_present = (kind[0] is not None and versioned[0])
958
            new_present = (kind[1] is not None and versioned[1])
959
            renamed = (parent[0], name[0]) != (parent[1], name[1])
3268.1.1 by C Miller
Describe the property changes in diffs. Currently, this is the executable-bit
960
961
            properties_changed = []
962
            properties_changed.extend(get_executable_change(executable[0], executable[1]))
963
964
            if properties_changed:
965
                prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)
966
            else:
967
                prop_str = ""
968
3123.4.1 by Aaron Bentley
Diff sorts files in alphabetical order
969
            if (old_present, new_present) == (True, False):
970
                self.to_file.write("=== removed %s '%s'\n" %
971
                                   (kind[0], oldpath_encoded))
3123.4.3 by Aaron Bentley
Tweak path handling
972
                newpath = oldpath
3123.4.1 by Aaron Bentley
Diff sorts files in alphabetical order
973
            elif (old_present, new_present) == (False, True):
974
                self.to_file.write("=== added %s '%s'\n" %
975
                                   (kind[1], newpath_encoded))
3123.4.3 by Aaron Bentley
Tweak path handling
976
                oldpath = newpath
3123.4.1 by Aaron Bentley
Diff sorts files in alphabetical order
977
            elif renamed:
978
                self.to_file.write("=== renamed %s '%s' => '%s'%s\n" %
979
                    (kind[0], oldpath_encoded, newpath_encoded, prop_str))
3123.4.2 by Aaron Bentley
Handle diff with property change correctly
980
            else:
3254.1.1 by Aaron Bentley
Make Tree.iter_changes a public method
981
                # if it was produced by iter_changes, it must be
3123.4.2 by Aaron Bentley
Handle diff with property change correctly
982
                # modified *somehow*, either content or execute bit.
3123.4.1 by Aaron Bentley
Diff sorts files in alphabetical order
983
                self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
984
                                   newpath_encoded, prop_str))
985
            if changed_content:
3123.4.3 by Aaron Bentley
Tweak path handling
986
                self.diff(file_id, oldpath, newpath)
3123.4.1 by Aaron Bentley
Diff sorts files in alphabetical order
987
                has_changes = 1
988
            if renamed:
989
                has_changes = 1
3009.2.6 by Aaron Bentley
Convert show_diff_trees into a Differ method
990
        return has_changes
3009.2.2 by Aaron Bentley
Implement Differ object for abstracting diffing
991
3009.2.12 by Aaron Bentley
Associate labels with text diffing only
992
    def diff(self, file_id, old_path, new_path):
3009.2.17 by Aaron Bentley
Update docs
993
        """Perform a diff of a single file
994
995
        :param file_id: file-id of the file
996
        :param old_path: The path of the file in the old tree
997
        :param new_path: The path of the file in the new tree
998
        """
3009.2.2 by Aaron Bentley
Implement Differ object for abstracting diffing
999
        try:
3009.2.8 by Aaron Bentley
Support diffing without indirecting through inventory entries
1000
            old_kind = self.old_tree.kind(file_id)
3087.1.1 by Aaron Bentley
Diff handles missing files correctly, with no tracebacks
1001
        except (errors.NoSuchId, errors.NoSuchFile):
3009.2.8 by Aaron Bentley
Support diffing without indirecting through inventory entries
1002
            old_kind = None
3009.2.3 by Aaron Bentley
Detect missing files from inv operation
1003
        try:
3009.2.8 by Aaron Bentley
Support diffing without indirecting through inventory entries
1004
            new_kind = self.new_tree.kind(file_id)
3087.1.1 by Aaron Bentley
Diff handles missing files correctly, with no tracebacks
1005
        except (errors.NoSuchId, errors.NoSuchFile):
3009.2.8 by Aaron Bentley
Support diffing without indirecting through inventory entries
1006
            new_kind = None
3009.2.7 by Aaron Bentley
Move responsibility for generating diff labels into Differ.diff
1007
3009.2.22 by Aaron Bentley
Update names & docstring
1008
        result = DiffPath._diff_many(self.differs, file_id, old_path,
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
1009
                                       new_path, old_kind, new_kind)
3009.2.22 by Aaron Bentley
Update names & docstring
1010
        if result is DiffPath.CANNOT_DIFF:
3009.2.11 by Aaron Bentley
Refactor diff to be more pluggable
1011
            error_path = new_path
1012
            if error_path is None:
1013
                error_path = old_path
3009.2.22 by Aaron Bentley
Update names & docstring
1014
            raise errors.NoDiffFound(error_path)