[CM2] Introduce deep categorization

This is a combination of 3 commits. Brace yourself.

For now the taxonomy depth is max 3. Because why not.

This required looking up to parent context for content modelling
information, instead of reaching out to the collection. So, throughout
the depth of the taxonomy, content modelling can manipulate the cascade.

To achieve that, the context object is converted into a stack. An
ImmutableStack class is used to pop() it without worrying. It has a
throwUntil() to dig the stack until reaching a point of interest (for
example digging the context to find a collection). That was needed to
avoid passing post and category contexts to tags, as tags don't carry a
hierarchial-relationship in respect to them.

Now, each subCategory can define content-modelling attributes in its
index file. Therefore, each subCategory can have a custom indexFileName
and custom names for its subCategories and posts. For example:

Demos (collection contentType: DemoPortfolio)
  - CSS (category contentType: Technology)
    + CSS-Only (category contentType: Technique)
    + Sliding Doors (category contentType: Technique)
  - Three.js
  - Whatever

The easiest way to deal with rendering subCategories was to merge
the rendering counterpart of models into the models themselves. So,
now, in addition to match() and create(), there's a render(). The render()
is pretty scrappy for now and probably needs more thinking. One of the
main ideas in this implementation is to nest the rendering of the
model's child entities (e.g. for a category, rendering of subCategories,
posts, attachments) into the models' render(). When root render()s,
render flows downstream from there. So, CM2's rendering counterpart is
now only the renderer itself, there's no more views.

Invent something called 'levelPosts' in Category. It contains only the
posts belonging to the category's specific depth. The regular 'posts'
field contains all posts downstream. This was particularly necessary to
avoid duplicate rendering of sub-categorized posts. So, each category
renders only its levelPosts.

For now, inject the global settings and debug as dependencies into
models. That's for keeping templates' access to those. Maybe a classier
way is needed.

Also, don't pass keys like collection and category into the templates
any more.

Should the pagination helper be kept in renderer though? Feels much like
it's a content-model thing. But the code implies otherwise.

Author: scriptype

src/compiler/contentModel2/index.js

@@ -1,6 +1,7 @@
 const { resolve } = require('path')
 const _ = require('lodash')
 const frontMatter = require('front-matter')
