Fixed various formatting line wrap bugs

This commit is contained in:
bigguy345 committed 2026-03-11 10:53:32 +02:00
1 parent 28b8cda4cf
commit 57128a8d8b
4 files changed
+350 -30

No files matched your search

@@ -2088,7 +2088,9 @@ public class GuiScriptTextArea extends GuiNpcTextField {
if (closeLineIdx < this.container.lines.size()) {
int closeIndent = IndentHelper.getLineIndent(
this.container.lines.get(closeLineIdx).text);
if (closeIndent == indent.length()) {
// <= handles multi-line declarations where '{' sits on a
// continuation line with higher indent than the closing '}'
if (closeIndent <= indent.length()) {
hasMatchingClose = true;
}
}
@@ -2940,9 +2942,11 @@ public class GuiScriptTextArea extends GuiNpcTextField {
}
private void formatText() {
// Calculate viewport width for line wrapping (account for gutter and scrollbar)
int viewportWidth = this.width - LINE_NUMBER_GUTTER_WIDTH - 10;
IndentHelper.FormatResult result = IndentHelper.formatText(text, selection.getCursorPosition(), viewportWidth);
int viewportPixels = this.width - LINE_NUMBER_GUTTER_WIDTH - 10;
int avgCharWidth = Math.max(1, ClientProxy.Font.width("abcdefghijklmnopqrstuvwxyz") / 26);
int viewportChars = (int) (viewportPixels * 0.8f / avgCharWidth);
int maxLineLength = Math.max(60, Math.min(viewportChars, 120));
IndentHelper.FormatResult result = IndentHelper.formatText(text, selection.getCursorPosition(), maxLineLength);
setText(result.text);
selection.reset(Math.max(0, Math.min(result.cursorPosition, this.text.length())));
}
@@ -326,7 +326,8 @@ public class BracketMatcher {
}
/**
* Check if a brace at given position has a matching close with same indent
* Check if a brace at given position has a matching close with compatible indent.
* Uses <= to handle multi-line declarations where '{' is on a continuation line.
*/
public static boolean hasMatchingCloseWithSameIndent(String text, int bracePos, List<LineData> lines, int currentIndent) {
if (text == null || lines == null || bracePos < 0) return false;
@@ -350,7 +351,7 @@ public class BracketMatcher {
if (closeLineIdx < lines.size()) {
String closeLine = lines.get(closeLineIdx).text;
int closeIndent = getLineIndent(closeLine);
return closeIndent == currentIndent;
return closeIndent <= currentIndent;
}
}
}
@@ -1642,7 +1642,10 @@ public class FormatHelper {
if (text == null || text.isEmpty()) return text;
int width = maxWidth > 0 ? maxWidth : settings.maxLineLength;
String[] lines = text.split("\n", -1);
String joined = format(joinContinuationLines(text));
String[] lines = joined.split("\n", -1);
StringBuilder result = new StringBuilder();
for (int i = 0; i < lines.length; i++) {
@@ -1670,6 +1673,92 @@ public class FormatHelper {
return result.toString();
}
/**
* Join continuation lines back onto their parent line so they can be
* re-evaluated and re-wrapped at the current target width.
* <p>
* A "continuation line" is one whose trimmed content starts with an operator,
* dot, comma, {@code ?}, or {@code :} — i.e. the wrapping markers used by
* {@link #wrapCodeContent}. Only code continuation lines are joined; comment
* lines ({@code //}, {@code *}) and lines inside lambda/block bodies (deeper
* indent than expected) are left alone.
*/
private String joinContinuationLines(String text) {
String[] lines = text.split("\n", -1);
List<String> out = new ArrayList<>();
for (int i = 0; i < lines.length; i++) {
String line = lines[i];
String trimmed = line.trim();
if (trimmed.isEmpty()
|| trimmed.startsWith("//")
|| trimmed.startsWith("/*")
|| trimmed.startsWith("*")) {
out.add(line);
continue;
}
boolean shouldJoin = false;
int parentIdx = -1;
if ((isContinuationLine(trimmed) || startsWithDeclarationKeyword(trimmed))
&& !out.isEmpty()) {
int idx = out.size() - 1;
while (idx >= 0 && out.get(idx).trim().isEmpty()) idx--;
if (idx >= 0) {
String parentTrimmed = out.get(idx).trim();
char last = parentTrimmed.isEmpty() ? 0 : parentTrimmed.charAt(parentTrimmed.length() - 1);
if (last != '{' && last != '}' && last != ';') {
shouldJoin = true;
parentIdx = idx;
}
}
}
if (!shouldJoin && !out.isEmpty()) {
int idx = out.size() - 1;
while (idx >= 0 && out.get(idx).trim().isEmpty()) idx--;
if (idx >= 0) {
String parentTrimmed = out.get(idx).trim();
if (!parentTrimmed.isEmpty()) {
char last = parentTrimmed.charAt(parentTrimmed.length() - 1);
if (last == '&' || last == '|' || last == '<' || last == '+'
|| last == '-' || last == '?' || last == ',' || last == '>') {
shouldJoin = true;
parentIdx = idx;
}
}
}
}
if (shouldJoin) {
out.set(parentIdx, trimTrailing(out.get(parentIdx)) + " " + trimmed);
continue;
}
out.add(line);
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < out.size(); i++) {
sb.append(out.get(i));
if (i < out.size() - 1) sb.append("\n");
}
return sb.toString();
}
private boolean startsWithDeclarationKeyword(String trimmed) {
for (String kw : DECLARATION_BREAK_KEYWORDS) {
if (trimmed.startsWith(kw)
&& (trimmed.length() == kw.length()
|| !Character.isJavaIdentifierPart(trimmed.charAt(kw.length())))) {
return true;
}
}
return false;
}
/**
* Get visual length of a line (tabs count as 4 spaces).
*/
@@ -1987,6 +2076,13 @@ public class FormatHelper {
* Core code wrapping logic (extracted from old wrapCodeLine, operates on code without comments).
*/
private String wrapCodeContent(String content, String indent, int maxWidth) {
if (settings.wrapMethodArguments) {
String argWrapped = tryArgumentAwareWrap(content, indent, maxWidth);
if (argWrapped != null) {
return argWrapped;
}
}
String wrapIndent = indent + spaces(settings.wrapIndentSpaces);
String fullLine = indent + content;
@@ -2005,36 +2101,28 @@ public class FormatHelper {
int currentLen = getVisualLength(indent);
int lastBreak = 0;
boolean isFirstLine = true;
for (BreakPoint bp : breakPoints) {
int segmentEnd = bp.position;
String segment = content.substring(lastBreak, segmentEnd);
int segmentLen = getVisualLength(segment);
if (currentLen + segmentLen > maxWidth && !isFirstLine) {
if (currentLen + segmentLen > maxWidth && lastBreak > 0) {
result.append("\n").append(wrapIndent);
currentLen = getVisualLength(wrapIndent);
isFirstLine = false;
segment = trimLeading(segment);
} else if (currentLen + segmentLen > maxWidth && isFirstLine && lastBreak > 0) {
result.append("\n").append(wrapIndent);
currentLen = getVisualLength(wrapIndent);
isFirstLine = false;
}
result.append(segment);
currentLen += getVisualLength(segment);
lastBreak = segmentEnd;
isFirstLine = false;
}
if (lastBreak < content.length()) {
String remaining = content.substring(lastBreak);
int remLen = getVisualLength(remaining);
if (currentLen + remLen > maxWidth && !isFirstLine) {
if (currentLen + remLen > maxWidth && lastBreak > 0) {
result.append("\n").append(wrapIndent);
remaining = trimLeading(remaining);
}
@@ -2046,8 +2134,188 @@ public class FormatHelper {
}
/**
* Trim leading whitespace (Java 8 compatible).
* Try argument-aware wrapping for method/constructor calls.
* When a call like {@code new Foo(arg1, arg2, arg3)} exceeds maxWidth,
* break after the opening paren, put each argument on its own line,
* and close paren on its own line:
* <pre>
* new Foo(
* arg1,
* arg2,
* arg3
* )
* </pre>
*
* @return the wrapped string, or {@code null} if this content doesn't
* qualify for argument-aware wrapping
*/
private String tryArgumentAwareWrap(String content, String indent, int maxWidth) {
String fullLine = indent + content;
if (getVisualLength(fullLine) <= maxWidth) {
return null;
}
int callParenIdx = findOutermostCallParen(content);
if (callParenIdx < 0) {
return null;
}
int matchingClose = findMatchingClose(content, callParenIdx);
if (matchingClose < 0 || matchingClose >= content.length()) {
return null;
}
String prefix = content.substring(0, callParenIdx + 1);
String argsBody = content.substring(callParenIdx + 1, matchingClose);
String suffix = content.substring(matchingClose);
List<String> args = splitArguments(argsBody);
if (args.size() < 2) {
return null;
}
String argIndent = indent + spaces(settings.wrapIndentSpaces);
String closeIndent = indent;
StringBuilder result = new StringBuilder();
result.append(indent).append(prefix).append("\n");
for (int i = 0; i < args.size(); i++) {
String arg = args.get(i).trim();
if (arg.isEmpty()) continue;
result.append(argIndent).append(arg);
if (i < args.size() - 1) {
result.append(",");
}
result.append("\n");
}
result.append(closeIndent).append(suffix);
String wrapped = result.toString();
if (getVisualLength(indent + prefix) <= maxWidth) {
return wrapped;
}
return wrapped;
}
/**
* Find the opening paren of the outermost method/constructor call
* that should trigger argument-aware wrapping.
* Looks for patterns: {@code identifier(}, {@code new Type(}, {@code .method(}
*
* @return index of the '(' or -1 if no suitable call found
*/
private int findOutermostCallParen(String content) {
int bestIdx = -1;
boolean inString = false;
char stringChar = 0;
for (int i = 0; i < content.length(); i++) {
char c = content.charAt(i);
char prev = i > 0 ? content.charAt(i - 1) : ' ';
if ((c == '"' || c == '\'') && prev != '\\') {
if (!inString) {
inString = true;
stringChar = c;
} else if (c == stringChar) {
inString = false;
}
}
if (inString) continue;
if (c == '(') {
if (i > 0 && (Character.isJavaIdentifierPart(content.charAt(i - 1)) ||
content.charAt(i - 1) == '>')) {
bestIdx = i;
break;
}
}
}
return bestIdx;
}
private int findMatchingClose(String content, int openIdx) {
int depth = 1;
boolean inString = false;
char stringChar = 0;
for (int i = openIdx + 1; i < content.length(); i++) {
char c = content.charAt(i);
char prev = i > 0 ? content.charAt(i - 1) : ' ';
if ((c == '"' || c == '\'') && prev != '\\') {
if (!inString) {
inString = true;
stringChar = c;
} else if (c == stringChar) {
inString = false;
}
}
if (inString) continue;
if (c == '(') depth++;
else if (c == ')') {
depth--;
if (depth == 0) return i;
}
}
return -1;
}
/**
* Split argument body by top-level commas, preserving nested parens,
* brackets, braces, strings, and lambda bodies.
*/
private List<String> splitArguments(String argsBody) {
List<String> args = new ArrayList<>();
StringBuilder current = new StringBuilder();
int depth = 0;
boolean inString = false;
char stringChar = 0;
for (int i = 0; i < argsBody.length(); i++) {
char c = argsBody.charAt(i);
char prev = i > 0 ? argsBody.charAt(i - 1) : ' ';
if ((c == '"' || c == '\'') && prev != '\\') {
if (!inString) {
inString = true;
stringChar = c;
} else if (c == stringChar) {
inString = false;
}
}
if (inString) {
current.append(c);
continue;
}
if (c == '(' || c == '[' || c == '{') depth++;
else if (c == ')' || c == ']' || c == '}') depth--;
if (c == ',' && depth == 0) {
args.add(current.toString());
current = new StringBuilder();
continue;
}
current.append(c);
}
if (current.length() > 0) {
args.add(current.toString());
}
return args;
}
private String trimLeading(String s) {
int start = 0;
while (start < s.length() && Character.isWhitespace(s.charAt(start))) {
@@ -2070,6 +2338,10 @@ public class FormatHelper {
}
}
private static final String[] DECLARATION_BREAK_KEYWORDS = {
"extends", "implements", "throws", "permits"
};
/**
* Find good positions to break a line.
*/
@@ -2125,15 +2397,41 @@ public class FormatHelper {
if ((c == '+' || c == '-') && i > 0 && i < content.length() - 1) {
char next = content.charAt(i + 1);
if (prev != '(' && prev != '[' && prev != ',' && prev != '=' &&
next != '+' && next != '-' && next != '=') {
next != '+' && next != '-' && next != '=' && next != '>') {
points.add(new BreakPoint(i + 1, 3 + depth));
}
}
if (c == '&' && i + 1 < content.length() && content.charAt(i + 1) == '&') {
points.add(new BreakPoint(i + 2, 2 + depth));
i++; // skip second &
continue;
}
if (c == '|' && i + 1 < content.length() && content.charAt(i + 1) == '|') {
points.add(new BreakPoint(i + 2, 2 + depth));
i++; // skip second |
continue;
}
// Single & as type intersection operator (e.g. T extends A & B)
if (c == '&' && i > 0 && i < content.length() - 1
&& content.charAt(i + 1) != '&' && content.charAt(i + 1) != '=') {
points.add(new BreakPoint(i + 1, 3 + depth));
}
if (c == '?' && depth == 0 && i > 0 && i < content.length() - 1) {
points.add(new BreakPoint(i, 2));
}
if (c == ':' && depth == 0 && i > 0 && i < content.length() - 1) {
if (prev != ':' && (i + 1 >= content.length() || content.charAt(i + 1) != ':')) {
points.add(new BreakPoint(i, 2));
}
}
if (c == '=' && depth == 0 && i > 0 && i < content.length() - 1) {
char next = content.charAt(i + 1);
if (prev != '=' && prev != '!' && prev != '<' && prev != '>' &&
prev != '+' && prev != '-' && prev != '*' && prev != '/' &&
prev != '%' && prev != '&' && prev != '|' && prev != '^' &&
next != '=' && next != '>') {
points.add(new BreakPoint(i + 1, 4 + depth));
}
}
}
@@ -2142,9 +2440,28 @@ public class FormatHelper {
points.add(new BreakPoint(i, 2 + depth));
}
// After opening brace
if (c == '{' && i + 1 < content.length()) {
points.add(new BreakPoint(i + 1, 1));
// After opening brace (even when last char — allows break before {)
if (c == '{') {
if (i + 1 < content.length()) {
points.add(new BreakPoint(i + 1, 1));
}
// Break before { so the brace can move to its own line
if (i > 0) {
points.add(new BreakPoint(i, 2));
}
}
// Break before declaration keywords (extends, implements, throws, permits)
if (c == ' ' && i + 1 < content.length() && Character.isLetter(content.charAt(i + 1))) {
for (String kw : DECLARATION_BREAK_KEYWORDS) {
if (i + 1 + kw.length() <= content.length()
&& content.substring(i + 1, i + 1 + kw.length()).equals(kw)
&& (i + 1 + kw.length() >= content.length()
|| !Character.isJavaIdentifierPart(content.charAt(i + 1 + kw.length())))) {
points.add(new BreakPoint(i + 1, 2));
break;
}
}
}
}
@@ -157,9 +157,9 @@ public class IndentHelper {
*
* @param text The text to format
* @param cursorPosition Current cursor position
* @param viewportWidth Viewport width for line wrapping (0 = no wrapping)
* @param maxLineLength Maximum line length in characters for wrapping (0 = no wrapping)
*/
public static FormatResult formatText(String text, int cursorPosition, int viewportWidth) {
public static FormatResult formatText(String text, int cursorPosition, int maxLineLength) {
// First pass: fix indentation
String indented = formatIndentation(text, cursorPosition);
@@ -167,19 +167,17 @@ public class IndentHelper {
FormatHelper helper = new FormatHelper();
FormatHelper.FormatSettings settings = helper.getSettings();
// Enable wrapping if viewport width is provided
if (viewportWidth > 0) {
// Enable wrapping if max line length is provided
if (maxLineLength > 0) {
settings.wrapLongLines = true;
settings.wrapComments = true;
// Use 75% of viewport width as max line length for some margin
int charWidth = 6; // Approximate character width
settings.maxLineLength = Math.max(60, (int) (viewportWidth * 0.8f / charWidth));
settings.maxLineLength = maxLineLength;
}
String formatted = helper.format(indented);
// Apply wrapping if enabled
if (viewportWidth > 0 && settings.wrapLongLines) {
if (maxLineLength > 0 && settings.wrapLongLines) {
formatted = helper.wrapLines(formatted, settings.maxLineLength);
}