← 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: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

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-2011 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
17
17
import difflib
18
18
import os
19
19
import re
20
 
import shutil
21
20
import string
22
21
import sys
23
22
 
26
25
import errno
27
26
import subprocess
28
27
import tempfile
29
 
import time
30
28
 
31
29
from bzrlib import (
32
 
    branch as _mod_branch,
33
30
    bzrdir,
34
 
    commands,
 
31
    cmdline,
 
32
    cleanup,
35
33
    errors,
36
34
    osutils,
37
35
    patiencediff,
43
41
from bzrlib.workingtree import WorkingTree
44
42
""")
45
43
 
46
 
from bzrlib.symbol_versioning import (
47
 
    deprecated_function,
 
44
from bzrlib.registry import (
 
45
    Registry,
48
46
    )
49
47
from bzrlib.trace import mutter, note, warning
50
48
 
95
93
    if sequence_matcher is None:
96
94
        sequence_matcher = patiencediff.PatienceSequenceMatcher
97
95
    ud = patiencediff.unified_diff(oldlines, newlines,
98
 
                      fromfile=old_filename.encode(path_encoding),
99
 
                      tofile=new_filename.encode(path_encoding),
 
96
                      fromfile=old_filename.encode(path_encoding, 'replace'),
 
97
                      tofile=new_filename.encode(path_encoding, 'replace'),
100
98
                      sequencematcher=sequence_matcher)
101
99
 
102
100
    ud = list(ud)
286
284
                        new_abspath, e)
287
285
 
288
286
 
289
 
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
290
 
                                   apply_view=True):
 
287
def get_trees_and_branches_to_diff_locked(
 
288
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
291
289
    """Get the trees and specific files to diff given a list of paths.
292
290
 
293
291
    This method works out the trees to be diff'ed and the files of
304
302
    :param new_url:
305
303
        The url of the new branch or tree. If None, the tree to use is
306
304
        taken from the first path, if any, or the current working tree.
 
305
    :param add_cleanup:
 
306
        a callable like Command.add_cleanup.  get_trees_and_branches_to_diff
 
307
        will register cleanups that must be run to unlock the trees, etc.
307
308
    :param apply_view:
308
309
        if True and a view is set, apply the view or check that the paths
309
310
        are within it
310
311
    :returns:
311
312
        a tuple of (old_tree, new_tree, old_branch, new_branch,
312
313
        specific_files, extra_trees) where extra_trees is a sequence of
313
 
        additional trees to search in for file-ids.
 
314
        additional trees to search in for file-ids.  The trees and branches
 
315
        will be read-locked until the cleanups registered via the add_cleanup
 
316
        param are run.
314
317
    """
315
318
    # Get the old and new revision specs
316
319
    old_revision_spec = None
339
342
        default_location = path_list[0]
340
343
        other_paths = path_list[1:]
341
344
 
 
345
    def lock_tree_or_branch(wt, br):
 
346
        if wt is not None:
 
347
            wt.lock_read()
 
348
            add_cleanup(wt.unlock)
 
349
        elif br is not None:
 
350
            br.lock_read()
 
351
            add_cleanup(br.unlock)
 
352
 
342
353
    # Get the old location
343
354
    specific_files = []
344
355
    if old_url is None:
345
356
        old_url = default_location
346
357
    working_tree, branch, relpath = \
347
358
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
 
359
    lock_tree_or_branch(working_tree, branch)
348
360
    if consider_relpath and relpath != '':
349
361
        if working_tree is not None and apply_view:
350
362
            views.check_path_in_view(working_tree, relpath)
358
370
    if new_url != old_url:
359
371
        working_tree, branch, relpath = \
360
372
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
 
373
        lock_tree_or_branch(working_tree, branch)
361
374
        if consider_relpath and relpath != '':
362
375
            if working_tree is not None and apply_view:
363
376
                views.check_path_in_view(working_tree, relpath)
368
381
 
369
382
    # Get the specific files (all files is None, no files is [])
370
383
    if make_paths_wt_relative and working_tree is not None:
371
 
        try:
372
 
            from bzrlib.builtins import safe_relpath_files
373
 
            other_paths = safe_relpath_files(working_tree, other_paths,
 
384
        other_paths = working_tree.safe_relpath_files(
 
385
            other_paths,
374
386
            apply_view=apply_view)
375
 
        except errors.FileInWrongBranch:
376
 
            raise errors.BzrCommandError("Files are in different branches")
377
387
    specific_files.extend(other_paths)
378
388
    if len(specific_files) == 0:
379
389
        specific_files = None
389
399
    extra_trees = None
390
400
    if working_tree is not None and working_tree not in (old_tree, new_tree):
391
401
        extra_trees = (working_tree,)
392
 
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
 
402
    return (old_tree, new_tree, old_branch, new_branch,
 
403
            specific_files, extra_trees)
393
404
 
394
405
 
395
406
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
411
422
                    old_label='a/', new_label='b/',
412
423
                    extra_trees=None,
413
424
                    path_encoding='utf8',
414
 
                    using=None):
 
425
                    using=None,
 
426
                    format_cls=None):
415
427
    """Show in text form the changes from one tree to another.
416
428
 
417
 
    to_file
418
 
        The output stream.
419
 
 
420
 
    specific_files
421
 
        Include only changes to these files - None for all changes.
422
 
 
423
 
    external_diff_options
424
 
        If set, use an external GNU diff and pass these options.
425
 
 
426
 
    extra_trees
427
 
        If set, more Trees to use for looking up file ids
428
 
 
429
 
    path_encoding
430
 
        If set, the path will be encoded as specified, otherwise is supposed
431
 
        to be utf8
 
429
    :param to_file: The output stream.
 
430
    :param specific_files: Include only changes to these files - None for all
 
431
        changes.
 
432
    :param external_diff_options: If set, use an external GNU diff and pass 
 
433
        these options.
 
434
    :param extra_trees: If set, more Trees to use for looking up file ids
 
435
    :param path_encoding: If set, the path will be encoded as specified, 
 
436
        otherwise is supposed to be utf8
 
437
    :param format_cls: Formatter class (DiffTree subclass)
432
438
    """
 
439
    if format_cls is None:
 
440
        format_cls = DiffTree
433
441
    old_tree.lock_read()
434
442
    try:
435
443
        if extra_trees is not None:
437
445
                tree.lock_read()
438
446
        new_tree.lock_read()
439
447
        try:
440
 
            differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
441
 
                                                 path_encoding,
442
 
                                                 external_diff_options,
443
 
                                                 old_label, new_label, using)
 
448
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
 
449
                                                   path_encoding,
 
450
                                                   external_diff_options,
 
451
                                                   old_label, new_label, using)
444
452
            return differ.show_diff(specific_files, extra_trees)
445
453
        finally:
446
454
            new_tree.unlock()
657
665
        """
658
666
        def _get_text(tree, file_id, path):
659
667
            if file_id is not None:
660
 
                return tree.get_file(file_id, path).readlines()
 
668
                return tree.get_file_lines(file_id, path)
661
669
            else:
662
670
                return []
663
671
        try:
664
672
            from_text = _get_text(self.old_tree, from_file_id, from_path)
665
673
            to_text = _get_text(self.new_tree, to_file_id, to_path)
666
674
            self.text_differ(from_label, from_text, to_label, to_text,
667
 
                             self.to_file)
 
675
                             self.to_file, path_encoding=self.path_encoding)
