Refactor radar creation

scripts/radar.js

@@ -1,19 +1,25 @@
 import { walk } from 'walk';
-import fs, { readFileSync } from 'fs-extra';
+import fs, { readFile } from 'fs-extra';
 import path from 'path';
 import frontmatter from 'front-matter';
 import marked from 'marked';
-import waterfall from 'async/waterfall';
 import { srcPath } from './file';
 
-export const getTree = () => (
+export const createRadar = async (tree) => {
+  const fileNames = await getAllMarkdownFiles();
+  const revisions = await createRevisionsFromFiles(fileNames);
+  const quadrants = createQuadrants(revisions);
+  return quadrants;
+};
+
+const getAllMarkdownFiles = () => (
   new Promise((resolve, reject) => {
     const walker = walk(srcPath(), { followLinks: false });
-    let radar = {};
+    const files = [];
 
     walker.on("file", (root, fileStat, next) => {
       if (isMarkdownFile(fileStat.name)) {
-        radar = addItemToRadar(radar, path.resolve(root, fileStat.name))
+        files.push(path.resolve(root, fileStat.name));
       }
       next();
     });
@@ -27,115 +33,75 @@ export const getTree = () => (
     });
 
     walker.on("end", () => {
-      resolve(radar);
+      resolve(files.sort().reverse());
     });
   })
 );
 
 const isMarkdownFile = (name) => name.match(/\.md$/);
 
-const addItemToRadar = (radar, pathName) => {
-  const item = createItemFromPath(pathName);
+const createRevisionsFromFiles = (fileNames) => (
+  Promise.all(fileNames.map((fileName) => {
+    return new Promise((resolve, reject) => {
+      readFile(fileName, 'utf8', (err, data) => {
+        if(err) {
+          reject(err);
+        } else {
+          const fm = frontmatter(data);
+          resolve({
+            ...itemInfoFromFilename(fileName),
+            fileName,
+            attributes: fm.attributes,
+            body: fm.body,
+          });
+        }
+      });
+    })
+  }))
+)
+
+const itemInfoFromFilename = (fileName) => {
+  const [
+    version,
+    quadrant,
+    nameWithSuffix,
+  ] = fileName.split('/').slice(-3);
   return {
-    ...radar,
-    [item.version]: addItemToVersion(radar[item.version] || {}, item),
+    name: nameWithSuffix.substr(0, nameWithSuffix.length - 3),
+    version,
+    quadrant,
   }
 };
 
-const addItemToVersion = (version, item) => {
-  return {
-    ...version,
-    [item.quadrant]: addItemToQuadrant(version[item.quadrant] || {}, item),
-  };
-};
+const createQuadrants = (revisions) => (
+  revisions.reduce((quadrants, revision) => {
+    return {
+      ...quadrants,
+      [revision.quadrant]: addRevisionToQuadrant(quadrants[revision.quadrant], revision),
+    };
+  }, {})
+);
 
-const addItemToQuadrant = (quadrant, item) => {
-  return {
-    ...quadrant,
-    [item.name]: item.path,
-  };
-};
+const addRevisionToQuadrant = (quadrant = {}, revision) => ({
+  ...quadrant,
+  [revision.name]: addRevisionToItem(quadrant[revision.name], revision),
+});
 
-const createItemFromPath = (pathName) => {
-  const [version, quadrant, fileName] = pathName.split('/').slice(-3);
-  return {
-    version,
+const addRevisionToItem = (item = {
+  attributes: {},
+  revisions: [],
+}, revision) => {
+  const {
+    name,
     quadrant,
-    path: pathName,
-    name: fileName.substr(0, fileName.length - 3),
-  };
-};
-
-export const createRadar = async (tree) => {
-  const versionNames = Object.keys(tree).sort();
-  const radar = versionNames.reduce((radar, versionName) => {
-    return updateRadarWithVersion(radar, versionName, tree);
-  }, {});
-
-  return readItemsDataFromFiles(radar);
-};
-
-const updateRadarWithVersion = (radar, versionName, tree) => {
-  const version = tree[versionName];
-  const quadrantNames = Object.keys(version);
-  return quadrantNames.reduce((updatedRadar, quadrantName) => {
-    return {
-      ...updatedRadar,
-      [quadrantName]: updateQuadrantWithVersion(updatedRadar[quadrantName] || {}, quadrantName, versionName, tree),
-    }
-  }, radar);
-};
-
-const updateQuadrantWithVersion = (quadrant, quadrantName, versionName, tree) => {
-  const quadrantInNewVersion = tree[versionName][quadrantName];
-  const fileNames = Object.keys(quadrantInNewVersion);
-  return fileNames.reduce((updatedQuadrant, fileName) => {
-    return {
-      ...updatedQuadrant,
-      [fileName]: updateItemWithVersion(updatedQuadrant[fileName], fileName, quadrantName, versionName, tree),
-    }
-  }, quadrant);
-};
-
-const updateItemWithVersion = (file = { revision: 0, files: [] }, fileName, quadrantName, versionName, tree) => {
-  const fileInNewVersion = tree[versionName][quadrantName][fileName];
+    fileName,
+    ...rest,
+  } = revision;
   return {
-    files: file.files.concat([{
-      version: versionName,
-      file: fileInNewVersion,
-    }]),
+    attributes: {
+      ...item.attributes,
+      ...revision.attributes,
+    },
+    revisions: item.revisions.concat(rest),
   };
 };
-
-const readItemsDataFromFiles = (radar) => {
-  return Object.entries(radar).reduce((newRadar, [quadrantName, quadrant]) => {
-    return {
-      ...newRadar,
-      [quadrantName]: Object.entries(quadrant).reduce((newQuadrant, [itemName, item]) => {
-        return {
-          ...newQuadrant,
-          [itemName]: {
-            revisions: item.files.length,
-            data: mergeDataFromFiles(item.files)
-          },
-        };
-      }, {}),
-    }
-  }, {});
-};
-
-const mergeDataFromFiles = (files) => {
-  const frontmatters = getFrontmatterForAllFiles(files);
-  console.log()
-  return frontmatters;
-};
-
-const getFrontmatterForAllFiles = (files) => {
-  return files.map(({ file }) => {
-    return getFrontmatter(file);
-  })
-};
-
-const getFrontmatter = (fileName) => {
-  return frontmatter(readFileSync(fileName, 'utf8'));
-};