ScriptEngine.AllowReflection, HostTypeCollection filtering, minor updates.

Author: ClearScriptLib

ClearScript/HostFunctions.cs

@@ -60,6 +60,9 @@
 //       
 
 using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Linq;
 using Microsoft.ClearScript.Util;
 
 namespace Microsoft.ClearScript
@@ -224,7 +227,7 @@ public Array newArr<T>(params int[] lengths)
         /// var dict = host.newObj(StringDictT);
         /// dict.Add("foo", "bar");
         /// dict.Add("baz", "qux");
-        /// // look up a dictionary entry */
+        /// // look up a dictionary entry
         /// var result = host.newVar(StringT);
         /// var found = dict.TryGetValue("baz", result.out);
         /// </code>
@@ -360,6 +363,10 @@ public object func<T>(int argCount, object scriptFunc)
         /// <c><see href="http://msdn.microsoft.com/en-us/library/58918ffs(VS.71).aspx">typeof</see></c>
         /// operator. It is overloaded with <see cref="typeOf(object)"/> and selected at runtime if
         /// <typeparamref name="T"/> can be used as a type argument.
+        /// <para>
+        /// This function throws an exception if the script engine's
+        /// <see cref="ScriptEngine.AllowReflection"/> property is set to <c>false</c>.
+        /// </para>
         /// </remarks>
         /// <example>
         /// The following code retrieves the assembly-qualified name of a host type.
@@ -374,6 +381,7 @@ public object func<T>(int argCount, object scriptFunc)
         /// <seealso cref="ExtendedHostFunctions.type(string, object[])"/>
         public Type typeOf<T>()
         {
+            GetEngine().CheckReflection();
             return typeof(T);
         }
 
@@ -389,6 +397,10 @@ public Type typeOf<T>()
         /// operator. It is overloaded with <see cref="typeOf{T}"/> and selected at runtime if
         /// <paramref name="value"/> cannot be used as a type argument. Note that this applies to
         /// some host types; examples are static types and overloaded generic type groups.
+        /// <para>
+        /// This function throws an exception if the script engine's
+        /// <see cref="ScriptEngine.AllowReflection"/> property is set to <c>false</c>.
+        /// </para>
         /// </remarks>
         /// <example>
         /// The following code retrieves the assembly-qualified name of a host type.
