function registerTestableCode() {
var yii = registerYii();
var code = fs.readFileSync(yiiActiveFormPath);
var script = new vm.Script(code);
var context = new vm.createContext({window: window, document: window.document, yii: yii});
script.runInContext(context);
}
function execInVm(file) {
const sandbox = {};
const script = new vm.Script(file.contents.toString());
const context = vm.createContext(sandbox);
script.runInContext(context);
return sandbox;
}
this.connPromise.then((conn) => {
let sandbox = {r: r, conn: conn, result: null};
let script = new vm.Script('result = ' + this.lineBuffer+ '.run(conn);');
let context = new vm.createContext(sandbox);
this.lineBuffer ='';
try {
script.runInContext(context);
sandbox.result.then((cursor) => {
cursor.toArray().then((item) => {
console.log(item);
this.promptLine();
}).error((error)=>{
console.log(error.msg);
this.promptLine();
});
}).error((error)=> {
console.log(error.msg);
this.promptLine();
});
} catch (error) {
console.error(error);
this.promptLine();
}
});
function newContext (globals) {
var sandbox = globals || {module:module,require:require,process:process,console:console}
sandbox.global = sandbox;
var ctx = vm.createContext(sandbox);
cljsScript.runInContext(ctx);
return ctx;
}
function registerTestableCode() {
var code = fs.readFileSync(yiiCaptchaPath);
var script = new vm.Script(code);
var context = new vm.createContext({window: window});
script.runInContext(context);
}
function initialize(filename, data){
const id = '__hola_xyzzy__';
let text = fs.readFileSync(filename, 'utf8');
let script = new vm.Script(text, {filename: filename});
let m = {exports: {}};
let console = Object.create(global.console);
// console.log = console.info = ()=>{}; // silence debug logging
let context = vm.createContext({
module: m,
exports: m.exports,
console,
Buffer,
});
context.global = context;
script.runInContext(context);
if (m.exports.init)
{
if (data)
{
Object.defineProperty(context, id, {value: data});
vm.runInContext(`module.exports.init(${id})`, context);
}
else
vm.runInContext(`module.exports.init()`, context);
} else if (data)
throw new Error('data supplied but no init function');
return context;
}
fs.readFile(configFile, 'utf8', function (err, data) {
if (err) {
console.log('Read configuration file failed');
} else {
console.log('Read configuration file success');
let obj;
try {
const vm = require('vm');
let sandbox = { module };
let script = new vm.Script(data);
const context = new vm.createContext(sandbox);
script.runInContext(context);
obj = sandbox.module.exports;
} catch (err) {
console.log(`[Error] Json parse failed: ${err.message}`);
}
if (obj) {
const Mcook = require('../lib');
const mcook = new Mcook(obj);
mcook.validateConfiguration((err) => {
if (err) {
console.log(err.message);
} else {
mcook.createProject((err) => {
if (err) {
console.log(err.message);
}
});
}
});
}
}
});
function runContext(func) {
var context = vm.createContext(sandBox);
var script = new vm.Script(func, {
timeout: 5000
});
script.runInContext(context);
}
function initialize(filename, data) {
var text = fs.readFileSync(filename, 'utf8');
var script = new vm.Script(text, {filename: filename});
m = {exports: {}};
var console = Object.create(global.console);
// console.log = console.info = ()=>{}; // silence debug logging
console.log(filename);
var context = vm.createContext({
module: m,
exports: m.exports,
console: console,
Buffer: Buffer,
});
context.global = context;
script.runInContext(context);
if (m.exports.init)
{
if (data)
{
context['data'] = {value: data};
vm.runInContext(m.exports.init(data), context);
}
else
vm.runInContext(m.exports.init(), context);
} else if (data)
throw new Error('data supplied but no init function');
return context;
}
HtmlWebpackPlugin.prototype.evaluateCompilationResult = function (compilation, source) {
if (!source) {
return Promise.reject('The child compilation didn\'t provide a result');
}
// The LibraryTemplatePlugin stores the template result in a local variable.
// To extract the result during the evaluation this part has to be removed.
source = source.replace('var HTML_WEBPACK_PLUGIN_RESULT =', '');
var template = this.options.template.replace(/^.+!/, '').replace(/\?.+$/, '');
var vmContext = vm.createContext(_.extend({HTML_WEBPACK_PLUGIN: true, require: require}, global));
var vmScript = new vm.Script(source, {filename: template});
// Evaluate code and cast to string
var newSource;
try {
newSource = vmScript.runInContext(vmContext);
} catch (e) {
return Promise.reject(e);
}
if (typeof newSource === 'object' && newSource.__esModule && newSource.default) {
newSource = newSource.default;
}
return typeof newSource === 'string' || typeof newSource === 'function'
? Promise.resolve(newSource)
: Promise.reject('The loader "' + this.options.template + '" didn\'t return html.');
};
execute(input){
this.createSandbox();
this.sandbox.print = data => {
this.getOutputstream().emit('print', data);
this.getOutputstream().write(data);
}
this.sandbox.template = template => {
const fileName = __dirname + '/../../templates/' + template + '.tpl'
const data = fs.readFileSync(fileName);
const TextParser = require('./TextParser');
return new TextParser({
sandbox: this.getSandbox()
}).parse(''+data);
};
this.createContext();
if (input.indexOf('use strict') === -1) {
input = '"use strict"; \n' + input;
}
var script = new vm.Script(input);
script.runInContext(this.getContext());
}
var _toggleCustomConditional = function(componentKey) {
if (_customConditionals.hasOwnProperty(componentKey)) {
var cond = _customConditionals[componentKey];
try {
// Create the sandbox.
var sandbox = vm.createContext({
data: submission.data
});
// Execute the script.
var script = new vm.Script(cond);
script.runInContext(sandbox, {
timeout: 250
});
if (boolean.hasOwnProperty(sandbox.show)) {
show[componentKey] = boolean[sandbox.show];
}
else {
show[componentKey] = true;
}
}
catch (e) {
debug.validator('Custom Conditional Error: ');
debug.validator(e);
debug.error(e);
// Default to true, if a validation error occurred.
show[componentKey] = true;
}
}
};
function evaluateJSON(data, incomingMsg, process, options) {
var sandbox = {
msg: incomingMsg,
pv: function pv(name) {
if (name === 'accessToken') {
return options.accessToken;
}
var val = process._processVariables[name];
if (typeof val === 'undefined' && process._parentProcessVariables) {
val = process._parentProcessVariables[name];
}
return val;
},
data: data,
_output: null
};
var script = '_output = ' + data;
// eslint-disable-next-line
var context = new vm.createContext(sandbox);
try {
var compiledScript = new vm.Script(script);
compiledScript.runInContext(context, { timeout: 1000 });
} catch (e) {
log.error(options, e);
return e;
}
return sandbox._output;
}
function registerYii() {
var code = fs.readFileSync(yiiPath);
var script = new vm.Script(code);
var sandbox = {window: window, jQuery: $};
var context = new vm.createContext(sandbox);
script.runInContext(context);
return sandbox.window.yii;
}
tests.forEach(test => {
let script = new vm.Script(test.script.exec);
try {
script.runInContext(context);
} catch(e) {
tests['Script execute without throwing an exception'] = false;
}
});
constructor() {
this.context = new vm.createContext(contextBase);
this.exec('window = this; global = this;');
meteorRuntimeConfig.runInContext(this.context);
for (let pkg of packages)
this.loadPackage(pkg);
}
function loadScript(path) {
var code = fs.readFileSync(path, {encoding: 'utf8'});
var script = new vm.Script(code, {
filename: path,
displayErrors: true
});
script.runInContext(context);
}
function sandboxByNode(sandbox={}, script){
const vm = require('vm');
script = new vm.Script(script);
const context = new vm.createContext(sandbox);
script.runInContext(context, {
timeout: 3000
});
return sandbox;
}
files.forEach((file) => {
let branch = fs.readFileSync(path.join(dir, file), 'utf8');
branch = new vm.Script('obj = Statement(' + branch + ');', {
filename: file,
displayErrors: true
});
let thisCtx = Object.assign({obj: null}, ctx);
branch.runInContext(thisCtx);
merge(blueprint, thisCtx.obj);
});
b.bundle(function(err, buffer) {
if(err) {
done(err);
return;
}
var script = new vm.Script(buffer.toString()+"; testOut=require('env')");
context = new vm.createContext({testOut: null});
script.runInContext(context);
done(undefined, context);
})
loaderScripts = ( function() {
var code = 'var CKEDITOR = { basePath : \'/ckeditor/\' }; ' + ckbuilder.io.readFile( loaderFile );
var script = new vm.Script( code, { filename: loaderFile } );
var scope = {};
vm.createContext( scope );
try {
script.runInContext( scope );
return scope.CKEDITOR.loader.scripts;
} catch ( e ) {
throw( 'Invalid JavaScript file: ' + loaderFile + '.\nError: ' + e.message );
}
}() );
}).then( async function ( bundle ) {
var generated = await bundle.generate({format: "es"});
var code = generated.code;
var script = new vm.Script(code);
var context = vm.createContext({
dirname: path.join(__dirname, 'fixtures'),
filename: path.join(__dirname, 'fixtures', 'dirname.js'),
setTimeout: setTimeout,
clearTimeout: clearTimeout,
});
context.self = context;
script.runInContext(context);
});
function executeCode(code, isCodeBlock) {
var flatScope = flattenScopes(); //make all levels of the scope accessable
if (!isCodeBlock) {
flatScope.__ChainsawResult = null; //get the result
code = "__ChainsawResult=(\n" + code + "\n)";
}
var context = new vm.createContext(flatScope);
var script = new vm.Script(code);
script.runInContext(context);
updateScopes(flatScope);
return flatScope.__ChainsawResult;
}
WebpackResourceLoader.prototype._evaluate = function (fileName, source) {
try {
var vmContext = vm.createContext(Object.assign({ require: require }, global));
var vmScript = new vm.Script(source, { filename: fileName });
// Evaluate code and cast to string
var newSource = void 0;
newSource = vmScript.runInContext(vmContext);
if (typeof newSource == 'string') {
return Promise.resolve(newSource);
}
return Promise.reject('The loader "' + fileName + '" didn\'t return a string.');
}
catch (e) {
return Promise.reject(e);
}
};
response.on('end', function() {
var pattern = /var (beaches = .*);\/\/]]>/g;
var match = pattern.exec(body);
var sandbox = {beaches: []};
const script = new vm.Script(match[1]);
const context = vm.createContext(sandbox);
script.runInContext(context);
context.beaches.forEach(function (station) {
stations.push(buildStation(station));
});
printStations();
});
_evaluate(fileName, source) {
try {
const vmContext = vm.createContext(Object.assign({ require: require }, global));
const vmScript = new vm.Script(source, { filename: fileName });
// Evaluate code and cast to string
let newSource;
newSource = vmScript.runInContext(vmContext);
if (typeof newSource == 'string') {
return Promise.resolve(newSource);
}
return Promise.reject('The loader "' + fileName + '" didn\'t return a string.');
}
catch (e) {
return Promise.reject(e);
}
}
run(source: string): Object {
const globals = {
module: {},
exports: {}
};
globals.module.exports = globals.exports;
const script = new vm.Script(source, { displayErrors: true });
const sandbox = Object.assign({}, globals, this.globals);
const context = vm.createContext(sandbox);
const result = script.runInContext(context);
if (result && isExport(result.default)) return result.default;
if (isExport(result)) return result;
if (isExport(sandbox.module.exports)) return sandbox.module.exports;
if (isExport(sandbox.exports)) return sandbox.exports;
else return {};
}
_evaluate(output) {
try {
const outputName = output.outputName;
const vmContext = vm.createContext(Object.assign({ require: require }, global));
const vmScript = new vm.Script(output.source, { filename: outputName });
// Evaluate code and cast to string
let evaluatedSource;
evaluatedSource = vmScript.runInContext(vmContext);
if (typeof evaluatedSource == 'string') {
return Promise.resolve(evaluatedSource);
}
return Promise.reject('The loader "' + outputName + '" didn\'t return a string.');
}
catch (e) {
return Promise.reject(e);
}
}
process.on('message', data => {
let sandbox = {};
if (data.sandbox !== undefined) {
sandbox = data.sandbox;
}
if (data.code === undefined) {
process.send({
error: 'No code given'
});
}
try {
const sandboxContext = vm.createContext(sandbox);
const script = new vm.Script(data.code);
const result = script.runInContext(sandboxContext);
process.send({
result,
context: sandboxContext
});
}
catch (e) {
if (e.name === 'SyntaxError') {
process.send({
error: 'Error running sandbox code',
err: {
name: e.name,
message: e.message,
stack: e.stack
}
});
}
else {
process.send({
result: true,
context: {}
});
}
}
});
async.eachSeries(actions, function(action, cb) {
var execute = true;
// See if there is a custom condition.
if (
action.condition &&
action.condition.custom
) {
try {
var script = new vm.Script(action.condition.custom);
var sandbox = {
data: req.body.data,
execute: false
};
script.runInContext(vm.createContext(sandbox), {
timeout: 500
});
execute = sandbox.execute;
}
catch (e) {
debug(e);
execute = false;
}
}
// See if a condition is not established within the action.
if (
action.condition &&
action.condition.field &&
(action.condition.eq === 'equals') &&
(req.body.data[action.condition.field] !== action.condition.value)
) {
execute = false;
}
if (!execute) {
return cb();
}
// Resolve the action.
action.resolve(handler, method, req, res, cb);
}, function(err) {