/// <summary>
/// Method to use for running Javascript Files.
/// </summary>
/// <param name="filePath">Path to JS or JSE File</param>
public void RunScript(object filePath)
{
try
{
/* CODIGO JINTENGINE VIEJO
Engine engine = new Engine(cfg => cfg.AllowClr(typeof(NinoJS.Resources.SQL).Assembly))
.SetValue("log", new Action<object>(Console.WriteLine));
engine.Execute(fileContent);
*/
string fileContent = new StreamReader(filePath.ToString()).ReadToEnd();
var engine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDebugging);
var typeCollection = new HostTypeCollection("mscorlib", "System", "System.Core", "NinoJS.Resources");
engine.AddHostObject("clr", typeCollection);
engine.AddHostObject("host", new HostFunctions());
engine.AddHostObject("extendedHost", new ExtendedHostFunctions());
engine.AddHostObject("console", new NinoJS.Core.Helpers.Console());
engine.Execute(fileContent);
}
catch (Exception ex)
{
System.Console.WriteLine(ex.ToString());
log.LogError(ex.ToString());
}
}
public Engine()
{
engine = new V8ScriptEngine (V8ScriptEngineFlags.EnableDebugging);
engine.AddHostObject ("dotnet", new Microsoft.ClearScript.HostTypeCollection ("mscorlib", "System.Core"));
engine.AddHostType ("WinJS_KeyUtil", typeof (KeyUtil));
engine.AddHostType ("WinJS_FileUtils", typeof (FileUtils));
engine.AddHostObject ("WinJS_host", new Microsoft.ClearScript.HostFunctions ());
}
public static HtmlDocumentFacade ProcessServerSideScripts(this HtmlDocumentFacade doc)
{
var scripts = doc.getElementsByTagName("script");
var noSideScripts = scripts
.Where(_TestForNoSide);
var noSideScriptsList = noSideScripts.ToList();
noSideScriptsList.ForEach(node =>
{
node.parentNode.removeChild(node);
});
var serverSideScripts = scripts
.Where(_TestForServerSide)
.Where(_TestForRealScript)
;
var sb = new StringBuilder();
//serverSideScripts = serverSideScripts.Where(node => string.IsNullOrEmpty(node.getAttribute(ModelAttribute)));
var serverSideScriptsList = serverSideScripts.ToList();
serverSideScriptsList.ForEach(node =>
{
string src = node.getAttribute("src");
if (string.IsNullOrEmpty(src))
{
sb.AppendLine(node.innerHTML);
}
else
{
sb.AppendLine(doc.GetHostContent(src));
}
if (!_TestForClientSide(node))
{
node.parentNode.removeChild(node);
}
});
string script = sb.ToString();
if (script.Length > 0)
{
// Initialize a context
script = sb.ToString();
using (var engine = new V8ScriptEngine())
{
var jqueryFacade = new JQueryFacade(doc);
engine.AddHostObject("console", new Console());
engine.AddHostObject("document", doc);
engine.AddHostObject("jQueryServerSideFacade", jqueryFacade);
engine.Execute("var " + modeParameter + "='server'");
if (doc.ProcessContext.Model != null)
{
engine.AddHostObject("model", doc.ProcessContext.Model);
}
engine.Execute(script);
}
}
return doc;
}
public static void Main()
{
using (var engine = new V8ScriptEngine(typeof(ClearScriptConsole).Name, V8ScriptEngineFlags.EnableDebugging))
{
engine.AddHostObject("host", new ExtendedHostFunctions());
engine.AddHostObject("lib", HostItemFlags.GlobalMembers, new HostTypeCollection("mscorlib", "System", "System.Core", "ClearScript"));
engine.AllowReflection = true;
RunStartupFile(engine);
RunConsole(engine);
}
}
public void RunScript(string script)
{
Console.WriteLine("[{0}] {1} clicked Run Script", DateTime.Now, Context.ConnectionId);
if (jContext == null)
{
jContext = new V8ScriptEngine();
jContext.AddHostObject("map", map);
jContext.AddHostType("Console", typeof(Console));
}
try
{
jContext.Evaluate(script);
}
catch (ScriptEngineException ex)
{
Clients.All.receiveMessage("JavaScript Engine:" + ex.Message + "<br>");
}
foreach (var token in map.GetTokenList())
{
Clients.All.onTokenMoved(token.Id, token.X, token.Y, "nobody");
}
}
public IJSPlayer(string fileFullPath, ILog iLog)
{
this.iLog = iLog;
engin = new V8ScriptEngine();
engin.Execute(File.ReadAllText(fileFullPath));
engin.AddHostObject("Console", iLog);
}
public void Can_Perform_JS_ToLower_On_An_Object_Property()
{
using (var engine = new V8ScriptEngine(V8ScriptEngineFlags.DisableGlobalMembers))
{
var myObject = new {MyString = "Just a test string"};
engine.Script.MyString = "Just a test string";
engine.AddHostType("Console", typeof(Console));
engine.AddHostObject("myObject", myObject);
engine.Execute("Console.WriteLine ('Length of MyString = {0}', myObject.MyString.toLowerCase())");
}
}
public Task <IRunResult> Run <T>(ClearScriptScript script, IScriptEnvironment <T> externalEnvironment)
{
//TODO: add checks for script context type, version and environment
var runId = Guid.NewGuid().ToString();
var jintContext = externalEnvironment.Context;
_engine.AddHostObject("context", jintContext);
_engine.Execute(script.JavaScriptCode);
return(Task.FromResult <IRunResult>(new ScriptExecutionSuccess()
{
Id = runId
}));
}
public void LogFromV8()
{
using var engine = new V8ScriptEngine();
engine.AddHostObject("output", _output);
engine.Execute(@"
function hello() {
output.WriteLine('Hello World');
};
hello();
");
}
public static void Initialize(TestContext context)
{
var settings = new SwiPrologInitializationSettings
{
HomeDirectory = @"C:\Program Files\swipl",
SetHomeDirectoryEnvironmentVariable = true,
BinaryDirectory = @"C:\Program Files\swipl\bin",
PrependBinaryDirectoryToPath = true
};
v8 = new V8ScriptEngine();
prolog = new SwiPrologEngine(settings);
v8.AddHostType("Console", typeof(Console));
v8.AddHostObject("prolog", prolog);
}
public void Execute(SaveFile saveFile, string folderPath, bool debuggingEnabled, int debuggingPort)
{
V8ScriptEngineFlags flag;
if (debuggingEnabled)
{
flag = V8ScriptEngineFlags.EnableDebugging;
}
else
{
flag = V8ScriptEngineFlags.None;
}
if (_engine == null)
{
_engine = new V8ScriptEngine(flag, debuggingPort);
}
_engine.DocumentSettings.AccessFlags = DocumentAccessFlags.EnableFileLoading;
_engine.AddHostObject("lib", new HostTypeCollection(typeof(SaveFile).Assembly));
_engine.AddHostObject("nodes", saveFile.Nodes);
_engine.AddHostObject("host", new HostFunctions());
_engine.AddHostType(typeof(Enumerable));
_engine.AddHostType(typeof(EnumerableExtensions));
_engine.ExecuteDocument(Path.Combine(folderPath, "script.js"));
}
protected override void InnerEmbedHostObject(string itemName, object value)
{
object processedValue = MapToClearScriptType(value);
lock (_executionSynchronizer)
{
try
{
_jsEngine.AddHostObject(itemName, processedValue);
}
catch (OriginalJsException e)
{
throw ConvertScriptEngineExceptionToJsRuntimeException(e);
}
}
}
internal void Init()
{
Dispose();
V8ScriptEngineFlags flags = V8ScriptEngineFlags.None;
#if DEBUG
flags |= V8ScriptEngineFlags.EnableDebugging;
flags |= V8ScriptEngineFlags.EnableRemoteDebugging;
#endif
scriptEngine = new V8ScriptEngine(flags);
loadedScripts = new HashSet <string>();
scriptEngine.AddHostObject("Engine", new GameEngineProxy(this));
LoadScript("src/Init.js");
scriptEngine.Execute("Init()");
executeScript = scriptEngine.Compile("Execute(Engine.Input);");
}
/// <summary>
/// Assumes layout has been already applied
/// Note: method mutates graph and graphLayout
/// </summary>
public void ImproveAppliedLayout(SigmaGraphModel graph, GraphLayout graphLayout, LayoutSettings layoutSettings, TimeSpan duration)
{
using (var engine = new V8ScriptEngine())
{
try
{
var v8Graph = new V8GraphModel();
v8Graph.LoadSigma(graph);
engine.AddHostObject("log", _log);
engine.Execute("var graph = " + JsonConvention.SerializeObject(v8Graph) + ";");
engine.Execute("var settings = " + JsonConvention.SerializeObject(layoutSettings) + ";");
engine.Execute("var duration = " + JsonConvention.SerializeObject(duration.TotalMilliseconds) + ";");
var baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
var forceAtlas2 = engine.Compile(File.ReadAllText($@"{baseDirectory}\App\Graph\Layout\ForceAtlas2.js"));
var serviceScript = engine.Compile(File.ReadAllText($@"{baseDirectory}\App\Graph\Layout\GraphLayoutService.js"));
engine.Execute(forceAtlas2);
engine.Execute(serviceScript);
var nodesJson = engine.Evaluate("JSON.stringify(nodes)").ToString();
var nodes = JsonConvention.DeserializeObject <V8NodeModel[]>(nodesJson);
for (int i = 0; i < nodes.Length; i++)
{
var node = graph.Nodes[i];
node.X = nodes[i].x;
node.Y = nodes[i].y;
var id = node.Entity;
if (id.HasValue)
{
graphLayout[id.Value] = new GraphLayout.Coords()
{
X = nodes[i].x,
Y = nodes[i].y
};
}
}
}
catch (ScriptEngineException e)
{
_log.Error("V8 exception: " + e.ErrorDetails);
throw;
}
}
}
private void compileScript(string src, Dictionary <string, object> hostObjects = null)
{
Ok = false;
engine = new V8ScriptEngine();
code = engine.Compile(src);
if (hostObjects != null)
{
foreach (var kvp in hostObjects)
{
engine.AddHostObject(kvp.Key, kvp.Value);
}
}
engine.Execute(code);
Ok = true;
}
private static void Execute(Context context)
{
try
{
using var engine = new V8ScriptEngine
{
AllowReflection = true
};
engine.AddHostObject("context", context);
Console.WriteLine(engine.Evaluate("context.Value.ToString()"));
}
catch (Exception exception)
{
Console.WriteLine($"{exception.Message} Error testing {context.Value} [{context.Value.GetType().Name}]");
}
}
public IActionResult Index()
{
string result = "Ok";
try
{
var engine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDateTimeConversion);
engine.AddHostObject("host", new HostFunctions());
engine.AddHostType("LoggerConsole", typeof(LoggerConsole));
// engine.Execute(@" var o=new LoggerConsole(); o.Log(2+3+''); ");
result = engine.Evaluate(@" 2+3 ") + "";
}
catch (Exception ex)
{
result = "Error " + ex.Message;
}
return(View("Index", result));
}
private MockEngineResponse ExecuteAction(V8ScriptEngine scriptEngine, string scenarioName, MockAction action)
{
_logProvider.Information("executing action: {action}", action);
var response = new MockEngineResponse()
{
Success = true
};
if (action.Before != null)
{
try
{
scriptEngine.Execute(action.Before);
}
catch (Exception e)
{
throw new MockEngineException(this.Name, scenarioName, $"error executing Before code: {e.Message}", e);
}
}
if (action.Response != null)
{
response = BuildResponse(scriptEngine, scenarioName, action);
if (response != null)
{
scriptEngine.AddHostObject("response", response);
}
}
if (action.After != null)
{
try
{
scriptEngine.Execute(action.After);
}
catch (Exception e)
{
throw new MockEngineException(this.Name, scenarioName, $"error executing After code: {e.Message}", e);
}
}
if (action.Log != null)
{
_logProvider.Information(ApplyExpressions(scriptEngine, action.Log, false));
}
return(response);
}
public bool ClearScript(Parameter parameter)
{
StringBuilder statementBuilder = new StringBuilder();
for (int i = 0; i < parameter.Statements.Length; ++i)
{
statementBuilder.Append("results[").Append(i).Append("] = ").Append(parameter.Statements[i]).AppendLine(";");
}
int[] results = new int[parameter.Statements.Length];
using (V8ScriptEngine engine = new V8ScriptEngine())
{
engine.AddHostObject("results", results);
engine.Execute(statementBuilder.ToString());
return(Assert(results, parameter.Sum));
}
}
private void ConfigureScriptEngine(V8ScriptEngine context, dynamic globalValues, dynamic flowValues, object functionValues)
{
// Always serialize object to string, and let the JS side deserialize it to proper JScript objects
dynamic valueProxy = null;
if (functionValues == null)
{
valueProxy = new object();
}
else
{
valueProxy = new { param1 = JsonConvert.SerializeObject(functionValues) }
};
// Dummy objects to support scripts meant for NodeJS
var exports = new Dictionary <string, object>().ToDynamic(context);
context.AddHostObject("exports", exports);
context.AddHostObject("module", new { exports });
context.AddHostObject("chatContext", new
{
isNode = false,
api = ScriptHost,
global = globalValues,
local = flowValues,
parameters = valueProxy,
sessionId = ChatModel.ChatId
});
// Add backward compatibility
context.AddHostObject("args", valueProxy);
context.AddHostObject("local", flowValues);
context.AddHostObject("global", globalValues);
context.AddHostObject("s", globalValues);
context.AddHostObject("api", ScriptHost);
LoadSharedScripts(context, false);
}
public void Test(XDPFile xdp, XDocument form)
{
_configDom.Initialize(_form);
_connectionSetDom.Initialize(_form);
_connectionDataDom.Initialize(_form);
_xmlDataDom.Initialize(_formData);
//xfa.record
_xfaDataDom.Initialize(_xfaObject, _formData);
//xfa.template
_templateDom.Initialize(_xfaObject, _xdp, _form);
_dataDescriptionDom.Initialize(_form);
//xfa.form
_formDom.Initialize(_form);
_layoutDom.Initialize(_form);
_engine.AddHostObject("xfa", _xfaObject);
var a1 = _engine.Evaluate("xfa.record.CurrentRisk.Options.nodes.length");
var a2 = _engine.Evaluate("xfa.record.CurrentRisk.Options.nodes.item(0)");
var a3 = _engine.Evaluate("xfa.record.CurrentRisk.Options.nodes.item(0).OptionId.value");
_engine.Execute("xfa.record.CurrentRisk.Options.nodes.item(0).OptionId.value=99");
var a5 = _engine.Evaluate("xfa.record.CurrentRisk.Options.nodes.item(0).OptionId.value");
var a6 = _engine.Evaluate("xfa.record.CurrentRisk.Options.nodes.item(0).OptionDetailECP.OptionDetailECPId.value");
if (_xdp.Filename.Contains("Sample_001"))
{
var x = _xfaObject.template.GetDynamicMemberNames();
var b1 = _engine.Evaluate("xfa.template.form1.minH");
var b2 = _engine.Evaluate("xfa.template.form1.layout");
}
}
public void Execute_Method_from_external_object_and_return_value()
{
var calculator = new TestCalculator();
using var engine = new V8ScriptEngine();
engine.AddHostObject("calculator", calculator);
engine.Execute(@"
function calc() {
return calculator.Add(1,2);
};
var result = calc();
");
var value = (int)engine.Script.result;
value.Should().Be(calculator.Add(1, 2));
_output.WriteLine(value.ToString());
}
public HighlightJS(IResourceProvider resource)
{
this.resource = resource;
engine = new V8ScriptEngine();
engine.AddHostObject("require", new Func <string, object>(x => {
string code = resource.ReadAllText(Path.Combine($@"\lib\{x.Substring(2)}.js"));
return(engine.Evaluate(new DocumentInfo(x), @"(function(){ var exports = {}; var module = { exports: exports };" + code + @"; return exports === module.exports ? exports : module.exports; })()"));
}));
hljs = engine.Script.require(@".\index");
var listLanguages = hljs.GetProperty("listLanguages") as ScriptObject;
var languagesArray = listLanguages.Invoke(false) as ScriptObject;
var length = languagesArray.GetProperty("length") as int? ?? 0;
languages = Enumerable.Range(0, length).Select(x => languagesArray.GetProperty(x).ToString()).ToArray();
highlightJsFunction = engine.Evaluate(@"((hljs, code, languageSubset) => hljs.highlightAuto(code, [languageSubset]).value)") as ScriptObject;
}
public void PropertyBag_MultiEngine_HostFunctions()
{
using (var scriptEngine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDebugging))
{
const string code = "bag.host.func(0, function () { return bag.func(); })";
var bag = new PropertyBag
{
{ "host", new HostFunctions() },
{ "func", new Func <object>(() => ScriptEngine.Current) }
};
engine.AddHostObject("bag", bag);
scriptEngine.AddHostObject("bag", bag);
var func = (Func <object>)engine.Evaluate(code);
Assert.AreSame(engine, func());
func = (Func <object>)scriptEngine.Evaluate(code);
Assert.AreSame(scriptEngine, func());
}
}
public CompileResult Compile(string scriptPath)
{
using (var engine = new V8ScriptEngine())
{
var output = new StringWriter();
try
{
engine.Execute(_coffeeScript);
output.WriteLine(@"/**
* CoffeeScript-Handler: {0}
* CoffeeScript Compiler: {1}
* ScriptPath: {2}
* Compiled at: {3}
*/",
FileVersionInfo.GetVersionInfo(GetType().Assembly.Location).FileVersion,
engine.Evaluate("CoffeeScript.VERSION"),
scriptPath,
DateTime.UtcNow);
var code = File.ReadAllText(scriptPath);
engine.AddHostObject("code", new { Str = code });
var result = engine.Evaluate("CoffeeScript.compile(code.Str, {no_wrap: true})");
output.WriteLine();
output.WriteLine(result);
return(new CompileResult {
Ok = true, Value = output.ToString()
});
}
catch (Exception ex)
{
output.WriteLine();
output.WriteLine(ex.Message);
return(new CompileResult {
Ok = false, Value = output.ToString()
});
}
}
}
public ClearScriptEngine(IHandlebarsResourceProvider resourceProvider)
{
Console.Out.WriteLine("ClearScriptEngine Loaded");
_resourceProvider = resourceProvider;
_context = new V8ScriptEngine();
_context.AddHostObject("clearScriptBridge",
HostItemFlags.GlobalMembers,
new ClearScriptBridgeFunctions(_context, _resourceProvider));
// _context.Script.moduleLoader = new ModuleLoader(_context);
// _context.Execute(File.ReadAllText("require.js"));
// _context.Execute(@"require.load = function(context, name, url) { moduleLoader.LoadModuleAsync(context, name, url); };");
_context.Execute("var raw = [];");
_context.Execute("require('./Script/handlebars-1.0.0.js');");
foreach (var script in HandlebarsConfiguration.Instance.Include)
{
_context.Execute("require('./" + script.Source + "');");
}
}
public void PropertyBag_MultiEngine()
{
var bag = new PropertyBag();
engine.AddHostObject("bag", bag);
Action innerTest = () =>
{
// The Visual Studio 2013 debugging stack fails to release the engine properly,
// resulting in test failure. Visual Studio 2012 does not have this bug.
using (var scriptEngine = new V8ScriptEngine())
{
scriptEngine.AddHostObject("bag", bag);
Assert.AreEqual(2, bag.EngineCount);
}
};
innerTest();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
Assert.AreEqual(1, bag.EngineCount);
}
public ClearScriptEngine(IHandlebarsResourceProvider resourceProvider)
{
Console.Out.WriteLine("ClearScriptEngine Loaded");
_resourceProvider = resourceProvider;
_context = new V8ScriptEngine();
_context.AddHostObject("clearScriptBridge",
HostItemFlags.GlobalMembers,
new ClearScriptBridgeFunctions(_context, _resourceProvider));
// _context.Script.moduleLoader = new ModuleLoader(_context);
// _context.Execute(File.ReadAllText("require.js"));
// _context.Execute(@"require.load = function(context, name, url) { moduleLoader.LoadModuleAsync(context, name, url); };");
_context.Execute("var raw = [];");
_context.Execute("require('./Script/handlebars-1.0.0.js');");
foreach (var script in HandlebarsConfiguration.Instance.Include)
{
_context.Execute("require('./" + script.Source + "');");
}
}
public static object RunJS_V8()
{
using (var engine = new V8ScriptEngine())
{
engine.AddHostType("Console", typeof(Console));
engine.Execute("Console.WriteLine('{0}',Math.PI)");
engine.AddHostObject("random", new Random());
engine.Execute("Console.WriteLine('Next random Number is {0}',random.Next())");
var f = "test.js";
var code = File.ReadAllText(f);
engine.Compile(code);
engine.AddHostType("Console", typeof(Console));
engine.Execute("Console.WriteLine('{0} is an interesting number.', Math.PI)");
engine.AddHostType("Console", typeof(Console));
engine.Evaluate("Console.debug('faasfafa')");
var res = engine.Evaluate("test(fsfs)");
Console.WriteLine(res);
}
return(null);
}
/// <summary>
/// 执行JS
/// </summary>
private static void RunJs(string code)
{
if (string.IsNullOrEmpty(code))
{
return;
}
using (var engine = new V8ScriptEngine())
{
// expose a host type
engine.AddHostType("Console", typeof(Console));
engine.AddHostObject("lib", new HostTypeCollection("mscorlib", "System.Core"));
//engine.Execute("Console.WriteLine(lib.System.DateTime.Now)");
// expose a host object
engine.AddHostObject("random", new Random());
//engine.Execute("Console.WriteLine(random.NextDouble())");
// expose entire assemblies
// create a host object from script
// engine.Execute(@"
// birthday = new lib.System.DateTime(2007, 5, 22);
// Console.WriteLine(birthday.ToLongDateString());
//");
// use a generic class from script
// engine.Execute(@"
// Dictionary = lib.System.Collections.Generic.Dictionary;
// dict = new Dictionary(lib.System.String, lib.System.Int32);
// dict.Add('foo', 123);
//");
// call a host method with an output parameter
engine.AddHostObject("host", new HostFunctions());
// engine.Execute(@"
// intVar = host.newVar(lib.System.Int32);
// found = dict.TryGetValue('foo', intVar.out);
// Console.WriteLine('{0} {1}', found, intVar);
//");
// create and populate a host array
// engine.Execute(@"
// numbers = host.newArr(lib.System.Int32, 20);
// for (var i = 0; i < numbers.Length; i++) { numbers[i] = i; }
// Console.WriteLine(lib.System.String.Join(', ', numbers));
//");
// create a script delegate
// engine.Execute(@"
// Filter = lib.System.Func(lib.System.Int32, lib.System.Boolean);
// oddFilter = new Filter(function(value) {
// return (value & 1) ? true : false;
// });
//");
// use LINQ from script
// engine.Execute(@"
// oddNumbers = numbers.Where(oddFilter);
// Console.WriteLine(lib.System.String.Join(', ', oddNumbers));
//");
// use a dynamic host object
// engine.Execute(@"
// expando = new lib.System.Dynamic.ExpandoObject();
// expando.foo = 123;
// expando.bar = 'qux';
// delete expando.foo;
//");
// call a script function
//engine.Execute("function print(x) { Console.WriteLine(x); }");
//engine.Script.print(DateTime.Now.DayOfWeek);
// examine a script object
//engine.Execute("person = { name: 'Fred', age: 5 }");
//Console.WriteLine(engine.Script.person.name);
// read a JavaScript typed array
//engine.Execute("values = new Int32Array([1, 2, 3, 4, 5])");
//var values = (ITypedArray<int>)engine.Script.values;
//Console.WriteLine(string.Join(", ", values.ToArray()));
var Proxy = new ScriptProxy();
Proxy.系统.Img = () =>
{
CaptureImage screen = FlaUI.Core.Capturing.Capture.Screen(engine.Script.屏幕());
return((Bitmap)screen.Bitmap.Clone());
};
engine.AddHostObject("代理", Proxy);
engine.Execute(code);
}
}
public void PropertyBag_MultiEngine_HostFunctions()
{
using (var scriptEngine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDebugging))
{
const string code = "bag.host.func(0, function () { return bag.func(); })";
var bag = new PropertyBag
{
{ "host", new HostFunctions() },
{ "func", new Func<object>(() => ScriptEngine.Current) }
};
engine.AddHostObject("bag", bag);
scriptEngine.AddHostObject("bag", bag);
var func = (Func<object>)engine.Evaluate(code);
Assert.AreSame(engine, func());
func = (Func<object>)scriptEngine.Evaluate(code);
Assert.AreSame(scriptEngine, func());
}
}
static void initJsEngine(V8ScriptEngine eng)
{
eng.AddHostObject("log", cs_log);
eng.AddHostObject("fileReadAllText", cs_fileReadAllText);
eng.AddHostObject("fileWriteAllText", cs_fileWriteAllText);
eng.AddHostObject("fileWriteLine", cs_fileWriteLine);
eng.AddHostObject("TimeNow", cs_TimeNow);
eng.AddHostObject("setShareData", cs_setShareData);
eng.AddHostObject("getShareData", cs_getShareData);
eng.AddHostObject("removeShareData", cs_removeShareData);
eng.AddHostObject("request", cs_request);
eng.AddHostObject("setTimeout", cs_setTimeout);
eng.AddHostObject("mkdir", cs_mkdir);
eng.AddHostObject("getWorkingPath", cs_getWorkingPath);
eng.AddHostObject("addBeforeActListener", cs_addBeforeActListener);
eng.AddHostObject("removeBeforeActListener", cs_removeBeforeActListener);
eng.AddHostObject("addAfterActListener", cs_addAfterActListener);
eng.AddHostObject("removeAfterActListener", cs_removeAfterActListener);
eng.AddHostObject("setCommandDescribe", cs_setCommandDescribe);
eng.AddHostObject("runcmd", cs_runcmd);
eng.AddHostObject("logout", cs_logout);
eng.AddHostObject("getOnLinePlayers", cs_getOnLinePlayers);
eng.AddHostObject("getStructure", cs_getStructure);
eng.AddHostObject("setStructure", cs_setStructure);
eng.AddHostObject("reNameByUuid", cs_reNameByUuid);
eng.AddHostObject("getPlayerAbilities", cs_getPlayerAbilities);
eng.AddHostObject("setPlayerAbilities", cs_setPlayerAbilities);
eng.AddHostObject("getPlayerAttributes", cs_getPlayerAttributes);
eng.AddHostObject("setPlayerTempAttributes", cs_setPlayerTempAttributes);
eng.AddHostObject("getPlayerMaxAttributes", cs_getPlayerMaxAttributes);
eng.AddHostObject("setPlayerMaxAttributes", cs_setPlayerMaxAttributes);
eng.AddHostObject("getPlayerItems", cs_getPlayerItems);
eng.AddHostObject("getPlayerSelectedItem", cs_getPlayerSelectedItem);
eng.AddHostObject("setPlayerItems", cs_setPlayerItems);
eng.AddHostObject("addPlayerItemEx", cs_addPlayerItemEx);
eng.AddHostObject("addPlayerItem", cs_addPlayerItem);
eng.AddHostObject("getPlayerEffects", cs_getPlayerEffects);
eng.AddHostObject("setPlayerEffects", cs_setPlayerEffects);
eng.AddHostObject("setPlayerBossBar", cs_setPlayerBossBar);
eng.AddHostObject("removePlayerBossBar", cs_removePlayerBossBar);
eng.AddHostObject("selectPlayer", cs_selectPlayer);
eng.AddHostObject("transferserver", cs_transferserver);
eng.AddHostObject("teleport", cs_teleport);
eng.AddHostObject("talkAs", cs_talkAs);
eng.AddHostObject("runcmdAs", cs_runcmdAs);
eng.AddHostObject("sendSimpleForm", cs_sendSimpleForm);
eng.AddHostObject("sendModalForm", cs_sendModalForm);
eng.AddHostObject("sendCustomForm", cs_sendCustomForm);
eng.AddHostObject("releaseForm", cs_releaseForm);
eng.AddHostObject("setPlayerSidebar", cs_setPlayerSidebar);
eng.AddHostObject("removePlayerSidebar", cs_removePlayerSidebar);
eng.AddHostObject("getPlayerPermissionAndGametype", cs_getPlayerPermissionAndGametype);
eng.AddHostObject("setPlayerPermissionAndGametype", cs_setPlayerPermissionAndGametype);
eng.AddHostObject("disconnectClient", cs_disconnectClient);
}
public V8EngineSession()
{
logFilePath = Path.Combine(Path.GetTempPath(), "V8Enginelog.log");
m_currentScriptName = GetRandomScriptTargetName();
var debuggingPort = PortUtilities.FindFreePort(IPAddress.Loopback);
m_scriptEngine = new V8ScriptEngine(V8ScriptEngineFlags.DisableGlobalMembers | V8ScriptEngineFlags.EnableDebugging, debuggingPort)
{
AllowReflection = false,
};
m_scriptEngine.AddHostObject("host", new HostFunctions());
m_scriptEngine.AddHostObject("lib", new HostTypeCollection("mscorlib", "System.Core"));
m_scriptEngine.AddHostObject("winform", new HostTypeCollection("System.Windows.Forms"));
portUri = new Uri("tcp://127.0.0.1:"+debuggingPort);
m_tcpClient = new TcpClient(portUri.Host, portUri.Port);
Connect();
}
/// <summary>
/// configura o Helper para posterior execuçao
/// </summary>
/// <param name="diretorioJavascripts">Diretório onde estão os arquivos em js</param>
/// <param name="setTimeout">Habilitar a função global setTimeout</param>
/// <param name="setInterval">Habilitar a função global setInterval</param>
private void Carregar(string diretorioJavascripts, bool setTimeout, bool setInterval)
{
TimedOuts = new List<IDisposable>();
_diretorioExecucao = diretorioJavascripts;
_timeoutTestes = int.MaxValue;
ExecutouTestesAteFinal = false;
SetTimeOutLigado = setTimeout;
//O manager vai compilar e cachear as bibliotecas
_manager = new RuntimeManager(new ManualManagerSettings() { MaxExecutableBytes = (1000000000 * 2), RuntimeMaxCount = int.MaxValue});
_engine = _manager.GetEngine();
//RequireManager.ClearPackages(); //garantir uma execução limpa
#region Ler arquivos Js
_cacheCodigos = new Dictionary<string, string>();
foreach (var enumerateFile in Directory.EnumerateFiles(diretorioJavascripts, "*.js"))
{
_cacheCodigos.Add(Path.GetFileNameWithoutExtension(enumerateFile), File.ReadAllText(enumerateFile));
//_manager.Compile(Path.GetFileNameWithoutExtension(enumerateFile), File.ReadAllText(enumerateFile), true, int.MaxValue);
}
#endregion
#region Configura a Engine com o JavascriptHelper e Console, Settimeout e etc
FalhasDosTestes = new List<string>();
_timers = new Dictionary<int, bool>();
_engine.AddHostObject("javascriptHelper", this);
_engine.Execute(@"'use strict';
function console() {
if (!(this instanceof console)) {
return new Console();
}
}
console.prototype.log = function(args, args1, args2) {
javascriptHelper.Escrever(args, args1, args2);
};");
_engine.Execute("var console = new console();");
_engine.Execute("var GLOBAL = this;");
_engine.Execute(@"var stFunctionsCallBack = new Array();");
if (setTimeout)
{
_engine.Execute(@"var setTimeout = function (funcToCall, millis) {
var textoId = javascriptHelper.CurrentThreadId;
var idlocal = javascriptHelper.SetTimeout(millis);
stFunctionsCallBack.push(funcToCall);
return idlocal;
};");
_engine.Execute(@"var clearTimeout = function(id) { javascriptHelper.ClearTimeout(id);};");
}
if (setInterval)
{
_engine.Execute(@"var setInterval = function (funcToCall, millis) {
var idlocal = javascriptHelper.SetTimeout(millis);
var funcaoTimeout = function() { funcToCall(); setTimeout(funcToCall, millis); };
stFunctionsCallBack.push(funcaoTimeout);
return idlocal;
};");
_engine.Execute(@"var clearInterval = function(id) { javascriptHelper.ClearTimeout(id);};");
}
#endregion
}
public void V8ScriptEngine_General_Precompiled_Dual()
{
engine.Dispose();
using (var runtime = new V8Runtime())
{
using (var script = runtime.Compile(generalScript))
{
engine = runtime.CreateScriptEngine();
using (var console = new StringWriter())
{
var clr = new HostTypeCollection(type => type != typeof(Console), "mscorlib", "System", "System.Core");
clr.GetNamespaceNode("System").SetPropertyNoCheck("Console", console);
engine.AddHostObject("host", new ExtendedHostFunctions());
engine.AddHostObject("clr", clr);
engine.Evaluate(script);
Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));
console.GetStringBuilder().Clear();
Assert.AreEqual(string.Empty, console.ToString());
engine.Evaluate(script);
Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));
}
engine.Dispose();
engine = runtime.CreateScriptEngine();
using (var console = new StringWriter())
{
var clr = new HostTypeCollection(type => type != typeof(Console), "mscorlib", "System", "System.Core");
clr.GetNamespaceNode("System").SetPropertyNoCheck("Console", console);
engine.AddHostObject("host", new ExtendedHostFunctions());
engine.AddHostObject("clr", clr);
engine.Evaluate(script);
Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));
console.GetStringBuilder().Clear();
Assert.AreEqual(string.Empty, console.ToString());
engine.Evaluate(script);
Assert.AreEqual(MiscHelpers.FormatCode(generalScriptOutput), console.ToString().Replace("\r\n", "\n"));
}
}
}
}
public void V8ScriptEngine_ErrorHandling_NestedHostException()
{
var innerEngine = new V8ScriptEngine("inner", V8ScriptEngineFlags.EnableDebugging);
innerEngine.AddHostObject("host", new HostFunctions());
engine.AddHostObject("engine", innerEngine);
TestUtil.AssertException<ScriptEngineException>(() =>
{
try
{
engine.Execute("engine.Evaluate('host.newObj(0)')");
}
catch (ScriptEngineException exception)
{
TestUtil.AssertValidException(engine, exception);
Assert.IsNotNull(exception.InnerException);
var hostException = exception.InnerException;
Assert.IsInstanceOfType(hostException, typeof(TargetInvocationException));
TestUtil.AssertValidException(hostException);
Assert.IsNotNull(hostException.InnerException);
var nestedException = hostException.InnerException as ScriptEngineException;
Assert.IsNotNull(nestedException);
TestUtil.AssertValidException(innerEngine, nestedException);
Assert.IsNotNull(nestedException.InnerException);
var nestedHostException = nestedException.InnerException;
Assert.IsInstanceOfType(nestedHostException, typeof(RuntimeBinderException));
TestUtil.AssertValidException(nestedHostException);
Assert.IsNull(nestedHostException.InnerException);
Assert.AreEqual("Error: " + nestedHostException.Message, nestedException.Message);
Assert.AreEqual("Error: " + hostException.Message, exception.Message);
throw;
}
});
}
private async Task Navigate(Uri uri)
{
controlsGrid.IsEnabled = false;
try
{
string url = uri.ToString();
urlBar.Text = url;
if (engine != null)
{
engine.Interrupt();
engine.Dispose();
}
engine = new V8ScriptEngine();
engine.AddHostObject("window", this);
engine.AddHostType(typeof(MessageBox));
engine.AddHostType(typeof(Console));
foreach (var t in availableTypesLazy.Value)
{
engine.AddHostType(t);
}
ParserContext parserContext = new ParserContext();
parserContext.XmlnsDictionary["s"] = "clr-namespace:DynamicWPF.Scripting;assembly=DynamicWPF";
try
{
var resp = await client.GetAsync(uri);
uri = resp.RequestMessage.RequestUri;
url = uri.ToString();
urlBar.Text = url;
parserContext.BaseUri = new Uri(url.Remove(url.LastIndexOf('/') + 1));
Page obj = null;
if (resp.IsSuccessStatusCode)
{
try
{
obj = (Page)XamlReader.Load(await resp.Content.ReadAsStreamAsync(), parserContext);
}
catch
{
Process.Start(url);
}
}
else
{
try
{
obj = (Page)XamlReader.Load(await resp.Content.ReadAsStreamAsync(), parserContext);
}
catch
{
resp.EnsureSuccessStatusCode();
}
}
if (obj != null)
{
contentFrame.Navigate(obj);
foreach (var link in (obj.Content as DependencyObject).FindVisualChildren <Hyperlink>())
{
link.RequestNavigate += async(o, ev) =>
{
ev.Handled = true;
var u = (o as Hyperlink).NavigateUri;
await Navigate(u.IsAbsoluteUri?u : new Uri(parserContext.BaseUri, u));
};
}
engine.AddHostObject("content", obj);
foreach (var s in ScriptManager.GetScripts(obj))
{
try
{
var str = await client.GetStringAsync(s.Source.IsAbsoluteUri?s.Source : new Uri(parserContext.BaseUri, s.Source));
engine.Execute(str);
}
catch { }
}
}
}
catch (Exception ex)
{
contentFrame.Navigate(new ErrorPage(ex));
}
}
finally
{
controlsGrid.IsEnabled = true;
}
}
public void AddHostObject(string itemName, object target)
{
v8ScriptEngine?.AddHostObject(itemName, target);
}
static void Main(string[] args)
{
// create a script engine
using (var engine = new V8ScriptEngine())
{
// expose a host type
engine.AddHostType("Console", typeof(Console));
engine.Execute("Console.WriteLine('{0} is an interesting number.', Math.PI)");
// expose a host object
engine.AddHostObject("random", new Random());
engine.Execute("Console.WriteLine(random.NextDouble())");
// expose entire assemblies
engine.AddHostObject("lib", new HostTypeCollection("mscorlib", "System.Core"));
engine.Execute("Console.WriteLine(lib.System.DateTime.Now)");
// create a host object from script
engine.Execute(@"
birthday = new lib.System.DateTime(2007, 5, 22);
Console.WriteLine(birthday.ToLongDateString());
");
// use a generic class from script
engine.Execute(@"
Dictionary = lib.System.Collections.Generic.Dictionary;
dict = new Dictionary(lib.System.String, lib.System.Int32);
dict.Add('foo', 123);
");
// call a host method with an output parameter
engine.AddHostObject("host", new HostFunctions());
engine.Execute(@"
intVar = host.newVar(lib.System.Int32);
found = dict.TryGetValue('foo', intVar.out);
Console.WriteLine('{0} {1}', found, intVar);
");
// create and populate a host array
engine.Execute(@"
numbers = host.newArr(lib.System.Int32, 20);
for (var i = 0; i < numbers.Length; i++) { numbers[i] = i; }
Console.WriteLine(lib.System.String.Join(', ', numbers));
");
// create a script delegate
engine.Execute(@"
Filter = lib.System.Func(lib.System.Int32, lib.System.Boolean);
oddFilter = new Filter(function(value) {
return (value & 1) ? true : false;
});
");
// use LINQ from script
engine.Execute(@"
oddNumbers = numbers.Where(oddFilter);
Console.WriteLine(lib.System.String.Join(', ', oddNumbers));
");
// use a dynamic host object
engine.Execute(@"
expando = new lib.System.Dynamic.ExpandoObject();
expando.foo = 123;
expando.bar = 'qux';
delete expando.foo;
");
// call a script function
engine.Execute("function print(x) { Console.WriteLine(x); }");
engine.Script.print(DateTime.Now.DayOfWeek);
// examine a script object
engine.Execute("person = { name: 'Fred', age: 5 }");
Console.WriteLine(engine.Script.person.name);
// read a JavaScript typed array
engine.Execute("values = new Int32Array([1, 2, 3, 4, 5])");
var values = (ITypedArray <int>)engine.Script.values;
Console.WriteLine(string.Join(", ", values.ToArray()));
}
}
private JsScriptRunner(JsScriptRunnerType type, object scriptingContext = null, string contextName = null)
{
if (!(scriptingContext is null) && contextName is null)
{
throw new ArgumentNullException(nameof(contextName));
}
ScriptingContext = scriptingContext;
Type = type;
switch (type)
{
case JsScriptRunnerType.Jint:
{
// engine settings:
// strict mode https://stackoverflow.com/a/34302448 https://stackoverflow.com/questions/34301881/should-i-use-strict-for-every-single-javascript-function-i-write
JintEngine = new Engine(cfg => cfg.Strict(true));
//JintEngine = new Engine();
if (!(scriptingContext is null))
{
JintEngine.SetValue(contextName, scriptingContext); // pass 'scriptingConnector' to Js
}
break;
}
case JsScriptRunnerType.ClearScript:
{
//ClearScriptEngine = new V8ScriptEngine();
//ClearScriptEngine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDateTimeConversion);
ClearScriptEngine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDateTimeConversion | V8ScriptEngineFlags.DisableGlobalMembers);
ClearScriptEngine.AllowReflection = false;
//ClearScriptEngine.DefaultAccess = Microsoft.ClearScript.ScriptAccess.Full;
//ClearScriptEngine.DefaultAccess = Microsoft.ClearScript.ScriptAccess.None;
if (!(scriptingContext is null))
{
ClearScriptEngine.AddHostObject(contextName, scriptingContext); // pass 'scriptingConnector' to Js
}
break;
}
case JsScriptRunnerType.ClearScriptDebugMode:
{
ClearScriptEngine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDateTimeConversion
| V8ScriptEngineFlags.DisableGlobalMembers
| V8ScriptEngineFlags.EnableDebugging
| V8ScriptEngineFlags.AwaitDebuggerAndPauseOnStart);
/* ClearScriptEngine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDateTimeConversion
| V8ScriptEngineFlags.DisableGlobalMembers
| V8ScriptEngineFlags.EnableDebugging
| V8ScriptEngineFlags.EnableRemoteDebugging
| V8ScriptEngineFlags.AwaitDebuggerAndPauseOnStart);*/
ClearScriptEngine.AllowReflection = false;
if (!(scriptingContext is null))
{
ClearScriptEngine.AddHostObject(contextName, scriptingContext); // pass 'scriptingConnector' to Js
}
break;
}
}
}
public void Execute(Script script)
{
script.SetExecutionEnvironment(this);
_engine.AddHostObject("script", script);
_engine.AddHostObject("world", ActiveWorld.Active.World);
_engine.AddHostObject("sky", ActiveWorld.Active.Sky);
_engine.AddHostObject("camera", ActiveWorld.Active.Camera);
_engine.Script.print = new Action <Object>(print);
_engine.Script.spawn = new Action <Object>(spawn);
_engine.Script.delay = new Action <Object, double>(delay);
_engine.Script.loop = new Action <Object, double>(loop);
_engine.Script.forLoop = new Action <Object, int, double>(forLoop);
_engine.Script.onRenderStep = new Action <Object>(onRenderStep);
_engine.Script.onStep = new Action <Object>(onStep);
_engine.Script.onKeyPress = new Action <int, Object>(onKeyPress);
_engine.Script.onKeyDown = new Action <int, Object>(onKeyDown);
_engine.Script.onKeyUp = new Action <int, Object>(onKeyUp);
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(Math));
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(Noise));
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(Random));
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(Key));
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(Camera));
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(Part));
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(Script));
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(Sky));
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(World));
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(Vector3));
_engine.AddHostType(HostItemFlags.DirectAccess, typeof(Rotation));
//Allow for reflection on Instance types to access higher concrete implementation properties
_engine.DisableTypeRestriction = true;
_engine.AllowReflection = true;
_engine.SuppressExtensionMethodEnumeration = false;
_engine.UseReflectionBindFallback = true;
_engine.DefaultAccess = ScriptAccess.None;
try
{
V8Script v8Script = _engine.Compile((script.source != null) ? script.source : String.Empty);
_engine.Execute(v8Script);
}
catch (ScriptEngineException e)
{
String errorDetails = e.ErrorDetails;
Match errDetailsMatch = Regex.Match(errorDetails, @"'(?<type>Flex\..*)'");
if (errDetailsMatch.Success)
{
Match match = Regex.Match(errorDetails, @"'Flex\..*.\.(?<class>.+)'");
if (match.Success)
{
errorDetails = errorDetails.Replace(errDetailsMatch.Groups["type"].Value, match.Groups["class"].Value);
}
}
_output.AppendLine(errorDetails);
}
catch (Exception e)
{
_output.AppendLine("[external error] " + e.Message);
}
}
/// <summary>
/// Add a .Net host object with a given name to the globel namespace of the JS processor.
/// The object is removed (JS delete) from the engine when it is disposed of.
/// </summary>
/// <param name="globalname">the name of the host object in the JS global namespace</param>
/// <param name="service">the .Net host object to be used as a service</param>
public void AddHostService(string globalname, object service)
{
engine.AddHostObject(globalname, service);
services.Add(globalname);
}
public ServerTester(Server server)
{
this.server = server;
engine = new V8ScriptEngine();
engine.AddHostObject("Server", server);
}
