Rewrite parser with explicit state transitions

Author: thecrypticace

src/util/toPath.js

@@ -15,68 +15,121 @@
 export function toPath(path) {
   if (Array.isArray(path)) return path
 
-  /** @type {'start' | 'in_property' | 'in_brackets' | 'end'} */
-  let state = 'start'
+  // The general outline of a path string is as follows:
+  // property.another[some.other.property.with.dots][0][0].and.so.on
+  // Properties may be separated by dots, optionally enclosed in brackets, can access array elements, etc...
+
+  // Tokens:
+  // [ = lb
+  // ] = rb
+  // . = dot if not in brackets
+  // . = ident if in brackets
+  // everything else = ident
+
+  // Valid transitions:
+  // start -> dot | lb | ident | end
+  // dot   -> ident
+  // lb    -> rb | ident
+  // rb    -> dot | lb
+  // ident -> dot | rb | ident | end
+  // ident -> lb if not in brackets
+
+  // Additional rules:
+  // lb :: set in brackets = true
+  // rb :: set in brackets = false
 
   let parts = []
+  let inBrackets = false
   let partStart = 0
   let partEnd = 0
 
-  for (let i = 0, len = path.length; i < len; i++) {
-    let c = path[i]
-    let previousState = state
-
-    if (c === '[') {
-      if (previousState === 'in_brackets') {
-        throw new Error(`Invalid path: ${path}\n` + `${' '.repeat(14 + i)}^`)
-      }
+  for (let i = 0, len = path.length; i <= len; i++) {
+    let prev = path[i - 1]
+    let curr = path[i]
 
-      // Append the current part to the parts if non-empty (would be in the case of concesutive brackets e.g. a[b][c])
-      partEnd = i
+    let error = () => {
+      throw new Error(`Invalid path: ${path}\n` + `${' '.repeat(14 + i)}^`)
+    }
+    let startNew = () => (partStart = partEnd = i)
+    let advance = () => (partEnd = i)
+    let setInBrackets = (v) => (inBrackets = v)
+    let capture = () => parts.push(path.slice(partStart, partEnd))
 
-      if (partStart !== partEnd) {
-        parts.push(path.slice(partStart, partEnd))
+    if (prev === undefined) {
+      if (curr === '.') {
+        // start -> dot
+        capture()
+      } else if (curr === '[') {
+        // start -> lb
+        startNew()
+        setInBrackets(true)
+      } else if (curr === ']') {
+        // start -> rb
+        return error()
+      } else {
+        // start -> ident | end
       }
-
-      state = 'in_brackets'
-      partStart = i + 1
-    } else if (c === ']') {
-      if (previousState !== 'in_brackets') {
-        throw new Error(`Invalid path: ${path}\n` + `${' '.repeat(14 + i)}^`)
+    } else if (prev === '.' && !inBrackets) {
+      if (curr === '[' || curr === ']' || curr === '.' || curr === undefined) {
+        // dot -> lb | rb | dot | end
+        return error()
+      } else {
+        // dot -> ident
+        startNew()
       }
-
-      // Append the part between brackets
-      partEnd = i
-      parts.push(path.slice(partStart, partEnd))
-
-      state = 'in_property'
-      partStart = i + 1
-    } else if (c === '.' && previousState !== 'in_brackets') {
-      // Append the current part to the parts if non-empty (would be in the case of concesutive brackets e.g. a[b][c])
-      // The exception is the start of the path
-      partEnd = i
-
-      if (partStart !== partEnd || previousState === 'start') {
-        parts.push(path.slice(partStart, partEnd))
+    } else if (prev === '[') {
+      if (curr === '[' || curr === undefined) {
+        // lb -> lb | end
+        return error()
+      } else if (curr === ']') {
+        // lb -> rb
+        capture()
+        setInBrackets(false)
+      } else {
+        // lb -> ident
+        startNew()
+      }
+    } else if (prev === ']') {
+      if (curr === '.') {
+        // rb -> dot
+        startNew()
+      } else if (curr === '[') {
+        // rb -> lb
+        setInBrackets(true)
+      } else if (curr === undefined) {
+        // rb -> end
+      } else {
+        // rb -> rb | ident
+        return error()
       }
-
-      state = 'in_property'
-      partStart = i + 1
     } else {
-      // Keep collecting this part of the path
-      partEnd = i + 1
-
-      // We've hit the end of the path
-      // Append the last part
-      if (partEnd === len) {
-        parts.push(path.slice(partStart, partEnd))
+      if (curr === '.' && !inBrackets) {
+        // ident -> dot
+        advance()
+        capture()
+      } else if (curr === ']') {
+        // ident -> rb
+        advance()
+        capture()
+        setInBrackets(false)
+      } else if (curr === '[' && inBrackets) {
+        // ident -> lb if in brackets
+        return error()
+      } else if (curr === '[' && !inBrackets) {
+        // ident -> lb
+        advance()
+        capture()
+        setInBrackets(true)
+      } else if (curr === undefined) {
+        // ident -> end
+        advance()
+        capture()
+      } else {
+        // ident -> ident
+        advance()
       }
     }
   }
 
-  if (state === 'in_brackets') {
-    throw new Error(`Unclosed path: ${path}`)
-  }
-
   return parts
 }