Experimenting with parser further.

docs/experiments/.gitignore

@@ -0,0 +1 @@
+node_modules/

docs/experiments/parser.js

@@ -1,19 +1,139 @@
 import { createLineData, useDocument } from '@terrace/core'
 import { createStringReader } from '@terrace/core/readers/js-string'
 
-async function main() {
-  const lines = [
-    `title Example`,
-    `subsection`,
-    ` position 1`,
-    ` Ea dolore in aliquip fugiat anim adipisicing amet aute tempor et deserunt est duis sint.`,
-    `subsection 2`,
-    ` position 2`,
-    ` Aute deserunt incididunt ad in sint adipisicing est officia velit pariatur ipsum deserunt quis nulla.`
-  ]
+const schema = {
+  types: {
+    subsection: {
+      type: 'object',
+      text: 'content',
+      tail: 'number',
+      values: {
+        position: {
+          type: 'number'
+        }
+      }
+    },
+    options: {
+      type: 'object',
+      values: {
+        parameter1: 'number',
+        parameter2: 'string'
+      }
+    }
+  },
+  root: {
+    type: 'object',
+    values: {
+      title: 'string',
+      options: 'options',
+      options2: 'options',
+      subsection: {
+        type: 'collection',
+        collection: 'subsection'
+      }
+    }
+  }
+}
 
-  const rootDoc = useDocument(createStringReader(lines))
-  console.log(await rootDoc.seek('subsection').then(r => r.content()))
+const lines = [
+  `title Example`,
+  `options`,
+  ` parameter1 30`,
+  ` parameter2 Enim eu id anim minim reprehenderit nostrud eu amet deserunt ea ut do cupidatat ea.`,
+  `options2`,
+  ` parameter1 0`,
+  ` parameter2 Esse incididunt et est adipisicing eiusmod aliqua enim ea aliqua id enim.`,
+  `subsection`,
+  ` position 1`,
+  ` Ea dolore in aliquip fugiat anim adipisicing amet aute tempor et deserunt est duis sint.`,
+  `subsection 2`,
+  ` position 2`,
+  ` Aute deserunt incididunt ad in sint adipisicing est officia velit pariatur ipsum deserunt quis nulla.`
+]
+
+
+const typeHandlers = {
+  string (key, definition, add) {
+    return (doc, handlers) => {
+      if (doc.head() !== key) return
+      add(key, doc.tail().slice(1))
+    }
+  },
+  number (key, definition, add) {
+    return (doc, handlers) => {
+      if (doc.head() !== key) return
+      add(key, +doc.tail().slice(1))
+    }
+  },
+  object (key, definition, add) {
+    definition = resolve(definition)
+    return (doc, handlers) => {
+      if (doc.head() !== key) return
+      const object = {}
+      add(key, object)
+
+      for (const [key, child] of Object.entries(definition.values)) {
+        addHandler(handlers, doc.level() + 1, key, child, (key, value) => (object[key] = value))
+      }
+    }
+  },
+  collection (key, definition, add) {
+    return (doc, handlers) => {
+      if (doc.head() !== key) return
+      const collection = []
+      add(key, collection)
+
+      const child = resolve(definition.collection)
+      addHandler(handlers, doc.level() + 1, '*', child, (key, value) => ( collection.push(value) ))
+    }
+  }
+}
+
+function resolve (definition) {
+  const type = typeof definition === 'string' ? definition : definition.type
+  if (schema.types[type]) return schema.types[type]
+  else return definition
+}
+
+function registerTypes(typeHandlers, types) {
+  for (const [key, definition] of Object.entries(types)) {
+    const existingType = typeof definition === 'string' ? definition : definition.type
+    typeHandlers[key] = typeHandlers[existingType]
+  }
+}
+
+function addHandler(handlers, level, key, definition, add) {
+  const type = typeof definition === 'string' ? definition : definition.type
+  if (!handlers[level]) handlers[level] = []
+  handlers[level].push(typeHandlers[type](key, definition, add))
+}
+
+async function main() {
+  const doc = useDocument(createStringReader(lines))
+
+  const handlers = []
+
+  registerTypes(typeHandlers, schema.types)
+
+  const root = {}
+  for (const [key, child] of Object.entries(schema.root.values)) {
+    addHandler(handlers, 0, key, child, (key, value) => (root[key] = value))
+  }
+
+  let ended = false
+  let lastLevel = 0
+  while (!ended) {
+    ended = await doc.next()
+    if (ended) break;
+    const level = doc.level()
+    handlers.length = level + 1
+
+    for (const handler of handlers[level] || []) {
+      handler(doc, handlers)
+    }
+  }
+
+  console.log(root)
 }
 
 main()