/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Andrew Bennetts
  • Date: 2010-04-13 04:33:55 UTC
  • mfrom: (5147 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5149.
  • Revision ID: andrew.bennetts@canonical.com-20100413043355-lg3id0uwtju0k3zs
Merge lp:bzr.

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
 
 
46
from bzrlib.registry import (
 
47
    Registry,
 
48
    )
42
49
from bzrlib.symbol_versioning import (
43
 
        deprecated_function,
44
 
        one_three
45
 
        )
46
 
from bzrlib.trace import warning
 
50
    deprecated_function,
 
51
    )
 
52
from bzrlib.trace import mutter, note, warning
 
53
 
 
54
 
 
55
class AtTemplate(string.Template):
 
56
    """Templating class that uses @ instead of $."""
 
57
 
 
58
    delimiter = '@'
47
59
 
48
60
 
49
61
# TODO: Rather than building a changeset object, we should probably
78
90
    # both sequences are empty.
79
91
    if not oldlines and not newlines:
80
92
        return
81
 
    
 
93
 
82
94
    if allow_binary is False:
83
95
        textfile.check_text_lines(oldlines)
84
96
        textfile.check_text_lines(newlines)
99
111
        ud[2] = ud[2].replace('-1,0', '-0,0')
100
112
    elif not newlines:
101
113
        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
114
 
106
115
    for line in ud:
107
116
        to_file.write(line)
174
183
 
175
184
        if not diff_opts:
176
185
            diff_opts = []
 
186
        if sys.platform == 'win32':
 
187
            # Popen doesn't do the proper encoding for external commands
 
188
            # Since we are dealing with an ANSI api, use mbcs encoding
 
189
            old_filename = old_filename.encode('mbcs')
 
190
            new_filename = new_filename.encode('mbcs')
177
191
        diffcmd = ['diff',
178
192
                   '--label', old_filename,
179
193
                   old_abspath,
202
216
            break
203
217
        else:
204
218
            diffcmd.append('-u')
205
 
                  
 
219
 
206
220
        if diff_opts:
207
221
            diffcmd.extend(diff_opts)
208
222
 
209
223
        pipe = _spawn_external_diff(diffcmd, capture_errors=True)
210
224
        out,err = pipe.communicate()
211
225
        rc = pipe.returncode
212
 
        
 
226
 
213
227
        # internal_diff() adds a trailing newline, add one here for consistency
214
228
        out += '\n'
215
229
        if rc == 2:
250
264
                msg = 'signal %d' % (-rc)
251
265
            else:
252
266
                msg = 'exit code %d' % rc
253
 
                
254
 
            raise errors.BzrError('external diff failed with %s; command: %r' 
 
267
 
 
268
            raise errors.BzrError('external diff failed with %s; command: %r'
255
269
                                  % (rc, diffcmd))
256
270
 
257
271
 
275
289
                        new_abspath, e)
276
290
 
277
291
 
278
 
def _get_trees_to_diff(path_list, revision_specs, old_url, new_url):
 
292
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
 
293
                                   apply_view=True):
279
294
    """Get the trees and specific files to diff given a list of paths.
280
295
 
281
296
    This method works out the trees to be diff'ed and the files of
292
307
    :param new_url:
293
308
        The url of the new branch or tree. If None, the tree to use is
294
309
        taken from the first path, if any, or the current working tree.
 
310
    :param apply_view:
 
311
        if True and a view is set, apply the view or check that the paths
 
312
        are within it
295
313
    :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.
 
314
        a tuple of (old_tree, new_tree, old_branch, new_branch,
 
315
        specific_files, extra_trees) where extra_trees is a sequence of
 
316
        additional trees to search in for file-ids.
299
317
    """
300
318
    # Get the old and new revision specs
301
319
    old_revision_spec = None
331
349
    working_tree, branch, relpath = \
332
350
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
333
351
    if consider_relpath and relpath != '':
 
352
        if working_tree is not None and apply_view:
 
353
            views.check_path_in_view(working_tree, relpath)
334
354
        specific_files.append(relpath)
335
355
    old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
 
356
    old_branch = branch
336
357
 
337
358
    # Get the new location
338
359
    if new_url is None:
341
362
        working_tree, branch, relpath = \
342
363
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
343
364
        if consider_relpath and relpath != '':
 
365
            if working_tree is not None and apply_view:
 
366
                views.check_path_in_view(working_tree, relpath)
344
367
            specific_files.append(relpath)
345
368
    new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
346
369
        basis_is_default=working_tree is None)
 
370
    new_branch = branch
347
371
 
