← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-04-08 06:17:41 UTC
  • mfrom: (4797.33.16 apport)
  • Revision ID: pqm@pqm.ubuntu.com-20100408061741-m7vl6z97vu33riv7
(robertc) Make sure ExecutablePath and InterpreterPath are set in
        Apport. (Martin Pool, James Westby, lp:528114)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
1
 
# Copyright (C) 2004, 2005, 2006 Canonical Ltd.
 
1
# Copyright (C) 2005-2010 Canonical Ltd.
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import difflib
18
18
import os
19
19
import re
20
20
import shutil
 
21
import string
21
22
import sys
22
23
 
23
24
from bzrlib.lazy_import import lazy_import
30
31
from bzrlib import (
31
32
    branch as _mod_branch,
32
33
    bzrdir,
33
 
    commands,
 
34
    cmdline,
34
35
    errors,
35
36
    osutils,
36
37
    patiencediff,
37
38
    textfile,
38
39
    timestamp,
 
40
    views,
39
41
    )
 
42
 
 
43
from bzrlib.workingtree import WorkingTree
40
44
""")
41
45
 
 
46
from bzrlib.registry import (
 
47
    Registry,
 
48
    )
42
49
from bzrlib.symbol_versioning import (
43
 
        deprecated_function,
44
 
        one_three
45
 
        )
46
 
from bzrlib.trace import mutter, warning
 
50
    deprecated_function,
 
51
    )
 
52
from bzrlib.trace import mutter, note, warning
 
53
 
 
54
 
 
55
class AtTemplate(string.Template):
 
56
    """Templating class that uses @ instead of $."""
 
57
 
 
58
    delimiter = '@'
47
59
 
48
60
 
49
61
# TODO: Rather than building a changeset object, we should probably
78
90
    # both sequences are empty.
79
91
    if not oldlines and not newlines:
80
92
        return
81
 
    
 
93
 
82
94
    if allow_binary is False:
83
95
        textfile.check_text_lines(oldlines)
84
96
        textfile.check_text_lines(newlines)
99
111
        ud[2] = ud[2].replace('-1,0', '-0,0')
100
112
    elif not newlines:
101
113
        ud[2] = ud[2].replace('+1,0', '+0,0')
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'
105
114
 
106
115
    for line in ud:
107
116
        to_file.write(line)
174
183
 
175
184
        if not diff_opts:
176
185
            diff_opts = []
 
186
        if sys.platform == 'win32':
 
187
            # Popen doesn't do the proper encoding for external commands
 
188
            # Since we are dealing with an ANSI api, use mbcs encoding
 
189
            old_filename = old_filename.encode('mbcs')
 
190
            new_filename = new_filename.encode('mbcs')
177
191
        diffcmd = ['diff',
178
192
                   '--label', old_filename,
179
193
                   old_abspath,
202
216
            break
203
217
        else:
204
218
            diffcmd.append('-u')
205
 
                  
 
219
 
206
220
        if diff_opts:
207
221
            diffcmd.extend(diff_opts)
208
222
 
209
223
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
210
224
        out,err = pipe.communicate()
211
225
        rc = pipe.returncode
212
 
        
 
226
 
213
227
        # internal_diff() adds a trailing newline, add one here for consistency
214
228
        out += '\n'
215
229
        if rc == 2:
250
264
                msg = 'signal %d' % (-rc)
251
265
            else:
252
266
                msg = 'exit code %d' % rc
253
 
                
254
 
            raise errors.BzrError('external diff failed with %s; command: %r' 
 
267
 
 
268
            raise errors.BzrError('external diff failed with %s; command: %r'
255
269
                                  % (rc, diffcmd))
256
270
 
257
271
 
275
289
                        new_abspath, e)
276
290
 
277
291
 
278
 
def _get_trees_to_diff(path_list, revision_specs, old_url, new_url):
 
292
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
 
293
                                   apply_view=True):
279
294
    """Get the trees and specific files to diff given a list of paths.
