Added ability for direct evaluation

Author: FlorianRappl

src/AngleSharp.Scripting.JavaScript/AngleSharp.Scripting.JavaScript.csproj

@@ -50,6 +50,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ApiExtensions.cs" />
     <Compile Include="Attributes\DomInstanceAttribute.cs" />
     <Compile Include="JsConfigurationExtensions.cs" />
     <Compile Include="ConsoleInstance.cs" />

src/AngleSharp.Scripting.JavaScript/ApiExtensions.cs

@@ -0,0 +1,31 @@
+namespace AngleSharp.Scripting.JavaScript
+{
+    using AngleSharp.Dom;
+    using AngleSharp.Scripting.JavaScript.Services;
+    using System;
+    using System.Linq;
+
+    /// <summary>
+    /// Useful extensions for the DOM.
+    /// </summary>
+    public static class ApiExtensions
+    {
+        /// <summary>
+        /// Executes the given script code in the context of the provided node.
+        /// </summary>
+        /// <param name="node">The node acting as context.</param>
+        /// <param name="scriptCode">The script to run.</param>
+        /// <returns>The result of running the script, if any.</returns>
+        public static Object Execute(this INode node, String scriptCode)
+        {
+            if (node == null)
+                throw new ArgumentNullException(nameof(node));
+
+            var document = node.Owner;
+            var options = document?.Context.Configuration;
+            var providers = options?.Services.OfType<JavaScriptProvider>();
+            var engine = providers?.FirstOrDefault()?.Engine;
+            return engine?.EvaluateScript(node, scriptCode);
+        }
+    }
+}

src/AngleSharp.Scripting.JavaScript/EngineInstance.cs

@@ -2,17 +2,19 @@
 {
     using AngleSharp.Dom;
     using Jint;
+    using Jint.Native;
     using Jint.Runtime.Environments;
     using Services;
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Runtime.CompilerServices;
 
     sealed class EngineInstance
     {
         #region Fields
 
-        private readonly Dictionary<Object, DomNodeInstance> _objects;
+        private readonly ConditionalWeakTable<Object, DomNodeInstance> _objects;
         private readonly Engine _engine;
         private readonly LexicalEnvironment _lexicals;
         private readonly LexicalEnvironment _variables;
@@ -34,7 +36,7 @@ public EngineInstance(IWindow window, IDictionary<String, Object> assignments)
                 logger = createLogger.Invoke(context);
             }
 
-            _objects = new Dictionary<Object, DomNodeInstance>();
+            _objects = new ConditionalWeakTable<Object, DomNodeInstance>();
             _engine = new Engine();
             _engine.SetValue("console", new ConsoleInstance(_engine, logger));
 
@@ -99,11 +101,12 @@ public DomNodeInstance GetDomNode(Object obj)
             return domNodeInstance;
         }
 
-        public void RunScript(String source)
+        public Object RunScript(String source, JsValue context)
         {
-            _engine.EnterExecutionContext(Lexicals, Variables, _window);
+            _engine.EnterExecutionContext(Lexicals, Variables, context);
             _engine.Execute(source);
             _engine.LeaveExecutionContext();
+            return _engine.GetCompletionValue().FromJsValue();
         }
 
         #endregion

src/AngleSharp.Scripting.JavaScript/Extensions.cs

@@ -55,6 +55,16 @@ public static JsValue ToJsValue(this Object obj, EngineInstance engine)
             return JsValue.Null;
         }
 
+        public static Object RunScript(this EngineInstance engine, String source)
+        {
+            return engine.RunScript(source, engine.Window);
+        }
+
+        public static Object RunScript(this EngineInstance engine, String source, INode context)
+        {
+            return engine.RunScript(source, context.ToJsValue(engine));
+        }
+
         public static ClrFunctionInstance AsValue(this Engine engine, Func<JsValue, JsValue[], JsValue> func)
         {
             return new ClrFunctionInstance(engine, func);

src/AngleSharp.Scripting.JavaScript/JavaScriptEngine.cs

@@ -84,6 +84,26 @@ public async Task EvaluateScriptAsync(IResponse response, ScriptOptions options,
             }
         }
 
+        /// <summary>
+        /// Evaluates the given script source in the provided context.
+        /// </summary>
+        /// <param name="context">The context of the evaluation.</param>
+        /// <param name="source">The source of the script.</param>
+        /// <returns>The result of the evaluation.</returns>
+        public Object EvaluateScript(INode context, String source)
+        {
+            if (context == null)
+                throw new ArgumentNullException(nameof(context));
+
+            var document = context.Owner;
+
+            if (document == null)
+                throw new ArgumentException("The context has to be attached to a document.");
+
+            var instance = GetOrCreateInstance(document);
+            return instance.RunScript(source, context);
+        }
+
         #endregion
 
         #region Helpers