~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Patch Queue Manager
  • Date: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 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
25
25
import errno
26
26
import subprocess
27
27
import tempfile
28
 
import time
29
28
 
30
29
from bzrlib import (
31
 
    branch as _mod_branch,
32
30
    bzrdir,
33
31
    cmdline,
34
32
    cleanup,
41
39
    )
42
40
 
43
41
from bzrlib.workingtree import WorkingTree
 
42
from bzrlib.i18n import gettext
44
43
""")
45
44
 
46
45
from bzrlib.registry import (
47
46
    Registry,
48
47
    )
49
 
from bzrlib.symbol_versioning import (
50
 
    deprecated_function,
51
 
    deprecated_in,
52
 
    )
53
48
from bzrlib.trace import mutter, note, warning
54
49
 
55
50
 
290
285
                        new_abspath, e)
291
286
 
292
287
 
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
 
 
326
288
def get_trees_and_branches_to_diff_locked(
327
289
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
328
290
    """Get the trees and specific files to diff given a list of paths.
432
394
            if view_files:
433
395
                specific_files = view_files
434
396
                view_str = views.view_display_str(view_files)
435
 
                note("*** Ignoring files outside view. View is %s" % view_str)
 
397
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
436
398
 
437
399
    # Get extra trees that ought to be searched for file-ids
438
400
    extra_trees = None
439
401
    if working_tree is not None and working_tree not in (old_tree, new_tree):
440
402
        extra_trees = (working_tree,)
441
 
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
 
403
    return (old_tree, new_tree, old_branch, new_branch,
 
404
            specific_files, extra_trees)
442
405
 
443
406
 
444
407
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
465
428
    """Show in text form the changes from one tree to another.
466
429
 
467
430
    :param to_file: The output stream.
468
 
    :param specific_files:Include only changes to these files - None for all
 
431
    :param specific_files: Include only changes to these files - None for all
469
432
        changes.
470
433
    :param external_diff_options: If set, use an external GNU diff and pass 
471
434
        these options.
747
710
 
748
711
    def _get_command(self, old_path, new_path):
749
712
        my_map = {'old_path': old_path, 'new_path': new_path}
750
 
        return [AtTemplate(t).substitute(my_map) for t in
751
 
                self.command_template]
 
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
752
725
 
753
726
    def _execute(self, old_path, new_path):
754
727
        command = self._get_command(old_path, new_path)
774
747
                raise
775
748
        return True
776
749
 
 
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
 
777
778
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
778
779
                    allow_write=False):
779
780
        if not force_temp and isinstance(tree, WorkingTree):
780
 
            return tree.abspath(tree.id2path(file_id))
781
 
        
782
 
        full_path = osutils.pathjoin(self._root, prefix, relpath)
 
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)
783
786
        if not force_temp and self._try_symlink_root(tree, prefix):
784
787
            return full_path
785
788
        parent_dir = osutils.dirname(full_path)
842
845
        """
843
846
        old_path = self.old_tree.id2path(file_id)
844
847
        new_path = self.new_tree.id2path(file_id)
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))
 
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)
850
853
        subprocess.call(command, cwd=self._root)
851
 
        new_file = open(new_abs_path, 'r')
 
854
        new_file = open(new_abs_path, 'rb')
852
855
        try:
853
856
            return new_file.read()
854
857
        finally:
904
907
        """Factory for producing a DiffTree.
905
908
 
906
909
        Designed to accept options used by show_diff_trees.
 
910
 
907
911
        :param old_tree: The tree to show as old in the comparison
908
912
        :param new_tree: The tree to show as new in the comparison
909
913
        :param to_file: File to write comparisons to