← 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-06 06:59:03 UTC
  • mfrom: (5051.5.1 subunit)
  • Revision ID: pqm@pqm.ubuntu.com-20100406065903-y9dxgwmog1pmw7dz
Use subunit when running tests in PQM.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
1
 
# Copyright (C) 2005-2011 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
17
17
import difflib
18
18
import os
19
19
import re
 
20
import shutil
20
21
import string
21
22
import sys
22
23
 
25
26
import errno
26
27
import subprocess
27
28
import tempfile
 
29
import time
28
30
 
29
31
from bzrlib import (
 
32
    branch as _mod_branch,
30
33
    bzrdir,
31
34
    cmdline,
32
 
    cleanup,
33
35
    errors,
34
36
    osutils,
35
37
    patiencediff,
46
48
    )
47
49
from bzrlib.symbol_versioning import (
48
50
    deprecated_function,
49
 
    deprecated_in,
50
51
    )
51
52
from bzrlib.trace import mutter, note, warning
52
53
 
97
98
    if sequence_matcher is None:
98
99
        sequence_matcher = patiencediff.PatienceSequenceMatcher
99
100
    ud = patiencediff.unified_diff(oldlines, newlines,
100
 
                      fromfile=old_filename.encode(path_encoding, 'replace'),
101
 
                      tofile=new_filename.encode(path_encoding, 'replace'),
 
101
                      fromfile=old_filename.encode(path_encoding),
 
102
                      tofile=new_filename.encode(path_encoding),
102
103
                      sequencematcher=sequence_matcher)
103
104
 
104
105
    ud = list(ud)
288
289
                        new_abspath, e)
289
290
 
290
291
 
291
 
@deprecated_function(deprecated_in((2, 2, 0)))
292
292
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
293
293
                                   apply_view=True):
294
294
    """Get the trees and specific files to diff given a list of paths.
313
313
    :returns:
314
314
        a tuple of (old_tree, new_tree, old_branch, new_branch,
315
315
        specific_files, extra_trees) where extra_trees is a sequence of
316
 
        additional trees to search in for file-ids.  The trees and branches
317
 
        are not locked.
318
 
    """
319
 
    op = cleanup.OperationWithCleanups(get_trees_and_branches_to_diff_locked)
320
 
    return op.run_simple(path_list, revision_specs, old_url, new_url,
321
 
            op.add_cleanup, apply_view=apply_view)
322
 
    
323
 
 
324
 
