This app provides monitoring and information features for the common freifunk user and the technical stuff of a freifunk community.
Code base is taken from a TUM Practical Course project and added here to see if Freifunk Altdorf can use it.
https://www.freifunk-altdorf.de
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
284 lines
7.1 KiB
284 lines
7.1 KiB
/* |
|
Copyright 2012-2015, Yahoo Inc. |
|
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. |
|
*/ |
|
"use strict"; |
|
|
|
var Path = require('./path'), |
|
util = require('util'), |
|
tree = require('./tree'), |
|
coverage = require('istanbul-lib-coverage'), |
|
BaseNode = tree.Node, |
|
BaseTree = tree.Tree; |
|
|
|
function ReportNode(path, fileCoverage) { |
|
this.path = path; |
|
this.parent = null; |
|
this.fileCoverage = fileCoverage; |
|
this.children = []; |
|
} |
|
|
|
util.inherits(ReportNode, BaseNode); |
|
|
|
ReportNode.prototype.addChild = function (child) { |
|
child.parent = this; |
|
this.children.push(child); |
|
}; |
|
|
|
ReportNode.prototype.asRelative = function (p) { |
|
/* istanbul ignore if */ |
|
if (p.substring(0,1) === '/') { |
|
return p.substring(1); |
|
} |
|
return p; |
|
}; |
|
|
|
ReportNode.prototype.getQualifiedName = function () { |
|
return this.asRelative(this.path.toString()); |
|
}; |
|
|
|
ReportNode.prototype.getRelativeName = function () { |
|
var parent = this.getParent(), |
|
myPath = this.path, |
|
relPath, |
|
i, |
|
parentPath = parent ? parent.path : new Path([]); |
|
if (parentPath.ancestorOf(myPath)) { |
|
relPath = new Path(myPath.elements()); |
|
for (i = 0; i < parentPath.length; i += 1) { |
|
relPath.shift(); |
|
} |
|
return this.asRelative(relPath.toString()); |
|
} |
|
return this.asRelative(this.path.toString()); |
|
}; |
|
|
|
ReportNode.prototype.getParent = function () { |
|
return this.parent; |
|
}; |
|
|
|
ReportNode.prototype.getChildren = function () { |
|
return this.children; |
|
}; |
|
|
|
ReportNode.prototype.isSummary = function () { |
|
return !this.fileCoverage; |
|
}; |
|
|
|
ReportNode.prototype.getFileCoverage = function () { |
|
return this.fileCoverage; |
|
}; |
|
|
|
ReportNode.prototype.getCoverageSummary = function (filesOnly) { |
|
var cacheProp = 'c_' + (filesOnly ? 'files' : 'full'), |
|
summary; |
|
|
|
if (this.hasOwnProperty(cacheProp)) { |
|
return this[cacheProp]; |
|
} |
|
|
|
if (!this.isSummary()) { |
|
summary = this.getFileCoverage().toSummary(); |
|
} else { |
|
var count = 0; |
|
summary = coverage.createCoverageSummary(); |
|
this.getChildren().forEach(function (child) { |
|
if (filesOnly && child.isSummary()) { |
|
return; |
|
} |
|
count += 1; |
|
summary.merge(child.getCoverageSummary(filesOnly)); |
|
}); |
|
if (count === 0 && filesOnly) { |
|
summary = null; |
|
} |
|
} |
|
this[cacheProp] = summary; |
|
return summary; |
|
}; |
|
|
|
function treeFor(root, childPrefix) { |
|
var tree = new BaseTree(), |
|
visitor, |
|
maybePrefix = function (node) { |
|
if (childPrefix && !node.isRoot()) { |
|
node.path.unshift(childPrefix); |
|
} |
|
}; |
|
tree.getRoot = function () { |
|
return root; |
|
}; |
|
visitor = { |
|
onDetail: function (node) { |
|
maybePrefix(node); |
|
}, |
|
onSummary: function (node) { |
|
maybePrefix(node); |
|
node.children.sort(function (a, b) { |
|
var astr = a.path.toString(), |
|
bstr = b.path.toString(); |
|
return astr < bstr ? -1 : astr > bstr ? 1: /* istanbul ignore next */ 0; |
|
}); |
|
} |
|
}; |
|
tree.visit(visitor); |
|
return tree; |
|
} |
|
|
|
function findCommonParent(paths) { |
|
if (paths.length === 0) { |
|
return new Path([]); |
|
} |
|
var common = paths[0], |
|
i; |
|
|
|
for (i = 1; i < paths.length; i += 1) { |
|
common = common.commonPrefixPath(paths[i]); |
|
if (common.length === 0) { |
|
break; |
|
} |
|
} |
|
return common; |
|
} |
|
|
|
function toInitialList(coverageMap) { |
|
var ret = [], |
|
commonParent; |
|
coverageMap.files().forEach(function (filePath) { |
|
var p = new Path(filePath), |
|
coverage = coverageMap.fileCoverageFor(filePath); |
|
ret.push({ |
|
filePath: filePath, |
|
path: p, |
|
fileCoverage: coverage |
|
}); |
|
}); |
|
commonParent = findCommonParent(ret.map(function (o) { return o.path.parent(); })); |
|
if (commonParent.length > 0) { |
|
ret.forEach(function (o) { |
|
o.path.splice(0, commonParent.length); |
|
}); |
|
} |
|
return { |
|
list: ret, |
|
commonParent: commonParent |
|
}; |
|
} |
|
|
|
function toDirParents(list) { |
|
var nodeMap = {}, |
|
parentNodeList = []; |
|
list.forEach(function (o) { |
|
var node = new ReportNode(o.path, o.fileCoverage), |
|
parentPath = o.path.parent(), |
|
parent = nodeMap[parentPath.toString()]; |
|
|
|
if (!parent) { |
|
parent = new ReportNode(parentPath); |
|
nodeMap[parentPath.toString()] = parent; |
|
parentNodeList.push(parent); |
|
} |
|
parent.addChild(node); |
|
}); |
|
return parentNodeList; |
|
} |
|
|
|
function foldIntoParents(nodeList) { |
|
var ret = [], i, j; |
|
|
|
// sort by longest length first |
|
nodeList.sort(function (a, b) { |
|
return -1 * Path.compare(a.path , b.path); |
|
}); |
|
|
|
for (i = 0; i < nodeList.length; i += 1) { |
|
var first = nodeList[i], |
|
inserted = false; |
|
|
|
for (j = i + 1; j < nodeList.length; j += 1) { |
|
var second = nodeList[j]; |
|
if (second.path.ancestorOf(first.path)) { |
|
second.addChild(first); |
|
inserted = true; |
|
break; |
|
} |
|
} |
|
|
|
if (!inserted) { |
|
ret.push(first); |
|
} |
|
} |
|
return ret; |
|
} |
|
|
|
function createRoot() { |
|
return new ReportNode(new Path([])); |
|
} |
|
|
|
function createNestedSummary(coverageMap) { |
|
var flattened = toInitialList(coverageMap), |
|
dirParents = toDirParents(flattened.list), |
|
topNodes = foldIntoParents(dirParents), |
|
root; |
|
|
|
if (topNodes.length === 0) { |
|
return treeFor(new ReportNode([])); |
|
} |
|
|
|
if (topNodes.length === 1) { |
|
return treeFor(topNodes[0]); |
|
} |
|
|
|
root = createRoot(); |
|
topNodes.forEach(function (node) { |
|
root.addChild(node); |
|
}); |
|
return treeFor(root); |
|
} |
|
|
|
function createPackageSummary(coverageMap) { |
|
var flattened = toInitialList(coverageMap), |
|
dirParents = toDirParents(flattened.list), |
|
common = flattened.commonParent, |
|
prefix, |
|
root; |
|
|
|
if (dirParents.length === 1) { |
|
root = dirParents[0]; |
|
} else { |
|
root = createRoot(); |
|
// if one of the dirs is itself the root, |
|
// then we need to create a top-level dir |
|
dirParents.forEach(function (dp) { |
|
if (dp.path.length === 0) { |
|
prefix = 'root'; |
|
} |
|
}); |
|
if (prefix && common.length > 0) { |
|
prefix = common.elements()[common.elements().length - 1]; |
|
} |
|
dirParents.forEach(function (node) { |
|
root.addChild(node); |
|
}); |
|
} |
|
return treeFor(root, prefix); |
|
} |
|
|
|
function createFlatSummary(coverageMap) { |
|
var flattened = toInitialList(coverageMap), |
|
list = flattened.list, |
|
root; |
|
|
|
root = createRoot(); |
|
list.forEach(function (o) { |
|
var node = new ReportNode(o.path, o.fileCoverage); |
|
root.addChild(node); |
|
}); |
|
return treeFor(root); |
|
} |
|
|
|
module.exports = { |
|
createNestedSummary: createNestedSummary, |
|
createPackageSummary: createPackageSummary, |
|
createFlatSummary: createFlatSummary |
|
};
|
|
|