Updated per ClearScript to obsolete an obsoleted property and updated XML documentation in a few places to make more descriptive.

Author: eswann

README.md

@@ -30,6 +30,7 @@ Along those lines, ClearScript.Manager does the following to make certain things
 	- Allow easy management of the memory usage of each instance of the V8 Runtime and sets the limits to a much lower threshold than the default V8 settings. 
 
 ## Configuration Parameters
+These settings can be set manually or added to the AppSettings of your application config file.
 
     //V8 Max Executable Size in bytes:  
     int MaxExecutableBytes { get; }
@@ -42,13 +43,13 @@ Along those lines, ClearScript.Manager does the following to make certain things
         
 	//Default script timeout in ms:
 	int ScriptTimeoutMilliSeconds { get; }  
+    
+    //Max number of simultaneous V8 Runtimes:  
+    int RuntimeMaxCount { get; }
+    
+    //Per Runtime, the maximum number of cached scripts:  
+    int ScriptCacheMaxCount { get; }
 
-	//Max number of simultaneous V8 Runtimes:  
-	int RuntimeMaxCount { get; }
-        
-	//Per Runtime, the maximum number of cached scripts:  
-	int ScriptCacheMaxCount { get; }
-        
 	//The default script cache expiration in seconds:  
 	int ScriptCacheExpirationSeconds { get; }
 

src/ClearScript.Manager.Test/WhenExecutingBasicJavaScript.cs

@@ -1,5 +1,6 @@
 using Microsoft.ClearScript;
 using NUnit.Framework;
