Cleanup and file reorganization

This commit is contained in:
Tom Raithel
2017-02-20 19:33:39 +01:00
parent 6cfd53a47a
commit 9f33c7a8ca
30 changed files with 176 additions and 446 deletions

18
common/config.js Normal file
View File

@@ -0,0 +1,18 @@
export const getPageNames = (radar) => {
return [
'index',
'overview',
'help',
'foo/bar',
]
}
const mappings = {
'languages-and-frameworks': 'Languages & Frameworks',
'methods-and-patterns': 'Methods & Patterns',
'platforms-and-aoe-services': 'Platforms and AOE Services',
'tools': 'Tools',
};
const formatRelease = (release) => moment(release, 'YYYY-MM-DD').format('MMM YYYY');

75
common/file.js Normal file
View File

@@ -0,0 +1,75 @@
import { outputFile } from 'fs-extra';
import path from 'path';
import { walk } from 'walk';
export const relativePath = (...relativePath) => (
path.resolve(__dirname, '..', ...relativePath)
);
export const radarPath = (...pathInSrc) => (
relativePath('radar', ...pathInSrc)
);
export const staticPath = (...pathInSrc) => (
relativePath('static-pages', ...pathInSrc)
);
export const stylesPath = (...pathInSrc) => (
relativePath('styles', ...pathInSrc)
);
export const assetsPath = (...pathInSrc) => (
relativePath('assets', ...pathInSrc)
);
export const jsPath = (...pathInSrc) => (
relativePath('js', ...pathInSrc)
);
export const distPath = (...pathInDist) => (
relativePath('dist', ...pathInDist)
);
export const getAllMarkdownFiles = (folder) => (
getAllFiles(folder, isMarkdownFile)
);
const getAllFiles = (folder, predicate) => (
new Promise((resolve, reject) => {
const walker = walk(folder, { followLinks: false });
const files = [];
walker.on("file", (root, fileStat, next) => {
if (predicate(fileStat.name)) {
files.push(path.resolve(root, fileStat.name));
}
next();
});
walker.on("errors", (root, nodeStatsArray, next) => {
nodeStatsArray.forEach(function (n) {
console.error("[ERROR] " + n.name)
console.error(n.error.message || (n.error.code + ": " + n.error.path));
});
next();
});
walker.on("end", () => {
resolve(files.sort());
});
})
);
const isMarkdownFile = (name) => name.match(/\.md$/);
export const save = (html, fileName) => (
new Promise((resolve, reject) => (
outputFile(distPath(fileName), html, (err, data) => {
if (err) {
reject(err);
} else {
resolve(data);
}
})
))
);

194
common/radar.js Normal file
View File

@@ -0,0 +1,194 @@
import fs, { readFile, outputFile } from 'fs-extra';
import path from 'path';
import frontmatter from 'front-matter';
import marked from 'marked';
import {
radarPath,
distPath,
getAllMarkdownFiles,
} from './file';
export const createRadar = async (tree) => {
const fileNames = (await getAllMarkdownFiles(radarPath()));
const revisions = await createRevisionsFromFiles(fileNames);
const allReleases = getAllReleases(revisions);
const items = createItems(revisions);
const flaggedItems = flagWithIsNew(items, allReleases);
return {
items: flaggedItems,
releases: allReleases,
};
};
export const groupByQuadrants = (items) => (
items.reduce((quadrants, item) => ({
...quadrants,
[item.quadrant]: addItemToQuadrant(quadrants[item.quadrant], item),
}), {})
);
const addItemToQuadrant = (quadrant = {}, item) => ({
...quadrant,
[item.ring]: addItemToRing(quadrant[item.ring], item),
});
export const groupByFirstLetter = (items) => (
items.reduce((letterIndex, item) => ({
...letterIndex,
[getFirstLetter(item)]: addItemToList(letterIndex[getFirstLetter(item)], item),
}), {})
);
export const groupByRing = (items) => (
items.reduce((rings, item) => ({
...rings,
[item.ring]: addItemToList(rings[item.ring], item),
}), {})
);
const addItemToList = (list = [], item) => ([
...list,
item,
]);
export const getFirstLetter = (item) => item.title.substr(0,1).toUpperCase();
const checkAttributes = (fileName, attributes) => {
const rings = ['trial', 'assess', 'adopt', 'hold'];
if (attributes.ring && !rings.includes(attributes.ring)) {
throw new Error(`Error: ${fileName} has an illegal value for 'ring' - must be one of ${rings}`);
}
const quadrants = ['languages-and-frameworks', 'methods-and-patterns', 'platforms-and-aoe-services', 'tools'];
if (attributes.quadrant && !quadrants.includes(attributes.quadrant)) {
throw new Error(`Error: ${fileName} has an illegal value for 'quadrant' - must be one of ${quadrants}`);
}
}
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);
checkAttributes(fileName, fm.attributes);
resolve({
...itemInfoFromFilename(fileName),
...fm.attributes,
fileName,
body: marked(fm.body),
});
}
});
})
}))
)
const itemInfoFromFilename = (fileName) => {
const [
release,
nameWithSuffix,
] = fileName.split('/').slice(-2);
return {
name: nameWithSuffix.substr(0, nameWithSuffix.length - 3),
release,
}
};
const getAllReleases = (revisions) => (
revisions.reduce((allReleases, { release }) => {
if(!allReleases.includes(release)) {
return [...allReleases, release];
}
return allReleases;
}, []).sort()
)
// const createQuadrants = (revisions) => (
// revisions.reduce((quadrants, revision) => {
// return {
// ...quadrants,
// [revision.quadrant]: addRevisionToQuadrant(quadrants[revision.quadrant], revision),
// };
// }, {})
// );
// const addRevisionToQuadrant = (quadrant = {}, revision) => ({
// ...quadrant,
// [revision.name]: addRevisionToItem(quadrant[revision.name], revision),
// });
const addRevisionToQuadrant = (quadrant = {}, revision) => ({
...quadrant,
[revision.ring]: addRevisionToRing(quadrant[revision.ring], revision),
});
const createItems = (revisions) => {
const itemMap = revisions.reduce((items, revision) => {
return {
...items,
[revision.name]: addRevisionToItem(items[revision.name], revision),
};
}, {});
return Object
.values(itemMap)
.sort((x, y) => (x.name > y.name ? 1 : -1));
}
const addRevisionToItem = (item = {
attributes: {
isFeatured: true,
},
revisions: [],
}, revision) => {
const {
fileName,
...rest,
} = revision;
let newItem = {
...item,
...rest,
attributes: {
...item.attributes,
...revision.attributes,
},
};
if (revisionCreatesNewHistoryEntry(revision)) {
newItem = {
...newItem,
revisions: [
rest,
...newItem.revisions,
],
}
}
return newItem;
};
const revisionCreatesNewHistoryEntry = (revision) => {
return revision.body.trim() !== '' ||
typeof revision.ring !== 'undefined';
};
const flagWithIsNew = (items, allReleases) => (
items.map((item) => ({
...item,
isNew: isNewItem(item, allReleases),
}), [])
);
const isNewItem = (item, allReleases) => {
return item.revisions.length > 1 && item.revisions[0].release === allReleases[allReleases.length-1]
}
const addItemToRing = (ring = [], item) => ([
...ring,
item,
]);