Fix parsing partials

Author: ben221199

src/main/java/com/yocto/yoclib/imap/protocol/ProtocolParser.java

@@ -44,45 +44,48 @@ private static ProtocolObject parseToken(Tokenizer t) {
         if (b == '[') return parseSubordinate(t);
         if (b == '"') return parseQuoted(t);
 
-        // === Read raw token until whitespace or ( or ) ===
+        // Read full token until whitespace / ( / )
         String raw = t.readAtom();
-        int bracketIdx = raw.indexOf('[');
 
-        // Case: atom[section]  (exactly one '[')
-        if (bracketIdx > 0 && raw.lastIndexOf('[') == bracketIdx) {
-            String base = raw.substring(0, bracketIdx);
+        // === Try to split atom[section]<partial> ===
+        int partialStart = raw.indexOf('<');
+        String beforePartial = (partialStart >= 0) ? raw.substring(0, partialStart) : raw;
+        String partialStr = (partialStart >= 0) ? raw.substring(partialStart) : null;
+
+        int bracketIdx = beforePartial.indexOf('[');
+
+        if (bracketIdx > 0 && beforePartial.lastIndexOf('[') == bracketIdx) {
+            // Has section
+            String base = beforePartial.substring(0, bracketIdx);
             if (isValidSectionBase(base)) {
-                int end = raw.lastIndexOf(']');
-                String sectionContent = (end > bracketIdx)
-                        ? raw.substring(bracketIdx + 1, end)
-                        : raw.substring(bracketIdx + 1);
+                int close = beforePartial.lastIndexOf(']');
+                String sectionContent = (close > bracketIdx)
+                        ? beforePartial.substring(bracketIdx + 1, close)
+                        : beforePartial.substring(bracketIdx + 1);
 
                 ProtocolAtom atom = new ProtocolAtom(base);
                 ProtocolSubordinate section = parseSubordinateContent(sectionContent);
 
-                // Check for <partial> right after the section
-                Integer offset = null;
-                Integer length = null;
-                if (t.hasMore() && t.isNextByteImmediate((byte) '<')) {
-                    PartialData pd = parsePartialData(t);
-                    offset = pd.offset;
-                    length = pd.length;
+                PartialData pd = null;
+                if (partialStr != null) {
+                    pd = parsePartialFromString(partialStr);
                 }
 
-                return new ProtocolSectionPartial(atom, section, offset, length);
+                return new ProtocolSectionPartial(atom, section,
+                        pd != null ? pd.offset : null,
+                        pd != null ? pd.length : null);
             }
         }
 
-        // Normal atom (or atom with only <partial>)
-        ProtocolAtom atom = new ProtocolAtom(raw);
-
-        // Partial <...> only allowed when base is A-Za-z0-9.
-        if (t.hasMore() && t.isNextByteImmediate((byte) '<') && isValidSectionBase(raw)) {
-            PartialData pd = parsePartialData(t);
+        // No section → check for plain atom<partial>
+        if (partialStr != null && isValidSectionBase(beforePartial)) {
+            ProtocolAtom atom = new ProtocolAtom(beforePartial);
+            PartialData pd = parsePartialFromString(partialStr);
             return new ProtocolSectionPartial(atom, null, pd.offset, pd.length);
         }
 
-        return atom;
+        // Normal atom (including complex ones with [ ] ! # etc.)
+        return new ProtocolAtom(raw);
     }
 
     // ====================== Literal Parsers ======================
@@ -167,27 +170,20 @@ private static ProtocolSubordinate parseSubordinateContent(String content) {
         if (content == null || content.isEmpty()) {
             return new ProtocolSubordinate(new ProtocolObject[0]);
         }
-        // For now treat the inside as a single atom (can be improved later)
         return new ProtocolSubordinate(new ProtocolObject[]{new ProtocolAtom(content)});
     }
 
-    private static PartialData parsePartialData(Tokenizer t) {
-        t.consumeNoSkip((byte) '<');
-        StringBuilder sb = new StringBuilder();
-
-        while (t.hasMore()) {
-            byte b = t.nextByteNoSkip();
-            if (b == '>') {
-                t.consumeNoSkip((byte) '>');
-                break;
-            }
-            sb.append((char) b);
+    private static PartialData parsePartialFromString(String s) {
+        if (s == null || !s.startsWith("<") || !s.endsWith(">")) {
+            return new PartialData(0, null);
         }
+        String inner = s.substring(1, s.length() - 1).trim();
+        return parsePartialContent(inner);
+    }
 
-        String content = sb.toString().trim();
+    private static PartialData parsePartialContent(String content) {
         Integer offset = null;
         Integer length = null;
-
         if (!content.isEmpty()) {
             try {
                 if (content.contains(".")) {
@@ -201,9 +197,7 @@ private static PartialData parsePartialData(Tokenizer t) {
                 offset = 0;
             }
         }
-        if (offset == null) offset = 0;
-
-        return new PartialData(offset, length);
+        return new PartialData(offset != null ? offset : 0, length);
     }
 
     private static ProtocolQuoted parseQuoted(Tokenizer t) {
@@ -274,10 +268,7 @@ public boolean isNextByteAfter(byte current, byte expected) {
             return pos + 1 < input.length && input[pos + 1] == expected;
         }
 
-        /**
-         * Reads until whitespace, '(' or ')'.
-         * Atoms can NEVER contain ( or ).
-         */
+        /** Reads full atom until whitespace, ( or ) — allows [ and < inside */
         public String readAtom() {
             skipWhitespace();
             int start = pos;
@@ -289,7 +280,6 @@ public String readAtom() {
                 }
                 pos++;
             }
-
             return new String(input, start, pos - start, StandardCharsets.US_ASCII);
         }
 

src/test/java/com/yocto/yoclib/imap/tests/protocol/ProtocolParserTest.java

@@ -8,6 +8,8 @@
 import com.yocto.yoclib.imap.protocol.ProtocolParser;
 import com.yocto.yoclib.imap.protocol.ProtocolQuoted;
 
+import com.yocto.yoclib.imap.protocol.ProtocolSectionPartial;
+import com.yocto.yoclib.imap.protocol.ProtocolSubordinate;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
@@ -107,6 +109,18 @@ public void testParsingLiteral(){
 		},ProtocolParser.parse("{3+}\r\ndef abc\r\n".getBytes()));
 	}
 
+	@Test
+	public void testParsingSectionPartial(){
+		assertArrayEquals(new ProtocolObject[]{
+				new ProtocolAtom("tag"),
+				new ProtocolAtom("FETCH"),
+				new ProtocolAtom("2"),
+				new ProtocolSectionPartial(new ProtocolAtom("body.peek"),new ProtocolSubordinate(new ProtocolObject[]{
+						new ProtocolAtom("text"),
+				}),0,3),
+		},ProtocolParser.parse("tag FETCH 2 body.peek[text]<0.3>\r\n".getBytes()));
+	}
+
 	@Test
 	public void testParsingList(){
 		assertArrayEquals(new ProtocolObject[]{