import org.eclipse.jgit.api.RebaseCommand.InteractiveHandler;
import org.eclipse.jgit.api.RebaseCommand.Operation;
import org.eclipse.jgit.api.RebaseResult.Status;
+import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.RefNotFoundException;
import org.eclipse.jgit.api.errors.UnmergedPathsException;
import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
import org.eclipse.jgit.dircache.DirCacheCheckout;
import org.eclipse.jgit.junit.RepositoryTestCase;
+import org.eclipse.jgit.lib.AbbreviatedObjectId;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.PersonIdent;
assertEquals(Action.REWORD, steps.get(1).getAction());
}
+ @Test
+ public void testRebaseShouldTryToParseValidLineMarkedAsComment()
+ throws IOException {
+ String todo = "# pick 1111111 Valid line commented out with space\n"
+ + "#edit 2222222 Valid line commented out without space\n"
+ + "# pick invalidLine Comment line at end\n";
+ write(getTodoFile(), todo);
+
+ List<RebaseTodoLine> steps = db.readRebaseTodo(GIT_REBASE_TODO, true);
+ assertEquals(3, steps.size());
+
+ RebaseTodoLine firstLine = steps.get(0);
+
+ assertEquals("1111111", firstLine.getCommit().name());
+ assertEquals("Valid line commented out with space",
+ firstLine.getShortMessage());
+ assertEquals("comment", firstLine.getAction().toToken());
+
+ try {
+ firstLine.setAction(Action.PICK);
+ assertEquals("1111111", firstLine.getCommit().name());
+ assertEquals("pick", firstLine.getAction().toToken());
+ } catch (Exception e) {
+ fail("Valid parsable RebaseTodoLine that has been commented out should allow to change the action, but failed");
+ }
+
+ assertEquals("2222222", steps.get(1).getCommit().name());
+ assertEquals("comment", steps.get(1).getAction().toToken());
+
+ assertEquals(null, steps.get(2).getCommit());
+ assertEquals(null, steps.get(2).getShortMessage());
+ assertEquals("comment", steps.get(2).getAction().toToken());
+ assertEquals("# pick invalidLine Comment line at end", steps.get(2)
+ .getComment());
+ try {
+ steps.get(2).setAction(Action.PICK);
+ fail("A comment RebaseTodoLine that doesn't contain a valid parsable line should fail, but doesn't");
+ } catch (Exception e) {
+ // expected
+ }
+
+ }
+
+ @SuppressWarnings("unused")
+ @Test
+ public void testRebaseTodoLineSetComment() throws Exception {
+ try {
+ new RebaseTodoLine("This is a invalid comment");
+ fail("Constructing a comment line with invalid comment string should fail, but doesn't");
+ } catch (JGitInternalException e) {
+ // expected
+ }
+ RebaseTodoLine validCommentLine = new RebaseTodoLine(
+ "# This is a comment");
+ assertEquals(Action.COMMENT, validCommentLine.getAction());
+ assertEquals("# This is a comment", validCommentLine.getComment());
+
+ RebaseTodoLine actionLineToBeChanged = new RebaseTodoLine(Action.EDIT,
+ AbbreviatedObjectId.fromString("1111111"), "short Message");
+ assertEquals(null, actionLineToBeChanged.getComment());
+
+ try {
+ actionLineToBeChanged.setComment("invalid comment");
+ fail("Setting a invalid comment string should fail but doesn't");
+ } catch (JGitInternalException e) {
+ assertEquals(null, actionLineToBeChanged.getComment());
+ }
+
+ actionLineToBeChanged.setComment("# valid comment");
+ assertEquals("# valid comment", actionLineToBeChanged.getComment());
+ try {
+ actionLineToBeChanged.setComment("invalid comment");
+ fail("Setting a invalid comment string should fail but doesn't");
+ } catch (JGitInternalException e) {
+ // expected
+ // setting comment failed, but was successfully set before,
+ // therefore it may not be altered since then
+ assertEquals("# valid comment", actionLineToBeChanged.getComment());
+ }
+ try {
+ actionLineToBeChanged.setComment("# line1 \n line2");
+ actionLineToBeChanged.setComment("line1 \n line2");
+ actionLineToBeChanged.setComment("\n");
+ actionLineToBeChanged.setComment("# line1 \r line2");
+ actionLineToBeChanged.setComment("line1 \r line2");
+ actionLineToBeChanged.setComment("\r");
+ actionLineToBeChanged.setComment("# line1 \n\r line2");
+ actionLineToBeChanged.setComment("line1 \n\r line2");
+ actionLineToBeChanged.setComment("\n\r");
+ fail("Setting a multiline comment string should fail but doesn't");
+ } catch (JGitInternalException e) {
+ // expected
+ }
+ // Try setting valid comments
+ actionLineToBeChanged.setComment("# valid comment");
+ assertEquals("# valid comment", actionLineToBeChanged.getComment());
+
+ actionLineToBeChanged.setComment("# \t \t valid comment");
+ assertEquals("# \t \t valid comment",
+ actionLineToBeChanged.getComment());
+
+ actionLineToBeChanged.setComment("# ");
+ assertEquals("# ", actionLineToBeChanged.getComment());
+
+ actionLineToBeChanged.setComment("");
+ assertEquals("", actionLineToBeChanged.getComment());
+
+ actionLineToBeChanged.setComment(" ");
+ assertEquals(" ", actionLineToBeChanged.getComment());
+
+ actionLineToBeChanged.setComment("\t\t");
+ assertEquals("\t\t", actionLineToBeChanged.getComment());
+
+ actionLineToBeChanged.setComment(null);
+ assertEquals(null, actionLineToBeChanged.getComment());
+ }
+
@Test
public void testRebaseInteractiveReword() throws Exception {
// create file1 on master
import java.util.LinkedList;
import java.util.List;
+import org.eclipse.jgit.lib.RebaseTodoLine.Action;
import org.eclipse.jgit.util.IO;
import org.eclipse.jgit.util.RawParseUtils;
int tokenBegin = 0;
List<RebaseTodoLine> r = new LinkedList<RebaseTodoLine>();
while (ptr < buf.length) {
- RebaseTodoLine.Action action = null;
- AbbreviatedObjectId commit = null;
tokenBegin = ptr;
ptr = RawParseUtils.nextLF(buf, ptr);
int lineStart = tokenBegin;
// Handle comments
if (buf[tokenBegin] == '#') {
if (includeComments)
- r.add(new RebaseTodoLine(RawParseUtils.decode(buf,
- tokenBegin, lineEnd + 1)));
- continue;
- }
- // skip leading spaces, tabs, CR
- while (tokenBegin <= lineEnd
- && (buf[tokenBegin] == ' ' || buf[tokenBegin] == '\t' || buf[tokenBegin] == '\r'))
- tokenBegin++;
- // Handle empty lines (maybe empty after skipping leading
- // whitespace)
- if (tokenBegin > lineEnd) {
- if (includeComments)
- r.add(new RebaseTodoLine(RawParseUtils.decode(buf,
- lineStart, 1 + lineEnd)));
- continue;
- }
- int nextSpace = RawParseUtils.next(buf, tokenBegin, ' ');
- int tokenCount = 0;
- while (tokenCount < 3 && nextSpace < ptr) {
- switch (tokenCount) {
- case 0:
- String actionToken = new String(buf, tokenBegin, nextSpace
- - tokenBegin - 1);
- tokenBegin = nextSpace;
- action = RebaseTodoLine.Action.parse(actionToken);
- break;
- case 1:
- if (action == null)
- break;
- nextSpace = RawParseUtils.next(buf, tokenBegin, ' ');
- String commitToken = new String(buf, tokenBegin, nextSpace
- - tokenBegin - 1);
- tokenBegin = nextSpace;
- commit = AbbreviatedObjectId.fromString(commitToken);
- break;
- case 2:
- if (action == null)
- break;
- r.add(new RebaseTodoLine(action, commit, RawParseUtils
- .decode(buf, tokenBegin, 1 + lineEnd)));
- break;
+ parseComments(buf, tokenBegin, r, lineEnd);
+ } else {
+ // skip leading spaces+tabs+cr
+ tokenBegin = nextParsableToken(buf, tokenBegin, lineEnd);
+ // Handle empty lines (maybe empty after skipping leading
+ // whitespace)
+ if (tokenBegin == -1) {
+ if (includeComments)
+ r.add(new RebaseTodoLine(RawParseUtils.decode(buf,
+ lineStart, 1 + lineEnd)));
+ continue;
}
- tokenCount++;
+ RebaseTodoLine line = parseLine(buf, tokenBegin, lineEnd);
+ if (line == null)
+ continue;
+ r.add(line);
}
}
return r;
}
+ private static void parseComments(byte[] buf, int tokenBegin,
+ List<RebaseTodoLine> r, int lineEnd) {
+ RebaseTodoLine line = null;
+ String commentString = RawParseUtils.decode(buf,
+ tokenBegin, lineEnd + 1);
+ try {
+ int skip = tokenBegin + 1; // skip '#'
+ skip = nextParsableToken(buf, skip, lineEnd);
+ if (skip != -1) {
+ // try to parse the line as non-comment
+ line = parseLine(buf, skip, lineEnd);
+ // successfully parsed as non-comment line
+ // mark this line as a comment explicitly
+ line.setAction(Action.COMMENT);
+ // use the read line as comment string
+ line.setComment(commentString);
+ }
+ } catch (Exception e) {
+ // parsing as non-comment line failed
+ line = null;
+ } finally {
+ if (line == null)
+ line = new RebaseTodoLine(commentString);
+ r.add(line);
+ }
+ }
+
+ /**
+ * Skip leading space, tab, CR and LF characters
+ *
+ * @param buf
+ * @param tokenBegin
+ * @param lineEnd
+ * @return the token within the range of the given {@code buf} that doesn't
+ * need to be skipped, {@code -1} if no such token found within the
+ * range (i.e. empty line)
+ */
+ private static int nextParsableToken(byte[] buf, int tokenBegin, int lineEnd) {
+ while (tokenBegin <= lineEnd
+ && (buf[tokenBegin] == ' ' || buf[tokenBegin] == '\t' || buf[tokenBegin] == '\r'))
+ tokenBegin++;
+ if (tokenBegin > lineEnd)
+ return -1;
+ return tokenBegin;
+ }
+
+ private static RebaseTodoLine parseLine(byte[] buf, int tokenBegin,
+ int lineEnd) {
+ RebaseTodoLine.Action action = null;
+ AbbreviatedObjectId commit = null;
+
+ int nextSpace = RawParseUtils.next(buf, tokenBegin, ' ');
+ int tokenCount = 0;
+ while (tokenCount < 3 && nextSpace < lineEnd) {
+ switch (tokenCount) {
+ case 0:
+ String actionToken = new String(buf, tokenBegin, nextSpace
+ - tokenBegin - 1);
+ tokenBegin = nextSpace;
+ action = RebaseTodoLine.Action.parse(actionToken);
+ if (action == null)
+ return null; // parsing failed
+ break;
+ case 1:
+ nextSpace = RawParseUtils.next(buf, tokenBegin, ' ');
+ String commitToken = new String(buf, tokenBegin, nextSpace
+ - tokenBegin - 1);
+ tokenBegin = nextSpace;
+ commit = AbbreviatedObjectId.fromString(commitToken);
+ break;
+ case 2:
+ return new RebaseTodoLine(action, commit, RawParseUtils.decode(
+ buf, tokenBegin, 1 + lineEnd));
+ }
+ tokenCount++;
+ }
+ return null;
+ }
+
/**
* Write a file formatted like a git-rebase-todo file.
*
projects / jgit.git / commitdiff