668
676
        except errors.BinaryFile:
669
677
            self.to_file.write(
670
678
                  ("Binary files %s and %s differ\n" %
671
 
                  (from_label, to_label)).encode(self.path_encoding))
 
679
                  (from_label, to_label)).encode(self.path_encoding,'replace'))
672
680
        return self.CHANGED
673
681
 
674
682
 
683
691
    @classmethod
684
692
    def from_string(klass, command_string, old_tree, new_tree, to_file,
685
693
                    path_encoding='utf-8'):
686
 
        command_template = commands.shlex_split_unicode(command_string)
 
694
        command_template = cmdline.split(command_string)
687
695
        if '@' not in command_string:
688
696
            command_template.extend(['@old_path', '@new_path'])
689
697
        return klass(command_template, old_tree, new_tree, to_file,
690
698
                     path_encoding)
691
699
 
692
700
    @classmethod
693
 
    def make_from_diff_tree(klass, command_string):
 
701
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
694
702
        def from_diff_tree(diff_tree):
695
 
            return klass.from_string(command_string, diff_tree.old_tree,
 
703
            full_command_string = [command_string]
 
704
            if external_diff_options is not None:
 
705
                full_command_string += ' ' + external_diff_options
 
706
            return klass.from_string(full_command_string, diff_tree.old_tree,
696
707
                                     diff_tree.new_tree, diff_tree.to_file)
697
708
        return from_diff_tree
698
709
 
699
710
    def _get_command(self, old_path, new_path):
700
711
        my_map = {'old_path': old_path, 'new_path': new_path}
701
 
        return [AtTemplate(t).substitute(my_map) for t in
702
 
                self.command_template]
 
712
        command = [AtTemplate(t).substitute(my_map) for t in
 
713
                   self.command_template]
 
714
        if sys.platform == 'win32': # Popen doesn't accept unicode on win32
 
715
            command_encoded = []
 
716
            for c in command:
 
717
                if isinstance(c, unicode):
 
718
                    command_encoded.append(c.encode('mbcs'))
 
719
                else:
 
720
                    command_encoded.append(c)
 
721
            return command_encoded
 
722
        else:
 
723
            return command
703
724
 
704
725
    def _execute(self, old_path, new_path):
705
726
        command = self._get_command(old_path, new_path)
725
746
                raise
726
747
        return True
727
748
 
 
749
    @staticmethod
 
750
    def _fenc():
 
751
        """Returns safe encoding for passing file path to diff tool"""
 
752
        if sys.platform == 'win32':
 
753
            return 'mbcs'
 
754
        else:
 
755
            # Don't fallback to 'utf-8' because subprocess may not be able to
 
756
            # handle utf-8 correctly when locale is not utf-8.
 
757
            return sys.getfilesystemencoding() or 'ascii'
 
758
 
 
759
    def _is_safepath(self, path):
 
760
        """Return true if `path` may be able to pass to subprocess."""
 
761
        fenc = self._fenc()
 
762
        try:
 
763
            return path == path.encode(fenc).decode(fenc)
 
764
        except UnicodeError:
 
765
            return False
 
766
 
 
767
    def _safe_filename(self, prefix, relpath):
 
768
        """Replace unsafe character in `relpath` then join `self._root`,
 
769
        `prefix` and `relpath`."""
 
770
        fenc = self._fenc()
 
771
        # encoded_str.replace('?', '_') may break multibyte char.
 
772
        # So we should encode, decode, then replace(u'?', u'_')
 
773
        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
 
774
        relpath_tmp = relpath_tmp.replace(u'?', u'_')
 
775
        return osutils.pathjoin(self._root, prefix, relpath_tmp)
 
776
 
728
777
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
729
778
                    allow_write=False):
