process.on('message', function(data) {
// handle debug logging specially
if (data[0] === 'nightmare:ipc:debug') {
debug.apply(null, sliced(data, 1));
}
emit.apply(emitter, sliced(data));
});
function emit(name, a, b, c, d) {
if (!name) return
var sharedEvents = Base.prototype._sharedEvents
var events = sharedEvents[name]
var length = events && events.length
var i = -1
if (length) {
switch (arguments.length) {
case 1: while (++i !== length) events[i].call(this); break
case 2: while (++i !== length) events[i].call(this, a); break
case 3: while (++i !== length) events[i].call(this, a, b); break
case 4: while (++i !== length) events[i].call(this, a, b, c); break
case 5: while (++i !== length) events[i].call(this, a, b, c, d); break
default: while (++i !== length) events[i].apply(this, slice(arguments, 1)); break
}
}
if (this._events && this._events[name]) {
_emit.apply(this, slice(arguments))
}
return this
}
Router.prototype[method] = function(path) {
// apth, handler1, hadnler2, ...
// path, config, hadnler1
// path config, handler1, handler2, ...
var fns;
var config;
switch (typeof arguments[1]) {
case 'function':
config = {};
fns = slice(arguments, 1);
break;
case 'object':
config = arguments[1];
fns = slice(arguments, 2);
break;
}
var spec = {
path: path,
method: method,
handler: fns
};
Object.keys(config).forEach(function(key) {
spec[key] = config[key];
});
this.route(spec);
return this;
};
Router.prototype[method] = function(path) {
// path, handler1, handler2, ...
// path, config, handler1
// path, config, handler1, handler2, ...
// path, config, [handler1, handler2], handler3, ...
let fns;
let config;
if (typeof arguments[1] === 'function' || Array.isArray(arguments[1])) {
config = {};
fns = slice(arguments, 1);
} else if (typeof arguments[1] === 'object') {
config = arguments[1];
fns = slice(arguments, 2);
}
const spec = {
path: path,
method: method,
handler: fns
};
Object.assign(spec, config);
this.route(spec);
return this;
};
// run in series
function next (err) {
if (err) return error(err, sliced(arguments, 1))
var fn = pipeline.shift()
while (fn && fn.length !== 2) fn = pipeline.shift()
if (!fn) return done.call(context, null, sliced(arguments, 1))
fn.call(context, sliced(arguments, 1), next)
}
// initialize a store
function store (action) {
var arrayContext = isArray(this)
if (!arguments.length && !arrayContext) return freeze(redux.getState())
var actions = arrayContext ? sliced(this) : sliced(arguments)
actions = wrapEmitterStyle(actions)
redux.dispatch.apply(redux, actions)
return redux.getState()
}
: (oldLength === 4) ? function() {
var n = arguments;
var newLength = arguments.length;
return (newLength === 0) ? func(o[1], o[2], o[3])
: (newLength === 1) ? func(n[0], o[1], o[2], o[3])
: (newLength === 2) ? func(n[0], n[1], o[1], o[2], o[3])
: (newLength === 3) ? func(n[0], n[1], n[2], o[1], o[2], o[3])
: (newLength === 4) ? func(n[0], n[1], n[2], n[3], o[1], o[2], o[3])
: func.apply(this, sliced(n).concat(sliced(o, 1)))
}
Vo.stack = function stack () {
var stack = isArray(this) ? sliced(this) : sliced(arguments)
// run the stack
return run(function (context, args, done) {
Stack(stack, context, args, function(err, v) {
if (err) return done(err)
return done.apply(this, [null].concat(v))
})
})
}
function Vo() {
var pipeline = isArray(this) ? sliced(this) : sliced(arguments)
// run vo
return run(function (context, args, done) {
Pipeline(pipeline, context, args, function(err, args) {
if (err) return done.call(context, err)
return done.apply(context, [null].concat(args))
})
})
}
var getJoinedTable = function getJoinedTable() {
var allColumns = sliced(order.columns).concat(sliced(menu.columns).concat(sliced(food.columns).concat(sliced(user.columns)))),
sql = order.select(allColumns)
.from(
order.leftJoin(menu).on(order.MenuId.equals(menu.idMenu))
.leftJoin(user).on(order.UserId.equals(user.idUser))
.leftJoin(food).on(menu.FoodId.equals(food.idFood))
);
return sql;
};
function wrap() {
var args = sliced(arguments);
var last = args[args.length - 1];
var ctx = this;
// done
var done = typeof last == 'function' ? args.pop() : noop;
// nothing
if (!fn) {
return done.apply(ctx, [null].concat(args));
}
// generator
if (generator(fn)) {
return co(fn).apply(ctx, args.concat(done));
}
// async
if (fn.length > args.length) {
// NOTE: this only handles uncaught synchronous errors
try {
return fn.apply(ctx, args.concat(done));
} catch (e) {
return done(e);
}
}
// sync
return sync(fn, done).apply(ctx, args);
}
insert: function(o) {
var self = this;
var args = sliced(arguments);
//object literal
if(arguments.length == 1 && !o.toNode && !o.forEach) {
args = Object.keys(o).map(function(key) {
return self.table[key].value(o[key]);
});
} else if (o.forEach) {
o.forEach(function (arg) {
return self.insert.call(self, arg);
});
return self;
}
if (self.insertClause) {
self.insertClause.add(args);
return self;
}
else {
self.insertClause = new Insert();
self.insertClause.add(args);
return self.add(self.insertClause);
}
},
function after (err, res) {
var args = sliced(arguments);
self.child.once('continue', function() {
next.apply(self, args);
});
self.child.emit('continue');
}
Queue.prototype.update = function Queue$update (options) {
var args; for (var i = arguments.length, a = args = new Array(i); i--; a[i] = arguments[i]) {}
args = slice(args, 1);
var key = this.getKeyFromArgs(args);
return this.updateByKey(key, options || {});
};
return function(err) {
if(err) {
parent(err);
} else {
callback.apply(callback, sliced(arguments, 1));
}
}
select: function() {
var select;
if(this._select) {
select = this._select;
} else {
select = this._select = new Select();
this.add(select);
}
var args = sliced(arguments);
if(util.isArray(args[0])) {
args = args[0];
}
select.addAll(args);
// if this is a subquery then add reference to this column
if(this.type === 'SUBQUERY') {
for(var j = 0; j < select.nodes.length; j++) {
var name = select.nodes[j].alias || select.nodes[j].name;
var col = new Column(select.nodes[j]);
col.name = name;
col.table = this;
if( this[name] === undefined ) {
this[name] = col;
}
}
}
return this;
},
function po() {
var lArgs = args.concat(sliced(arguments))
if (lArgs.length >= arity)
return series(pipeline, lArgs);
else
return generator(lArgs);
}
distinctOn: function() {
var distinctOn;
if (this._distinctOn) {
distinctOn = this._distinctOn;
} else {
var select = this.nodes.filter(function (node) {return node.type === 'SELECT';}).shift();
distinctOn = this._distinctOn = new DistinctOn();
select.add(distinctOn);
}
//allow things like .distinctOn(a.star(), [ a.id, a.name ])
//this will flatten them into a single array
var args = sliced(arguments).reduce(function(cur, next) {
if (util.isArray(next)) {
return cur.concat(next);
}
cur.push(next);
return cur;
}, []);
distinctOn.addAll(args);
return this;
},
return function () {
if (canLoadDomain && !gettext.options.locale_data[domain]) {
gettext.loadDomain(domain);
}
let args = sliced(arguments);
const firstArg = args[0];
if (typeof firstArg === 'object' && firstArg instanceof NopArgs) {
args = firstArg.args.concat(args.slice(1));
}
let expandArgs = args[args.length - 1];
if (expandArgs && typeof expandArgs === 'object') {
args.pop();
} else {
expandArgs = null;
}
if (method === 'dpgettext') {
// Swap order of context, msgid.
[args[0], args[1]] = [args[1], args[0]];
}
args.unshift(domain);
const string = gettext[method].apply(gettext, args);
if (expandArgs) {
return expand(string, expandArgs, !!expandArgs.__react);
}
return string;
};
pluck: function() {
var args = sliced(arguments);
var cb = args.pop();
var fields = _.uniq(_.compact(_.flatten(args)));
var relation = this;
// TODO: handle associations
relation.setSelectValues(fields);
this.model.query(relation.toSQL(), function(err, result) {
if (err) { cb(err); return; }
var columns = result.rows.map(function(row) {
return fields.reduce(function(items, field) {
return items.concat(row[field]);
}, []);
});
if (fields.length === 1) {
columns = columns.map(function(column) { return column[0]; });
}
cb(null, columns);
});
},
function inject(element, callback) {
callback = typeof callback === 'function' ? callback : noop
var url = element.getAttribute('src')
if (!url) return
var attributes = slice(element.attributes).map(function(attr) {
return [attr.name, attr.value]
})
xhr({
uri: url
}, function(err, res, body) {
if (err) return callback(err)
if (!res.responseXML) {
return callback(new Error(
'Invalid SVG file: ' + url
))
}
var svg = res.responseXML.querySelector('svg')
for (var i = 0; i < attributes.length; i++) {
svg.setAttribute(attributes[i][0], attributes[i][1])
}
if (element.parentNode) {
element.parentNode.replaceChild(svg, element)
}
callback(null, svg)
})
}
module.exports = function braceExpandJoin() {
var args = sliced(arguments);
if (args.length === 0) {
throw new TypeError('More than 1 glob pattern string required.');
}
var len = args.length;
var patterns = new Array(len);
while (len--) {
patterns[len] = braceExpansion(args[len]).map(path.normalize);
}
var joinedPatterns = patterns.reduce(function(parentPatterns, childPatterns) {
return concatMap(parentPatterns, function(parentPattern) {
return childPatterns.map(function(childPattern) {
return path.join(parentPattern, childPattern);
});
});
});
joinedPatterns = arrayUniq(joinedPatterns);
if (joinedPatterns.length > 1) {
return '{' + joinedPatterns.join(',') + '}';
}
return joinedPatterns[0];
};
return function (options, callback) {
var args = argsToArray(arguments)
callback = args.pop()
args.unshift(this)
var run = fn.bind.apply(fn, args)
var self = this
return tv.instrument(function (last) {
var coll = (self.collection && self.collection.collectionName) || self.ns
var db = is2 ? self.options.db : self.db
var query = is2
? self.cmd.query
: (Object.keys(self.selector).length
? self.selector
: 'all'
)
var data = {
QueryOp: 'find',
Query: JSON.stringify(query),
CursorId: (self.cursorId || 0).toString(),
CursorOp: 'nextObject'
}
if (self.limitValue) {
data.Limit = self.limitValue
}
return last.descend('mongodb', withCommonData(coll, db, data))
}, function (done) {
run(done)
}, conf, callback)
}
exports.evaluate = function (fn/**, arg1, arg2..., done**/) {
var args = sliced(arguments);
var done = args[args.length-1];
var newArgs = [fn, done].concat(args.slice(1,-1));
debug('.evaluate() fn on the page');
this.evaluate_now.apply(this, newArgs);
};
emitter.call = function(name) {
var args = sliced(arguments, 1);
var callback = args.pop();
if (typeof callback !== 'function') {
args.push(callback);
callback = undefined;
}
var id = callId++;
var progress = new Emitter();
emitter.on(`CALL_DATA_${id}`, function() {
progress.emit.apply(progress, ['data'].concat(sliced(arguments)));
});
emitter.once(`CALL_RESULT_${id}`, function() {
progress.emit.apply(progress, ['end'].concat(sliced(arguments)));
emitter.removeAllListeners(`CALL_DATA_${id}`);
progress.removeAllListeners();
progress = undefined;
if (callback) {
callback.apply(null, arguments);
}
});
emitter.emit.apply(emitter, ['CALL', id, name].concat(args));
return progress;
};
exports.wait = function () {
var args = sliced(arguments);
var done = args[args.length-1];
if (args.length < 2) {
debug('Not enough arguments for .wait()');
return done();
}
var arg = args[0];
if (typeof arg === 'number') {
debug('.wait() for ' + arg + 'ms');
if(arg < this.optionWaitTimeout){
waitms(arg, done);
} else {
waitms(this.optionWaitTimeout, function(){
done(new Error('.wait() timed out after '+this.optionWaitTimeout+'msec'));
}.bind(this));
}
}
else if (typeof arg === 'string') {
debug('.wait() for ' + arg + ' element');
waitelem(this, arg, done);
}
else if (typeof arg === 'function') {
debug('.wait() for fn');
args.unshift(this);
waitfn.apply(this, args);
}
else {
done();
}
};
insert: function(o) {
var self = this;
var args = sliced(arguments);
if (o.length == 0) {
o = {};
}
// object literal
if (arguments.length === 1 && !o.toNode && !o.forEach) {
args = [];
Object.keys(o).forEach(function(key) {
var col = self.table.get(key);
if(col && !col.autoGenerated)
args.push(col.value(o[key]));
});
} else if (o.forEach) {
o.forEach(function(arg) {
return self.insert.call(self, arg);
});
return self;
}
if (self.insertClause) {
self.insertClause.add(args);
return self;
} else {
self.insertClause = new Insert();
self.insertClause.add(args);
return self.add(self.insertClause);
}
},
return function(_event) {
// NOTE: the raw Electron event used to be forwarded here, but we now send
// an empty event in its place -- the raw event is not JSON serializable.
if (!closed) {
parent.emit.apply(parent, [name, {}].concat(sliced(arguments, 1)))
}
}
return function () {
var args = sliced(arguments)
var cb = args.pop()
fn.apply(this, args.concat([function (err, value) {
if (err) cb(err)
else hook.call(this, value, cb)
}.bind(this)]))
}
Food.list = function (req, res) {
var food = schema.Food,
vendor = schema.Vendor,
allColumns = sliced(food.columns).concat(sliced(vendor.columns)),
sql = food.select(allColumns)
.from(food.join(vendor).on(food.VendorId.equals(vendor.idVendor)))
.where(food.isAvailable.equals("use"))
.order(food.VendorId)
.toQuery();
db.runSql(sql, function (err, rows, fields) {
if (!err) res.json(rows);
});
};