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.
211 lines
10 KiB
211 lines
10 KiB
'use strict'; |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /* |
|
Copyright 2012-2015, Yahoo Inc. |
|
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. |
|
*/ |
|
|
|
|
|
var _babylon = require('babylon'); |
|
|
|
var babylon = _interopRequireWildcard(_babylon); |
|
|
|
var _babelTypes = require('babel-types'); |
|
|
|
var t = _interopRequireWildcard(_babelTypes); |
|
|
|
var _babelTraverse = require('babel-traverse'); |
|
|
|
var _babelTraverse2 = _interopRequireDefault(_babelTraverse); |
|
|
|
var _babelGenerator = require('babel-generator'); |
|
|
|
var _babelGenerator2 = _interopRequireDefault(_babelGenerator); |
|
|
|
var _visitor = require('./visitor'); |
|
|
|
var _visitor2 = _interopRequireDefault(_visitor); |
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function defaultOpts() { |
|
return { |
|
coverageVariable: "__coverage__", |
|
preserveComments: false, |
|
compact: true, |
|
esModules: false, |
|
autoWrap: false, |
|
produceSourceMap: false, |
|
ignoreClassMethods: [], |
|
sourceMapUrlCallback: null, |
|
debug: false |
|
}; |
|
} |
|
/** |
|
* Instrumenter is the public API for the instrument library. |
|
* It is typically used for ES5 code. For ES6 code that you |
|
* are already running under `babel` use the coverage plugin |
|
* instead. |
|
* @param {Object} opts optional. |
|
* @param {string} [opts.coverageVariable=__coverage__] name of global coverage variable. |
|
* @param {boolean} [opts.preserveComments=false] preserve comments in output |
|
* @param {boolean} [opts.compact=true] generate compact code. |
|
* @param {boolean} [opts.esModules=false] set to true to instrument ES6 modules. |
|
* @param {boolean} [opts.autoWrap=false] set to true to allow `return` statements outside of functions. |
|
* @param {boolean} [opts.produceSourceMap=false] set to true to produce a source map for the instrumented code. |
|
* @param {Array} [opts.ignoreClassMethods=[]] set to array of class method names to ignore for coverage. |
|
* @param {Function} [opts.sourceMapUrlCallback=null] a callback function that is called when a source map URL |
|
* is found in the original code. This function is called with the source file name and the source map URL. |
|
* @param {boolean} [opts.debug=false] - turn debugging on |
|
*/ |
|
|
|
var Instrumenter = function () { |
|
function Instrumenter() { |
|
var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultOpts(); |
|
|
|
_classCallCheck(this, Instrumenter); |
|
|
|
this.opts = this.normalizeOpts(opts); |
|
this.fileCoverage = null; |
|
this.sourceMap = null; |
|
} |
|
/** |
|
* normalize options passed in and assign defaults. |
|
* @param opts |
|
* @private |
|
*/ |
|
|
|
|
|
_createClass(Instrumenter, [{ |
|
key: 'normalizeOpts', |
|
value: function normalizeOpts(opts) { |
|
var normalize = function normalize(name, defaultValue) { |
|
if (!opts.hasOwnProperty(name)) { |
|
opts[name] = defaultValue; |
|
} |
|
}; |
|
var defOpts = defaultOpts(); |
|
Object.keys(defOpts).forEach(function (k) { |
|
normalize(k, defOpts[k]); |
|
}); |
|
return opts; |
|
} |
|
/** |
|
* instrument the supplied code and track coverage against the supplied |
|
* filename. It throws if invalid code is passed to it. ES5 and ES6 syntax |
|
* is supported. To instrument ES6 modules, make sure that you set the |
|
* `esModules` property to `true` when creating the instrumenter. |
|
* |
|
* @param {string} code - the code to instrument |
|
* @param {string} filename - the filename against which to track coverage. |
|
* @param {object} [inputSourceMap] - the source map that maps the not instrumented code back to it's original form. |
|
* Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the |
|
* coverage to the untranspiled source. |
|
* @returns {string} the instrumented code. |
|
*/ |
|
|
|
}, { |
|
key: 'instrumentSync', |
|
value: function instrumentSync(code, filename, inputSourceMap) { |
|
if (typeof code !== 'string') { |
|
throw new Error('Code must be a string'); |
|
} |
|
filename = filename || String(new Date().getTime()) + '.js'; |
|
var opts = this.opts; |
|
var ast = babylon.parse(code, { |
|
allowReturnOutsideFunction: opts.autoWrap, |
|
sourceType: opts.esModules ? "module" : "script", |
|
plugins: ['asyncGenerators', 'dynamicImport', 'objectRestSpread', 'flow', 'jsx'] |
|
}); |
|
var ee = (0, _visitor2.default)(t, filename, { |
|
coverageVariable: opts.coverageVariable, |
|
ignoreClassMethods: opts.ignoreClassMethods, |
|
inputSourceMap: inputSourceMap |
|
}); |
|
var output = {}; |
|
var visitor = { |
|
Program: { |
|
enter: ee.enter, |
|
exit: function exit(path) { |
|
output = ee.exit(path); |
|
} |
|
} |
|
}; |
|
(0, _babelTraverse2.default)(ast, visitor); |
|
|
|
var generateOptions = { |
|
compact: opts.compact, |
|
comments: opts.preserveComments, |
|
sourceMaps: opts.produceSourceMap, |
|
sourceFileName: filename |
|
}; |
|
var codeMap = (0, _babelGenerator2.default)(ast, generateOptions, code); |
|
this.fileCoverage = output.fileCoverage; |
|
this.sourceMap = codeMap.map; |
|
var cb = this.opts.sourceMapUrlCallback; |
|
if (cb && output.sourceMappingURL) { |
|
cb(filename, output.sourceMappingURL); |
|
} |
|
return codeMap.code; |
|
} |
|
/** |
|
* callback-style instrument method that calls back with an error |
|
* as opposed to throwing one. Note that in the current implementation, |
|
* the callback will be called in the same process tick and is not asynchronous. |
|
* |
|
* @param {string} code - the code to instrument |
|
* @param {string} filename - the filename against which to track coverage. |
|
* @param {Function} callback - the callback |
|
* @param {Object} inputSourceMap - the source map that maps the not instrumented code back to it's original form. |
|
* Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the |
|
* coverage to the untranspiled source. |
|
*/ |
|
|
|
}, { |
|
key: 'instrument', |
|
value: function instrument(code, filename, callback, inputSourceMap) { |
|
if (!callback && typeof filename === 'function') { |
|
callback = filename; |
|
filename = null; |
|
} |
|
try { |
|
var out = this.instrumentSync(code, filename, inputSourceMap); |
|
callback(null, out); |
|
} catch (ex) { |
|
callback(ex); |
|
} |
|
} |
|
/** |
|
* returns the file coverage object for the last file instrumented. |
|
* @returns {Object} the file coverage object. |
|
*/ |
|
|
|
}, { |
|
key: 'lastFileCoverage', |
|
value: function lastFileCoverage() { |
|
return this.fileCoverage; |
|
} |
|
/** |
|
* returns the source map produced for the last file instrumented. |
|
* @returns {null|Object} the source map object. |
|
*/ |
|
|
|
}, { |
|
key: 'lastSourceMap', |
|
value: function lastSourceMap() { |
|
return this.sourceMap; |
|
} |
|
}]); |
|
|
|
return Instrumenter; |
|
}(); |
|
|
|
exports.default = Instrumenter; |