author | FUJIWARA Katsunori <foozy@lares.dti.ne.jp> |
Fri, 17 Oct 2014 02:07:04 +0900 | |
changeset 22973 | bcff9ecdaae0 |
parent 21790 | 3fbef7ac26f0 |
child 23293 | b89856abf4e2 |
permissions | -rw-r--r-- |
239
75840796e8e2
mdiff.py: kill #! line, add copyright notice
mpm@selenic.com
parents:
184
diff
changeset
|
1 |
# mdiff.py - diff and patch routines for mercurial |
75840796e8e2
mdiff.py: kill #! line, add copyright notice
mpm@selenic.com
parents:
184
diff
changeset
|
2 |
# |
2859 | 3 |
# Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> |
239
75840796e8e2
mdiff.py: kill #! line, add copyright notice
mpm@selenic.com
parents:
184
diff
changeset
|
4 |
# |
8225
46293a0c7e9f
updated license to be explicit about GPL version 2
Martin Geisler <mg@lazybytes.net>
parents:
7436
diff
changeset
|
5 |
# This software may be used and distributed according to the terms of the |
10263 | 6 |
# GNU General Public License version 2 or any later version. |
239
75840796e8e2
mdiff.py: kill #! line, add copyright notice
mpm@selenic.com
parents:
184
diff
changeset
|
7 |
|
6467
65029a3aafc2
Let --unified default to diff.unified (issue 1076)
Patrick Mezard <pmezard@gmail.com>
parents:
5863
diff
changeset
|
8 |
from i18n import _ |
20034
1e5b38a919dd
cleanup: move stdlib imports to their own import statement
Augie Fackler <raf@durin42.com>
parents:
17946
diff
changeset
|
9 |
import bdiff, mpatch, util, base85 |
1e5b38a919dd
cleanup: move stdlib imports to their own import statement
Augie Fackler <raf@durin42.com>
parents:
17946
diff
changeset
|
10 |
import re, struct, zlib |
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
11 |
|
2251
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
12 |
def splitnewlines(text): |
2248
b914f0557832
fix diffs containing embedded "\r".
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2078
diff
changeset
|
13 |
'''like str.splitlines, but only split on newlines.''' |
2251
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
14 |
lines = [l + '\n' for l in text.split('\n')] |
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
15 |
if lines: |
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
16 |
if lines[-1] == '\n': |
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
17 |
lines.pop() |
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
18 |
else: |
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
19 |
lines[-1] = lines[-1][:-1] |
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
20 |
return lines |
2248
b914f0557832
fix diffs containing embedded "\r".
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2078
diff
changeset
|
21 |
|
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
22 |
class diffopts(object): |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
23 |
'''context is the number of context lines |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
24 |
text treats all files as text |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
25 |
showfunc enables diff -p output |
2907 | 26 |
git enables the git extended patch format |
3199
096f1c73cdc3
Add -D/--nodates options to hg diff/export that removes dates from diff headers
Stephen Darnell <stephen@darnell.plus.com>
parents:
3026
diff
changeset
|
27 |
nodates removes dates from diff headers |
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
28 |
ignorews ignores all whitespace changes in the diff |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
29 |
ignorewsamount ignores changes in the amount of whitespace |
10189
e451e599fbcf
patch: support diff data loss detection and upgrade
Patrick Mezard <pmezard@gmail.com>
parents:
10185
diff
changeset
|
30 |
ignoreblanklines ignores changes whose lines are all blank |
e451e599fbcf
patch: support diff data loss detection and upgrade
Patrick Mezard <pmezard@gmail.com>
parents:
10185
diff
changeset
|
31 |
upgrade generates git diffs to avoid data loss |
e451e599fbcf
patch: support diff data loss detection and upgrade
Patrick Mezard <pmezard@gmail.com>
parents:
10185
diff
changeset
|
32 |
''' |
396
8f8bb77d560e
Show revisions in diffs like CVS, based on a patch from Goffredo Baroncelli.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
361
diff
changeset
|
33 |
|
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
34 |
defaults = { |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
35 |
'context': 3, |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
36 |
'text': False, |
5863
3d1f9dcecdea
diff: don't show function name by default
Matt Mackall <mpm@selenic.com>
parents:
5482
diff
changeset
|
37 |
'showfunc': False, |
2907 | 38 |
'git': False, |
3199
096f1c73cdc3
Add -D/--nodates options to hg diff/export that removes dates from diff headers
Stephen Darnell <stephen@darnell.plus.com>
parents:
3026
diff
changeset
|
39 |
'nodates': False, |
21790
3fbef7ac26f0
diff: add nobinary config to suppress git-style binary diffs
Stephen Lee <sphen.lee@gmail.com>
parents:
20034
diff
changeset
|
40 |
'nobinary': False, |
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
41 |
'ignorews': False, |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
42 |
'ignorewsamount': False, |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
43 |
'ignoreblanklines': False, |
10189
e451e599fbcf
patch: support diff data loss detection and upgrade
Patrick Mezard <pmezard@gmail.com>
parents:
10185
diff
changeset
|
44 |
'upgrade': False, |
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
45 |
} |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
46 |
|
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
47 |
__slots__ = defaults.keys() |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
48 |
|
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
49 |
def __init__(self, **opts): |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
50 |
for k in self.__slots__: |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
51 |
v = opts.get(k) |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
52 |
if v is None: |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
53 |
v = self.defaults[k] |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
54 |
setattr(self, k, v) |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
55 |
|
6467
65029a3aafc2
Let --unified default to diff.unified (issue 1076)
Patrick Mezard <pmezard@gmail.com>
parents:
5863
diff
changeset
|
56 |
try: |
65029a3aafc2
Let --unified default to diff.unified (issue 1076)
Patrick Mezard <pmezard@gmail.com>
parents:
5863
diff
changeset
|
57 |
self.context = int(self.context) |
65029a3aafc2
Let --unified default to diff.unified (issue 1076)
Patrick Mezard <pmezard@gmail.com>
parents:
5863
diff
changeset
|
58 |
except ValueError: |
65029a3aafc2
Let --unified default to diff.unified (issue 1076)
Patrick Mezard <pmezard@gmail.com>
parents:
5863
diff
changeset
|
59 |
raise util.Abort(_('diff context lines count must be ' |
65029a3aafc2
Let --unified default to diff.unified (issue 1076)
Patrick Mezard <pmezard@gmail.com>
parents:
5863
diff
changeset
|
60 |
'an integer, not %r') % self.context) |
65029a3aafc2
Let --unified default to diff.unified (issue 1076)
Patrick Mezard <pmezard@gmail.com>
parents:
5863
diff
changeset
|
61 |
|
10185
7637fe4f525d
mq: preserve --git flag when merging patches
Patrick Mezard <pmezard@gmail.com>
parents:
9827
diff
changeset
|
62 |
def copy(self, **kwargs): |
7637fe4f525d
mq: preserve --git flag when merging patches
Patrick Mezard <pmezard@gmail.com>
parents:
9827
diff
changeset
|
63 |
opts = dict((k, getattr(self, k)) for k in self.defaults) |
7637fe4f525d
mq: preserve --git flag when merging patches
Patrick Mezard <pmezard@gmail.com>
parents:
9827
diff
changeset
|
64 |
opts.update(kwargs) |
7637fe4f525d
mq: preserve --git flag when merging patches
Patrick Mezard <pmezard@gmail.com>
parents:
9827
diff
changeset
|
65 |
return diffopts(**opts) |
7637fe4f525d
mq: preserve --git flag when merging patches
Patrick Mezard <pmezard@gmail.com>
parents:
9827
diff
changeset
|
66 |
|
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
67 |
defaultopts = diffopts() |
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
68 |
|
9827
4fe9ca519637
mdiff: fix diff -b/B/w on mixed whitespace hunks (issue127)
Patrick Mezard <pmezard@gmail.com>
parents:
8632
diff
changeset
|
69 |
def wsclean(opts, text, blank=True): |
4878
372d93f03d3a
diff: correctly handle combinations of whitespace options
Matt Mackall <mpm@selenic.com>
parents:
4679
diff
changeset
|
70 |
if opts.ignorews: |
15530
eeac5e179243
mdiff: replace wscleanup() regexps with C loops
Patrick Mezard <pmezard@gmail.com>
parents:
15529
diff
changeset
|
71 |
text = bdiff.fixws(text, 1) |
4878
372d93f03d3a
diff: correctly handle combinations of whitespace options
Matt Mackall <mpm@selenic.com>
parents:
4679
diff
changeset
|
72 |
elif opts.ignorewsamount: |
15530
eeac5e179243
mdiff: replace wscleanup() regexps with C loops
Patrick Mezard <pmezard@gmail.com>
parents:
15529
diff
changeset
|
73 |
text = bdiff.fixws(text, 0) |
9827
4fe9ca519637
mdiff: fix diff -b/B/w on mixed whitespace hunks (issue127)
Patrick Mezard <pmezard@gmail.com>
parents:
8632
diff
changeset
|
74 |
if blank and opts.ignoreblanklines: |
15509
3774e1453ef4
diff: --ignore-blank-lines was too enthusiastic
Patrick Mezard <pmezard@gmail.com>
parents:
15462
diff
changeset
|
75 |
text = re.sub('\n+', '\n', text).strip('\n') |
4878
372d93f03d3a
diff: correctly handle combinations of whitespace options
Matt Mackall <mpm@selenic.com>
parents:
4679
diff
changeset
|
76 |
return text |
372d93f03d3a
diff: correctly handle combinations of whitespace options
Matt Mackall <mpm@selenic.com>
parents:
4679
diff
changeset
|
77 |
|
15528
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
78 |
def splitblock(base1, lines1, base2, lines2, opts): |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
79 |
# The input lines matches except for interwoven blank lines. We |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
80 |
# transform it into a sequence of matching blocks and blank blocks. |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
81 |
lines1 = [(wsclean(opts, l) and 1 or 0) for l in lines1] |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
82 |
lines2 = [(wsclean(opts, l) and 1 or 0) for l in lines2] |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
83 |
s1, e1 = 0, len(lines1) |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
84 |
s2, e2 = 0, len(lines2) |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
85 |
while s1 < e1 or s2 < e2: |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
86 |
i1, i2, btype = s1, s2, '=' |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
87 |
if (i1 >= e1 or lines1[i1] == 0 |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
88 |
or i2 >= e2 or lines2[i2] == 0): |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
89 |
# Consume the block of blank lines |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
90 |
btype = '~' |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
91 |
while i1 < e1 and lines1[i1] == 0: |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
92 |
i1 += 1 |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
93 |
while i2 < e2 and lines2[i2] == 0: |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
94 |
i2 += 1 |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
95 |
else: |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
96 |
# Consume the matching lines |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
97 |
while i1 < e1 and lines1[i1] == 1 and lines2[i2] == 1: |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
98 |
i1 += 1 |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
99 |
i2 += 1 |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
100 |
yield [base1 + s1, base1 + i1, base2 + s2, base2 + i2], btype |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
101 |
s1 = i1 |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
102 |
s2 = i2 |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
103 |
|
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
104 |
def allblocks(text1, text2, opts=None, lines1=None, lines2=None, refine=False): |
15526
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
105 |
"""Return (block, type) tuples, where block is an mdiff.blocks |
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
106 |
line entry. type is '=' for blocks matching exactly one another |
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
107 |
(bdiff blocks), '!' for non-matching blocks and '~' for blocks |
15528
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
108 |
matching only after having filtered blank lines. If refine is True, |
a84698badf0b
annotate: support diff whitespace filtering flags (issue3030)
Patrick Mezard <pmezard@gmail.com>
parents:
15526
diff
changeset
|
109 |
then '~' blocks are refined and are only made of blank lines. |
15526
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
110 |
line1 and line2 are text1 and text2 split with splitnewlines() if |
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
111 |
they are already available. |
15525
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
112 |
""" |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
113 |
if opts is None: |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
114 |
opts = defaultopts |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
115 |
if opts.ignorews or opts.ignorewsamount: |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
116 |
text1 = wsclean(opts, text1, False) |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
117 |
text2 = wsclean(opts, text2, False) |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
118 |
diff = bdiff.blocks(text1, text2) |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
119 |
for i, s1 in enumerate(diff): |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
120 |
# The first match is special. |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
121 |
# we've either found a match starting at line 0 or a match later |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
122 |
# in the file. If it starts later, old and new below will both be |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
123 |
# empty and we'll continue to the next match. |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
124 |
if i > 0: |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
125 |
s = diff[i - 1] |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
126 |
else: |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
127 |
s = [0, 0, 0, 0] |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
128 |
s = [s[1], s1[0], s[3], s1[2]] |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
129 |
|
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
130 |
# bdiff sometimes gives huge matches past eof, this check eats them, |
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
131 |
# and deals with the special first match case described above |
15529
b35cf47286a6
mdiff: split lines in allblocks() only when necessary
Patrick Mezard <pmezard@gmail.com>
parents:
15528
diff
changeset
|
132 |
if s[0] != s[1] or s[2] != s[3]: |
15526
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
133 |
type = '!' |
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
134 |
if opts.ignoreblanklines: |
15529
b35cf47286a6
mdiff: split lines in allblocks() only when necessary
Patrick Mezard <pmezard@gmail.com>
parents:
15528
diff
changeset
|
135 |
if lines1 is None: |
b35cf47286a6
mdiff: split lines in allblocks() only when necessary
Patrick Mezard <pmezard@gmail.com>
parents:
15528
diff
changeset
|
136 |
lines1 = splitnewlines(text1) |
b35cf47286a6
mdiff: split lines in allblocks() only when necessary
Patrick Mezard <pmezard@gmail.com>
parents:
15528
diff
changeset
|
137 |
if lines2 is None: |
b35cf47286a6
mdiff: split lines in allblocks() only when necessary
Patrick Mezard <pmezard@gmail.com>
parents:
15528
diff
changeset
|
138 |
lines2 = splitnewlines(text2) |
b35cf47286a6
mdiff: split lines in allblocks() only when necessary
Patrick Mezard <pmezard@gmail.com>
parents:
15528
diff
changeset
|
139 |
old = wsclean(opts, "".join(lines1[s[0]:s[1]])) |
b35cf47286a6
mdiff: split lines in allblocks() only when necessary
Patrick Mezard <pmezard@gmail.com>
parents:
15528
diff
changeset
|
140 |
new = wsclean(opts, "".join(lines2[s[2]:s[3]])) |
b35cf47286a6
mdiff: split lines in allblocks() only when necessary
Patrick Mezard <pmezard@gmail.com>
parents:
15528
diff
changeset
|
141 |
if old == new: |
15526
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
142 |
type = '~' |
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
143 |
yield s, type |
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
144 |
yield s1, '=' |
15525
935bf2e7dbc5
mdiff: extract blocks whitespace normalization in diffblocks()
Patrick Mezard <pmezard@gmail.com>
parents:
15513
diff
changeset
|
145 |
|
17940
c84ef0047a94
diff: unify calls to diffline
Guillermo Pérez <bisho@fb.com>
parents:
17939
diff
changeset
|
146 |
def unidiff(a, ad, b, bd, fn1, fn2, opts=defaultopts): |
16362
16b75661828e
mdiff: fix diff header generation for files with spaces (issue3357)
Patrick Mezard <patrick@mezard.eu>
parents:
16089
diff
changeset
|
147 |
def datetag(date, fn=None): |
4679
826659bd8053
git patches: correct handling of filenames with spaces
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4361
diff
changeset
|
148 |
if not opts.git and not opts.nodates: |
826659bd8053
git patches: correct handling of filenames with spaces
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4361
diff
changeset
|
149 |
return '\t%s\n' % date |
16362
16b75661828e
mdiff: fix diff header generation for files with spaces (issue3357)
Patrick Mezard <patrick@mezard.eu>
parents:
16089
diff
changeset
|
150 |
if fn and ' ' in fn: |
4679
826659bd8053
git patches: correct handling of filenames with spaces
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4361
diff
changeset
|
151 |
return '\t\n' |
826659bd8053
git patches: correct handling of filenames with spaces
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4361
diff
changeset
|
152 |
return '\n' |
3026
d838bfac668d
Remove dates from git export file lines - they confuse git-apply
Brendan Cully <brendan@kublai.com>
parents:
2907
diff
changeset
|
153 |
|
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
154 |
if not a and not b: |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
155 |
return "" |
1379 | 156 |
epoch = util.datestr((0, 0)) |
264
4c1d7072d5cd
Attempt to make diff deal with null sources properly
mpm@selenic.com
parents:
249
diff
changeset
|
157 |
|
15437
8f08b635cdce
diff: always use / in paths in diff
Mads Kiilerich <mads@kiilerich.com>
parents:
15141
diff
changeset
|
158 |
fn1 = util.pconvert(fn1) |
8f08b635cdce
diff: always use / in paths in diff
Mads Kiilerich <mads@kiilerich.com>
parents:
15141
diff
changeset
|
159 |
fn2 = util.pconvert(fn2) |
8f08b635cdce
diff: always use / in paths in diff
Mads Kiilerich <mads@kiilerich.com>
parents:
15141
diff
changeset
|
160 |
|
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
161 |
if not opts.text and (util.binary(a) or util.binary(b)): |
6871
13fe85fe396b
mdiff: compare content of binary files directly
Martin Geisler <mg@daimi.au.dk>
parents:
6470
diff
changeset
|
162 |
if a and b and len(a) == len(b) and a == b: |
4103
544838cc1158
Don't lie that "binary file has changed"
tailgunner@smtp.ru
parents:
3199
diff
changeset
|
163 |
return "" |
5482
e5eedd74e70f
Use both the from and to name in mdiff.unidiff.
Dustin Sallings <dustin@spy.net>
parents:
5367
diff
changeset
|
164 |
l = ['Binary file %s has changed\n' % fn1] |
1723
fde8fb2cbede
Fix diff against an empty file (issue124) and add a test for this.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1637
diff
changeset
|
165 |
elif not a: |
2251
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
166 |
b = splitnewlines(b) |
1723
fde8fb2cbede
Fix diff against an empty file (issue124) and add a test for this.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1637
diff
changeset
|
167 |
if a is None: |
16362
16b75661828e
mdiff: fix diff header generation for files with spaces (issue3357)
Patrick Mezard <patrick@mezard.eu>
parents:
16089
diff
changeset
|
168 |
l1 = '--- /dev/null%s' % datetag(epoch) |
1723
fde8fb2cbede
Fix diff against an empty file (issue124) and add a test for this.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1637
diff
changeset
|
169 |
else: |
16362
16b75661828e
mdiff: fix diff header generation for files with spaces (issue3357)
Patrick Mezard <patrick@mezard.eu>
parents:
16089
diff
changeset
|
170 |
l1 = "--- %s%s" % ("a/" + fn1, datetag(ad, fn1)) |
16b75661828e
mdiff: fix diff header generation for files with spaces (issue3357)
Patrick Mezard <patrick@mezard.eu>
parents:
16089
diff
changeset
|
171 |
l2 = "+++ %s%s" % ("b/" + fn2, datetag(bd, fn2)) |
264
4c1d7072d5cd
Attempt to make diff deal with null sources properly
mpm@selenic.com
parents:
249
diff
changeset
|
172 |
l3 = "@@ -0,0 +1,%d @@\n" % len(b) |
4c1d7072d5cd
Attempt to make diff deal with null sources properly
mpm@selenic.com
parents:
249
diff
changeset
|
173 |
l = [l1, l2, l3] + ["+" + e for e in b] |
1723
fde8fb2cbede
Fix diff against an empty file (issue124) and add a test for this.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1637
diff
changeset
|
174 |
elif not b: |
2251
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
175 |
a = splitnewlines(a) |
16362
16b75661828e
mdiff: fix diff header generation for files with spaces (issue3357)
Patrick Mezard <patrick@mezard.eu>
parents:
16089
diff
changeset
|
176 |
l1 = "--- %s%s" % ("a/" + fn1, datetag(ad, fn1)) |
1723
fde8fb2cbede
Fix diff against an empty file (issue124) and add a test for this.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1637
diff
changeset
|
177 |
if b is None: |
16362
16b75661828e
mdiff: fix diff header generation for files with spaces (issue3357)
Patrick Mezard <patrick@mezard.eu>
parents:
16089
diff
changeset
|
178 |
l2 = '+++ /dev/null%s' % datetag(epoch) |
1723
fde8fb2cbede
Fix diff against an empty file (issue124) and add a test for this.
Thomas Arendsen Hein <thomas@intevation.de>
parents:
1637
diff
changeset
|
179 |
else: |
16362
16b75661828e
mdiff: fix diff header generation for files with spaces (issue3357)
Patrick Mezard <patrick@mezard.eu>
parents:
16089
diff
changeset
|
180 |
l2 = "+++ %s%s" % ("b/" + fn2, datetag(bd, fn2)) |
264
4c1d7072d5cd
Attempt to make diff deal with null sources properly
mpm@selenic.com
parents:
249
diff
changeset
|
181 |
l3 = "@@ -1,%d +0,0 @@\n" % len(a) |
4c1d7072d5cd
Attempt to make diff deal with null sources properly
mpm@selenic.com
parents:
249
diff
changeset
|
182 |
l = [l1, l2, l3] + ["-" + e for e in a] |
4c1d7072d5cd
Attempt to make diff deal with null sources properly
mpm@selenic.com
parents:
249
diff
changeset
|
183 |
else: |
2251
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
184 |
al = splitnewlines(a) |
35fb62a3a673
fix speed regression in mdiff caused by line split bugfix.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2248
diff
changeset
|
185 |
bl = splitnewlines(b) |
10614
d0050f36e688
remove header handling out of mdiff.bunidiff, rename it
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10282
diff
changeset
|
186 |
l = list(_unidiff(a, b, al, bl, opts=opts)) |
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
187 |
if not l: |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
188 |
return "" |
10614
d0050f36e688
remove header handling out of mdiff.bunidiff, rename it
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10282
diff
changeset
|
189 |
|
16362
16b75661828e
mdiff: fix diff header generation for files with spaces (issue3357)
Patrick Mezard <patrick@mezard.eu>
parents:
16089
diff
changeset
|
190 |
l.insert(0, "--- a/%s%s" % (fn1, datetag(ad, fn1))) |
16b75661828e
mdiff: fix diff header generation for files with spaces (issue3357)
Patrick Mezard <patrick@mezard.eu>
parents:
16089
diff
changeset
|
191 |
l.insert(1, "+++ b/%s%s" % (fn2, datetag(bd, fn2))) |
170 | 192 |
|
193 |
for ln in xrange(len(l)): |
|
194 |
if l[ln][-1] != '\n': |
|
195 |
l[ln] += "\n\ No newline at end of file\n" |
|
196 |
||
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
197 |
return "".join(l) |
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
198 |
|
10614
d0050f36e688
remove header handling out of mdiff.bunidiff, rename it
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10282
diff
changeset
|
199 |
# creates a headerless unified diff |
1637 | 200 |
# t1 and t2 are the text to be diffed |
201 |
# l1 and l2 are the text broken up into lines |
|
10614
d0050f36e688
remove header handling out of mdiff.bunidiff, rename it
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10282
diff
changeset
|
202 |
def _unidiff(t1, t2, l1, l2, opts=defaultopts): |
1637 | 203 |
def contextend(l, len): |
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
204 |
ret = l + opts.context |
1637 | 205 |
if ret > len: |
206 |
ret = len |
|
207 |
return ret |
|
208 |
||
209 |
def contextstart(l): |
|
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
210 |
ret = l - opts.context |
1637 | 211 |
if ret < 0: |
212 |
return 0 |
|
213 |
return ret |
|
214 |
||
15141
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
215 |
lastfunc = [0, ''] |
10614
d0050f36e688
remove header handling out of mdiff.bunidiff, rename it
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10282
diff
changeset
|
216 |
def yieldhunk(hunk): |
1637 | 217 |
(astart, a2, bstart, b2, delta) = hunk |
218 |
aend = contextend(a2, len(l1)) |
|
219 |
alen = aend - astart |
|
220 |
blen = b2 - bstart + aend - a2 |
|
221 |
||
222 |
func = "" |
|
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
223 |
if opts.showfunc: |
15141
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
224 |
lastpos, func = lastfunc |
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
225 |
# walk backwards from the start of the context up to the start of |
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
226 |
# the previous hunk context until we find a line starting with an |
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
227 |
# alphanumeric char. |
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
228 |
for i in xrange(astart - 1, lastpos - 1, -1): |
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
229 |
if l1[i][0].isalnum(): |
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
230 |
func = ' ' + l1[i].rstrip()[:40] |
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
231 |
lastfunc[1] = func |
1637 | 232 |
break |
15141
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
233 |
# by recording this hunk's starting point as the next place to |
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
234 |
# start looking for function lines, we avoid reading any line in |
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
235 |
# the file more than once. |
16dc9a32ca04
mdiff: speed up showfunc for large diffs
Brodie Rao <brodie@bitheap.org>
parents:
12751
diff
changeset
|
236 |
lastfunc[0] = astart |
1637 | 237 |
|
15462
2b1ec74c961f
mdiff/patch: fix bad hunk handling for unified diffs with zero context
Nicolas Venegas <nvenegas@atlassian.com>
parents:
15141
diff
changeset
|
238 |
# zero-length hunk ranges report their start line as one less |
2b1ec74c961f
mdiff/patch: fix bad hunk handling for unified diffs with zero context
Nicolas Venegas <nvenegas@atlassian.com>
parents:
15141
diff
changeset
|
239 |
if alen: |
2b1ec74c961f
mdiff/patch: fix bad hunk handling for unified diffs with zero context
Nicolas Venegas <nvenegas@atlassian.com>
parents:
15141
diff
changeset
|
240 |
astart += 1 |
2b1ec74c961f
mdiff/patch: fix bad hunk handling for unified diffs with zero context
Nicolas Venegas <nvenegas@atlassian.com>
parents:
15141
diff
changeset
|
241 |
if blen: |
2b1ec74c961f
mdiff/patch: fix bad hunk handling for unified diffs with zero context
Nicolas Venegas <nvenegas@atlassian.com>
parents:
15141
diff
changeset
|
242 |
bstart += 1 |
2b1ec74c961f
mdiff/patch: fix bad hunk handling for unified diffs with zero context
Nicolas Venegas <nvenegas@atlassian.com>
parents:
15141
diff
changeset
|
243 |
|
2b1ec74c961f
mdiff/patch: fix bad hunk handling for unified diffs with zero context
Nicolas Venegas <nvenegas@atlassian.com>
parents:
15141
diff
changeset
|
244 |
yield "@@ -%d,%d +%d,%d @@%s\n" % (astart, alen, |
2b1ec74c961f
mdiff/patch: fix bad hunk handling for unified diffs with zero context
Nicolas Venegas <nvenegas@atlassian.com>
parents:
15141
diff
changeset
|
245 |
bstart, blen, func) |
1637 | 246 |
for x in delta: |
247 |
yield x |
|
248 |
for x in xrange(a2, aend): |
|
249 |
yield ' ' + l1[x] |
|
250 |
||
251 |
# bdiff.blocks gives us the matching sequences in the files. The loop |
|
252 |
# below finds the spaces between those matching sequences and translates |
|
253 |
# them into diff output. |
|
254 |
# |
|
255 |
hunk = None |
|
16089
2e8f4b82c551
mdiff: adjust hunk offsets with --ignore-blank-lines (issue3234)
Patrick Mezard <patrick@mezard.eu>
parents:
15657
diff
changeset
|
256 |
ignoredlines = 0 |
15526
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
257 |
for s, stype in allblocks(t1, t2, opts, l1, l2): |
16089
2e8f4b82c551
mdiff: adjust hunk offsets with --ignore-blank-lines (issue3234)
Patrick Mezard <patrick@mezard.eu>
parents:
15657
diff
changeset
|
258 |
a1, a2, b1, b2 = s |
15526
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
259 |
if stype != '!': |
16089
2e8f4b82c551
mdiff: adjust hunk offsets with --ignore-blank-lines (issue3234)
Patrick Mezard <patrick@mezard.eu>
parents:
15657
diff
changeset
|
260 |
if stype == '~': |
2e8f4b82c551
mdiff: adjust hunk offsets with --ignore-blank-lines (issue3234)
Patrick Mezard <patrick@mezard.eu>
parents:
15657
diff
changeset
|
261 |
# The diff context lines are based on t1 content. When |
2e8f4b82c551
mdiff: adjust hunk offsets with --ignore-blank-lines (issue3234)
Patrick Mezard <patrick@mezard.eu>
parents:
15657
diff
changeset
|
262 |
# blank lines are ignored, the new lines offsets must |
2e8f4b82c551
mdiff: adjust hunk offsets with --ignore-blank-lines (issue3234)
Patrick Mezard <patrick@mezard.eu>
parents:
15657
diff
changeset
|
263 |
# be adjusted as if equivalent blocks ('~') had the |
2e8f4b82c551
mdiff: adjust hunk offsets with --ignore-blank-lines (issue3234)
Patrick Mezard <patrick@mezard.eu>
parents:
15657
diff
changeset
|
264 |
# same sizes on both sides. |
2e8f4b82c551
mdiff: adjust hunk offsets with --ignore-blank-lines (issue3234)
Patrick Mezard <patrick@mezard.eu>
parents:
15657
diff
changeset
|
265 |
ignoredlines += (b2 - b1) - (a2 - a1) |
15526
e6519c628454
mdiff: make diffblocks() return all blocks, matching and changed
Patrick Mezard <pmezard@gmail.com>
parents:
15525
diff
changeset
|
266 |
continue |
1637 | 267 |
delta = [] |
268 |
old = l1[a1:a2] |
|
269 |
new = l2[b1:b2] |
|
270 |
||
16089
2e8f4b82c551
mdiff: adjust hunk offsets with --ignore-blank-lines (issue3234)
Patrick Mezard <patrick@mezard.eu>
parents:
15657
diff
changeset
|
271 |
b1 -= ignoredlines |
2e8f4b82c551
mdiff: adjust hunk offsets with --ignore-blank-lines (issue3234)
Patrick Mezard <patrick@mezard.eu>
parents:
15657
diff
changeset
|
272 |
b2 -= ignoredlines |
1637 | 273 |
astart = contextstart(a1) |
274 |
bstart = contextstart(b1) |
|
275 |
prev = None |
|
276 |
if hunk: |
|
277 |
# join with the previous hunk if it falls inside the context |
|
2874
4ec58b157265
refactor text diff/patch code.
Vadim Gelfer <vadim.gelfer@gmail.com>
parents:
2859
diff
changeset
|
278 |
if astart < hunk[1] + opts.context + 1: |
1637 | 279 |
prev = hunk |
280 |
astart = hunk[1] |
|
281 |
bstart = hunk[3] |
|
282 |
else: |
|
10614
d0050f36e688
remove header handling out of mdiff.bunidiff, rename it
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10282
diff
changeset
|
283 |
for x in yieldhunk(hunk): |
1637 | 284 |
yield x |
285 |
if prev: |
|
286 |
# we've joined the previous hunk, record the new ending points. |
|
287 |
hunk[1] = a2 |
|
288 |
hunk[3] = b2 |
|
289 |
delta = hunk[4] |
|
290 |
else: |
|
291 |
# create a new hunk |
|
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
292 |
hunk = [astart, a2, bstart, b2, delta] |
1637 | 293 |
|
10282
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
294 |
delta[len(delta):] = [' ' + x for x in l1[astart:a1]] |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
295 |
delta[len(delta):] = ['-' + x for x in old] |
08a0f04b56bd
many, many trivial check-code fixups
Matt Mackall <mpm@selenic.com>
parents:
10264
diff
changeset
|
296 |
delta[len(delta):] = ['+' + x for x in new] |
1637 | 297 |
|
298 |
if hunk: |
|
10614
d0050f36e688
remove header handling out of mdiff.bunidiff, rename it
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10282
diff
changeset
|
299 |
for x in yieldhunk(hunk): |
1637 | 300 |
yield x |
301 |
||
17939
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
302 |
def b85diff(to, tn): |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
303 |
'''print base85-encoded binary diff''' |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
304 |
def fmtline(line): |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
305 |
l = len(line) |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
306 |
if l <= 26: |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
307 |
l = chr(ord('A') + l - 1) |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
308 |
else: |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
309 |
l = chr(l - 26 + ord('a') - 1) |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
310 |
return '%c%s\n' % (l, base85.b85encode(line, True)) |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
311 |
|
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
312 |
def chunk(text, csize=52): |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
313 |
l = len(text) |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
314 |
i = 0 |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
315 |
while i < l: |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
316 |
yield text[i:i + csize] |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
317 |
i += csize |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
318 |
|
17946
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
319 |
if to is None: |
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
320 |
to = '' |
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
321 |
if tn is None: |
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
322 |
tn = '' |
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
323 |
|
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
324 |
if to == tn: |
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
325 |
return '' |
17939
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
326 |
|
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
327 |
# TODO: deltas |
17946
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
328 |
ret = [] |
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
329 |
ret.append('GIT binary patch\n') |
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
330 |
ret.append('literal %s\n' % len(tn)) |
17939
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
331 |
for l in chunk(zlib.compress(tn)): |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
332 |
ret.append(fmtline(l)) |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
333 |
ret.append('\n') |
17946
1e13b1184292
diff: move index header generation to patch
Guillermo Pérez <bisho@fb.com>
parents:
17941
diff
changeset
|
334 |
|
17939
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
335 |
return ''.join(ret) |
d587925680d9
diff: move b85diff to mdiff module
Guillermo Pérez <bisho at fb.com>
parents:
16362
diff
changeset
|
336 |
|
120
bae6f0328f63
Add a function to return the new text from a binary diff
mpm@selenic.com
parents:
75
diff
changeset
|
337 |
def patchtext(bin): |
bae6f0328f63
Add a function to return the new text from a binary diff
mpm@selenic.com
parents:
75
diff
changeset
|
338 |
pos = 0 |
bae6f0328f63
Add a function to return the new text from a binary diff
mpm@selenic.com
parents:
75
diff
changeset
|
339 |
t = [] |
bae6f0328f63
Add a function to return the new text from a binary diff
mpm@selenic.com
parents:
75
diff
changeset
|
340 |
while pos < len(bin): |
bae6f0328f63
Add a function to return the new text from a binary diff
mpm@selenic.com
parents:
75
diff
changeset
|
341 |
p1, p2, l = struct.unpack(">lll", bin[pos:pos + 12]) |
bae6f0328f63
Add a function to return the new text from a binary diff
mpm@selenic.com
parents:
75
diff
changeset
|
342 |
pos += 12 |
bae6f0328f63
Add a function to return the new text from a binary diff
mpm@selenic.com
parents:
75
diff
changeset
|
343 |
t.append(bin[pos:pos + l]) |
bae6f0328f63
Add a function to return the new text from a binary diff
mpm@selenic.com
parents:
75
diff
changeset
|
344 |
pos += l |
bae6f0328f63
Add a function to return the new text from a binary diff
mpm@selenic.com
parents:
75
diff
changeset
|
345 |
return "".join(t) |
bae6f0328f63
Add a function to return the new text from a binary diff
mpm@selenic.com
parents:
75
diff
changeset
|
346 |
|
0
9117c6561b0b
Add back links from file revisions to changeset revisions
mpm@selenic.com
parents:
diff
changeset
|
347 |
def patch(a, bin): |
12025
2315a95ee887
mdiff.patch(): add a special case for when the base text is empty
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10614
diff
changeset
|
348 |
if len(a) == 0: |
2315a95ee887
mdiff.patch(): add a special case for when the base text is empty
Benoit Boissinot <benoit.boissinot@ens-lyon.org>
parents:
10614
diff
changeset
|
349 |
# skip over trivial delta header |
15657
d976b1ef6760
util: don't mess with builtins to emulate buffer()
Matt Mackall <mpm@selenic.com>
parents:
15530
diff
changeset
|
350 |
return util.buffer(bin, 12) |
1379 | 351 |
return mpatch.patches(a, [bin]) |
432 | 352 |
|
4361
99c853a1408c
add mdiff.get_matching_blocks
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4108
diff
changeset
|
353 |
# similar to difflib.SequenceMatcher.get_matching_blocks |
99c853a1408c
add mdiff.get_matching_blocks
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4108
diff
changeset
|
354 |
def get_matching_blocks(a, b): |
99c853a1408c
add mdiff.get_matching_blocks
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4108
diff
changeset
|
355 |
return [(d[0], d[2], d[1] - d[0]) for d in bdiff.blocks(a, b)] |
99c853a1408c
add mdiff.get_matching_blocks
Alexis S. L. Carvalho <alexis@cecm.usp.br>
parents:
4108
diff
changeset
|
356 |
|
5367
7530334bf301
revlog: generate trivial deltas against null revision
Matt Mackall <mpm@selenic.com>
parents:
4878
diff
changeset
|
357 |
def trivialdiffheader(length): |
7530334bf301
revlog: generate trivial deltas against null revision
Matt Mackall <mpm@selenic.com>
parents:
4878
diff
changeset
|
358 |
return struct.pack(">lll", 0, 0, length) |
7530334bf301
revlog: generate trivial deltas against null revision
Matt Mackall <mpm@selenic.com>
parents:
4878
diff
changeset
|
359 |
|
1379 | 360 |
patches = mpatch.patches |
2078
441ea218414e
Fill in the uncompressed size during revlog.addgroup
mason@suse.com
parents:
1723
diff
changeset
|
361 |
patchedsize = mpatch.patchedsize |
432 | 362 |
textdiff = bdiff.bdiff |