348
372
    # Get the specific files (all files is None, no files is [])
349
373
    if make_paths_wt_relative and working_tree is not None:
350
 
        other_paths = _relative_paths_in_tree(working_tree, other_paths)
 
374
        try:
 
375
            from bzrlib.builtins import safe_relpath_files
 
376
            other_paths = safe_relpath_files(working_tree, other_paths,
 
377
            apply_view=apply_view)
 
378
        except errors.FileInWrongBranch:
 
379
            raise errors.BzrCommandError("Files are in different branches")
351
380
    specific_files.extend(other_paths)
352
381
    if len(specific_files) == 0:
353
382
        specific_files = None
 
383
        if (working_tree is not None and working_tree.supports_views()
 
384
            and apply_view):
 
385
            view_files = working_tree.views.lookup_view()
 
386
            if view_files:
 
387
                specific_files = view_files
 
388
                view_str = views.view_display_str(view_files)
 
389
                note("*** Ignoring files outside view. View is %s" % view_str)
354
390
 
355
391
    # Get extra trees that ought to be searched for file-ids
356
392
    extra_trees = None
357
393
    if working_tree is not None and working_tree not in (old_tree, new_tree):
358
394
        extra_trees = (working_tree,)
359
 
    return old_tree, new_tree, specific_files, extra_trees
 
395
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
360
396
 
361
397
 
362
398
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
373
409
    return spec.as_tree(branch)
374
410
 
375
411
 
376
 
def _relative_paths_in_tree(tree, paths):
377
 
    """Get the relative paths within a working tree.
378
 
 
379
 
    Each path may be either an absolute path or a path relative to the
380
 
    current working directory.
381
 
    """
382
 
    result = []
383
 
    for filename in paths:
384
 
        try:
385
 
            result.append(tree.relpath(osutils.dereference_path(filename)))
386
 
        except errors.PathNotChild:
387
 
            raise errors.BzrCommandError("Files are in different branches")
388
 
    return result
389
 
 
390
 
 
391
412
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
392
413
                    external_diff_options=None,
393
414
                    old_label='a/', new_label='b/',
394
415
                    extra_trees=None,
395
416
                    path_encoding='utf8',
396
 
                    using=None):
 
417
                    using=None,
 
418
                    format_cls=None):
397
419
    """Show in text form the changes from one tree to another.
398
420
 
399
 
    to_file
400
 
        The output stream.
401
 
 
402
 
    specific_files
403
 
        Include only changes to these files - None for all changes.
404
 
 
405
 
    external_diff_options
406
 
        If set, use an external GNU diff and pass these options.
407
 
 
408
 
    extra_trees
409
 
        If set, more Trees to use for looking up file ids
410
 
 
411
 
    path_encoding
412
 
        If set, the path will be encoded as specified, otherwise is supposed
413
 
        to be utf8
 
421
    :param to_file: The output stream.
 
422
    :param specific_files:Include only changes to these files - None for all
 
423
        changes.
 
424
    :param external_diff_options: If set, use an external GNU diff and pass 
 
425
        these options.
 
426
    :param extra_trees: If set, more Trees to use for looking up file ids
 
427
    :param path_encoding: If set, the path will be encoded as specified, 
 
428
        otherwise is supposed to be utf8
 
429
    :param format_cls: Formatter class (DiffTree subclass)
414
430
    """
 
431
    if format_cls is None:
 
432
        format_cls = DiffTree
415
433
    old_tree.lock_read()
416
434
    try:
417
435
        if extra_trees is not None:
419
437
                tree.lock_read()
420
438
        new_tree.lock_read()
421
439
        try:
422
 
            differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
423
 
                                                 path_encoding,
424
 
                                                 external_diff_options,
425
 
                                                 old_label, new_label, using)
 
440
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
 
441
                                                   path_encoding,
 
442
                                                   external_diff_options,
 
443
                                                   old_label, new_label, using)
426
444
            return differ.show_diff(specific_files, extra_trees)
427
445
        finally:
428
446
            new_tree.unlock()
435
453
 
436
454
def _patch_header_date(tree, file_id, path):
437
455
    """Returns a timestamp suitable for use in a patch header."""
438
 
    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
439
460
    return timestamp.format_patch_date(mtime)
440
461
 
441
462
 
442
 
@deprecated_function(one_three)
443
 
def get_prop_change(meta_modified):
444
 
    if meta_modified:
445
 
        return " (properties changed)"
446
 
    else:
447
 
        return  ""
448
 
 
449
463
def get_executable_change(old_is_x, new_is_x):
450
464
    descr = { True:"+x", False:"-x", None:"??" }
