diffhelpers: be more tolerant for stripped empty lines of CRLF ending

Exchange. It appears to trim lines containing only whitespace as well as
converting LF to CRLF.

mercurial/diffhelpers.py

@@ -1,77 +1,77
 # diffhelpers.py - helper routines for patch
 #
 # Copyright 2009 Matt Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from .i18n import _
 
 from . import (
     error,
 )
 
 def addlines(fp, hunk, lena, lenb, a, b):
     """Read lines from fp into the hunk
 
     The hunk is parsed into two arrays, a and b. a gets the old state of
     the text, b gets the new state. The control char from the hunk is saved
     when inserting into a, but not b (for performance while deleting files.)
     """
     while True:
         todoa = lena - len(a)
         todob = lenb - len(b)
         num = max(todoa, todob)
         if num == 0:
             break
         for i in xrange(num):
             s = fp.readline()
             if not s:
                 raise error.ParseError(_('incomplete hunk'))
             if s == "\\ No newline at end of file\n":
                 fixnewline(hunk, a, b)
                 continue
-            if s == "\n":
+            if s == '\n' or s == '\r\n':
                 # Some patches may be missing the control char
                 # on empty lines. Supply a leading space.
-                s = " \n"
+                s = ' ' + s
             hunk.append(s)
             if s.startswith('+'):
                 b.append(s[1:])
             elif s.startswith('-'):
                 a.append(s)
             else:
                 b.append(s[1:])
                 a.append(s)
 
 def fixnewline(hunk, a, b):
     """Fix up the last lines of a and b when the patch has no newline at EOF"""
     l = hunk[-1]
     # tolerate CRLF in last line
     if l.endswith('\r\n'):
         hline = l[:-2]
     else:
         hline = l[:-1]
 
     if hline.startswith((' ', '+')):
         b[-1] = hline[1:]
     if hline.startswith((' ', '-')):
         a[-1] = hline
     hunk[-1] = hline
 
 def testhunk(a, b, bstart):
     """Compare the lines in a with the lines in b
 
     a is assumed to have a control char at the start of each line, this char
     is ignored in the compare.
     """
     alen = len(a)
     blen = len(b)
     if alen > blen - bstart:
         return False
     for i in xrange(alen):
         if a[i][1:] != b[i + bstart]:
             return False
     return True

tests/test-import-eol.t

@@ -1,146 +1,173
   $ cat > makepatch.py <<EOF
-  > f = open('eol.diff', 'wb')
+  > import sys
+  > f = open(sys.argv[2], 'wb')
   > w = f.write
   > w(b'test message\n')
   > w(b'diff --git a/a b/a\n')
   > w(b'--- a/a\n')
   > w(b'+++ b/a\n')
   > w(b'@@ -1,5 +1,5 @@\n')
   > w(b' a\n')
   > w(b'-bbb\r\n')
   > w(b'+yyyy\r\n')
   > w(b' cc\r\n')
-  > w(b' \n')
+  > w({'empty:lf': b' \n',
+  >    'empty:crlf': b' \r\n',
+  >    'empty:stripped-lf': b'\n',
+  >    'empty:stripped-crlf': b'\r\n'}[sys.argv[1]])
   > w(b' d\n')
   > w(b'-e\n')
   > w(b'\ No newline at end of file\n')
   > w(b'+z\r\n')
   > w(b'\ No newline at end of file\r\n')
   > EOF
 
   $ hg init repo
   $ cd repo
   $ echo '\.diff' > .hgignore
 
 
 Test different --eol values
 
   $ $PYTHON -c 'open("a", "wb").write(b"a\nbbb\ncc\n\nd\ne")'
   $ hg ci -Am adda
   adding .hgignore
   adding a