280
295
 
281
296
    This method works out the trees to be diff'ed and the files of
292
307
    :param new_url:
293
308
        The url of the new branch or tree. If None, the tree to use is
294
309
        taken from the first path, if any, or the current working tree.
 
310
    :param apply_view:
 
311
        if True and a view is set, apply the view or check that the paths
 
312
        are within it
295
313
    :returns:
296
 
        a tuple of (old_tree, new_tree, specific_files, extra_trees) where
297
 
        extra_trees is a sequence of additional trees to search in for
298
 
        file-ids.
 
314
        a tuple of (old_tree, new_tree, old_branch, new_branch,
 
315
        specific_files, extra_trees) where extra_trees is a sequence of
 
316
        additional trees to search in for file-ids.
299
317
    """
300
318
    # Get the old and new revision specs
301
319
    old_revision_spec = None
331
349
    working_tree, branch, relpath = \
332
350
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
333
351
    if consider_relpath and relpath != '':
 
352
        if working_tree is not None and apply_view:
 
353
            views.check_path_in_view(working_tree, relpath)
334
354
        specific_files.append(relpath)
335
355
    old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
 
356
    old_branch = branch
336
357
 
337
358
    # Get the new location
338
359
    if new_url is None:
341
362
        working_tree, branch, relpath = \
342
363
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
343
364
        if consider_relpath and relpath != '':
 
365
            if working_tree is not None and apply_view:
 
366
                views.check_path_in_view(working_tree, relpath)
344
367
            specific_files.append(relpath)
345
368
    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
346
369
        basis_is_default=working_tree is None)
 
370
    new_branch = branch
347
371
 
348
372
    # Get the specific files (all files is None, no files is [])
349
373
    if make_paths_wt_relative and working_tree is not None:
350
 
        other_paths = _relative_paths_in_tree(working_tree, other_paths)
 
374
        try:
 
375
            from bzrlib.builtins import safe_relpath_files
 
376
            other_paths = safe_relpath_files(working_tree, other_paths,
 
377
            apply_view=apply_view)
 
378
        except errors.FileInWrongBranch:
 
379
            raise errors.BzrCommandError("Files are in different branches")
351
380
    specific_files.extend(other_paths)
352
381
    if len(specific_files) == 0:
353
382
        specific_files = None
 
383
        if (working_tree is not None and working_tree.supports_views()
 
384
            and apply_view):
 
385
            view_files = working_tree.views.lookup_view()
 
386
            if view_files:
 
387
                specific_files = view_files
 
388
                view_str = views.view_display_str(view_files)
 
389
                note("*** Ignoring files outside view. View is %s" % view_str)
354
390
 
355
391
    # Get extra trees that ought to be searched for file-ids
356
392
    extra_trees = None
357
393
    if working_tree is not None and working_tree not in (old_tree, new_tree):
358
394
        extra_trees = (working_tree,)
359
 
    return old_tree, new_tree, specific_files, extra_trees
 
395
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
360
396
 
361
397
 
362
398
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
370
406
                return branch.basis_tree()
371
407
        else:
372
408
            return tree
373
 
    if not spec.needs_branch():
374
 
        branch = _mod_branch.Branch.open(spec.get_branch())
375
 
    revision_id = spec.as_revision_id(branch)
376
 
    return branch.repository.revision_tree(revision_id)
377
 
 
378
 
 
379
 
def _relative_paths_in_tree(tree, paths):
380
 
    """Get the relative paths within a working tree.
381
 
 
382
 
    Each path may be either an absolute path or a path relative to the
383
 
    current working directory.
