Fix parsing atoms

Author: ben221199

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

@@ -44,13 +44,33 @@ private static ProtocolObject parseToken(Tokenizer t) {
         if (b == '[') return parseSubordinate(t);
         if (b == '"') return parseQuoted(t);
 
-        // Atom
-        String atomValue = t.readAtom();
-        ProtocolAtom atom = new ProtocolAtom(atomValue);
+        // === Atom (may contain one [section]) ===
+        String raw = t.readAtom();                    // reads until whitespace
+        int bracketIdx = raw.indexOf('[');
+
+        // Case 1: Looks like atom[section]
+        if (bracketIdx > 0 && raw.lastIndexOf('[') == bracketIdx) {  // exactly one [
+            String base = raw.substring(0, bracketIdx);
+            if (isValidSectionBase(base)) {
+                // Extract content between [ and ]
+                int end = raw.lastIndexOf(']');
+                String sectionContent = (end > bracketIdx)
+                        ? raw.substring(bracketIdx + 1, end)
+                        : raw.substring(bracketIdx + 1);
+
+                ProtocolAtom atom = new ProtocolAtom(base);
+                ProtocolSubordinate section = parseSubordinateContent(sectionContent);
+                return new ProtocolSectionPartial(atom, section, null, null);
+            }
+        }
+
+        // Normal atom
+        ProtocolAtom atom = new ProtocolAtom(raw);
 
-        if (t.hasMore() &&
-                (t.isNextByteImmediate((byte) '[') || t.isNextByteImmediate((byte) '<'))) {
-            return parseSectionPartial(atom, t);
+        // Still allow <partial> after a normal atom
+        if (t.hasMore() && t.isNextByteImmediate((byte) '<')) {
+            PartialData pd = parsePartialData(t);
+            return new ProtocolSectionPartial(atom, null, pd.offset, pd.length);
         }
 
         return atom;
@@ -134,6 +154,15 @@ private static ProtocolSubordinate parseSubordinate(Tokenizer t) {
         return new ProtocolSubordinate(elements.toArray(new ProtocolObject[0]));
     }
 
+    /** Parse subordinate from a string that was already consumed inside [] */
+    private static ProtocolSubordinate parseSubordinateContent(String content) {
+        if (content == null || content.isEmpty()) {
+            return new ProtocolSubordinate(new ProtocolObject[0]);
+        }
+        // Simple fallback: treat as single atom for now
+        return new ProtocolSubordinate(new ProtocolObject[]{new ProtocolAtom(content)});
+    }
+
     private static ProtocolSectionPartial parseSectionPartial(ProtocolAtom baseAtom, Tokenizer t) {
         ProtocolSubordinate section = null;
         Integer offset = null;
@@ -251,23 +280,25 @@ public boolean isNextByteImmediate(byte expected) {
         }
 
         public boolean isNextByteAfter(byte current, byte expected) {
-            if (pos >= input.length || input[pos] != current) {
-                return false;
-            }
+            if (pos >= input.length || input[pos] != current) return false;
             return pos + 1 < input.length && input[pos + 1] == expected;
         }
 
+        /**
+         * Reads until whitespace — allows [, ], !, #, $, etc.
+         */
         public String readAtom() {
             skipWhitespace();
             int start = pos;
+
             while (pos < input.length) {
                 byte b = input[pos];
-                if (Character.isWhitespace(b & 0xFF) || b == '(' || b == ')' || b == '[' || b == ']' ||
-                        b == '"' || b == '{' || b == '}' || b == '<' || b == '>') {
+                if (Character.isWhitespace(b & 0xFF)) {
                     break;
                 }
                 pos++;
             }
+
             return new String(input, start, pos - start, StandardCharsets.US_ASCII);
         }
 
@@ -294,6 +325,19 @@ public byte nextByteNoSkip() {
         }
     }
 
+    // ====================== Helpers ======================
+
+    private static boolean isValidSectionBase(String s) {
+        if (s == null || s.isEmpty()) return false;
+        for (char c : s.toCharArray()) {
+            if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
+                    (c >= '0' && c <= '9') || c == '.')) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     // ====================== Helper Classes ======================
 
     private static class LiteralHeader {

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

@@ -5,14 +5,30 @@
 import com.yocto.yoclib.imap.protocol.ProtocolLiteral;
 import com.yocto.yoclib.imap.protocol.ProtocolObject;
 import com.yocto.yoclib.imap.protocol.ProtocolParser;
-
 import com.yocto.yoclib.imap.protocol.ProtocolQuoted;
+
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 
 public class ProtocolParserTest{
 
+	@Test
+	public void testParsingAtom(){
+		assertArrayEquals(new ProtocolObject[]{
+				new ProtocolAtom("tag"),
+				new ProtocolAtom("SELECT"),
+				new ProtocolAtom("!#$$&'+,-.0123456789:;<=>?@^_`|[}"),
+		},ProtocolParser.parse("tag SELECT !#$$&'+,-.0123456789:;<=>?@^_`|[}".getBytes()));
+
+		assertArrayEquals(new ProtocolObject[]{
+				new ProtocolAtom("tag"),
+				new ProtocolAtom("LIST"),
+				new ProtocolQuoted(""),
+				new ProtocolAtom("!#$$&'+,-.0123456789:;<=>?@^_`|[}%*"),
+		},ProtocolParser.parse("tag LIST \"\" !#$$&'+,-.0123456789:;<=>?@^_`|[}%*".getBytes()));
+	}
+
 	@Test
 	public void testParsingQuoted(){
 		assertArrayEquals(new ProtocolObject[]{
@@ -90,15 +106,4 @@ public void testParsingLiteral(){
 		},ProtocolParser.parse("{3+}\r\ndef abc\r\n".getBytes()));
 	}
 
-	@Test
-	public void testParsingComplexAtom(){
-		//ProtocolObject[] objects = ProtocolParser.parse("!#$$&'+,-.0123456789:;<=>?@^_`|[}");
-
-		//assertEquals(1,objects.length);
-		//assertInstanceOf(ProtocolAtom.class,objects[0]);
-
-		//ProtocolAtom atom = (ProtocolAtom) objects[0];
-		//assertEquals("!#$$&'+,-.0123456789:;<=>?@^_`|[}",atom.getValue());
-	}
-
 }