def get_trees_and_branches_to_diff_locked(
325
 
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
326
 
    """Get the trees and specific files to diff given a list of paths.
327
 
 
328
 
    This method works out the trees to be diff'ed and the files of
329
 
    interest within those trees.
330
 
 
331
 
    :param path_list:
332
 
        the list of arguments passed to the diff command
333
 
    :param revision_specs:
334
 
        Zero, one or two RevisionSpecs from the diff command line,
335
 
        saying what revisions to compare.
336
 
    :param old_url:
337
 
        The url of the old branch or tree. If None, the tree to use is
338
 
        taken from the first path, if any, or the current working tree.
339
 
    :param new_url:
340
 
        The url of the new branch or tree. If None, the tree to use is
341
 
        taken from the first path, if any, or the current working tree.
342
 
    :param add_cleanup:
343
 
        a callable like Command.add_cleanup.  get_trees_and_branches_to_diff
344
 
        will register cleanups that must be run to unlock the trees, etc.
345
 
    :param apply_view:
346
 
        if True and a view is set, apply the view or check that the paths
347
 
        are within it
348
 
    :returns:
349
 
        a tuple of (old_tree, new_tree, old_branch, new_branch,
350
 
        specific_files, extra_trees) where extra_trees is a sequence of
351
 
        additional trees to search in for file-ids.  The trees and branches
352
 
        will be read-locked until the cleanups registered via the add_cleanup
353
 
        param are run.
 
316
        additional trees to search in for file-ids.
354
317
    """
355
318
    # Get the old and new revision specs
356
319
    old_revision_spec = None
379
342
        default_location = path_list[0]
380
343
        other_paths = path_list[1:]
381
344
 
382
 
    def lock_tree_or_branch(wt, br):
383
 
        if wt is not None:
384
 
            wt.lock_read()
385
 
            add_cleanup(wt.unlock)
386
 
        elif br is not None:
387
 
            br.lock_read()
388
 
            add_cleanup(br.unlock)
389
 
 
390
345
    # Get the old location
391
346
    specific_files = []
392
347
    if old_url is None:
393
348
        old_url = default_location
394
349
    working_tree, branch, relpath = \
395
350
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
396
 
    lock_tree_or_branch(working_tree, branch)
397
351
    if consider_relpath and relpath != '':
398
352
        if working_tree is not None and apply_view:
399
353
            views.check_path_in_view(working_tree, relpath)
407
361
    if new_url != old_url:
408
362
        working_tree, branch, relpath = \
409
363
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
410
 
        lock_tree_or_branch(working_tree, branch)
411
364
        if consider_relpath and relpath != '':
412
365
            if working_tree is not None and apply_view:
413
366
                views.check_path_in_view(working_tree, relpath)
418
371
 
419
372
    # Get the specific files (all files is None, no files is [])
420
373
    if make_paths_wt_relative and working_tree is not None:
421
 
        other_paths = working_tree.safe_relpath_files(
422
 
            other_paths,
 
374
        try:
 
375
            from bzrlib.builtins import safe_relpath_files
 
376
            other_paths = safe_relpath_files(working_tree, other_paths,
423
377
            apply_view=apply_view)
 
378
        except errors.FileInWrongBranch:
 
379
            raise errors.BzrCommandError("Files are in different branches")
424
380
    specific_files.extend(other_paths)
425
381
    if len(specific_files) == 0:
426
382
        specific_files = None
463
419
    """Show in text form the changes from one tree to another.
464
420
 
465
421
    :param to_file: The output stream.
466
 
    :param specific_files: Include only changes to these files - None for all
 
422
    :param specific_files:Include only changes to these files - None for all
467
423
        changes.
468
424
    :param external_diff_options: If set, use an external GNU diff and pass 
469
425
        these options.
701
657
        """
702
658
        def _get_text(tree, file_id, path):
703
659
            if file_id is not None:
704
 
                return tree.get_file_lines(file_id, path)
 
660
                return tree.get_file(file_id, path).readlines()
705
661
            else:
706
662
                return []
707
663
        try:
708
664
            from_text = _get_text(self.old_tree, from_file_id, from_path)
709
665
            to_text = _get_text(self.new_tree, to_file_id, to_path)
710
666
            self.text_differ(from_label, from_text, to_label, to_text,
711
 
                             self.to_file, path_encoding=self.path_encoding)
 
667
                             self.to_file)
712
668
        except errors.BinaryFile:
713
669
            self.to_file.write(
714
670
                  ("Binary files %s and %s differ\n" %
715
 
                  (from_label, to_label)).encode(self.path_encoding,'replace'))
 
671
                  (from_label, to_label)).encode(self.path_encoding))
716
672
        return self.CHANGED
717
673
 
718
674
 
734
690
                     path_encoding)
735
691
 
736
692
    @classmethod
737
 
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
 
693
    def make_from_diff_tree(klass, command_string):
738
694
        def from_diff_tree(diff_tree):
739
 
            full_command_string = [command_string]
740
 
            if external_diff_options is not None:
741
 
                full_command_string += ' ' + external_diff_options