+const ImmutableStack = require('../../lib/ImmutableStack')
 const { isTemplateFile } = require('./helpers')
 const models = {
   homepage: require('./models/homepage'),
@@ -57,7 +58,12 @@ const defaultContentModelSettings = {
   defaultCategoryName: 'Unclassified',
   assetsDirectory: 'assets',
   pagesDirectory: 'pages',
-  homepageDirectory: 'homepage'
+  homepageDirectory: 'homepage',
+  debug: false,
+  site: {
+    title: '',
+    description: ''
+  }
 }
 class ContentModel {
   constructor(contentModelSettings = defaultContentModelSettings, contentTypes = []) {
@@ -80,10 +86,11 @@ class ContentModel {
     const indexFile = fileSystemTree.find(isRootIndexFile)
     const indexProps = indexFile ? frontMatter(indexFile.content) : {}
 
-    const context = {
+    const context = new ImmutableStack([{
+      key: 'root',
       outputPath: this.settings.out,
       permalink: this.settings.permalinkPrefix
-    }
+    }])
 
     this.models = {
       collection: models.collection({
@@ -109,66 +116,119 @@ class ContentModel {
       })
     }
 
-    const contentModel = {
+    this.contentModel = {
       homepage: this.models.homepage.create({
         name: 'index',
         extension: 'md',
         content: ''
-      }, { root: context }),
+      }, context),
       subpages: [],
       collections: [],
       assets: []
     }
 
     fileSystemTree.forEach(node => {
       if (this.models.homepage.match(node)) {
-        contentModel.homepage = this.models.homepage.create(node, { root: context })
+        this.contentModel.homepage = this.models.homepage.create(node, context)
         return
       }
 
       if (this.models.subpage.match(node)) {
-        return contentModel.subpages.push(
-          this.models.subpage.create(node, { root: context })
+        return this.contentModel.subpages.push(
+          this.models.subpage.create(node, context)
         )
       }
 
       if (this.models.subpage.matchPagesDirectory(node)) {
         return node.children.forEach(childNode => {
           if (this.models.subpage.match(childNode)) {
-            contentModel.subpages.push(
-              this.models.subpage.create(childNode, { root: context })
+            this.contentModel.subpages.push(
+              this.models.subpage.create(childNode, context)
             )
           } else if (this.models.asset.match(childNode)) {
-            contentModel.assets.push(
-              this.models.asset.create(childNode, { root: context })
+            this.contentModel.assets.push(
+              this.models.asset.create(childNode, context)
             )
           }
         })
       }
 
       if (this.models.collection.match(node)) {
-        return contentModel.collections.push(
-          this.models.collection.create(node, { root: context })
+        return this.contentModel.collections.push(
+          this.models.collection.create(node, context)
         )
       }
 
       if (this.models.asset.matchAssetsDirectory(node)) {
-        return contentModel.assets.push(
+        return this.contentModel.assets.push(
           ...node.children.map(childNode => {
-            return this.models.asset.create(childNode, { root: context })
+            return this.models.asset.create(childNode, context)
           })
         )
       }
 
       if (this.models.asset.match(node)) {
-        return contentModel.assets.push(
-          this.models.asset.create(node, { root: context })
+        return this.contentModel.assets.push(
+          this.models.asset.create(node, context)
         )
       }
     })
 
-    linkEntries(contentModel)
-    return contentModel
+    linkEntries(this.contentModel)
+    return this.contentModel
+  }
+
+  render(renderer) {
+    const renderHomepage = () => {
+      return this.models.homepage.render(renderer, this.contentModel.homepage, {
+        contentModel: this.contentModel,
+        settings: this.settings,
+        debug: this.settings.debug
+      })
+    }
+
+    const renderCollections = () => {
+      return Promise.all(
+        this.contentModel.collections.map(collection => {
+          return this.models.collection.render( renderer, collection, {
+            contentModel: this.contentModel,
+            settings: this.settings,
+            debug: this.settings.debug
+          })
+        })
+      )
+    }
+
+    const renderSubpages = () => {
+      return Promise.all(
+        this.contentModel.subpages.map(subpage => {
+          return this.models.subpage.render(renderer, subpage, {
+            contentModel: this.contentModel,
+            settings: this.settings,
+            debug: this.settings.debug
+          })
+        })
+      )
+    }
+
+    const renderAssets = () => {
+      return Promise.all(
+        this.contentModel.assets.map(asset => {
+          return this.models.asset.render(renderer, asset, {
+            contentModel: this.contentModel,
+            settings: this.settings,
+            debug: this.settings.debug
+          })
+        })
+      )
+    }
+
+    return Promise.all([
+      renderHomepage(),
+      renderCollections(),
+      renderSubpages(),
+      renderAssets()
+    ])
   }
 }
 

src/compiler/contentModel2/models/asset.js

@@ -3,7 +3,7 @@ const { join, resolve } = require('path')
 const defaultSettings = {
   assetsDirectory: 'assets'
 }
-module.exports = function asset(settings = defaultSettings) {
+module.exports = function Asset(settings = defaultSettings) {
   const assetsDirectoryNameOptions = [settings.assetsDirectory, 'assets']
 
   const isAssetsDirectory = (node) => {
@@ -18,14 +18,15 @@ module.exports = function asset(settings = defaultSettings) {
   return {
     match: node => true,
     matchAssetsDirectory: isAssetsDirectory,
+
     create: (node, context) => {
       const permalink = (
-        context.root.permalink +
+        context.peek().permalink +
         [settings.assetsDirectory, node.name].join('/')
       )
 
       const outputPath = join(
-        context.root.outputPath,
+        context.peek().outputPath,
         settings.assetsDirectory,
         node.name
       )
@@ -37,6 +38,14 @@ module.exports = function asset(settings = defaultSettings) {
         outputPath,
         date: new Date(node.stats.birthtime || Date.now())
       }
+    },
+
+    render: (renderer, asset) => {
+      return renderer.copy({
+        src: asset.absolutePath,
+        dest: asset.outputPath,
+        recursive: !!asset.children
+      })
     }
   }
 }

src/compiler/contentModel2/models/attachment.js

@@ -1,24 +1,22 @@
 const { join } = require('path')
+const _ = require('lodash')
 
-module.exports = function attachment() {
+module.exports = function Attachment() {
   return {
     match: node => true,
+
     create(node, context) {
-      const permalink = [
-        context.page?.permalink ||
-        context.post?.permalink ||
-        context.category?.permalink ||
-        context.collection?.permalink,
+      const permalink = _.compact([
+        context.peek()?.permalink,
         node.name
-      ].filter(Boolean).join('/')
+      ]).join('/')
 
-      const outputPath = join(...[
-        context.page?.outputPath ||
-        context.post?.outputPath ||
-        context.category?.outputPath ||
-        context.collection?.outputPath,
-        node.name
-      ].filter(Boolean))
+      const outputPath = join(
+        ..._.compact([
+          context.peek()?.outputPath,
+          node.name
+        ])
+      )
 
       return {
         ...node,
@@ -27,6 +25,14 @@ module.exports = function attachment() {
         outputPath,
         date: new Date(node.stats.birthtime || Date.now())
       }
+    },
+
+    render: (renderer, attachment) => {
+      return renderer.copy({
+        src: attachment.absolutePath,
+        dest: attachment.outputPath,
+        recursive: !!attachment.children
+      })
     }
   }
 }