384
 
    """
385
 
    result = []
386
 
    for filename in paths:
387
 
        try:
388
 
            result.append(tree.relpath(osutils.dereference_path(filename)))
389
 
        except errors.PathNotChild:
390
 
            raise errors.BzrCommandError("Files are in different branches")
391
 
    return result
 
409
    return spec.as_tree(branch)
392
410
 
393
411
 
394
412
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
396
414
                    old_label='a/', new_label='b/',
397
415
                    extra_trees=None,
398
416
                    path_encoding='utf8',
399
 
                    using=None):
 
417
                    using=None,
 
418
                    format_cls=None):
400
419
    """Show in text form the changes from one tree to another.
401
420
 
402
 
    to_file
403
 
        The output stream.
404
 
 
405
 
    specific_files
406
 
        Include only changes to these files - None for all changes.
407
 
 
408
 
    external_diff_options
409
 
        If set, use an external GNU diff and pass these options.
410
 
 
411
 
    extra_trees
412
 
        If set, more Trees to use for looking up file ids
413
 
 
414
 
    path_encoding
415
 
        If set, the path will be encoded as specified, otherwise is supposed
416
 
        to be utf8
 
421
    :param to_file: The output stream.
 
422
    :param specific_files:Include only changes to these files - None for all
 
423
        changes.
 
424
    :param external_diff_options: If set, use an external GNU diff and pass 
 
425
        these options.
 
426
    :param extra_trees: If set, more Trees to use for looking up file ids
 
427
    :param path_encoding: If set, the path will be encoded as specified, 
 
428
        otherwise is supposed to be utf8
 
429
    :param format_cls: Formatter class (DiffTree subclass)
417
430
    """
 
431
    if format_cls is None:
 
432
        format_cls = DiffTree
418
433
    old_tree.lock_read()
419
434
    try:
420
435
        if extra_trees is not None:
422
437
                tree.lock_read()
423
438
        new_tree.lock_read()
424
439
        try:
425
 
            differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
426
 
                                                 path_encoding,
427
 
                                                 external_diff_options,
428
 
                                                 old_label, new_label, using)
 
440
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
 
441
                                                   path_encoding,
 
442
                                                   external_diff_options,
 
443
                                                   old_label, new_label, using)
429
444
            return differ.show_diff(specific_files, extra_trees)
430
445
        finally:
431
446
            new_tree.unlock()
438
453
 
439
454
def _patch_header_date(tree, file_id, path):
440
455
    """Returns a timestamp suitable for use in a patch header."""
441
 
    mtime = tree.get_file_mtime(file_id, path)
 
456
    try:
 
457
        mtime = tree.get_file_mtime(file_id, path)
 
458
    except errors.FileTimestampUnavailable:
 
459
        mtime = 0
442
460
    return timestamp.format_patch_date(mtime)
443
461
 
444
462
 
445
 
def _raise_if_nonexistent(paths, old_tree, new_tree):
446
 
    """Complain if paths are not in either inventory or tree.
447
 
 
448
 
    It's OK with the files exist in either tree's inventory, or 
449
 
    if they exist in the tree but are not versioned.
450
 
    
451
 
    This can be used by operations such as bzr status that can accept
452
 
    unknown or ignored files.
453
 
    """
454
 
    mutter("check paths: %r", paths)
455
 
    if not paths:
456
 
        return
457
 
    s = old_tree.filter_unversioned_files(paths)
458
 
    s = new_tree.filter_unversioned_files(s)
459
 
    s = [path for path in s if not new_tree.has_filename(path)]
460
 
    if s:
461
 
        raise errors.PathsDoNotExist(sorted(s))
462
 
 
463
 
 
464
 
@deprecated_function(one_three)
465
 
def get_prop_change(meta_modified):
466
 
    if meta_modified:
467
 
        return " (properties changed)"
468
 
    else:
469
 
        return  ""
470
 
 
471
463
def get_executable_change(old_is_x, new_is_x):
472
464
    descr = { True:"+x", False:"-x", None:"??" }
473
465
    if old_is_x != new_is_x:
648
640
            return self.CANNOT_DIFF
649
641
        from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
650
642
        to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
651
 
        return self.diff_text(from_file_id, to_file_id, from_label, to_label)
 
643
        return self.diff_text(from_file_id, to_file_id, from_label, to_label,
 
644
            old_path, new_path)
652
645
 
653
 
    def diff_text(self, from_file_id, to_file_id, from_label, to_label):
 
646
    def diff_text(self, from_file_id, to_file_id, from_label, to_label,
 
647
        from_path=None, to_path=None):
654
648
        """Diff the content of given files in two trees
