return function($rootScope, $scope, currentScenario, taskDefinition, MCDAResultsService) {
$scope.scenario = currentScenario;
var alternativeTitle = function(id) {
var problem = currentScenario.state.problem;
return problem.alternatives[id].title;
};
var getCentralWeights = _.memoize(function(state) {
var problem = state.problem;
var data = state.results.cw.data;
var result = [];
_.each(_.pairs(data), function(alternative) {
var values = _.map(_.pairs(alternative[1].w), function(criterion, index) {
return { x: index, label: criterion[0], y: criterion[1] };
});
var labels = _.map(_.pluck(values, 'label'), function(id) { return problem.criteria[id].title; });
result.push({ key: alternativeTitle(alternative[0]), labels: labels, values: values });
});
return result;
});
var getAlterativesByRank = _.memoize(function(state) {
var data = state.results.ranks.data;
var rank = parseInt(state.selectedRank);
var values = _.map(_.pairs(data), function(alternative) {
return {label: alternativeTitle(alternative[0]), value: alternative[1][rank] };
});
var name = 'Alternatives for rank ' + (rank + 1);
return [{ key: name, values: values }];
}, function(val) { // Hash function
return 31 * val.selectedRank.hashCode() + angular.toJson(val.results).hashCode();
});
var getRanksByAlternative = _.memoize(function(state) {
var data = state.results.ranks.data;
var alternative = state.selectedAlternative;
var values = [];
_.each(data[alternative], function(rank, index) {
values.push({ label: 'Rank ' + (index + 1), value: [rank] });
});
return [{ key: alternativeTitle(alternative), values: values }];
}, function(val) {
return 31 * val.selectedAlternative.hashCode() + angular.toJson(val.results).hashCode();
});
var initialize = function(state) {
var next = _.extend(state, {
selectedAlternative: _.keys(state.problem.alternatives)[0],
selectedRank: '0',
ranksByAlternative: getRanksByAlternative,
alternativesByRank: getAlterativesByRank,
centralWeights: getCentralWeights
});
return MCDAResultsService.getResults($scope, next);
};
$scope.state = initialize(taskDefinition.clean(currentScenario.state));
};
function DocSet(path) {
// Path of X.docset
this.path = path;
// Setup index
this.idx = new DocSetIndex(this.idxPath());
// Bind methods
_.bindAll(this);
// Memoize
this.name = _.memoize(this.name);
this.search = _.memoize(this.search);
}
var memoize = ((fn) => _.memoize(fn, ((d) => {
var i = seq.indexOf(d);
if (i < 0) {
i = ((seq.push(d)) - 1);
}
return i;
})));
var getData = function() {
// Pulling data from a file
var getContent = _.memoize(function(path) {
return fs.readFileSync(path, 'utf8');
});
// CSV file path (used for memorized function)
var path = require('path').normalize(__dirname + '/../datum/data_1.csv'),
content = getContent(path),
lines = content.split("\n"),
data = [],
headers = [];
_.each(lines, function(line, index) {
var cells = line.split(',');
if (index === 0) {
// Header row
headers = _.object(
_.map(cells, function(cell) { return slug(cell, '_').toLowerCase(); }),
cells
);
} else {
// Regular row
data.push(_.object(Object.keys(headers), cells));
}
});
return {headers: headers, data: data};
};
define(function(require) {
var _ = require('underscore');
var Backbone = require('backbone');
var Q = require('q');
var $ = require('jquery');
var Collection = require('models/collection');
return Backbone.Model.extend({
getResourceTypes: function() {
return _.chain(this.attributes).keys().without('sessions').value();
},
getUrlForResource: function (resource) {
var resourceSchema = this.get(resource);
return resourceSchema.url + '?fields='+ _.keys(resourceSchema.fields).join(',');
},
fetchResource: _.memoize(function(resource) {
return Q($.get(this.getUrlForResource(resource))).then(function(data) {
return new Collection(data.elements);
});
})
});
});
var getBoroughResponseTimes = async.memoize(function (borough, closedStations, callback) {
// Estimates the response time of a generic incident in a square; it expects
// boroughIncidentsNotImpacted to be an array of incidents not impacted from
// the stations closure, hence relevant for calculation
var estimateSquareResponseTime = _.memoize(function (longitude, latitude) {
var MIN_NO_OF_INCIDENTS = 1,
results = [ ],
foundEnough = false;
for (var m = 0; !foundEnough; m++) {
results = _.filter(boroughIncidentsNotImpacted, function (i) {
return (i.simplifiedLongitude >= longitude - m * SIMPLIFIED_SQUARE_LONGITUDE_SIZE) &&
(i.simplifiedLongitude < longitude + (m + 1) * SIMPLIFIED_SQUARE_LONGITUDE_SIZE) &&
(i.simplifiedLatitude <= latitude + m * SIMPLIFIED_SQUARE_LATITUDE_SIZE) &&
(i.simplifiedLatitude > latitude - (m + 1) * SIMPLIFIED_SQUARE_LATITUDE_SIZE);
});
foundEnough = results.length >= MIN_NO_OF_INCIDENTS;
}
return mean(_.map(results, function (i) { return i.firstPumpTime; }));
}, function (longitude, latitude) {
return longitude + '_' + latitude;
});
var boroughIncidentsNotImpacted = [ ];
log("Calculating for the first time getBoroughResponseTimes for " + borough + " with closed stations: " + closedStations.join(", "));
mongo.collection('incidentsData')
.find({ $and: [ { borough: borough }, { firstPumpStation: { $nin: closedStations }} ] }, { firstPumpTime: 1 , simplifiedLongitude: 1, simplifiedLatitude: 1 })
.toArray(function (err, items) {
boroughIncidentsNotImpacted = items;
mongo.collection('incidentsData')
.find({ $and: [ { borough: borough }, { firstPumpStation: { $in: closedStations } } ]}, { simplifiedLongitude: 1, simplifiedLatitude: 1 })
.toArray(function (err, boroughIncidentsImpacted) {
oldTimings = _.map(boroughIncidentsNotImpacted, function (i) { return i.firstPumpTime; }),
newTimings = _.reduce(
_.map(
_.values(
_.groupBy(
boroughIncidentsImpacted,
function (i) {
return i.simplifiedLongitude + '_' + i.simplifiedLatitude;
}
)
),
function (incidentsInSameSquare) {
return {
noOfIncidents: incidentsInSameSquare.length,
longitude: incidentsInSameSquare[0].simplifiedLongitude,
latitude: incidentsInSameSquare[0].simplifiedLatitude
};
}),
function (memo, coordinates) {
var newResponseTime = estimateSquareResponseTime(coordinates.longitude, coordinates.latitude);
// See http://stackoverflow.com/a/19290390/1218376 for the strange expression below
return memo.concat(_.map(Array(coordinates.noOfIncidents + 1).join(1).split(''), function() { return newResponseTime; }));
},
[ ]);
callback(null, oldTimings.concat(newTimings));
});
});
}, function (borough, closedStations) {
generateRatioFunction: (dimPropName, paramsList, chartInstanceRef) => {
var unify = (v) => (v instanceof Date) ? v.getTime() : v;
var dataNewSnap = 0;
var dataPrevRef = null;
var xHash = _.memoize(
(data, keys) => {
return _(data)
.chain()
.map((row) => (keys.reduce((r, k) => (r.concat(unify(row[k]))), [])))
.uniq((t) => JSON.stringify(t))
.reduce((memo, t) => {
var k = t[0];
memo[k] = memo[k] || 0;
memo[k] += 1;
return memo;
}, {})
.value();
},
(data, keys) => {
let seed = (dataPrevRef === data) ? dataNewSnap : (++dataNewSnap);
dataPrevRef = data;
return `${keys.join('')}-${seed}`;
});
return (key, size, varSet) => {
var facetSize = varSet.length;
var chartSpec = chartInstanceRef.getSpec();
var data = chartSpec.sources['/'].data;
var level2Guide = chartSpec.unit.units[0].guide || {};
level2Guide.padding = level2Guide.padding || {l: 0, r: 0, t: 0, b: 0};
var pad = 0;
if (dimPropName === 'x') {
pad = level2Guide.padding.l + level2Guide.padding.r;
} else if (dimPropName === 'y') {
pad = level2Guide.padding.t + level2Guide.padding.b;
}
var xTotal = (keys) => {
return _.values(xHash(data, keys)).reduce((sum, v) => (sum + v), 0);
};
var xPart = ((keys, k) => (xHash(data, keys)[k]));
var totalItems = xTotal(paramsList);
var tickPxSize = (size - (facetSize * pad)) / totalItems;
var countOfTicksInTheFacet = xPart(paramsList, key);
return (countOfTicksInTheFacet * tickPxSize + pad) / size;
};
},
(function testSync() {
var _ = require('underscore')
, gssSync = require('../gss').gssSync
, f = function(x) { return Math.pow(x, 2); } // f(x) = x^2
, min = gssSync(_.memoize(f), -100, -50, 100, Math.sqrt(1e-10));
console.log(min, 'should be pretty darn close to zero.');
})();
getSortedVersions: function (name) {
var self = this;
var match = this._columnsQuery(
"SELECT version FROM versions WHERE packageName=?", name);
if (match === null)
return [];
var pvParse = _.memoize(VersionParser.parse);
return _.pluck(match, 'version').sort(function (a, b) {
return VersionParser.compare(pvParse(a), pvParse(b));
});
},
it("should memoize a given function by caching the computed result", function() {
var count = 0;
var add = _.memoize(function(a, b) {
count++;
return a + b;
});
add(1, 2);
add(2, 3);
add(1, 2);
assert.strictEqual(count, 2);
});
getSortedVersionRecords: function (name) {
var self = this;
var versionRecords = this._contentQuery(
"SELECT content FROM versions WHERE packageName=?", [name]);
if (! versionRecords)
return [];
var pvParse = _.memoize(VersionParser.parse);
versionRecords.sort(function (a, b) {
return VersionParser.compare(pvParse(a.version),
pvParse(b.version));
});
return versionRecords;
},
function reload() {
localeNames = [];
languages = [];
websiteUpParts = _.memoize( function( website ) {
var parts = k.hierarchy.upParts( website );
parts.push( "" );
return parts;
});
var dirs = fs.readdirSync( k.kernOpts.websitesRoot );
/* load master locale */
loadWebsite( "", folderName );
/* load directories */
dirs.forEach( dir => {
var folder = path.join( k.kernOpts.websitesRoot, dir, folderName );
if( fs.existsSync( folder ) )
loadWebsite( dir, folder );
});
};
function Template(model, opts) {
var stack;
opts = opts || {};
model = model || {};
this.bound = false;
this.stack = opts.stack || [];
this.reactions = {};
this.getElement = _.memoize(this.getElement);
if (!this.markup) {
throw new Error("Created template without markup");
}
this.el = this.template = this.markup.clone(); // template is deprecated but used in some outside systems
if (model) {
this.bind(model);
}
}
String.prototype.format = function (vals) {
return this.replace(format_regex, function (match, p) {
return vals[p];
});
};
// For a friendly message that we forgot to set env vars.
function DBEnvNotSet () {
this.message = 'Database not configured.';
this.name = 'DBEnvNotSet';
}
// Make the connect string for pg. pg also uses this string as a key in its
// table of connections.
var make_pg_constring = _.memoize(function (user, pass, host, db) {
return 'postgres://{0}:{1}@{2}/{3}'.format(arguments);
});
// Make a string suitable for an IN query.
// Note: the underscore docs disagree with the source. `_memoize` uses the whole `arguments`
// pseudo-array to make keys, not just the first one.
var make_placeholder_string = _.memoize(function (arr) {
return arr.map(function (v, i) {
return '$' + (i + 1);
}).join(',');
});
// db connection
var db = function (fn) {
var pg = require('pg'),
pg_user = process.env.BLOG_PG_USER || false,
(_.sortBy(['hello', 'world'], function(e) { return e.length }): Array<string>);
(_.uniq([1,2,2]): Array<number>);
(_.compact([1, null]): Array<number>);
(_.select([1,2,3], function(e) { return e % 2 == 0 }): Array<number>);
(_.reject([1,2,3], function(e) { return e % 2 == 0 }): Array<number>);
(_.without([1,2,3], 1, 2): Array<number>);
(_.has({a: 1, b: 2}, 'b'): boolean);
(_.isArray([1, 2]): boolean);
(_.isArray(1): boolean);
(_.pick({a: 1, b: 2}, 'a'): {[key: string]: number});
(_.omit({a: 1, b: 2}, 'a'): {[key: string]: number});
_.throttle(function(a) {a.length}, 10)('hello');
_.debounce(function(a) {a.length}, 10)('hello');
_.memoize(function(){})();
_.partial(function (a, b) { return a + b }, 1)(2);
_.delay(function(){}, 0);
_.defer(function(){});
(
_.compose(
function (name:string):string { return name + ', hello!'; },
function (user:Object):string { return user.name; }
): (user: Object) => string
);
(_.partition([1,5,2,4], function(i: number) { return i<4 }): [Array<number>, Array<number>]);
(_.partition({x: 'foo', y: 'bar'}, function(v: string, k: string) { return k === 'bar' }): [Array<string>, Array<string>]);
// combinedfile: list of pieces
var combinedFilePieces = {};
var buildCombiningInfo = function (cachedPath, originalPath, trueExt) {
var combinedFilePaths = combinedPathsForSourcePath(originalPath);
_.each(combinedFilePaths, function(one, combinedFilePath) {
// don't have to worry about race conditions here because node is awesome
if (!_.has(combinedFilePieces, combinedFilePath)) {
combinedFilePieces[combinedFilePath] = [];
}
combinedFilePieces[combinedFilePath].push(cachedPath);
});
};
var memoized_mkdirp = _.memoize(mkdirp.sync);
var combiningStage = function (currentTargetFile, currentWriteStream) {
if (_.isEmpty(combinedFilePieces)) {
logger.debug("Done!");
return;
}
if (!currentTargetFile) {
currentTargetFile = _.keys(combinedFilePieces).pop();
actualOutputFile = path.join(globalConfig.output_dir, currentTargetFile);
memoized_mkdirp(path.dirname(actualOutputFile));
currentWriteStream = fs.createWriteStream(actualOutputFile);
}
if (!combinedFilePieces[currentTargetFile].length) {
currentWriteStream.end();
/** module initializer */
function init(options) {
if (!options) options = {};
if (!options.assemblies) options.assemblies = ['mscorlib', 'System', 'System.Core'];
for (var i = 0; i < options.assemblies.length; i++){
clr.import(options.assemblies[i]);
}
// define namespace factory
var types = clr.getTypes();
var namespaces = _.chain(types)
.map(function (type) {
return parseType(type);
})
.groupBy(function (type) {
return type.namespace;
})
.value();
var namespaceFactory = _.memoize(function (name) {
var ns = {};
var prefix = (name !== '') ? name + '.' : name;
// define nested namespaces
_.chain(namespaces)
.keys()
.filter(function (item) {
return (item.indexOf(prefix) === 0) && (item !== prefix);
})
.map(function (item) {
return prefix + item.slice(prefix.length).split('.')[0];
})
.sortBy(_.identity)
.unique(true)
.each(function (item) {
Object.defineProperty(ns, item.slice(prefix.length), {
configurable: true,
enumerable: true,
get: function () {
return namespaceFactory(item);
}
});
});
// define types
_.chain(namespaces[name])
.sortBy(function (type) {
return type.name;
})
.sortBy(function (type) {
return type.keyword;
})
.unique(true, function (type) {
return type.keyword;
})
.each(function (type) {
Object.defineProperty(ns, type.keyword, {
configurable: true,
enumerable: true,
get: function () {
return constructorFactory(type.assemblyQualifiedName);
}
});
});
return ns;
});
// define constructor factory
var constructorFactory = _.memoize(function (type) {
var ctor = clr.createConstructor(type, function () { imbue(this); });
Object.defineProperty(ctor, 'of', {
configurable: true,
enumerable: false,
value: function () {
var name = parseType(type);
var args = _.map(arguments, function (item) {
return (clr.isCLRConstructor(item))
? clr.typeOf(item)
: item;
});
return constructorFactory(
util.format(
'%s`%d[%s], %s',
name.fullName.split('`')[0],
args.length,
args.map(function (arg) {
return util.format('[%s]', arg);
}).join(','),
name.assembly));
}
});
// define static members
_.chain(clr.getMembers(type, null))
.sortBy(function (member) { return member.name; })
.each(function (member) {
if (member.type === 'nestedType') {
Object.defineProperty(ctor, member.name, {
configurable: true,
enumerable: true,
get: function () {
return constructorFactory(member.fullName);
}
});
} else if (member.type === 'event') {
ctor[member.name] = {
add: function (callback) {
clr.invokeMethod(type, 'add_' + member.name, null, [callback]);
},
remove: function (callback) {
// TODO: does not work
clr.invokeMethod(type, 'remove_' + member.name, null, [callback]);
}
};
} else if (member.type === 'field') {
Object.defineProperty(ctor, member.name, {
configurable: true,
enumerable: true,
get: (_.contains(member.access, 'get'))
? function () { return imbue(clr.getField(type, member.name, null)); }
: undefined,
set: (_.contains(member.access, 'set'))
? function (value) { clr.setField(type, member.name, null, value); }
: undefined
});
} else if (member.type === 'property') {
if (!member.indexed) {
Object.defineProperty(ctor, member.name, {
configurable: true,
enumerable: true,
get: (_.contains(member.access, 'get'))
? function () { return imbue(clr.invokeMethod(type, 'get_' + member.name, null, [])); }
: undefined,
set: (_.contains(member.access, 'set'))
? function (value) { clr.invokeMethod(type, 'set_' + member.name, null, [value]); }
: undefined
});
} else if (member.name == 'Item') {
if (_.contains(member.access, 'get')) {
ctor.get = function () {
return imbue(clr.invokeMethod(type, 'get_' + member.name, null, _.toArray(arguments)));
};
}
if (_.contains(member.access, 'set')) {
ctor.set = function () {
clr.invokeMethod(type, 'set_', member.name, null, _.toArray(arguments));
}
}
} else {
ctor[member.name] = {};
if (_.contains(member.access, 'get')) {
ctor[member.name].get = function () {
return imbue(clr.invokeMethod(type, 'get_' + member.name, null, _.toArray(arguments)));
}
}
if (_.contains(member.access, 'set')) {
ctor[member.name].set = function () {
return clr.invokeMethod(type, 'set_' + member.name, null, _.toArray(arguments));
}
}
}
} else if (member.type === 'method') {
ctor[member.name] = function () {
return imbue(clr.invokeMethod(type, member.name, null, _.toArray(arguments)));
};
}
});
// define instance members
_.chain(clr.getMembers(type, true))
.sortBy(function (member) { return member.name; })
.each(function (member) {
if (member.type === 'event') {
Object.defineProperty(ctor.prototype, member.name, {
configurable: true,
enumerable: true,
get: function () {
var self = this;
return {
add: function (callback) {
clr.invokeMethod(type, 'add_' + member.name, self, [callback]);
},
remove: function (callback) {
// TODO: does not work
clr.invokeMethod(type, 'remove_' + member.name, self, [callback]);
}
}
}
});
} else if (member.type === 'field') {
Object.defineProperty(ctor.prototype, member.name, {
configurable: true,
enumerable: true,
get: (_.contains(member.access, 'get'))
? function () { return imbue(clr.getField(type, member.name, this)); }
: undefined,
set: (_.contains(member.access, 'set'))
? function (value) { clr.setField(type, member.name, this, value); }
: undefined
});
} else if (member.type === 'property') {
if (!member.indexed) {
Object.defineProperty(ctor.prototype, member.name, {
configurable: true,
enumerable: true,
get: (_.contains(member.access, 'get'))
? function () { return imbue(clr.invokeMethod(type, 'get_' + member.name, this, [])); }
: undefined,
set: (_.contains(member.access, 'set'))
? function (value) { clr.invokeMethod(type, 'set_' + member.name, this, [value]); }
: undefined
});
} else if (member.name == 'Item') {
if (_.contains(member.access, 'get')) {
ctor.prototype.get = function () {
return imbue(clr.invokeMethod(type, 'get_' + member.name, this, _.toArray(arguments)));
};
}
if (_.contains(member.access, 'set')) {
ctor.prototype.set = function () {
clr.invokeMethod(type, 'set_' + member.name, this, _.toArray(arguments));
}
}
} else {
Object.defineProperty(ctor.prototype, member.name, {
configurable: true,
enumerable: true,
get: function () {
var self = this;
var obj = {};
if (_.contains(member.access, 'get')) {
obj.get = function () {
return imbue(clr.invokeMethod(type, 'get_' + member.name, self, _.toArray(arguments)));
}
}
if (_.contains(member.access, 'set')) {
obj.set = function () {
return clr.invokeMethod(type, 'set_' + member.name, self, _.toArray(arguments));
}
}
}
});
}
} else if (member.type === 'method') {
ctor.prototype[member.name] = function () {
return imbue(clr.invokeMethod(type, member.name, this, _.toArray(arguments)));
};
}
});
Object.defineProperty(ctor.prototype, 'toString', {
configurable: true,
enumerable: false,
value: function () {
return '[CLRObject: ' + parseType(clr.getType(this)).fullName + ']';
}
});
// custom inspector function
// TODO: colorize?
Object.defineProperty(ctor.prototype, 'inspect', {
configurable: true,
enumerable: false,
value: function (recurseTimes) {
var str = util.inspect(this, { customInspect: false, depth: recurseTimes });
var base = this.toString();
if (str === '{}') {
return base;
} else {
return '{ ' + base + '\n ' + str.substr(1);
}
}
});
return ctor;
});
// set __proto__ to plain CLR wrapped object
function imbue(obj) {
if (clr.isCLRObject(obj)) {
var ctor = constructorFactory(clr.getType(obj));
obj.__proto__ = ctor.prototype;
}
return obj;
}
return namespaceFactory('');
}
constructor() {
this._getBankName = _.memoize(function(bankId) {
return window.firebase.database().ref(`banks/${bankId}`).once('value');
});
}
'Chrome >= 20',
'Firefox >= 24', // Firefox 24 is the latest ESR
'Explorer >= 8',
'iOS >= 6',
'Opera >= 12',
'Safari >= 6',
],
};
const LIVERELOAD_PORT = 10666;
let isWatching = false;
// get dependencies once for any arguments
const getEnyoDeps = _.memoize(() => {
const boot = enyoWalker.getDependencies(`${BASE_BOOTPLATE_PATH}/lib/enyo/source/boot`);
const source = enyoWalker.getDependencies(`${BASE_BOOTPLATE_PATH}/lib/enyo/source`);
return enyoWalker.mergeDependencyCollections(boot, source);
}, _.noop);
const getK2eDeps = _.memoize(() =>
enyoWalker.getDependencies(`${BASE_BOOTPLATE_PATH}`), _.noop
);
// using a subset of babel's es2015 preset since enyo does not support strict mode
// (essentialy everything minus modules-commonjs)
const BABEL_PLUGINS = [
'transform-es2015-arrow-functions',
'transform-es2015-block-scoped-functions',
'transform-es2015-block-scoping',
'transform-es2015-classes',
import {utilsDraw} from '../utils/utils-draw';
import {default as _} from 'underscore';
import {default as d3} from 'd3';
var d3getComputedTextLength = _.memoize(
(d3Text) => d3Text.node().getComputedTextLength(),
(d3Text) => d3Text.node().textContent.length);
var cutText = (textString, widthLimit, getComputedTextLength) => {
getComputedTextLength = getComputedTextLength || d3getComputedTextLength;
textString.each(function () {
var textD3 = d3.select(this);
var tokens = textD3.text().split(/\s+/);
var stop = false;
var parts = tokens.reduce((memo, t, i) => {
if (stop) {
return memo;
}
var text = (i > 0) ? [memo, t].join(' ') : t;
var len = getComputedTextLength(textD3.text(text));
if (len < widthLimit) {
memo = text;
} else {
var available = Math.floor(widthLimit / len * text.length);
memo = text.substr(0, available - 4) + '...';
stop = true;
md_to_html(post.body, function (html) {
post.body = html;
});
md_to_html(post.title, function (html) {
post.title = html;
});
});
fn(html_posts);
};
var default_fields = ['posts_id', 'body', 'title', 'published_date'];
var posts = {
default_fields_str: _.memoize(function () {
return default_fields.join(',');
}),
get_latest: function (fn, err, count) {
// Fetch the latest (published) post(s)
var count = Number(count) || 1,
query = {
text: 'SELECT {0} FROM posts ORDER BY published_date DESC LIMIT $1'.format(
[this.default_fields_str()]),
name: 'latest-post',
values: [count]
};
db(function (err, client, done) {
client.query(query, function (err, result) {
done();
var _ = require("underscore");
var Client = require("tvchous-client");
var client = new Client("http://localhost:5004");
module.exports = client;
var oldCall = client.call;
var getQ = _.memoize(function () {
return angular.element(document.body).injector().get("$q");
});
// ES6 promises to $q
client.call = function () {
var $q = getQ();
var deferred = $q.defer();
oldCall.apply(client, arguments).then(deferred.resolve, deferred.reject);
return deferred.promise;
};
module.exports = function() {
var getConn = _.memoize(function() {
return new (dynode.Client)({
accessKeyId: dynamoConfig.auth.accessKeyId,
secretAccessKey: dynamoConfig.auth.secretAccessKey,
tableNamePrefix: dynamoConfig.tableNamePrefix
});
});
var getStackTrace = function() { return new Error().stack; };
var applyStackTrace = function(error, stackTrace) {
error.stack = stackTrace;
return error;
};
var generateId = function() { return mongo.ObjectID.createPk().toString(); };
var idEncode = function(obj) { return obj; };
var idDecode = function(obj) { return obj; };
var keyTransform = function(key) {
if (key.primary) {
key.hash = key.primary;
delete key.primary;
}
return key;
}
var createTable = function(tableName, options, callback) {
var conn = getConn();
var stackTrace = getStackTrace();
conn.createTable(tableName, options, function(error) {
if (error) { return callback(translateError(error, stackTrace)); }
return callback(null);
});
};
var insert = function(obj, context, callback) {
var conn = getConn();
var stackTrace = getStackTrace();
upsert({}, obj, context, function(error) {
if (error) { return callback(translateError(error, stackTrace)); }
return callback(null);
});
};
// in this case criteria must be hash. One of the following: 'myHash' or { hash: 'myHashKey', range: 'myRangeKey' }
// refer to http://docs.amazonwebservices.com/amazondynamodb/latest/developerguide/API_GetItem.html
var retrieve = function(key, context, options, callback) {
var conn = getConn();
var stackTrace = getStackTrace();
conn.getItem(context.collection, keyTransform(key), options, function(error, item, meta) {
if (error) { return callback(translateError(error)); }
return callback(null, item);
});
};
var update = function(criteria, obj, context, callback) {
var conn = getConn();
var stackTrace = getStackTrace();
conn.updateItem(context, criteria, obj, function(error) {
if (error) { return callback(translateError(error, stackTrace)); }
return callback(null);
});
};
var upsert = function(criteria /* unused */, obj, context, callback) {
var conn = getConn();
var stackTrace = getStackTrace();
var options = {};
conn.putItem(context.collection, obj, options, function(error, consumedUnits) {
if (error) { return callback(error); }
return callback(null);
});
};
// http://docs.amazonwebservices.com/amazondynamodb/latest/developerguide/API_DeleteItem.html
var destroy = function(key, context, callback) {
var conn = getConn();
var stackTrace = getStackTrace();
conn.deleteItem(context.collection, keyTransform(key), function(error) {
if (error) { return callback(translateError(error, stackTrace)); }
return callback(null);
});
};
var list = function(key, criteria, limit, lastId, context, callback) {
var conn = getConn();
var stackTrace = getStackTrace();
if (!key.primary) {
console.log(JSON.stringify({type: 'scan'}));
return scan(criteria, context, limit, lastId, function(error, items) {
if (error) { return callback(error); }
return callback(null, items);
});
}
if (!key.range) {
console.log(JSON.stringify({type: 'query'}));
return query(key.primary, criteria, context, limit, lastId, function(error, response) {
if (error) { return callback(error); }
return callback(null, response.Items);
});
}
console.log(JSON.stringify({type: 'retrieve'}));
return retrieve(key, context, {}, function(error, item) {
if (error) { return callback(error); }
return callback(null, [item]);
});
};
/* Dynamo specific querying methods */
var query = function(hash, criteria, context, limit, lastId, callback) {
var conn = getConn();
var stackTrace = getStackTrace();
var options = {};
if (limit) { options = _.extend(options, { Limit: limit }); }
if (lastId) {
if (!(lastId = createDynamoLastId(lastId))) { return callback(new Error('invalid: lastId not populated properly')); }
options = _.extend(options, { ExclusiveStartKey: lastId });
}
conn.query(context.collection, hash, options, function(error, items, meta) {
if (error) { return callback(translateError(error)); }
// do some sifting via criteria and perhaps recursive queries until we have up to limit (or no more)
return callback(null, items);
});
};
var scan = function(criteria, context, limit, lastId, callback) {
console.log(JSON.stringify(Array().slice.call(arguments)));
var conn = getConn();
var stackTrace = getStackTrace();
var options = {};
if (limit) { options = _.extend(options, { Limit: limit }); }
if (lastId) {
if (!(lastId = createDynamoLastId(lastId))) { return callback(new Error('invalid: lastId not populated properly')); }
options = _.extend(options, { ExclusiveStartKey: lastId });
}
conn.scan(context.collection, options, function(error, items, meta) {
if (error) { return callback(translateError(error)); }
// do some sifting via criteria and perhaps recursive queries until we have up to limit (or no more)
return callback(null, items);
});
};
var createDynamoLastId = function(lastId) {
if (!lastId.primary) { return false; }
var key = { HashKeyElement: createDynamoTypedValue(lastId.primary) };
if (lastId.range) {
key = _.extend(key, { RangeKeyElement: createDynamoTypedValue(lastId.range) });
}
return key;
};
var createDynamoTypedValue = function(value) {
var typedValue = {};
typedValue[typeIndicator(value)] = value;
return typedValue;
};
var typeIndicator = function(value) {
if (_.isArray(value)) { return typeIndicator(_.first(value)) + 'S'; }
return _.isNumber(value) ? 'N' : 'S';
};
var translateError = function(error, stackTrace) {
return applyStackTrace(error, stackTrace);
};
return {
createTable: createTable,
insert: insert,
retrieve: retrieve,
list: list,
update: update,
upsert: upsert,
destroy: destroy,
generateId: generateId,
idEncode: idEncode,
idDecode: idDecode
};
};
var toComplements = function(sequence) {
var map = toComplementsMap;
return _.map(sequence.split(''), (base) => map[base] || ' ').join('');
};
var toReverseComplements = function(sequence) {
var o = '';
for (var i = sequence.length - 1; i >= 0; i--)
o += toComplementsMap[sequence[i]];
return o;
};
var iupacToBases = _.memoize(function(sequence) {
var output = sequence;
iupacToBasesMap = iupacToBasesMap || _.invert(SynbioData.bases2iupac);
_.each(iupacToBasesMap, function(bases, iupac) {
output = output.replace(new RegExp(iupac, 'gi'), bases);
});
return output;
});
var isPalindromic = function(sequence) {
return sequence == toReverseComplements(sequence);
};
var areComplementary = function(sequence1, sequence2) {
// TODO: support partial complementary sequences
if(sequence1.length !== sequence2.length) return false;
return !_.find(sequence1, function(base1, i) {
return toComplementsMap[base1] !== sequence2[i];
});
return function($scope, $filter, $location, currentScenario, $anchorScroll, PartialValueFunction, Tasks, TaskDependencies, intervalHull, taskDefinition) {
$scope.scenario = currentScenario;
$scope.intervalHull = intervalHull;
$scope.scales = $scope.workspace.$$scales;
$scope.pvf = PartialValueFunction;
$scope.criteria = _.sortBy(_.map(_.pairs(currentScenario.state.problem.criteria), function(crit, idx) {
return _.extend(crit[1], {
id: crit[0],
w: 'w_' + (idx + 1)
});
}), 'w');
var willReset = function(safe) {
var resets = safe.resets.map(function(reset) {
return TaskDependencies.definitions[reset].title;
}).join(", ").replace(/,([^,]*)$/, ' & $1');
return resets ? "Saving this preference will reset: " + resets : null;
};
var isSafe = function(taskId) {
var safe = TaskDependencies.isSafe($scope.tasks[taskId], $scope.scenario.state);
safe.tooltip = willReset(safe);
return safe;
};
$scope.isSafe = _.reduce($scope.tasks, function(obj, task) {
obj[task.id] = isSafe(task.id);
return obj;
}, {});
$scope.isPVFDefined = function(criterion) {
return criterion.pvf && criterion.pvf.type;
};
$scope.isAccessible = function(task, state) {
return TaskDependencies.isAccessible(task, state);
};
$scope.isPartialValueFunctionAccessible = function() {
return $scope.isAccessible($scope.tasks['partial-value-function'], $scope.scenario.state).accessible;
};
$scope.isOrdinalSwingAccessible = function() {
return $scope.isAccessible($scope.tasks['ordinal-swing'], $scope.scenario.state).accessible;
};
$scope.isTradeoffRatiosAccessible = function() {
return $scope.isAccessible($scope.tasks['exact-swing'], $scope.scenario.state).accessible;
};
$scope.isScaleRangePresent = function() {
var isPresent = _.every($scope.scenario.state.problem.criteria, function(criterion) {
return criterion.pvf && criterion.pvf.range;
});
return isPresent;
};
$scope.isPartialValueFunctionPresent = function() {
return _.every($scope.scenario.state.problem.criteria, function(criterion) {
var pvf = criterion.pvf;
return pvf && pvf.direction && pvf.type;
});
};
$scope.isOrdinalSwingPresent = function() {
return $scope.scenario.state.prefs;
};
$scope.isExactSwingPresent = function() {
return $scope.scenario.state.prefs && _.some($scope.scenario.state.prefs, function(pref) {
return pref.type === 'exact swing';
});
};
$scope.isIntervalSwingPresent = function() {
return $scope.scenario.state.prefs && _.some($scope.scenario.state.prefs, function(pref) {
return pref.type === 'ratio bound';
});
};
$scope.isTradeoffRatiosPresent = function() {
return $scope.isExactSwingPresent() || $scope.isIntervalSwingPresent();
};
$scope.scrollToScaleRanges = function() {
$location.hash('scale-ranges-block');
$anchorScroll();
};
$scope.scrollToPVFs = function(scrollEnabled) {
if (scrollEnabled) {
$location.hash('partial-value-functions-block');
$anchorScroll();
}
};
$scope.scrollToTradeOffs = function(scrollEnabled) {
if (scrollEnabled) {
$location.hash('trade-off-block');
$anchorScroll();
}
};
$scope.getXY = _.memoize(PartialValueFunction.getXY, function(arg) {
return angular.toJson(arg.pvf);
});
};
var read = function (filename, callback) {
var mainGroup = null,
groups = { };
// the memoization below is important to make recursion acceptable
var readIndividualGroup = _.memoize(function (groupName) {
// extract the part ids and number of pieces, including 'expanding'
// any reference to other groups
return groups[groupName].split("\r\n").reduce(function (memo, line) {
var found = line.match(/^1 \d+ (([-+]?[0-9]*\.?[0-9]+ ){12})(.+)$/);
if (found) {
var found2 = found[3].toLowerCase().match(/(.+).dat$/);
if (found2) {
// the line is a reference to a simple piece
memo[found2[1]] = (memo[found2[1]] || 0) + 1;
} else {
// the line is a reference to another group
var temp = readIndividualGroup(found[3]);
_.keys(temp).forEach(function (partId) {
memo[partId] = (memo[partId] || 0) + temp[partId];
});
}
}
return memo;
}, { });
});
fs.readFile(filename, { 'encoding': 'utf-8' }, function (err, ldrText) {
// split the file in its "components"
var found,
nextGroupName = null,
itIsTheBeginningOfTheFile = true;
do {
// TODO: what characters can be used in the component names?
found = ldrText.match(/0 Name: (.+)\r\n/);
if (found) {
var temp = ldrText.split(found[0]);
if (!nextGroupName) {
// the next group of lines is going to be the very first
// (or only) group, hence the root to the whole model
mainGroup = found[1];
} else {
groups[nextGroupName] = temp[0];
}
nextGroupName = found[1];
ldrText = temp[1];
} else {
groups[nextGroupName] = ldrText;
}
} while (found);
// calculate the requirements by 'expanding' the component that has
// a "FILE" directive in its specs
var result = readIndividualGroup(mainGroup);
// flatten to an array
result = _.keys(result).map(function (x) {
return { 'partId': x, 'quantity': result[x] };
});
callback(null, result);
});
};
func();
var buttonView = {
label: 'underscore',
onClick: function () {
alert('clicked: ' + this.label);
},
onHover: function () {
console.log('hovering: ' + this.label);
}
};
_.bindAll(buttonView);
$('#underscore_button').bind('click', buttonView.onClick);
var fibonacci = _.memoize(function (n) {
return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
});
var log = _.bind(console.log, console);
_.delay(log, 1000, 'logged later');
_.defer(function () {
alert('deferred');
});
var updatePosition = function () {
return alert('updating position...');
};
var throttled = _.throttle(updatePosition, 100);
$(window).scroll(throttled);
function defineScriptTask(gulp, options) {
var baseOptions = options;
var bundler = _.memoize(function(bundlerOptions) {
bundlerOptions = _.extend({
debug: baseOptions.debug,
entries: baseOptions.entries
}, bundlerOptions);
mkdirp.sync(bundlerOptions.dest);
var defaults = {
watch: false,
debug: false
};
if (bundlerOptions.watch) {
bundlerOptions = _.extend(defaults, bundlerOptions, watchify.args);
}
var b = browserify(bundlerOptions);
if (baseOptions.core) {
core.forEach(function(module) {
b.require(module);
});
} else {
b = b.require('APP').external(core);
}
if (bundlerOptions.watch) {
b = watchify(b);
}
return b;
});
var bundle = function(options) {
var stream = bundler(options).transform(ngHtml2Js({
module: 'templates', // optional module name
extension: 'ngt', // optionally specify what file types to look for
baseDir: 'src/app', // optionally specify base directory for filename
stripPathBefore: '/templates', // optionally specify the part of the path that should be the starting point
prefix: '', // optionally specify a prefix to be added to the filename,
requireAngular: false // (default: false) optionally include `var angular = require('angular');`
// Supported in Angular 1.3.14 and above if you bundle angular with browserify
})).bundle();
stream = stream.on('error', gutil.log.bind(gutil, gutil.colors.red.bold('x error ' + options.bundleName)))
.pipe(source(options.bundleName + '.js'))
.pipe(buffer());
return stream.pipe(gulp.dest(options.dest))
.on('end', options.message);
};
gulp.task('scripts.' + (baseOptions.core ? 'core' : 'app'), function() {
bundle({
debug: true,
message: function() {
gutil.log(gutil.colors.green.bold('☺ success on ' + baseOptions.bundleName + ':scripts'));
},
bundleName: baseOptions.bundleName,
src: baseOptions.src,
dest: baseOptions.dest,
core: baseOptions.core
});
});
if (baseOptions.watch) {
gulp.task('scripts.' + (baseOptions.core ? 'core' : 'app') + ':watch', function() {
var _options = {
watch: true,
debug: true,
message: function() {
gutil.log(gutil.colors.green.bold(' ** watching ' + baseOptions.bundleName + ':scripts'));
},
bundleName: baseOptions.bundleName,
src: baseOptions.src,
dest: baseOptions.dest,
core: baseOptions.core
};
bundle(_options);
bundler(_options).on('update', function() {
bundle(_options);
});
});
}
}
import _ from 'underscore';
import _str from 'underscore.string';
import api from '../utils/api';
import moment from 'moment-timezone';
var PER_PAGE = 100;
var cache = _.memoize(moment.tz, function (date, tz) {
return date + '/' + tz;
});
export var getMoment = function (date, tz) { return cache(date, tz).clone(); };
export var getDaySpan = function (start, end, tz) {
return Math.ceil(
getMoment(end, tz).diff(getMoment(start, tz).startOf('day'), 'days', true)
);
};
export var isAllDay = function (event, tz) {
if (event.is_all_day) return true;
var startMom = getMoment(event.starts_at, tz);
var endMom = getMoment(event.ends_at, tz);
return startMom.isSame(startMom.clone().startOf('day')) &&
endMom.isSame(endMom.clone().startOf('day'));
};
var searchableWords = function (event) {
return _str.words(_.values(
_.pick(event, 'title', 'description', 'location')
).join(' ').toLowerCase());
r = r * r;
g = g * g;
b = b * b;
return {r: r, g: g, b: b};
}
function color2(x) {
var r = normalize1(Math.cos(3.1415 * x / 128));
var g = 0.25;
var b = Math.min(1, 0.5 + normalize1(Math.sin(3.1415 * x / 128)));
return {r: r, g: g, b: b};
}
color2 = _.memoize(color2);
var Plasma1 = base.Effect.extend({
initialize: function () {
console.log('static init');
this.on('render', _.bind(this.render, this));
this.colors = [];
this.color1 = {r: 1, g: 0, b: 0};
this.color2 = {r: 0, g: 1, b: 0};
this.color3 = {r: 0, g: 0, b: 1};
this.calcColormap();
this.value = 0;
this.enabled = false;