730
779
        if not force_temp and isinstance(tree, WorkingTree):
731
 
            return tree.abspath(tree.id2path(file_id))
732
 
        
733
 
        full_path = osutils.pathjoin(self._root, prefix, relpath)
 
780
            full_path = tree.abspath(tree.id2path(file_id))
 
781
            if self._is_safepath(full_path):
 
782
                return full_path
 
783
 
 
784
        full_path = self._safe_filename(prefix, relpath)
734
785
        if not force_temp and self._try_symlink_root(tree, prefix):
735
786
            return full_path
736
787
        parent_dir = osutils.dirname(full_path)
748
799
                target.close()
749
800
        finally:
750
801
            source.close()
 
802
        try:
 
803
            mtime = tree.get_file_mtime(file_id)
 
804
        except errors.FileTimestampUnavailable:
 
805
            pass
 
806
        else:
 
807
            os.utime(full_path, (mtime, mtime))
751
808
        if not allow_write:
752
809
            osutils.make_readonly(full_path)
753
 
        try:
754
 
            mtime = tree.get_file_mtime(file_id)
755
 
        except errors.FileTimestampUnavailable:
756
 
            mtime = 0
757
 
        os.utime(full_path, (mtime, mtime))
758
810
        return full_path
759
811
 
760
812
    def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
792
844
        """
793
845
        old_path = self.old_tree.id2path(file_id)
794
846
        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))
 
847
        old_abs_path, new_abs_path = self._prepare_files(
 
848
                                            file_id, old_path, new_path,
 
849
                                            allow_write_new=True,
 
850
                                            force_temp=True)
 
851
        command = self._get_command(old_abs_path, new_abs_path)
800
852
        subprocess.call(command, cwd=self._root)
801
 
        new_file = open(new_abs_path, 'r')
 
853
        new_file = open(new_abs_path, 'rb')
802
854
        try:
803
855
            return new_file.read()
804
856
        finally:
854
906
        """Factory for producing a DiffTree.
855
907
 
856
908
        Designed to accept options used by show_diff_trees.
 
909
 
857
910
        :param old_tree: The tree to show as old in the comparison
858
911
        :param new_tree: The tree to show as new in the comparison
859
912
        :param to_file: File to write comparisons to
865
918
        :param using: Commandline to use to invoke an external diff tool
866
919
        """
867
920
        if using is not None:
868
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
 
921
            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
869
922
        else:
870
923
            extra_factories = []
871
924
        if external_diff_options:
872
925
            opts = external_diff_options.split()
873
 
            def diff_file(olab, olines, nlab, nlines, to_file):
 
926
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None):
 
927
                """:param path_encoding: not used but required
 
928
                        to match the signature of internal_diff.
 
929
                """
874
930
                external_diff(olab, olines, nlab, nlines, to_file, opts)
875
931
        else:
876
932
            diff_file = internal_diff
882
938
    def show_diff(self, specific_files, extra_trees=None):
883
939
        """Write tree diff to self.to_file
884
940
 
885
 
        :param sepecific_files: the specific files to compare (recursive)
 
941
        :param specific_files: the specific files to compare (recursive)
886
942
        :param extra_trees: extra trees to use for mapping paths to file_ids
887
943
        """
888
944
        try:
978
1034
            if error_path is None:
979
1035
                error_path = old_path
980
1036
            raise errors.NoDiffFound(error_path)
 
1037
 
 
1038
 
 
1039
format_registry = Registry()
 
1040
format_registry.register('default', DiffTree)