@@ -403,6 +415,8 @@ public Type typeOf<T>()
         /// <seealso cref="ExtendedHostFunctions.type(string, object[])"/>
         public Type typeOf(object value)
         {
+            GetEngine().CheckReflection();
+
             var hostType = value as HostType;
             if (hostType == null)
             {
@@ -544,6 +558,51 @@ public bool isTypeObj<T>()
 
         // ReSharper restore UnusedTypeParameter
 
+        /// <summary>
+        /// Creates a strongly typed flag set.
+        /// </summary>
+        /// <typeparam name="T">The type of flag set to create.</typeparam>
+        /// <param name="args">The flags to include in the flag set.</param>
+        /// <returns>A strongly typed flag set containing the specified flags.</returns>
+        /// <remarks>
+        /// This function throws an exception if <typeparamref name="T"/> is not a flag set type.
+        /// </remarks>
+        /// <example>
+        /// The following code demonstrates using a strongly typed flag set.
+        /// It assumes that an instance of <see cref="ExtendedHostFunctions"/> is exposed under
+        /// the name "host"
+        /// (see <see cref="ScriptEngine.AddHostObject(string, object)">AddHostObject</see>).
+        /// <code lang="JavaScript">
+        /// // import URI types
+        /// var UriT = host.type("System.Uri", "System");
+        /// var UriFormatT = host.type("System.UriFormat", "System");
+        /// var UriComponentsT = host.type("System.UriComponents", "System");
+        /// // create a URI
+        /// var uri = host.newObj(UriT, "http://www.example.com:8080/path/to/file/sample.htm?x=1&amp;y=2");
+        /// // extract URI components
+        /// var components = host.flags(UriComponentsT.Scheme, UriComponentsT.Host, UriComponentsT.Path);
+        /// var result = uri.GetComponents(components, UriFormatT.Unescaped);
+        /// </code>
+        /// </example>
+        /// <seealso cref="ExtendedHostFunctions.type(string, string, object[])"/>
+        public T flags<T>(params T[] args)
+        {
+            var type = typeof(T);
+            if (!type.IsFlagsEnum())
+            {
+                throw new InvalidOperationException(MiscHelpers.FormatInvariant("{0} is not a flag set type", type.GetFullFriendlyName()));
+            }
+
+            try
+            {
+                return args.Aggregate(0UL, (flags, arg) => flags | ((IConvertible)arg).ToUInt64(CultureInfo.InvariantCulture)).DynamicCast<T>();
+            }
+            catch (OverflowException)
+            {
+                return args.Aggregate(0L, (flags, arg) => flags | ((IConvertible)arg).ToInt64(CultureInfo.InvariantCulture)).DynamicCast<T>();
+            }
+        }
+
         // ReSharper restore InconsistentNaming
 
         #endregion
@@ -562,6 +621,7 @@ internal ScriptEngine GetEngine()
 
         // ReSharper disable ParameterHidesMember
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member is not expected to be re-implemented in derived classes.")]
         void IScriptableObject.OnExposedToScriptCode(ScriptEngine engine)
         {
             MiscHelpers.VerifyNonNullArgument(engine, "engine");

ClearScript/HostItem.Invoke.cs

@@ -100,12 +100,12 @@ private object InvokeMethod(string name, Type[] typeArgs, object[] args)
                     var extensionBindResult = extensionHostItem.BindMethod(name, typeArgs, extensionArgs);
                     if (extensionBindResult is MethodBindSuccess)
                     {
-                        return extensionBindResult.Invoke();
+                        return extensionBindResult.Invoke(engine);
                     }
                 }
             }
 
-            return bindResult.Invoke();
+            return bindResult.Invoke(engine);
         }
 
         private static IEnumerable<Type> GetTypeArgs(object[] args)
@@ -265,7 +265,7 @@ public static MethodBindResult Create(string name, object rawResult, HostTarget
                 return new MethodBindFailure((rawResult as Exception) ?? new NotSupportedException(MiscHelpers.FormatInvariant("Invocation of method '{0}' failed (unrecognized binding)", name)));
             }
 
-            public abstract object Invoke();
+            public abstract object Invoke(ScriptEngine engine);
         }
 
         #endregion
