WIP blog subOntology

Author: scriptype

src/compiler2/drivers/fs/index.js

@@ -181,7 +181,22 @@ class FileSystemDriver extends Driver {
           [key]: this.deepTokenize(obj[key])
         }
       }, {}),
-      subTree: (obj.children || []).map(c => this.deepTokenize(c))
+      subTree: (obj.children || []).map(child => {
+        if (child.content) {
+          const frontMatterResult = frontMatter(child.content || '')
+          return this.deepTokenize({
+            ...child,
+            ...(frontMatterResult.attributes || {}),
+            content: frontMatterResult.body,
+            format: this.mapExtensionToFormat(child.extension),
+          })
+        }
+
+        return this.deepTokenize({
+          ...child,
+          format: this.mapExtensionToFormat(child.extension),
+        })
+      })
     }
   }
 

src/compiler2/index.js

@@ -23,7 +23,7 @@ const compile = async () => {
   } = await fileSystem.parse(contentRootPath)
   console.log('settings.rootContentModel', rootContentModel)
   const RootOntology = Ontologies.get(rootContentModel)
-  const root = new RootOntology(contentTree)
+  const root = new RootOntology(contentTree.tree)
   await root.render(Renderer)
   Debug.timeEnd('compiler')
   return {

src/compiler2/lib/Ontology.js

@@ -48,6 +48,68 @@ const createContentModel = async (fsTree, initialModel) => {
 }
 */
 
+/*
+
+class Ontology {
+  constructor(contentTree, schema) {
+    this.schema = schema
+    this.contentTree = contentTree
+    this.contentModel = this.map(contentTree, schema)
+  }
+
+  async map(contentTree, schema) {
+    console.log(contentTree, schema)
+    return contentTree.reduce((contentNode, entry) => {
+      const models = Array.isArray(schema) ? schema : [schema]
+      return models.reduce((contentModel, model) => {
+        const newContentModel = model.reduce(contentNode, entry)
+        if (contentModel) {
+          return contentModel
+        }
+        return model
+      }, {})
+    }, {})
+  }
+
+  match(entry, _schema) {
+    const schema = _schema || this.schema(entry)
+    return Object.keys(schema).every((key) => {
+      const expected = schema[key]
+      const actual = entry[key]
+      if (typeof expected === 'string') {
+        return (actual.data || actual) === expected
+      }
+      if (expected instanceof RegExp) {
+        return !!(actual.data || actual).match(expected)
+      }
+      if (expected instanceof Function) {
+        return expected(actual.data || actual)
+      }
+      if (key === 'data') {
+        return this.match(actual, expected)
+      }
+    })
+  }
+
+  reduce(model, entry) {
+    if (!this.match(entry)) {
+      return undefined
+    }
+    const newModel = {
+      ...model,
+      homepage: this.contentModel.data
+    }
+    return newModel
+  }
+
+  async render(renderer, model) {
+    await this.view(renderer, model)
+  }
+}
+
+module.exports = Ontology
+ */
+
 class Ontology {
   constructor(name, contentTree) {
     this.name = name

src/compiler2/ontologies/blog/contentTypes.js

@@ -0,0 +1,6 @@
+module.exports = {
+  POSTS: 'posts',
+  POST: 'post',
+  FOLDERED_POST_INDEX: 'folderedPostIndex',
+  LOCAL_ASSET: 'localAsset'
+}

src/compiler2/ontologies/blog/index.js

@@ -1,10 +1,78 @@
 const Ontology = require('../../lib/Ontology')
+const contentTypes = require('./contentTypes')
+
+class Post {
+  constructor(entry) {
+    this.contentModel = {
+      type: contentTypes.POST,
+      data: {
+        title: entry.data.name.data
+      }
+    }
+  }
+}
+
+const Models = {
+  Post: {
+    schema: (entry) => ({
+      type: 'object',
+      data: {
+        format: /(markdown|plaintext|hypertext|handlebars)/,
+      }
+    }),
+
+    match: (entry, _schema) => {
+      const schema = _schema || Models.Post.schema(entry)
+      return Object.keys(schema).every((key) => {
+        const expected = schema[key]
+        const actual = entry[key]?.data || entry[key]
+        console.log(key, actual, expected, entry)
+        if (typeof expected === 'string') {
+          return actual === expected
+        }
+        if (expected instanceof RegExp) {
+          return !!actual.match(expected)
+        }
+        if (expected instanceof Function) {
+          return expected(actual)
+        }
+        if (typeof expected === 'object') {
+          return Models.Post.match(actual, expected)
+        }
+      })
+    },
+
+    reduce: (model, entry) => {
+      if (!Models.Post.match(entry)) {
+        return undefined
+      }
+      const post = new Post(entry)
+      const newModel = {
+        ...model,
+        posts: (model.posts || []).concat(post.contentModel.data)
+      }
+      return newModel
+    },
+  }
+}
 
 class Blog extends Ontology {
-  constructor(contentTree) {
+  constructor(contentTree, entry) {
     super('blog', contentTree)
-    this.contentModel = 'blog contentModel'
-    // console.log(`Blog contentTree`, JSON.stringify(contentTree, null, 2))
+    console.log('Blog contentTree', contentTree, entry)
+    this.contentModel = entry.subTree.reduce((model, entry) => {
+      const withPosts = Models.Post.reduce(model, entry)
+      if (withPosts) {
+        console.log('yes posts', withPosts)
+        return withPosts
+      }
+
+      console.log('no posts', withPosts)
+
+      // localAssets
+
+      return model
+    }, {})
   }
 }
 

src/compiler2/ontologies/portal/index.js

@@ -24,15 +24,15 @@ module.exports = ({ ontologies }) => {
       const schema = _schema || SubOntologies.schema(entry)
       return Object.keys(schema).every((key) => {
         const expected = schema[key]
-        const actual = entry[key]
+        const actual = entry[key]?.data || entry[key]
         if (typeof expected === 'string') {
-          return actual.data === expected
+          return actual === expected
         }
         if (expected instanceof RegExp) {
-          return !!actual.data.match(expected)
+          return !!actual.match(expected)
         }
         if (expected instanceof Function) {
-          return expected(actual.data)
+          return expected(actual)
         }
         if (typeof expected === 'object') {
           return SubOntologies.match(actual, expected)
@@ -41,14 +41,14 @@ module.exports = ({ ontologies }) => {
     },
 
     reduce: (model, entry) => {
-      return undefined
       if (!SubOntologies.match(entry)) {
         return undefined
       }
-      const subOntology = ontologies.get(entry.data.name.data)
+      const subOntologyClass = ontologies.get(entry.data.name.data)
+      const subOntology = new subOntologyClass(model, entry)
       return {
         ...model,
-        [entry.data.name.data]: entry.contentModel
+        [entry.data.name.data]: subOntology.contentModel
       }
     },
 
@@ -166,8 +166,8 @@ module.exports = ({ ontologies }) => {
 
   class Portal extends Ontology {
     constructor(contentTree) {
-      super(contentTree)
-      this.contentModel = contentTree.tree.reduce((model, entry) => {
+      super('portal', contentTree)
+      this.contentModel = contentTree.reduce((model, entry) => {
 
         const withSubOntologies = SubOntologies.reduce(model, entry)
         if (withSubOntologies) {