~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

(gz) Fix test failure on alpha by correcting format string for
 gc_chk_sha1_record (Martin [gz])

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
25
25
import errno
26
26
import subprocess
27
27
import tempfile
 
28
import time
28
29
 
29
30
from bzrlib import (
 
31
    branch as _mod_branch,
30
32
    bzrdir,
31
33
    cmdline,
32
34
    cleanup,
39
41
    )
40
42
 
41
43
from bzrlib.workingtree import WorkingTree
42
 
from bzrlib.i18n import gettext
43
44
""")
44
45
 
45
46
from bzrlib.registry import (
46
47
    Registry,
47
48
    )
 
49
from bzrlib.symbol_versioning import (
 
50
    deprecated_function,
 
51
    deprecated_in,
 
52
    )
48
53
from bzrlib.trace import mutter, note, warning
49
54
 
50
55
 
285
290
                        new_abspath, e)
286
291
 
287
292
 
 
293
@deprecated_function(deprecated_in((2, 2, 0)))
 
294
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
 
295
                                   apply_view=True):
 
296
    """Get the trees and specific files to diff given a list of paths.
 
297
 
 
298
    This method works out the trees to be diff'ed and the files of
 
299
    interest within those trees.
 
300
 
 
301
    :param path_list:
 
302
        the list of arguments passed to the diff command
 
303
    :param revision_specs:
 
304
        Zero, one or two RevisionSpecs from the diff command line,
 
305
        saying what revisions to compare.
 
306
    :param old_url:
 
307
        The url of the old branch or tree. If None, the tree to use is
 
308
        taken from the first path, if any, or the current working tree.
 
309
    :param new_url:
 
310
        The url of the new branch or tree. If None, the tree to use is
 
311
        taken from the first path, if any, or the current working tree.
 
312
    :param apply_view:
 
313
        if True and a view is set, apply the view or check that the paths
 
314
        are within it
 
315
    :returns:
 
316
        a tuple of (old_tree, new_tree, old_branch, new_branch,
 
317
        specific_files, extra_trees) where extra_trees is a sequence of
 
318
        additional trees to search in for file-ids.  The trees and branches
 
319
        are not locked.
 
320
    """
 
321
    op = cleanup.OperationWithCleanups(get_trees_and_branches_to_diff_locked)
 
322
    return op.run_simple(path_list, revision_specs, old_url, new_url,
 
323
            op.add_cleanup, apply_view=apply_view)
 
324
    
 
325
 
288
326
def get_trees_and_branches_to_diff_locked(
289
327
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
290
328
    """Get the trees and specific files to diff given a list of paths.
394
432
            if view_files:
395
433
                specific_files = view_files
396
434
                view_str = views.view_display_str(view_files)
397
 
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
 
435
                note("*** Ignoring files outside view. View is %s" % view_str)
398
436
 
399
437
    # Get extra trees that ought to be searched for file-ids
400
438
    extra_trees = None
401
439
    if working_tree is not None and working_tree not in (old_tree, new_tree):
402
440
        extra_trees = (working_tree,)
403
 
    return (old_tree, new_tree, old_branch, new_branch,
404
 
            specific_files, extra_trees)
 
441
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
405
442
 
406
443
 
