com.google.googlejavaformat.java.javadoc.JavadocWriter Maven / Gradle / Ivy

tag. Ignore it, and don't request a blank line before the * next token. */ return; } requestBlankLine(); writeToken(token); } void writeBlockquoteOpenOrClose(Token token) { requestBlankLine(); writeToken(token); requestBlankLine(); } void writePreOpen(Token token) { requestBlankLine(); writeToken(token); } void writePreClose(Token token) { writeToken(token); requestBlankLine(); } void writeCodeOpen(Token token) { writeToken(token); } void writeCodeClose(Token token) { writeToken(token); } void writeTableOpen(Token token) { requestBlankLine(); writeToken(token); } void writeTableClose(Token token) { writeToken(token); requestBlankLine(); } void writeMoeEndStripComment(Token token) { writeLineBreakNoAutoIndent(); appendSpaces(indentForMoeEndStripComment); // Or maybe just "output.append(token.getValue())?" I'm kind of surprised this is so easy. writeToken(token); requestNewline(); } void writeHtmlComment(Token token) { requestNewline(); writeToken(token); requestNewline(); } void writeBr(Token token) { writeToken(token); requestNewline(); } void writeLineBreakNoAutoIndent() { writeNewline(NO_AUTO_INDENT); } void writeLiteral(Token token) { writeToken(token); } @Override public String toString() { return output.toString(); } private void requestBlankLine() { requestWhitespace(BLANK_LINE); } private void requestNewline() { requestWhitespace(NEWLINE); } private void requestWhitespace(RequestedWhitespace requestedWhitespace) { this.requestedWhitespace = Ordering.natural().max(requestedWhitespace, this.requestedWhitespace); } /** * The kind of whitespace that has been requested between the previous and next tokens. The order * of the values is significant: It goes from lowest priority to highest. For example, if the * previous token requests {@link #BLANK_LINE} after it but the next token requests only {@link * #NEWLINE} before it, we insert {@link #BLANK_LINE}. */ enum RequestedWhitespace { NONE, WHITESPACE, NEWLINE, BLANK_LINE, ; } private void writeToken(Token token) { if (requestedMoeBeginStripComment != null) { requestNewline(); } if (requestedWhitespace == BLANK_LINE && (postWriteModifiedContinuingListCount.isPositive() || continuingFooterTag)) { /* * We don't write blank lines inside lists or footer tags, even in cases where we otherwise * would (e.g., before a

tag). Justification: We don't write blank lines _between_ list * items or footer tags, so it would be strange to write blank lines _within_ one. Of course, * an alternative approach would be to go ahead and write blank lines between items/tags, * either always or only in the case that an item contains a blank line. */ requestedWhitespace = NEWLINE; } if (requestedWhitespace == BLANK_LINE) { writeBlankLine(); requestedWhitespace = NONE; } else if (requestedWhitespace == NEWLINE) { writeNewline(); requestedWhitespace = NONE; } boolean needWhitespace = (requestedWhitespace == WHITESPACE); /* * Write a newline if necessary to respect the line limit. (But if we're at the beginning of the * line, a newline won't help. Or it might help but only by separating "

veryverylongword," * which goes against our style.) */ if (!atStartOfLine && token.length() + (needWhitespace ? 1 : 0) > remainingOnLine) { writeNewline(); } if (!atStartOfLine && needWhitespace) { output.append(" "); remainingOnLine--; } if (requestedMoeBeginStripComment != null) { output.append(requestedMoeBeginStripComment.getValue()); requestedMoeBeginStripComment = null; indentForMoeEndStripComment = innerIndent(); requestNewline(); writeToken(token); return; } output.append(token.getValue()); if (!START_OF_LINE_TOKENS.contains(token.getType())) { atStartOfLine = false; } /* * TODO(cpovirk): We really want the number of "characters," not chars. Figure out what the * right way of measuring that is (grapheme count (with BreakIterator?)? sum of widths of all * graphemes? I don't think that our style guide is specific about this.). Moreover, I am * probably brushing other problems with surrogates, etc. under the table. Hopefully I mostly * get away with it by joining all non-space, non-tab characters together. * * Possibly the "width" question has no right answer: * http://denisbider.blogspot.com/2015/09/when-monospace-fonts-arent-unicode.html */ remainingOnLine -= token.length(); requestedWhitespace = NONE; wroteAnythingSignificant = true; } private void writeBlankLine() { output.append("\n"); appendSpaces(blockIndent + 1); output.append("*"); writeNewline(); } private void writeNewline() { writeNewline(AUTO_INDENT); } private void writeNewline(AutoIndent autoIndent) { output.append("\n"); appendSpaces(blockIndent + 1); output.append("*"); appendSpaces(1); remainingOnLine = options.maxLineLength() - blockIndent - 3; if (autoIndent == AUTO_INDENT) { appendSpaces(innerIndent()); remainingOnLine -= innerIndent(); } atStartOfLine = true; } enum AutoIndent { AUTO_INDENT, NO_AUTO_INDENT } private int innerIndent() { int innerIndent = continuingListItemCount.value() * 4 + continuingListCount.value() * 2; if (continuingFooterTag) { innerIndent += 4; } return innerIndent; } // If this is a hotspot, keep a String of many spaces around, and call append(string, start, end). private void appendSpaces(int count) { output.append(Strings.repeat(" ", count)); } /** * Tokens that are always pinned to the following token. For example, {@code

} in {@code

Foo * bar} (never {@code

Foo bar} or {@code

\nFoo bar}). * *