655
649
 
656
650
        :param from_file_id: The id of the file in the from tree.  If None,
658
652
        :param to_file_id: The id of the file in the to tree.  This may refer
659
653
            to a different file from from_file_id.  If None,
660
654
            the file is not present in the to tree.
 
655
        :param from_path: The path in the from tree or None if unknown.
 
656
        :param to_path: The path in the to tree or None if unknown.
661
657
        """
662
 
        def _get_text(tree, file_id):
 
658
        def _get_text(tree, file_id, path):
663
659
            if file_id is not None:
664
 
                return tree.get_file(file_id).readlines()
 
660
                return tree.get_file(file_id, path).readlines()
665
661
            else:
666
662
                return []
667
663
        try:
668
 
            from_text = _get_text(self.old_tree, from_file_id)
669
 
            to_text = _get_text(self.new_tree, to_file_id)
 
664
            from_text = _get_text(self.old_tree, from_file_id, from_path)
 
665
            to_text = _get_text(self.new_tree, to_file_id, to_path)
670
666
            self.text_differ(from_label, from_text, to_label, to_text,
671
667
                             self.to_file)
672
668
        except errors.BinaryFile:
687
683
    @classmethod
688
684
    def from_string(klass, command_string, old_tree, new_tree, to_file,
689
685
                    path_encoding='utf-8'):
690
 
        command_template = commands.shlex_split_unicode(command_string)
691
 
        command_template.extend(['%(old_path)s', '%(new_path)s'])
 
686
        command_template = cmdline.split(command_string)
 
687
        if '@' not in command_string:
 
688
            command_template.extend(['@old_path', '@new_path'])
692
689
        return klass(command_template, old_tree, new_tree, to_file,
693
690
                     path_encoding)
694
691
 
701
698
 
702
699
    def _get_command(self, old_path, new_path):
703
700
        my_map = {'old_path': old_path, 'new_path': new_path}
704
 
        return [t % my_map for t in self.command_template]
 
701
        return [AtTemplate(t).substitute(my_map) for t in
 
702
                self.command_template]
705
703
 
706
704
    def _execute(self, old_path, new_path):
707
705
        command = self._get_command(old_path, new_path)
727
725
                raise
728
726
        return True
729
727
 
730
 
    def _write_file(self, file_id, tree, prefix, relpath):
 
728
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
 
729
                    allow_write=False):
 
730
        if not force_temp and isinstance(tree, WorkingTree):
 
731
            return tree.abspath(tree.id2path(file_id))
 
732
        
731
733
        full_path = osutils.pathjoin(self._root, prefix, relpath)
732
 
        if self._try_symlink_root(tree, prefix):
 
734
        if not force_temp and self._try_symlink_root(tree, prefix):
733
735
            return full_path
734
736
        parent_dir = osutils.dirname(full_path)
735
737
        try:
746
748
                target.close()
747
749
        finally:
748
750
            source.close()
749
 
        osutils.make_readonly(full_path)
750
 
        mtime = tree.get_file_mtime(file_id)
 
751
        if not allow_write:
 
752
            osutils.make_readonly(full_path)
 
753
        try:
 
754
            mtime = tree.get_file_mtime(file_id)
 
755
        except errors.FileTimestampUnavailable:
 
756
            mtime = 0
751
757
        os.utime(full_path, (mtime, mtime))
752
758
        return full_path
753
759
 
754
 
    def _prepare_files(self, file_id, old_path, new_path):
 
760
    def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
 
761
                       allow_write_new=False):
755
762
        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
756
 
                                         old_path)
 
763
                                         old_path, force_temp)
757
764
        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
758
 
                                         new_path)
 
765
                                         new_path, force_temp,
 
766
                                         allow_write=allow_write_new)
759
767
        return old_disk_path, new_disk_path
760
768
 
761
769
    def finish(self):
762
 
        osutils.rmtree(self._root)
 
770
        try:
 
771
            osutils.rmtree(self._root)
 
772
        except OSError, e:
 
773
            if e.errno != errno.ENOENT:
 
774
                mutter("The temporary directory \"%s\" was not "
 
775
                        "cleanly removed: %s." % (self._root, e))
763
776
 
764
777
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
765
778
        if (old_kind, new_kind) != ('file', 'file'):
766
779
            return DiffPath.CANNOT_DIFF
767
 
        self._prepare_files(file_id, old_path, new_path)
768
 
        self._execute(osutils.pathjoin('old', old_path),
769
 
                      osutils.pathjoin('new', new_path))
 
780
        (old_disk_path, new_disk_path) = self._prepare_files(
 
781
                                                file_id, old_path, new_path)
 
782
        self._execute(old_disk_path, new_disk_path)
 
783
 
 
784
    def edit_file(self, file_id):
 
785
        """Use this tool to edit a file.
 