742
 
            return klass.from_string(full_command_string, diff_tree.old_tree,
 
695
            return klass.from_string(command_string, diff_tree.old_tree,
743
696
                                     diff_tree.new_tree, diff_tree.to_file)
744
697
        return from_diff_tree
745
698
 
746
699
    def _get_command(self, old_path, new_path):
747
700
        my_map = {'old_path': old_path, 'new_path': new_path}
748
 
        command = [AtTemplate(t).substitute(my_map) for t in
749
 
                   self.command_template]
750
 
        if sys.platform == 'win32': # Popen doesn't accept unicode on win32
751
 
            command_encoded = []
752
 
            for c in command:
753
 
                if isinstance(c, unicode):
754
 
                    command_encoded.append(c.encode('mbcs'))
755
 
                else:
756
 
                    command_encoded.append(c)
757
 
            return command_encoded
758
 
        else:
759
 
            return command
 
701
        return [AtTemplate(t).substitute(my_map) for t in
 
702
                self.command_template]
760
703
 
761
704
    def _execute(self, old_path, new_path):
762
705
        command = self._get_command(old_path, new_path)
782
725
                raise
783
726
        return True
784
727
 
785
 
    @staticmethod
786
 
    def _fenc():
787
 
        """Returns safe encoding for passing file path to diff tool"""
788
 
        if sys.platform == 'win32':
789
 
            return 'mbcs'
790
 
        else:
791
 
            # Don't fallback to 'utf-8' because subprocess may not be able to
792
 
            # handle utf-8 correctly when locale is not utf-8.
793
 
            return sys.getfilesystemencoding() or 'ascii'
794
 
 
795
 
    def _is_safepath(self, path):
796
 
        """Return true if `path` may be able to pass to subprocess."""
797
 
        fenc = self._fenc()
798
 
        try:
799
 
            return path == path.encode(fenc).decode(fenc)
800
 
        except UnicodeError:
801
 
            return False
802
 
 
803
 
    def _safe_filename(self, prefix, relpath):
804
 
        """Replace unsafe character in `relpath` then join `self._root`,
805
 
        `prefix` and `relpath`."""
806
 
        fenc = self._fenc()
807
 
        # encoded_str.replace('?', '_') may break multibyte char.
808
 
        # So we should encode, decode, then replace(u'?', u'_')
809
 
        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
810
 
        relpath_tmp = relpath_tmp.replace(u'?', u'_')
811
 
        return osutils.pathjoin(self._root, prefix, relpath_tmp)
812
 
 
813
728
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
814
729
                    allow_write=False):
815
730
        if not force_temp and isinstance(tree, WorkingTree):
816
 
            full_path = tree.abspath(tree.id2path(file_id))
817
 
            if self._is_safepath(full_path):
818
 
                return full_path
819
 
 
820
 
        full_path = self._safe_filename(prefix, relpath)
 
731
            return tree.abspath(tree.id2path(file_id))
 
732
        
 
733
        full_path = osutils.pathjoin(self._root, prefix, relpath)
821
734
        if not force_temp and self._try_symlink_root(tree, prefix):
822
735
            return full_path
823
736
        parent_dir = osutils.dirname(full_path)
835
748
                target.close()
836
749
        finally:
837
750
            source.close()
 
751
        if not allow_write:
 
752
            osutils.make_readonly(full_path)
838
753
        try:
839
754
            mtime = tree.get_file_mtime(file_id)
840
755
        except errors.FileTimestampUnavailable:
841
 
            pass
842
 
        else:
843
 
            os.utime(full_path, (mtime, mtime))
844
 
        if not allow_write:
845
 
            osutils.make_readonly(full_path)
 
756
            mtime = 0
 
757
        os.utime(full_path, (mtime, mtime))
846
758
        return full_path
847
759
 
848
760
    def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
880
792
        """
881
793
        old_path = self.old_tree.id2path(file_id)
882
794
        new_path = self.new_tree.id2path(file_id)
883
 
        old_abs_path, new_abs_path = self._prepare_files(
884
 
                                            file_id, old_path, new_path,
885
 
                                            allow_write_new=True,
886
 
                                            force_temp=True)
887
 
        command = self._get_command(old_abs_path, new_abs_path)
 
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))
888
800
        subprocess.call(command, cwd=self._root)
889
 
        new_file = open(new_abs_path, 'rb')
 
801
        new_file = open(new_abs_path, 'r')
890
802
        try:
891
803
            return new_file.read()
892
804
        finally:
942
854
        """Factory for producing a DiffTree.
943
855
 
944
856
        Designed to accept options used by show_diff_trees.
945
 
 
946
857
        :param old_tree: The tree to show as old in the comparison
947
858
        :param new_tree: The tree to show as new in the comparison
948
859
        :param to_file: File to write comparisons to
954
865
        :param using: Commandline to use to invoke an external diff tool
955
866
        """
956
867
        if using is not None:
957
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
 
868
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
958
869
        else:
959
870
            extra_factories = []
960
871
        if external_diff_options:
961
872
            opts = external_diff_options.split()
962
 
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None):
963
 
                """:param path_encoding: not used but required
964
 
                        to match the signature of internal_diff.
965
 
                """
 
873
            def diff_file(olab, olines, nlab, nlines, to_file):
966
874
                external_diff(olab, olines, nlab, nlines, to_file, opts)
967
875
        else:
968
876
            diff_file = internal_diff