407
444
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
428
465
    """Show in text form the changes from one tree to another.
429
466
 
430
467
    :param to_file: The output stream.
431
 
    :param specific_files: Include only changes to these files - None for all
 
468
    :param specific_files:Include only changes to these files - None for all
432
469
        changes.
433
470
    :param external_diff_options: If set, use an external GNU diff and pass 
434
471
        these options.
710
747
 
711
748
    def _get_command(self, old_path, new_path):
712
749
        my_map = {'old_path': old_path, 'new_path': new_path}
713
 
        command = [AtTemplate(t).substitute(my_map) for t in
714
 
                   self.command_template]
715
 
        if sys.platform == 'win32': # Popen doesn't accept unicode on win32
716
 
            command_encoded = []
717
 
            for c in command:
718
 
                if isinstance(c, unicode):
719
 
                    command_encoded.append(c.encode('mbcs'))
720
 
                else:
721
 
                    command_encoded.append(c)
722
 
            return command_encoded
723
 
        else:
724
 
            return command
 
750
        return [AtTemplate(t).substitute(my_map) for t in
 
751
                self.command_template]
725
752
 
726
753
    def _execute(self, old_path, new_path):
727
754
        command = self._get_command(old_path, new_path)
747
774
                raise
748
775
        return True
749
776
 
750
 
    @staticmethod
751
 
    def _fenc():
752
 
        """Returns safe encoding for passing file path to diff tool"""
753
 
        if sys.platform == 'win32':
754
 
            return 'mbcs'
755
 
        else:
756
 
            # Don't fallback to 'utf-8' because subprocess may not be able to
757
 
            # handle utf-8 correctly when locale is not utf-8.
758
 
            return sys.getfilesystemencoding() or 'ascii'
759
 
 
760
 
    def _is_safepath(self, path):
761
 
        """Return true if `path` may be able to pass to subprocess."""
762
 
        fenc = self._fenc()
763
 
        try:
764
 
            return path == path.encode(fenc).decode(fenc)
765
 
        except UnicodeError:
766
 
            return False
767
 
 
768
 
    def _safe_filename(self, prefix, relpath):
769
 
        """Replace unsafe character in `relpath` then join `self._root`,
770
 
        `prefix` and `relpath`."""
771
 
        fenc = self._fenc()
772
 
        # encoded_str.replace('?', '_') may break multibyte char.
773
 
        # So we should encode, decode, then replace(u'?', u'_')
774
 
        relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
775
 
        relpath_tmp = relpath_tmp.replace(u'?', u'_')
776
 
        return osutils.pathjoin(self._root, prefix, relpath_tmp)
777
 
 
778
777
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
779
778
                    allow_write=False):
780
779
        if not force_temp and isinstance(tree, WorkingTree):
781
 
            full_path = tree.abspath(tree.id2path(file_id))
782
 
            if self._is_safepath(full_path):
783
 
                return full_path
784
 
 
785
 
        full_path = self._safe_filename(prefix, relpath)
 
780
            return tree.abspath(tree.id2path(file_id))
 
781
        
 
782
        full_path = osutils.pathjoin(self._root, prefix, relpath)
786
783
        if not force_temp and self._try_symlink_root(tree, prefix):
787
784
            return full_path
788
785
        parent_dir = osutils.dirname(full_path)
845
842
        """
846
843
        old_path = self.old_tree.id2path(file_id)
847
844
        new_path = self.new_tree.id2path(file_id)
848
 
        old_abs_path, new_abs_path = self._prepare_files(
849
 
                                            file_id, old_path, new_path,
850
 
                                            allow_write_new=True,
851
 
                                            force_temp=True)
852
 
        command = self._get_command(old_abs_path, new_abs_path)
 
845
        new_abs_path = self._prepare_files(file_id, old_path, new_path,
 
846
                                           allow_write_new=True,
 
847
                                           force_temp=True)[1]
 
848
        command = self._get_command(osutils.pathjoin('old', old_path),
 
849
                                    osutils.pathjoin('new', new_path))
853
850
        subprocess.call(command, cwd=self._root)
854
 
        new_file = open(new_abs_path, 'rb')
 
851
        new_file = open(new_abs_path, 'r')
855
852
        try:
856
853
            return new_file.read()
857
854
        finally:
907
904
        """Factory for producing a DiffTree.
908
905
 
909
906
        Designed to accept options used by show_diff_trees.
910
 
 
911
907
        :param old_tree: The tree to show as old in the comparison
912
908
        :param new_tree: The tree to show as new in the comparison
913
909
        :param to_file: File to write comparisons to