+using Should;
 
 namespace ClearScript.Manager.Test
 {

src/ClearScript.Manager/HostObject.cs

@@ -2,12 +2,25 @@
 
 namespace ClearScript.Manager
 {
+    /// <summary>
+    /// A specific object instance to inject into the javascript to execute.
+    /// </summary>
     public class HostObject
     {
+        /// <summary>
+        /// Name of the object used to access the object in the JavaScript.
+        /// </summary>
         public string Name { get; set; }
 
+        /// <summary>
+        /// HostItemFlags to apply to the HostType.  Limits the scope of the type and which type members are available.
+        /// See ClearScript documentation for more information.
+        /// </summary>
         public HostItemFlags Flags { get; set; }
 
+        /// <summary>
+        /// The target object to inject into the JavaScript.
+        /// </summary>
         public object Target { get; set; }
     }
 }

src/ClearScript.Manager/HostType.cs

@@ -3,14 +3,32 @@
 
 namespace ClearScript.Manager
 {
+    /// <summary>
+    /// A type to make available in JavaScript.
+    /// </summary>
     public class HostType
     {
+        /// <summary>
+        /// Name of the type that is used to reference the type within the JavaScript.
+        /// </summary>
         public string Name { get; set; }
 
+        /// <summary>
+        /// HostItemFlags to apply to the HostType.  Limits the scope of the type and which type members are available.
+        /// See ClearScript documentation for more information.
+        /// </summary>
         public HostItemFlags Flags { get; set; }
 
+        /// <summary>
+        /// Host type collections provide convenient scriptable access to all the types defined in one or more host assemblies. 
+        /// They are hierarchical collections where leaf nodes represent types and parent nodes represent namespaces. 
+        /// See ClearScript documentation for more information.
+        /// </summary>
         public HostTypeCollection HostTypeCollection { get; set; }
 
+        /// <summary>
+        /// An individual type to make available to the script.
+        /// </summary>
         public Type Type { get; set; }
     }
 }

src/ClearScript.Manager/ManagerPool.cs

@@ -3,22 +3,48 @@
 
 namespace ClearScript.Manager
 {
+    /// <summary>
+    /// Defines a pool from which Runtime Managers are requested.
+    /// </summary>
     public interface IManagerPool
     {
+        /// <summary>
+        /// Gets a runtime from the pool.  Blocks until a manager becomes available.
+        /// </summary>
+        /// <returns>The next available IRuntimeManager.</returns>
         IRuntimeManager GetRuntime();
+
+        /// <summary>
+        /// Returns a Runtime Manager to the pool.
+        /// </summary>
+        /// <param name="runtimeManager">The Runtime Manager to return to the pool.</param>
         void ReturnToPool(IRuntimeManager runtimeManager);
     }
 
+    /// <summary>
+    /// Defines a pool from which Runtime Managers are requested.
+    /// </summary>
     public class ManagerPool : IManagerPool
     {
+        /// <summary>
+        /// Static reference to the current pool of Runtime Managers.
+        /// </summary>
         public static IManagerPool CurrentPool;
 
         private readonly object _addLock = new object();
+
+        /// <summary>
+        /// Current count of Runtimes within the pool.
+        /// </summary>
         public int RuntimeCurrentCount = 0;
 
         private readonly BlockingCollection<IRuntimeManager> _availableRuntimes = new BlockingCollection<IRuntimeManager>();
         private readonly IManagerSettings _settings;
 
+        /// <summary>
+        /// Creates a new Runtime Manager Pool.
+        /// </summary>
+        /// <param name="settings">Settings to apply to the Runtime Manager.</param>
         public ManagerPool(IManagerSettings settings)
         {
             if(settings == null)
@@ -27,6 +53,10 @@ public ManagerPool(IManagerSettings settings)
             _settings = settings;
         }
 
+        /// <summary>
+        /// Initializes the CurrentPool with the provided settings.  
+        /// </summary>
+        /// <param name="settings">Settings to apply.</param>
         public static void InitializeCurrentPool(IManagerSettings settings)
         {
             CurrentPool = new ManagerPool(settings);

src/ClearScript.Manager/ManagerScope.cs

@@ -2,17 +2,29 @@
 
 namespace ClearScript.Manager
 {
+    /// <summary>
+    /// Scope in which a Runtime Manager is requested from the pool and returned upon completion.
+    /// </summary>
     public class ManagerScope : IDisposable
     {
         private bool _disposed;
 
+        /// <summary>
+        /// Creates a new ManagerScope and requests a RuntimeManager.
+        /// </summary>
         public ManagerScope()
         {
             RuntimeManager = ManagerPool.CurrentPool.GetRuntime();
         }
 
+        /// <summary>
+        /// Allows access to the allocated Runtime Manager from within this scope.
+        /// </summary>
         public IRuntimeManager RuntimeManager { get; private set; }
 
+        /// <summary>
+        /// Disposed the object and returns the Runtime Manager to the pool.
+        /// </summary>
         public void Dispose()
         {
             if (!_disposed)

src/ClearScript.Manager/ManagerSettings.cs

@@ -1,17 +1,27 @@
-using System.Configuration;
+using System;
+using System.Configuration;
 
 namespace ClearScript.Manager
 {
+    /// <summary>
+    /// Settings to apply to the RuntimeManager and to created runtimes.
+    /// </summary>
     public interface IManagerSettings
     {
         /// <summary>
         /// V8 Max Executable Size in bytes.
         /// </summary>
         int MaxExecutableBytes { get; }
 
+        /// <summary>
+        /// V8 Max New Space in bytes.
+        /// </summary>
+        int MaxNewSpaceBytes { get; }
+
         /// <summary>
         /// V8 Max Young Space in bytes.
         /// </summary>
+        [Obsolete("Use MaxNewSpaceBytes instead.")]
         int MaxYoungSpaceBytes { get; }
 
         /// <summary>
@@ -40,24 +50,57 @@ public interface IManagerSettings
         int ScriptCacheExpirationSeconds { get; }
     }
 
+    /// <summary>
+    /// Settings to apply to the RuntimeManager and to created runtimes.
+    /// </summary>
     public class ManagerSettings : IManagerSettings
     {
+        /// <summary>
+        /// Default MaxExecutableBytes if not present in settings.
+        /// </summary>
         public const int DefaultMaxExecutableBytes = 8 * 1024 * 1024;
-        public const int DefaultMaxYoungSpaceBytes = 16 * 1024 * 1024;
+        /// <summary>
+        /// Default MaxNewSpaceBytes if not present in settings.
+        /// </summary>
+        public const int DefaultMaxNewSpaceBytes = 16 * 1024 * 1024;
+        /// <summary>
+        /// Default tMaxOldSpaceBytes if not present in settings.
+        /// </summary>
         public const int DefaultMaxOldSpaceBytes = 16 * 1024 * 1024;
+        /// <summary>
+        /// Default ScriptTimeoutMilliSeconds if not present in settings.
+        /// </summary>
         public const int DefaultScriptTimeoutMilliSeconds = 60000;
+        /// <summary>
+        /// Default RuntimeMaxCount if not present in settings.
+        /// </summary>
         public const int DefaultRuntimeMaxCount = 8;
+        /// <summary>
+        /// Default ScriptCacheMaxCount if not present in settings.
+        /// </summary>
         public const int DefaultScriptCacheMaxCount = 1000;
+        /// <summary>
+        /// Default ScriptCacheExpirationSeconds if not present in settings.
+        /// </summary>
         public const int DefaultScriptCacheExpirationSeconds = 600;
 
         public int MaxExecutableBytes
         {
             get { return SettingToInt("MaxExecutableBytes", DefaultMaxExecutableBytes); }
         }
 
+        public int MaxNewSpaceBytes
+        {
+            get
+            {
+                return SettingToInt("MaxNewSpaceBytes", SettingToInt("MaxYoungSpaceBytes", DefaultMaxNewSpaceBytes));
+            }
+        }
+
+        [Obsolete("Use MaxNewSpaceBytes instead.")]
         public int MaxYoungSpaceBytes
         {
-            get { return SettingToInt("MaxYoungSpaceBytes", DefaultMaxYoungSpaceBytes); }
+            get { return MaxNewSpaceBytes; }
         }
 
         public int MaxOldSpaceBytes
@@ -86,6 +129,12 @@ public int ScriptCacheExpirationSeconds
         }
 
 
+        /// <summary>
+        /// Parses the setting and converts it to an int or sets the default value if the setting is not present.
+        /// </summary>
+        /// <param name="settingName">Name of the setting to check.</param>
+        /// <param name="defaultValue">Default value if setting is not present.</param>
+        /// <returns>Setting or default value.</returns>
         public static int SettingToInt(string settingName, int defaultValue)
         {
             int? setting = null;
@@ -107,11 +156,14 @@ public static int SettingToInt(string settingName, int defaultValue)
     /// </summary>
     public class ManualManagerSettings : IManagerSettings
     {
+        /// <summary>
+        /// Creates a ManualManagerSettings.
+        /// </summary>
         public ManualManagerSettings()
         {
             MaxExecutableBytes = ManagerSettings.DefaultMaxExecutableBytes;
-            MaxYoungSpaceBytes = ManagerSettings.DefaultMaxOldSpaceBytes;
-            MaxOldSpaceBytes = ManagerSettings.DefaultMaxYoungSpaceBytes;
+            MaxNewSpaceBytes = ManagerSettings.DefaultMaxOldSpaceBytes;
+            MaxOldSpaceBytes = ManagerSettings.DefaultMaxNewSpaceBytes;
             ScriptTimeoutMilliSeconds = ManagerSettings.DefaultScriptTimeoutMilliSeconds;
             RuntimeMaxCount = ManagerSettings.DefaultRuntimeMaxCount;
             ScriptCacheMaxCount = ManagerSettings.DefaultScriptCacheMaxCount;
@@ -120,7 +172,14 @@ public ManualManagerSettings()
 
         public int MaxExecutableBytes { get; set; }
 
-        public int MaxYoungSpaceBytes { get; set; }
+        public int MaxNewSpaceBytes { get; set; }
+
+        [Obsolete("Use MaxNewSpaceBytes instead.")]
+        public int MaxYoungSpaceBytes
+        {
+            get { return MaxNewSpaceBytes; }
+            set { MaxNewSpaceBytes = value; }
+        }
 
         public int MaxOldSpaceBytes { get; set; }