~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Patch Queue Manager
  • Date: 2013-07-14 10:59:28 UTC
  • mfrom: (6579.2.1 1195783-platform-utf8)
  • Revision ID: pqm@pqm.ubuntu.com-20130714105928-78j748r1djstxmo1
(vila) Make 'bzr version' support utf8 platform names. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
import difflib
18
20
import os
19
21
import re
27
29
import tempfile
28
30
 
29
31
from bzrlib import (
30
 
    bzrdir,
 
32
    cleanup,
31
33
    cmdline,
32
 
    cleanup,
 
34
    controldir,
33
35
    errors,
34
36
    osutils,
35
37
    patiencediff,
39
41
    )
40
42
 
41
43
from bzrlib.workingtree import WorkingTree
 
44
from bzrlib.i18n import gettext
42
45
""")
43
46
 
44
47
from bzrlib.registry import (
45
48
    Registry,
46
49
    )
47
 
from bzrlib.symbol_versioning import (
48
 
    deprecated_function,
49
 
    deprecated_in,
50
 
    )
51
50
from bzrlib.trace import mutter, note, warning
52
51
 
 
52
DEFAULT_CONTEXT_AMOUNT = 3
53
53
 
54
54
class AtTemplate(string.Template):
55
55
    """Templating class that uses @ instead of $."""
73
73
 
74
74
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
75
75
                  allow_binary=False, sequence_matcher=None,
76
 
                  path_encoding='utf8'):
 
76
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
77
77
    # FIXME: difflib is wrong if there is no trailing newline.
78
78
    # The syntax used by patch seems to be "\ No newline at
79
79
    # end of file" following the last diff line from that
99
99
    ud = patiencediff.unified_diff(oldlines, newlines,
100
100
                      fromfile=old_filename.encode(path_encoding, 'replace'),
101
101
                      tofile=new_filename.encode(path_encoding, 'replace'),
102
 
                      sequencematcher=sequence_matcher)
 
102
                      n=context_lines, sequencematcher=sequence_matcher)
103
103
 
104
104
    ud = list(ud)
105
105
    if len(ud) == 0: # Identical contents, nothing to do
288
288
                        new_abspath, e)
289
289
 
290
290
 
291
 
@deprecated_function(deprecated_in((2, 2, 0)))
292
 
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
293
 
                                   apply_view=True):
294
 
    """Get the trees and specific files to diff given a list of paths.
295
 
 
296
 
    This method works out the trees to be diff'ed and the files of
297
 
    interest within those trees.
298
 
 
299
 
    :param path_list:
300
 
        the list of arguments passed to the diff command
301
 
    :param revision_specs:
302
 
        Zero, one or two RevisionSpecs from the diff command line,
303
 
        saying what revisions to compare.
304
 
    :param old_url:
305
 
        The url of the old branch or tree. If None, the tree to use is
306
 
        taken from the first path, if any, or the current working tree.
307
 
    :param new_url:
308
 
        The url of the new branch or tree. If None, the tree to use is
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
313
 
    :returns:
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.  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
291
def get_trees_and_branches_to_diff_locked(
325
292
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
326
293
    """Get the trees and specific files to diff given a list of paths.
392
359
    if old_url is None:
393
360
        old_url = default_location
394
361
    working_tree, branch, relpath = \
395
 
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
 
362
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
396
363
    lock_tree_or_branch(working_tree, branch)
397
364
    if consider_relpath and relpath != '':
398
365
        if working_tree is not None and apply_view:
406
373
        new_url = default_location
407
374
    if new_url != old_url:
408
375
        working_tree, branch, relpath = \
409
 
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
 
376
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
410
377
        lock_tree_or_branch(working_tree, branch)
411
378
        if consider_relpath and relpath != '':
412
379
            if working_tree is not None and apply_view:
430
397
            if view_files:
431
398
                specific_files = view_files
432
399
                view_str = views.view_display_str(view_files)
433
 
                note("*** Ignoring files outside view. View is %s" % view_str)
 
400
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
434
401
 
435
402
    # Get extra trees that ought to be searched for file-ids
436
403
    extra_trees = None
437
404
    if working_tree is not None and working_tree not in (old_tree, new_tree):
438
405
        extra_trees = (working_tree,)
439
 
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
 
406
    return (old_tree, new_tree, old_branch, new_branch,
 
407
            specific_files, extra_trees)
440
408
 
441
409
 
442
410
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
459
427
                    extra_trees=None,
460
428
                    path_encoding='utf8',
461
429
                    using=None,
462
 
                    format_cls=None):
 
430
                    format_cls=None,
 
431
                    context=DEFAULT_CONTEXT_AMOUNT):
463
432
    """Show in text form the changes from one tree to another.
464
433
 
465
434
    :param to_file: The output stream.
472
441
        otherwise is supposed to be utf8
473
442
    :param format_cls: Formatter class (DiffTree subclass)
474
443
    """
 
444
    if context is None:
 
445
        context = DEFAULT_CONTEXT_AMOUNT
475
446
    if format_cls is None:
476
447
        format_cls = DiffTree
477
448
    old_tree.lock_read()
484
455
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
485
456
                                                   path_encoding,
486
457
                                                   external_diff_options,
487
 
                                                   old_label, new_label, using)
 
458
                                                   old_label, new_label, using,
 
459
                                                   context_lines=context)
488
460
            return differ.show_diff(specific_files, extra_trees)
489
461
        finally:
490
462
            new_tree.unlock()
648
620
    # or removed in a diff.
649
621
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
650
622
 
651
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
652
 
                 old_label='', new_label='', text_differ=internal_diff):
 
623
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8', 
 
624
                 old_label='', new_label='', text_differ=internal_diff, 
 
625
                 context_lines=DEFAULT_CONTEXT_AMOUNT):
653
626
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
654
627
        self.text_differ = text_differ
655
628
        self.old_label = old_label
656
629
        self.new_label = new_label
657
630
        self.path_encoding = path_encoding
 
631
        self.context_lines = context_lines
658
632
 
659
633
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
660
634
        """Compare two files in unified diff format
708
682
            from_text = _get_text(self.old_tree, from_file_id, from_path)
709
683
            to_text = _get_text(self.new_tree, to_file_id, to_path)
710
684
            self.text_differ(from_label, from_text, to_label, to_text,
711
 
                             self.to_file, path_encoding=self.path_encoding)
 
685
                             self.to_file, path_encoding=self.path_encoding,
 
686
                             context_lines=self.context_lines)
712
687
        except errors.BinaryFile:
713
688
            self.to_file.write(
714
689
                  ("Binary files %s and %s differ\n" %
938
913
    @classmethod
939
914
    def from_trees_options(klass, old_tree, new_tree, to_file,
940
915
                           path_encoding, external_diff_options, old_label,
941
 
                           new_label, using):
 
916
                           new_label, using, context_lines):
942
917
        """Factory for producing a DiffTree.
943
918
 
944
919
        Designed to accept options used by show_diff_trees.
959
934
            extra_factories = []
960
935
        if external_diff_options:
961
936
            opts = external_diff_options.split()
962
 
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None):
 
937
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
963
938
                """:param path_encoding: not used but required
964
939
                        to match the signature of internal_diff.
965
940
                """
967
942
        else:
968
943
            diff_file = internal_diff
969
944
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
970
 
                             old_label, new_label, diff_file)
 
945
                             old_label, new_label, diff_file, context_lines=context_lines)
971
946
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
972
947
                     extra_factories)
973
948