786
 
 
787
        A temporary copy will be edited, and the new contents will be
 
788
        returned.
 
789
 
 
790
        :param file_id: The id of the file to edit.
 
791
        :return: The new contents of the file.
 
792
        """
 
793
        old_path = self.old_tree.id2path(file_id)
 
794
        new_path = self.new_tree.id2path(file_id)
 
795
        new_abs_path = self._prepare_files(file_id, old_path, new_path,
 
796
                                           allow_write_new=True,
 
797
                                           force_temp=True)[1]
 
798
        command = self._get_command(osutils.pathjoin('old', old_path),
 
799
                                    osutils.pathjoin('new', new_path))
 
800
        subprocess.call(command, cwd=self._root)
 
801
        new_file = open(new_abs_path, 'r')
 
802
        try:
 
803
            return new_file.read()
 
804
        finally:
 
805
            new_file.close()
770
806
 
771
807
 
772
808
class DiffTree(object):
846
882
    def show_diff(self, specific_files, extra_trees=None):
847
883
        """Write tree diff to self.to_file
848
884
 
849
 
        :param sepecific_files: the specific files to compare (recursive)
 
885
        :param specific_files: the specific files to compare (recursive)
850
886
        :param extra_trees: extra trees to use for mapping paths to file_ids
851
887
        """
852
888
        try:
910
946
                self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
911
947
                                   newpath_encoded, prop_str))
912
948
            if changed_content:
913
 
                self.diff(file_id, oldpath, newpath)
 
949
                self._diff(file_id, oldpath, newpath, kind[0], kind[1])
914
950
                has_changes = 1
915
951
            if renamed:
916
952
                has_changes = 1
931
967
            new_kind = self.new_tree.kind(file_id)
932
968
        except (errors.NoSuchId, errors.NoSuchFile):
933
969
            new_kind = None
934
 
 
 
970
        self._diff(file_id, old_path, new_path, old_kind, new_kind)
 
971
 
 
972
 
 
973
    def _diff(self, file_id, old_path, new_path, old_kind, new_kind):
935
974
        result = DiffPath._diff_many(self.differs, file_id, old_path,
936
975
                                       new_path, old_kind, new_kind)
937
976
        if result is DiffPath.CANNOT_DIFF:
939
978
            if error_path is None:
940
979
                error_path = old_path
941
980
            raise errors.NoDiffFound(error_path)
 
981
 
 
982
 
 
983
format_registry = Registry()
 
984
format_registry.register('default', DiffTree)