451
465
    if old_is_x != new_is_x:
626
640
            return self.CANNOT_DIFF
627
641
        from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
628
642
        to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
629
 
        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)
630
645
 
631
 
    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):
632
648
        """Diff the content of given files in two trees
633
649
 
634
650
        :param from_file_id: The id of the file in the from tree.  If None,
636
652
        :param to_file_id: The id of the file in the to tree.  This may refer
637
653
            to a different file from from_file_id.  If None,
638
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.
639
657
        """
640
 
        def _get_text(tree, file_id):
 
658
        def _get_text(tree, file_id, path):
641
659
            if file_id is not None:
642
 
                return tree.get_file(file_id).readlines()
 
660
                return tree.get_file(file_id, path).readlines()
643
661
            else:
644
662
                return []
645
663
        try:
646
 
            from_text = _get_text(self.old_tree, from_file_id)
647
 
            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)
648
666
            self.text_differ(from_label, from_text, to_label, to_text,
649
667
                             self.to_file)
650
668
        except errors.BinaryFile:
665
683
    @classmethod
666
684
    def from_string(klass, command_string, old_tree, new_tree, to_file,
667
685
                    path_encoding='utf-8'):
668
 
        command_template = commands.shlex_split_unicode(command_string)
669
 
        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'])
670
689
        return klass(command_template, old_tree, new_tree, to_file,
671
690
                     path_encoding)
672
691
 
679
698
 
680
699
    def _get_command(self, old_path, new_path):
681
700
        my_map = {'old_path': old_path, 'new_path': new_path}
682
 
        return [t % my_map for t in self.command_template]
 
701
        return [AtTemplate(t).substitute(my_map) for t in
 
702
                self.command_template]
683
703
 
684
704
    def _execute(self, old_path, new_path):
685
705
        command = self._get_command(old_path, new_path)
705
725
                raise
706
726
        return True
707
727
 
708
 
    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
        
709
733
        full_path = osutils.pathjoin(self._root, prefix, relpath)
710
 
        if self._try_symlink_root(tree, prefix):
 
734
        if not force_temp and self._try_symlink_root(tree, prefix):
711
735
            return full_path
712
736
        parent_dir = osutils.dirname(full_path)
713
737
        try:
724
748
                target.close()
725
749
        finally:
726
750
            source.close()
727
 
        osutils.make_readonly(full_path)
728
 
        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
729
757
        os.utime(full_path, (mtime, mtime))
730
758
        return full_path
731
759
 
732
 
    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):
733
762
        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
734
 
                                         old_path)
 
763
                                         old_path, force_temp)
735
764
        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
736
 
                                         new_path)
 
765
                                         new_path, force_temp,
 
766
                                         allow_write=allow_write_new)
737
767
        return old_disk_path, new_disk_path
738
768
 
739
769
    def finish(self):
740
 
        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))
741
776
 
742
777
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
743
778
        if (old_kind, new_kind) != ('file', 'file'):
744
779
            return DiffPath.CANNOT_DIFF
745
 
        self._prepare_files(file_id, old_path, new_path)
746
 
        self._execute(osutils.pathjoin('old', old_path),
747
 
                      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()
748
806
 
749
807
 
750
808
class DiffTree(object):
824
882
    def show_diff(self, specific_files, extra_trees=None):
825
883
        """Write tree diff to self.to_file
826
884
 
827
 
        :param sepecific_files: the specific files to compare (recursive)
 
885
        :param specific_files: the specific files to compare (recursive)
828
886
        :param extra_trees: extra trees to use for mapping paths to file_ids
829
887
        """
830
888
        try:
888
946
                self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
889
947
                                   newpath_encoded, prop_str))
890
948
            if changed_content:
891
 
                self.diff(file_id, oldpath, newpath)
 
949
                self._diff(file_id, oldpath, newpath, kind[0], kind[1])
892
950
                has_changes = 1
893
951
            if renamed:
894
952
                has_changes = 1
909
967
            new_kind = self.new_tree.kind(file_id)
910
968
        except (errors.NoSuchId, errors.NoSuchFile):
911
969
            new_kind = None
912
 
 
 
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):
913
974
        result = DiffPath._diff_many(self.differs, file_id, old_path,
914
975
                                       new_path, old_kind, new_kind)
915
976
        if result is DiffPath.CANNOT_DIFF:
917
978
            if error_path is None:
918
979
                error_path = old_path
919
980
            raise errors.NoDiffFound(error_path)
 
981
 
 
982
 
 
983
format_registry = Registry()
 
984
format_registry.register('default', DiffTree)