← 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-03-11 13:47:06 UTC
  • mfrom: (5051.3.16 use-branch-open)
  • Revision ID: pqm@pqm.ubuntu.com-20100311134706-kaerqhx3lf7xn6rh
(Jelmer) Pass colocated branch names further down the call stack.

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
 
42
46
from bzrlib.symbol_versioning import (
43
 
        deprecated_function,
44
 
        one_three
45
 
        )
46
 
from bzrlib.trace import mutter, warning
 
47
    deprecated_function,
 
48
    )
 
49
from bzrlib.trace import mutter, note, warning
 
50
 
 
51
 
 
52
class AtTemplate(string.Template):
 
53
    """Templating class that uses @ instead of $."""
 
54
 
 
55
    delimiter = '@'
47
56
 
48
57
 
49
58
# TODO: Rather than building a changeset object, we should probably
78
87
    # both sequences are empty.
79
88
    if not oldlines and not newlines:
80
89
        return
81
 
    
 
90
 
82
91
    if allow_binary is False:
83
92
        textfile.check_text_lines(oldlines)
84
93
        textfile.check_text_lines(newlines)
99
108
        ud[2] = ud[2].replace('-1,0', '-0,0')
100
109
    elif not newlines:
101
110
        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
111
 
106
112
    for line in ud:
107
113
        to_file.write(line)
174
180
 
175
181
        if not diff_opts:
176
182
            diff_opts = []
 
183
        if sys.platform == 'win32':
 
184
            # Popen doesn't do the proper encoding for external commands
 
185
            # Since we are dealing with an ANSI api, use mbcs encoding
 
186
            old_filename = old_filename.encode('mbcs')
 
187
            new_filename = new_filename.encode('mbcs')
177
188
        diffcmd = ['diff',
178
189
                   '--label', old_filename,
179
190
                   old_abspath,
202
213
            break
203
214
        else:
204
215
            diffcmd.append('-u')
205
 
                  
 
216
 
206
217
        if diff_opts:
207
218
            diffcmd.extend(diff_opts)
208
219
 
209
220
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
210
221
        out,err = pipe.communicate()
211
222
        rc = pipe.returncode
212
 
        
 
223
 
213
224
        # internal_diff() adds a trailing newline, add one here for consistency
214
225
        out += '\n'
215
226
        if rc == 2:
250
261
                msg = 'signal %d' % (-rc)
251
262
            else:
252
263
                msg = 'exit code %d' % rc
253
 
                
254
 
            raise errors.BzrError('external diff failed with %s; command: %r' 
 
264
 
 
265
            raise errors.BzrError('external diff failed with %s; command: %r'
255
266
                                  % (rc, diffcmd))
256
267
 
257
268
 
275
286
                        new_abspath, e)
276
287
 
277
288
 
278
 
def _get_trees_to_diff(path_list, revision_specs, old_url, new_url):
 
289
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
 
290
                                   apply_view=True):
279
291
    """Get the trees and specific files to diff given a list of paths.
280
292
 
281
293
    This method works out the trees to be diff'ed and the files of
292
304
    :param new_url:
293
305
        The url of the new branch or tree. If None, the tree to use is
294
306
        taken from the first path, if any, or the current working tree.
 
307
    :param apply_view:
 
308
        if True and a view is set, apply the view or check that the paths
 
309
        are within it
295
310
    :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.
 
311
        a tuple of (old_tree, new_tree, old_branch, new_branch,
 
312
        specific_files, extra_trees) where extra_trees is a sequence of
 
313
        additional trees to search in for file-ids.
299
314
    """
300
315
    # Get the old and new revision specs
301
316
    old_revision_spec = None
331
346
    working_tree, branch, relpath = \
332
347
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
333
348
    if consider_relpath and relpath != '':
 
349
        if working_tree is not None and apply_view:
 
350
            views.check_path_in_view(working_tree, relpath)
334
351
        specific_files.append(relpath)
335
352
    old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
 
353
    old_branch = branch
336
354
 
337
355
    # Get the new location
338
356
    if new_url is None:
341
359
        working_tree, branch, relpath = \
342
360
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
343
361
        if consider_relpath and relpath != '':
 
362
            if working_tree is not None and apply_view:
 
363
                views.check_path_in_view(working_tree, relpath)
344
364
            specific_files.append(relpath)
345
365
    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
346
366
        basis_is_default=working_tree is None)
 
367
    new_branch = branch
347
368
 
348
369
    # Get the specific files (all files is None, no files is [])
349
370
    if make_paths_wt_relative and working_tree is not None:
350
 
        other_paths = _relative_paths_in_tree(working_tree, other_paths)
 
371
        try:
 
372
            from bzrlib.builtins import safe_relpath_files
 
373
            other_paths = safe_relpath_files(working_tree, other_paths,
 
374
            apply_view=apply_view)
 
375
        except errors.FileInWrongBranch:
 
376
            raise errors.BzrCommandError("Files are in different branches")
351
377
    specific_files.extend(other_paths)
352
378
    if len(specific_files) == 0:
353
379
        specific_files = None
 
380
        if (working_tree is not None and working_tree.supports_views()
 
381
            and apply_view):
 
382
            view_files = working_tree.views.lookup_view()
 
383
            if view_files:
 
384
                specific_files = view_files
 
385
                view_str = views.view_display_str(view_files)
 
386
                note("*** Ignoring files outside view. View is %s" % view_str)
354
387
 
355
388
    # Get extra trees that ought to be searched for file-ids
356
389
    extra_trees = None
357
390
    if working_tree is not None and working_tree not in (old_tree, new_tree):
358
391
        extra_trees = (working_tree,)
359
 
    return old_tree, new_tree, specific_files, extra_trees
 
392
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
360
393
 
361
394
 
362
395
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
370
403
                return branch.basis_tree()
371
404
        else:
372
405
            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
 
406
    return spec.as_tree(branch)
392
407
 
393
408
 
394
409
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
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):
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: