@Override
public void addHunk(PatchHunk hunk) {
if (myHunkCount == 0) {
if (hunk.isNewContent()) {
myNew = true;
} else if (hunk.isDeletedContent()) {
myDeleted = true;
}
}
myHunkCount++;
}
@Nullable
private PatchHunk readNextHunkContext(ListIterator<String> iterator)
throws PatchSyntaxException {
while (iterator.hasNext()) {
String curLine = iterator.next();
if (curLine.startsWith(CONTEXT_FILE_PREFIX)) {
iterator.previous();
return null;
}
if (curLine.startsWith(CONTEXT_HUNK_PREFIX)) {
break;
}
}
if (!iterator.hasNext()) {
return null;
}
Matcher beforeMatcher = ourContextBeforeHunkStartPattern.matcher(iterator.next());
if (!beforeMatcher.matches()) {
throw new PatchSyntaxException(
iterator.previousIndex(), "Unknown before hunk start syntax");
}
List<String> beforeLines = readContextDiffLines(iterator);
if (!iterator.hasNext()) {
throw new PatchSyntaxException(iterator.previousIndex(), "Missing after hunk");
}
Matcher afterMatcher = ourContextAfterHunkStartPattern.matcher(iterator.next());
if (!afterMatcher.matches()) {
throw new PatchSyntaxException(iterator.previousIndex(), "Unknown after hunk start syntax");
}
// if (! iterator.hasNext()) {
// throw new PatchSyntaxException(iterator.previousIndex(), "Unexpected patch end");
// }
List<String> afterLines = readContextDiffLines(iterator);
int startLineBefore = Integer.parseInt(beforeMatcher.group(1));
int endLineBefore = Integer.parseInt(beforeMatcher.group(2));
int startLineAfter = Integer.parseInt(afterMatcher.group(1));
int endLineAfter = Integer.parseInt(afterMatcher.group(2));
PatchHunk hunk =
new PatchHunk(
startLineBefore - 1, endLineBefore - 1, startLineAfter - 1, endLineAfter - 1);
int beforeLineIndex = 0;
int afterLineIndex = 0;
PatchLine lastBeforePatchLine = null;
PatchLine lastAfterPatchLine = null;
if (beforeLines.size() == 0) {
for (String line : afterLines) {
hunk.addLine(parsePatchLine(line, 2));
}
} else if (afterLines.size() == 0) {
for (String line : beforeLines) {
hunk.addLine(parsePatchLine(line, 2));
}
} else {
while (beforeLineIndex < beforeLines.size() || afterLineIndex < afterLines.size()) {
String beforeLine =
beforeLineIndex >= beforeLines.size() ? null : beforeLines.get(beforeLineIndex);
String afterLine =
afterLineIndex >= afterLines.size() ? null : afterLines.get(afterLineIndex);
if (startsWith(beforeLine, NO_NEWLINE_SIGNATURE) && lastBeforePatchLine != null) {
lastBeforePatchLine.setSuppressNewLine(true);
beforeLineIndex++;
} else if (startsWith(afterLine, NO_NEWLINE_SIGNATURE) && lastAfterPatchLine != null) {
lastAfterPatchLine.setSuppressNewLine(true);
afterLineIndex++;
} else if (startsWith(beforeLine, " ")
&& (startsWith(afterLine, " ")
|| afterLine
== null /* handle some weird cases with line breaks truncated at EOF */)) {
addContextDiffLine(hunk, beforeLine, PatchLine.Type.CONTEXT);
beforeLineIndex++;
afterLineIndex++;
} else if (startsWith(beforeLine, "-")) {
lastBeforePatchLine = addContextDiffLine(hunk, beforeLine, PatchLine.Type.REMOVE);
beforeLineIndex++;
} else if (startsWith(afterLine, "+")) {
lastAfterPatchLine = addContextDiffLine(hunk, afterLine, PatchLine.Type.ADD);
afterLineIndex++;
} else if (startsWith(beforeLine, "!") && startsWith(afterLine, "!")) {
while (beforeLineIndex < beforeLines.size()
&& beforeLines.get(beforeLineIndex).startsWith("! ")) {
lastBeforePatchLine =
addContextDiffLine(hunk, beforeLines.get(beforeLineIndex), PatchLine.Type.REMOVE);
beforeLineIndex++;
}
while (afterLineIndex < afterLines.size()
&& afterLines.get(afterLineIndex).startsWith("! ")) {
lastAfterPatchLine =
addContextDiffLine(hunk, afterLines.get(afterLineIndex), PatchLine.Type.ADD);
afterLineIndex++;
}
} else {
throw new PatchSyntaxException(-1, "Unknown line prefix");
}
}
}
return hunk;
}
private static PatchLine addContextDiffLine(
final PatchHunk hunk, final String line, final PatchLine.Type type) {
final PatchLine patchLine = new PatchLine(type, line.length() < 2 ? "" : line.substring(2));
hunk.addLine(patchLine);
return patchLine;
}
@Nullable
private PatchHunk readNextHunkUnified(ListIterator<String> iterator)
throws PatchSyntaxException {
String curLine = null;
int numIncrements = 0;
while (iterator.hasNext()) {
curLine = iterator.next();
++numIncrements;
if (curLine.startsWith("--- ")) {
for (int i = 0; i < numIncrements; i++) {
iterator.previous();
}
return null;
}
if (curLine.startsWith("@@ ")) {
break;
}
}
if (!iterator.hasNext()) return null;
Matcher m = ourUnifiedHunkStartPattern.matcher(curLine);
if (!m.matches()) {
throw new PatchSyntaxException(iterator.previousIndex(), "Unknown hunk start syntax");
}
int startLineBefore = Integer.parseInt(m.group(1));
final String linesBeforeText = m.group(3);
int linesBefore = linesBeforeText == null ? 1 : Integer.parseInt(linesBeforeText);
int startLineAfter = Integer.parseInt(m.group(4));
final String linesAfterText = m.group(6);
int linesAfter = linesAfterText == null ? 1 : Integer.parseInt(linesAfterText);
PatchHunk hunk =
new PatchHunk(
startLineBefore - 1,
startLineBefore + linesBefore - 1,
startLineAfter - 1,
startLineAfter + linesAfter - 1);
PatchLine lastLine = null;
int before = 0;
int after = 0;
while (iterator.hasNext()) {
String hunkCurLine = iterator.next();
if (lastLine != null && hunkCurLine.startsWith(NO_NEWLINE_SIGNATURE)) {
lastLine.setSuppressNewLine(true);
continue;
}
lastLine = parsePatchLine(hunkCurLine, 1, before < linesBefore || after < linesAfter);
if (lastLine == null) {
iterator.previous();
break;
}
switch (lastLine.getType()) {
case CONTEXT:
before++;
after++;
break;
case ADD:
after++;
break;
case REMOVE:
before++;
break;
}
hunk.addLine(lastLine);
}
return hunk;
}