Automate childNode matching and parsing in ContentModelEntryNode

Introduce a getSubtreeConfig method, in which all necessities of
matching childNodes and building subtree out of them are defined.

For each key in subtree, a definition like this is added to the config
array:

{
  matcher: matcha;
  key?: string;
  settings?: object;
  model?: ContentModelNode constructor;
  singular?: boolean (false);
  sideEffect?: function;
}

Then parseSubtree template method is actually implemented in the
ContentModelEntryNode. It loops over childNodes and subtree configs.

For everything to look and feel smooth some additional changes are made:

- ContentModel does not pass a contentType property to collection any
more. Instead, collection itself computes it based on the
settings.contentTypes in its getSchema method
- Compiler passes the { children: fileSystemTree } to the contentModel
- static draftCheck is now a class method of ContentModelEntryNode
- A getChildContext template method is added for models to be able to
customize the context they pass to their childNodes. E.g. ContentModel,
AssetsDirectory, PagesDirectory

Author: scriptype

src/compiler/contentModel/index.js

@@ -172,159 +172,134 @@ class ContentModel extends ContentModelEntryNode {
 
     this.contentTypes = contentTypes
 
-    const collectionAliasesFromContentTypes = contentTypes
-      .filter(ct => ct.model === 'collection')
-      .map(ct => ct.collectionAlias)
-
-    const collectionAliasesFromFrontMatter = this.collectionAliases || []
+    this.subtreeConfig = this.getSubtreeConfig()
 
-    this.collectionAliases = [
-      ...collectionAliasesFromContentTypes,
-      ...collectionAliasesFromFrontMatter
-    ]
+    this.subtree = this.parseSubtree({
+      homepage: new models.Homepage(
+        { name: 'index', extension: 'md', content: '' },
+        this.context,
+        { homepageDirectory: this.settings.homepageDirectory }
+      ),
+      pagesDirectory: [],
+      subpages: [],
+      collections: [],
+      assets: []
+    })
 
-    this.matchers = this.getSubtreeMatchers()
-    this.subtree = this.parseSubtree()
     this.afterEffects()
   }
 
   getIndexFile() {
-    return this.fsNode.find(
+    return this.fsNode.children.find(
       matcha.templateFile({
         nameOptions: ['root']
       })
     )
   }
 
-  getSubtreeMatchers() {
-    return {
-      collectionIndexFile: matcha.templateFile({
-        nameOptions: this.collectionAliases.concat('collection')
-      }),
+  getCollectionAliases() {
+    const collectionAliasesFromContentTypes = this.contentTypes
+      .filter(ct => ct.model === 'collection')
+      .map(ct => ct.collectionAlias)
 
-      collection: matcha.directory({
-        children: matcha.either(
-          matcha.templateFile({
-            nameOptions: this.collectionAliases.concat('collection')
-          }),
-          matcha.dataFile({
-            nameOptions: (fsNode) => ([fsNode.name])
-          }),
-        )
-      }),
+    const collectionAliasesFromFrontMatter = this.collectionAliases || []
+
+    return [
+      ...collectionAliasesFromContentTypes,
+      ...collectionAliasesFromFrontMatter
+    ]
+  }
 
-      homepage: matcha.folderable({
+  getChildContext() {
+    return this.context
+  }
+
+  getSubtreeConfig() {
+    const collectionAliases = this.getCollectionAliases()
+
+    return [{
+      key: 'homepage',
+      singular: true,
+      model: models.Homepage,
+      matcher: matcha.folderable({
         nameOptions: {
           folder: [this.settings.homepageDirectory, 'homepage', 'home'],
           index: ['index'],
           standalone: ['homepage', 'home', 'index']
         }
       }),
-
-      subpage: matcha.folderable({
+      settings: {
+        homepageDirectory: this.settings.homepageDirectory
+      }
+    }, {
+      key: 'subpages',
+      model: models.Subpage,
+      matcher: matcha.folderable({
         nameOptions: {
           index: ['page', 'index']
         }
       }),
-
-      pagesDirectory: matcha.directory({
+      settings: {
+        pagesDirectory: this.settings.pagesDirectory
+      }
+    }, {
+      key: 'pagesDirectory',
+      singular: true,
+      model: models.PagesDirectory,
+      matcher: matcha.directory({
         nameOptions: [this.settings.pagesDirectory, 'subpages', 'pages']
       }),
-
-      assetsDirectory: matcha.directory({
-        nameOptions: [this.settings.assetsDirectory, 'assets']
-      }),
-
-      asset: matcha.true()
-    }
-  }
-
-  parseSubtree() {
-    const tree = {
-      homepage: new models.Homepage(
-        { name: 'index', extension: 'md', content: '' },
-        this.context,
-        { homepageDirectory: this.settings.homepageDirectory }
-      ),
-      pagesDirectory: [],
-      subpages: [],
-      collections: [],
-      assets: []
-    }
-
-    this.fsNode.forEach(node => {
-      if (node === this.indexFile) {
-        return
-      }
-
-      if (this.matchers.homepage(node)) {
-        tree.homepage = new models.Homepage(node, this.context, {
-          homepageDirectory: this.settings.homepageDirectory
-        })
-        return
+      settings: {
+        pagesDirectory: this.settings.pagesDirectory,
+        assetsDirectory: this.settings.assetsDirectory,
+        debug: this.settings.debug
+      },
+      sideEffect: (tree, entry) => {
+        tree.subpages.push(...entry.subtree.subpages)
+        tree.assets.push(...entry.subtree.assets)
       }
-
-      if (this.matchers.subpage(node)) {
-        return tree.subpages.push(
-          new models.Subpage(node, this.context, {
-            pagesDirectory: this.settings.pagesDirectory
-          })
+    }, {
+      key: 'collections',
+      model: models.Collection,
+      matcher: matcha.directory({
+        children: matcha.either(
+          matcha.templateFile({
+            nameOptions: collectionAliases.concat('collection')
+          }),
+          matcha.dataFile({
+            nameOptions: (fsNode) => ([fsNode.name])
+          }),
         )
+      }),
+      settings: {
+        defaultCategoryName: this.settings.defaultCategoryName,
+        collectionAliases,
+        mode: this.settings.mode,
+        contentTypes: this.contentTypes,
+        sortBy: 'date',
+        sortOrder: -1
       }
-
-      if (this.matchers.pagesDirectory(node)) {
-        tree.pagesDirectory = new models.PagesDirectory(node, this.context, {
-          pagesDirectory: this.settings.pagesDirectory,
-          assetsDirectory: this.settings.assetsDirectory,
-          debug: this.settings.debug
-        })
-        tree.subpages.push(...tree.pagesDirectory.subtree.subpages)
-        tree.assets.push(...tree.pagesDirectory.subtree.assets)
-        return
-      }
-
-      if (this.matchers.collection(node)) {
-        const indexFile = node.children.find(this.matchers.collectionIndexFile)
-
-        const contentType = this.contentTypes
-          .filter(ct => ct.model === 'collection')
-          .find(ct => {
-            return ct.collectionAlias === (indexFile ? removeExtension(indexFile.name) : node.name)
-          })
-
-        const collection = new models.Collection(node, this.context, {
-          defaultCategoryName: this.settings.defaultCategoryName,
-          collectionAliases: this.collectionAliases,
-          mode: this.settings.mode,
-          contentTypes: this.contentTypes,
-          sortBy: 'date',
-          sortOrder: -1,
-          contentType
-        })
-
-        if (ContentModel.draftCheck(this.settings.mode, collection)) {
-          tree.collections.push(collection)
-        }
-        return
-      }
-
-      if (this.matchers.assetsDirectory(node)) {
-        tree.assetsDirectory = new models.AssetsDirectory(node, this.context, {
-          assetsDirectory: this.settings.assetsDirectory
-        })
-        tree.assets.push(...tree.assetsDirectory.subtree.assets)
-        return
+    }, {
+      key: 'assetsDirectory',
+      singular: true,
+      model: models.AssetsDirectory,
+      matcher: matcha.directory({
+        nameOptions: [this.settings.assetsDirectory, 'assets']
+      }),
+      settings: {
+        assetsDirectory: this.settings.assetsDirectory
+      },
+      sideEffect: (tree, entry) => {
+        tree.assets.push(...entry.subtree.assets)
       }
-
-      if (this.matchers.asset(node)) {
-        return tree.assets.push(
-          new models.Asset(node, this.context, {
-            assetsDirectory: this.settings.assetsDirectory
-          })
-        )
+    }, {
+      key: 'assets',
+      model: models.Asset,
+      matcher: matcha.true(),
+      settings: {
+        assetsDirectory: this.settings.assetsDirectory
       }
-    })
-    return tree
+    }]
   }
 
   afterEffects() {

src/compiler/contentModel/models/asset.js

@@ -12,7 +12,6 @@ class Asset extends ContentModelResourceNode {
 
   constructor(fsNode, context, settings = defaultSettings) {
     super(fsNode, context, settings)
-    this.subtree = this.parseSubtree()
   }
 
   getPermalink() {

src/compiler/contentModel/models/assetsDirectory.js

@@ -17,32 +17,25 @@ class AssetsDirectory extends ContentModelEntryNode {
 
   constructor(fsNode, context, settings) {
     super(fsNode, context, settings)
-    this.matchers = this.getSubtreeMatchers()
-    this.subtree = this.parseSubtree()
-    this.afterEffects()
+    this.subtreeConfig = this.getSubtreeConfig()
+    this.subtree = this.parseSubtree({
+      assets: []
+    })
   }
 
-  getSubtreeMatchers() {
-    return {
-      asset: matcha.true()
-    }
+  getChildContext() {
+    return this.context
   }
 
-  parseSubtree() {
-    const tree = {
-      assets: []
-    }
-
-    this.fsNode.children.forEach(childNode => {
-      if (this.matchers.asset(childNode)) {
-        return tree.assets.push(
-          new models.Asset(childNode, this.context, {
-            assetsDirectory: this.settings.assetsDirectory
-          })
-        )
+  getSubtreeConfig() {
+    return [{
+      key: 'assets',
+      model: models.Asset,
+      matcher: matcha.true(),
+      settings: {
+        assetsDirectory: this.settings.assetsDirectory
       }
-    })
-    return tree
+    }]
   }
 }
 

src/compiler/contentModel/models/attachment.js

@@ -7,7 +7,6 @@ class Attachment extends ContentModelResourceNode {
 
   constructor(fsNode, context, settings) {
     super(fsNode, context, settings)
-    this.subtree = this.parseSubtree()
   }
 
   render(renderer) {