-  $ $PYTHON ../makepatch.py
-
+  $ $PYTHON ../makepatch.py empty:lf eol.diff
+  $ $PYTHON ../makepatch.py empty:crlf eol-empty-crlf.diff
+  $ $PYTHON ../makepatch.py empty:stripped-lf eol-empty-stripped-lf.diff
+  $ $PYTHON ../makepatch.py empty:stripped-crlf eol-empty-stripped-crlf.diff
 
 invalid eol
 
   $ hg --config patch.eol='LFCR' import eol.diff
   applying eol.diff
   abort: unsupported line endings type: LFCR
   [255]
   $ hg revert -a
 
 
 force LF
 
   $ hg --traceback --config patch.eol='LF' import eol.diff
   applying eol.diff
+  $ hg id
+  9e4ef7b3d4af tip
   $ cat a
   a
   yyyy
   cc
   
   d
   e (no-eol)
   $ hg st
 
+ (test empty-line variants: all of them should generate the same revision)
+
+  $ hg up -qC 0
+  $ hg --config patch.eol='LF' import eol-empty-crlf.diff
+  applying eol-empty-crlf.diff
+  $ hg id
+  9e4ef7b3d4af tip
+
+  $ hg up -qC 0
+  $ hg --config patch.eol='LF' import eol-empty-stripped-lf.diff
+  applying eol-empty-stripped-lf.diff
+  $ hg id
+  9e4ef7b3d4af tip
+
+  $ hg up -qC 0
+  $ hg --config patch.eol='LF' import eol-empty-stripped-crlf.diff
+  applying eol-empty-stripped-crlf.diff
+  $ hg id
+  9e4ef7b3d4af tip
 
 force CRLF
 
   $ hg up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg --traceback --config patch.eol='CRLF' import eol.diff
   applying eol.diff
   $ cat a
   a\r (esc)
   yyyy\r (esc)
   cc\r (esc)
   \r (esc)
   d\r (esc)
   e (no-eol)
   $ hg st
 
 
 auto EOL on LF file
 
   $ hg up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg --traceback --config patch.eol='auto' import eol.diff
   applying eol.diff
   $ cat a
   a
   yyyy
   cc
   
   d
   e (no-eol)
   $ hg st
 
 
 auto EOL on CRLF file
 
   $ $PYTHON -c 'open("a", "wb").write(b"a\r\nbbb\r\ncc\r\n\r\nd\r\ne")'
   $ hg commit -m 'switch EOLs in a'
   $ hg --traceback --config patch.eol='auto' import eol.diff
   applying eol.diff
   $ cat a
   a\r (esc)
   yyyy\r (esc)
   cc\r (esc)
   \r (esc)
   d\r (esc)
   e (no-eol)
   $ hg st
 
 
 auto EOL on new file or source without any EOL
 
   $ $PYTHON -c 'open("noeol", "wb").write(b"noeol")'
   $ hg add noeol
   $ hg commit -m 'add noeol'
   $ $PYTHON -c 'open("noeol", "wb").write(b"noeol\r\nnoeol\n")'
   $ $PYTHON -c 'open("neweol", "wb").write(b"neweol\nneweol\r\n")'
   $ hg add neweol
   $ hg diff --git > noeol.diff
   $ hg revert --no-backup noeol neweol
   $ rm neweol
   $ hg --traceback --config patch.eol='auto' import -m noeol noeol.diff
   applying noeol.diff
   $ cat noeol
   noeol\r (esc)
   noeol
   $ cat neweol
   neweol
   neweol\r (esc)
   $ hg st
 
 
 Test --eol and binary patches
 
   $ $PYTHON -c 'open("b", "wb").write(b"a\x00\nb\r\nd")'
   $ hg ci -Am addb
   adding b
   $ $PYTHON -c 'open("b", "wb").write(b"a\x00\nc\r\nd")'
   $ hg diff --git > bin.diff
   $ hg revert --no-backup b
 
 binary patch with --eol
 
   $ hg import --config patch.eol='CRLF' -m changeb bin.diff
   applying bin.diff
   $ cat b
   a\x00 (esc)
   c\r (esc)
   d (no-eol)
   $ hg st
   $ cd ..