@@ -274,6 +274,8 @@ public static MethodBindResult Create(string name, object rawResult, HostTarget
 
         private class MethodBindSuccess : MethodBindResult
         {
+            private static readonly MethodInfo getTypeMethod = typeof(object).GetMethod("GetType");
+
             private readonly HostTarget hostTarget;
             private readonly MethodInfo method;
             private readonly object[] args;
@@ -287,8 +289,13 @@ public MethodBindSuccess(HostTarget hostTarget, MethodInfo method, object[] args
 
             #region MethodBindResult overrides
 
-            public override object Invoke()
+            public override object Invoke(ScriptEngine engine)
             {
+                if (method == getTypeMethod)
+                {
+                    engine.CheckReflection();
+                }
+
                 return InvokeHelpers.InvokeMethod(hostTarget.InvokeTarget, method, args);
             }
 
@@ -310,7 +317,7 @@ public MethodBindFailure(Exception exception)
 
             #region MethodBindResult overrides
 
-            public override object Invoke()
+            public override object Invoke(ScriptEngine engine)
             {
                 throw exception;
             }

ClearScript/HostTypeCollection.cs

@@ -82,6 +82,8 @@ namespace Microsoft.ClearScript
     /// </remarks>
     public class HostTypeCollection : PropertyBag
     {
+        private static readonly Predicate<Type> defaultFilter = type => true; 
+
         /// <summary>
         /// Initializes a new host type collection.
         /// </summary>
@@ -102,8 +104,8 @@ public HostTypeCollection(params Assembly[] assemblies)
         }
 
         /// <summary>
-        /// Initializes a new host type collection with types from one or more assemblies. The assemblies
-        /// are specified by name.
+        /// Initializes a new host type collection with types from one or more assemblies. The
+        /// assemblies are specified by name.
         /// </summary>
         /// <param name="assemblyNames">The names of the assemblies that contain the types with which to initialize the collection.</param>
         public HostTypeCollection(params string[] assemblyNames)
@@ -113,6 +115,29 @@ public HostTypeCollection(params string[] assemblyNames)
             Array.ForEach(assemblyNames, AddAssembly);
         }
 
+        /// <summary>
+        /// Initializes a new host type collection with selected types from one or more assemblies.
+        /// </summary>
+        /// <param name="filter">A filter for selecting the types to add.</param>
+        /// <param name="assemblies">The assemblies that contain the types with which to initialize the collection.</param>
+        public HostTypeCollection(Predicate<Type> filter, params Assembly[] assemblies)
+        {
+            MiscHelpers.VerifyNonNullArgument(assemblies, "assemblies");
+            Array.ForEach(assemblies, assembly => AddAssembly(assembly, filter));
+        }
+
+        /// <summary>
+        /// Initializes a new host type collection with selected types from one or more assemblies.
+        /// The assemblies are specified by name.
+        /// </summary>
+        /// <param name="filter">A filter for selecting the types to add.</param>
+        /// <param name="assemblyNames">The names of the assemblies that contain the types with which to initialize the collection.</param>
+        public HostTypeCollection(Predicate<Type> filter, params string[] assemblyNames)
+        {
+            MiscHelpers.VerifyNonNullArgument(assemblyNames, "assemblyNames");
+            Array.ForEach(assemblyNames, assemblyName => AddAssembly(assemblyName, filter));
+        }
+
         /// <summary>
         /// Adds types from an assembly to a host type collection.
         /// </summary>
@@ -132,12 +157,36 @@ public void AddAssembly(Assembly assembly)
         /// <param name="assemblyName">The name of the assembly that contains the types to add.</param>
         public void AddAssembly(string assemblyName)
         {
-            if (string.IsNullOrWhiteSpace(assemblyName))
+            MiscHelpers.VerifyNonBlankArgument(assemblyName, "assemblyName", "Invalid assembly name");
+            AddAssembly(Assembly.Load(AssemblyHelpers.GetFullAssemblyName(assemblyName)));
+        }
+
+        /// <summary>
+        /// Adds selected types from an assembly to a host type collection.
+        /// </summary>
+        /// <param name="assembly">The assembly that contains the types to add.</param>
+        /// <param name="filter">A filter for selecting the types to add.</param>
+        public void AddAssembly(Assembly assembly, Predicate<Type> filter)
+        {
+            MiscHelpers.VerifyNonNullArgument(assembly, "assembly");
+
+            var activeFilter = filter ?? defaultFilter;
+            foreach (var type in assembly.GetTypes().Where(type => type.IsImportable() && activeFilter(type)))
             {
-                throw new ArgumentException("Invalid assembly name", "assemblyName");
+                AddType(type);
             }
+        }
 
-            AddAssembly(Assembly.Load(AssemblyHelpers.GetFullAssemblyName(assemblyName)));
+        /// <summary>
+        /// Adds selected types from an assembly to a host type collection. The assembly is
+        /// specified by name.
+        /// </summary>
+        /// <param name="assemblyName">The name of the assembly that contains the types to add.</param>
+        /// <param name="filter">A filter for selecting the types to add.</param>
+        public void AddAssembly(string assemblyName, Predicate<Type> filter)
+        {
+            MiscHelpers.VerifyNonBlankArgument(assemblyName, "assemblyName", "Invalid assembly name");
+            AddAssembly(Assembly.Load(AssemblyHelpers.GetFullAssemblyName(assemblyName)), filter);
         }
 
         /// <summary>

ClearScript/PropertyBag.cs

@@ -63,6 +63,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.ClearScript.Util;
 
@@ -169,11 +170,13 @@ private void InvokePropertyChanged(string name)
 
         #region IEnumerable<KeyValuePair<string, object>> implementation
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member requires explicit implementation to resolve ambiguity.")]
         IEnumerator<KeyValuePair<string, object>> IEnumerable<KeyValuePair<string, object>>.GetEnumerator()
         {
             return dictionary.GetEnumerator();
         }
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member requires explicit implementation to resolve ambiguity.")]
         IEnumerator IEnumerable.GetEnumerator()
         {
             return dictionary.GetEnumerator();
@@ -183,30 +186,35 @@ IEnumerator IEnumerable.GetEnumerator()
 
         #region ICollection<KeyValuePair<string, object>> implementation
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member is not expected to be re-implemented in derived classes.")]
         void ICollection<KeyValuePair<string, object>>.Add(KeyValuePair<string, object> item)
         {
             CheckReadOnly();
             SetPropertyNoCheck(item.Key, item.Value);
             InvokePropertyChanged(item.Key);
         }
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member is not expected to be re-implemented in derived classes.")]
         void ICollection<KeyValuePair<string, object>>.Clear()
         {
             CheckReadOnly();
             collection.Clear();
             InvokePropertyChanged(null);
         }
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member is not expected to be re-implemented in derived classes.")]
         bool ICollection<KeyValuePair<string, object>>.Contains(KeyValuePair<string, object> item)
         {
             return collection.Contains(item);
         }
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member is not expected to be re-implemented in derived classes.")]
         void ICollection<KeyValuePair<string, object>>.CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
         {
             collection.CopyTo(array, arrayIndex);
         }
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member is not expected to be re-implemented in derived classes.")]
         bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, object> item)
         {
             CheckReadOnly();
@@ -219,11 +227,13 @@ bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, objec
             return false;
         }
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member is not expected to be re-implemented in derived classes.")]
         int ICollection<KeyValuePair<string, object>>.Count
         {
             get { return collection.Count; }
         }
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member is not expected to be re-implemented in derived classes.")]
         bool ICollection<KeyValuePair<string, object>>.IsReadOnly
         {
             get { return isReadOnly; }
@@ -329,6 +339,7 @@ public ICollection<object> Values
 
         #region IScriptableObject implementation
 
+        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This member is not expected to be re-implemented in derived classes.")]
         void IScriptableObject.OnExposedToScriptCode(ScriptEngine engine)
         {
             if ((engine != null) && engineSet.TryAdd(engine))

ClearScript/ScriptEngine.cs

@@ -107,6 +107,18 @@ protected ScriptEngine()
         /// </remarks>
         public Type AccessContext { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value that controls whether script code is permitted to use reflection.
+        /// </summary>
+        /// <remarks>
+        /// When this property is set to <c>true</c>, script code running in the current script
+        /// engine is permitted to use reflection. This affects
+        /// <see cref="System.Object.GetType"/>, <see cref="HostFunctions.typeOf(object)"/> and
+        /// <see cref="HostFunctions.typeOf{T}"/>. By default, any attempt to invoke these methods
+        /// from script code results in an exception.
+        /// </remarks>
+        public bool AllowReflection { get; set; }
+
         /// <summary>
         /// Gets or sets a callback that can be used to halt script execution.
         /// </summary>
@@ -589,6 +601,14 @@ internal void RequestInterrupt()
             }
         }
 
+        internal void CheckReflection()
+        {
+            if (!AllowReflection)
+            {
+                throw new UnauthorizedAccessException("Use of reflection is prohibited in this script engine");
+            }
+        }
+
         #endregion
 
         #region host-side invocation

ClearScript/Util/MiscHelpers.cs

@@ -81,6 +81,14 @@ public static void VerifyNonNullArgument(object value, string name)
             }
         }
 
+        public static void VerifyNonBlankArgument(string value, string name, string message)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                throw new ArgumentException(message, name);
+            }
+        }
+
         public static string EnsureNonBlank(string input, string alternate)
         {
             Debug.Assert(!string.IsNullOrWhiteSpace(alternate));