Handle dictionaries with non-object values.

In cases where a Dictionary property had a non-object value type, the
dictionary couldn't be treated like an object. This code will wrap a
dictionary so its non-object values are upcast to objects.

mustache-sharp.test/UpcastDictionaryTester.cs

@@ -0,0 +1,206 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Mustache.Test
+{
+    [TestClass]
+    public class UpcastDictionaryTester
+    {
+        [TestMethod]
+        public void ShouldReturnNullForNull()
+        {
+            IDictionary<string, object> result = UpcastDictionary.Create(null);
+            Assert.IsNull(result, "Null should be returned for null.");
+        }
+
+        [TestMethod]
+        public void ShouldReturnArgumentIfIDictionary_string_object()
+        {
+            object source = new Dictionary<string, object>();
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            Assert.AreSame(source, result, "The up-cast wrapper should not be applied if already a IDictionary<string, object>.");
+        }
+
+        [TestMethod]
+        public void ShouldReturnNullIfNotGenericType()
+        {
+            object source = String.Empty;
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            Assert.IsNull(result, "Null should be returned for non-generic types.");
+        }
+
+        [TestMethod]
+        public void ShouldReturnNullIfWrongNumberOfGenericArguments()
+        {
+            object source = new List<string>();
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            Assert.IsNull(result, "Null should be returned for generic types with the wrong number of type arguments.");
+        }
+
+        [TestMethod]
+        public void ShouldReturnNullIfFirstGenericTypeArgumentIsNotAString()
+        {
+            object source = new Dictionary<object, object>();
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            Assert.IsNull(result, "Null should be returned if the first generic type argument is not a string.");
+        }
+
+        [TestMethod]
+        public void ShouldReturnNullIfNotDictionaryType()
+        {
+            object source = (Converter<string, object>)(s => (object)s);
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            Assert.IsNull(result, "Null should be returned for non-dictionary types.");
+        }
+
+        [TestMethod]
+        public void ShouldReturnUpcastWrapperForDictionary_string_TValue()
+        {
+            object source = new Dictionary<string, string>();
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            Assert.IsInstanceOfType(result, typeof(UpcastDictionary<string>), "The source was not wrapped.");
+        }
+
+        [TestMethod]
+        public void ShouldFindKeyIfInWrappedDictionary()
+        {
+            object source = new Dictionary<string, string>() { { "Name", "Bob" } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            bool containsKey = result.ContainsKey("Name");
+            Assert.IsTrue(containsKey, "The key Name should have been found.");
+        }
+
+        [TestMethod]
+        public void ShouldNotFindKeyIfNotInWrappedDictionary()
+        {
+            object source = new Dictionary<string, string>() { { "Name", "Bob" } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            bool containsKey = result.ContainsKey("Age");
+            Assert.IsFalse(containsKey, "The key Age should not have been found.");
+        }
+
+        [TestMethod]
+        public void ShouldFindKeysInWrappedDictionary()
+        {
+            var source = new Dictionary<string, string>() { { "Name", "Bob" }, { "Age", "100" } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            ICollection sourceKeys = source.Keys;
+            ICollection wrappedKeys = result.Keys.ToArray();
+            CollectionAssert.AreEquivalent(sourceKeys, wrappedKeys, "The same keys should have been found in both collections.");
+        }
+
+        [TestMethod]
+        public void ShouldFindKeyIfInWrappedDictionary_TryGetValue()
+        {
+            var source = new Dictionary<string, string>() { { "Name", "Bob" } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            object value;
+            bool found = result.TryGetValue("Name", out value);
+            Assert.IsTrue(found, "The key should have been found.");
+            Assert.AreSame(source["Name"], value, "The value in the underlying dictionary should have been returned.");
+        }
+
+        [TestMethod]
+        public void ShouldNotFindKeyIfNotInWrappedDictionary_TryGetValue()
+        {
+            var source = new Dictionary<string, int>() { { "Age", 100 } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            object value;
+            bool found = result.TryGetValue("Name", out value);
+            Assert.IsFalse(found, "The key should not have been found.");
+            Assert.IsNull(value, "The value should be null even if the actual type is a struct.");
+        
+        }
+
+        [TestMethod]
+        public void ShouldReturnValuesAsObjects()
+        {
+            var source = new Dictionary<string, int>() { { "Age", 100 }, { "Weight", 500 } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            ICollection sourceValues = source.Values;
+            ICollection wrappedValues = result.Values.ToArray();
+            CollectionAssert.AreEquivalent(sourceValues, wrappedValues, "The underlying values were not returned.");
+        }
+
+        [TestMethod]
+        public void ShouldFindKeyIfInWrappedDictionary_Indexer()
+        {
+            var source = new Dictionary<string, string>() { { "Name", "Bob" } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            object value = result["Name"];
+            Assert.AreSame(source["Name"], value, "The value in the underlying dictionary should have been returned.");
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(KeyNotFoundException))]
+        public void ShouldNotFindKeyIfNotInWrappedDictionary_Indexer()
+        {
+            var source = new Dictionary<string, int>() { { "Age", 100 } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            object value = result["Name"];
+        }
+
+        [TestMethod]
+        public void ShouldNotFindPairIfValueWrongType()
+        {
+            var source = new Dictionary<string, int>() { { "Age", 100 } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            bool contains = result.Contains(new KeyValuePair<string, object>("Age", "Blah"));
+            Assert.IsFalse(contains, "The pair should not have been found.");
+        }
+
+        [TestMethod]
+        public void ShouldFindPairInWrappedDictionary()
+        {
+            var source = new Dictionary<string, int>() { { "Age", 100 } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            bool contains = result.Contains(new KeyValuePair<string, object>("Age", 100));
+            Assert.IsTrue(contains, "The pair should have been found.");
+        }
+
+        [TestMethod]
+        public void ShouldCopyPairsToArray()
+        {
+            var source = new Dictionary<string, int>() { { "Age", 100 }, { "Weight", 45 } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            var array = new KeyValuePair<string, object>[2];
+            result.CopyTo(array, 0);
+            var expected = new KeyValuePair<string, object>[]
+            {
+                new KeyValuePair<string, object>("Age", 100),
+                new KeyValuePair<string, object>("Weight", 45)
+            };
+            CollectionAssert.AreEqual(expected, array, "The pairs were not copied.");
+        }
+
+        [TestMethod]
+        public void ShouldGetCount()
+        {
+            var source = new Dictionary<string, int>() { { "Age", 100 }, { "Weight", 45 } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            Assert.AreEqual(source.Count, result.Count, "The source and Upcast dictionary should have the same count.");
+        }
+
+        [TestMethod]
+        public void ShouldGetEnumerator()
+        {
+            var source = new Dictionary<string, int>() { { "Age", 100 }, { "Weight", 45 } };
+            IDictionary<string, object> result = UpcastDictionary.Create(source);
+            IEnumerator<KeyValuePair<string, object>> enumerator = result.GetEnumerator();
+            var values = new List<KeyValuePair<string, object>>();
+            while (enumerator.MoveNext())
+            {
+                values.Add(enumerator.Current);
+            }
+            var expected = new KeyValuePair<string, object>[]
+            {
+                new KeyValuePair<string, object>("Age", 100),
+                new KeyValuePair<string, object>("Weight", 45)
+            };
+            CollectionAssert.AreEqual(expected, values, "The enumerator did not return the correct pairs.");
+        }
+    }
+}

mustache-sharp.test/mustache-sharp.test.csproj

@@ -45,6 +45,7 @@
   <ItemGroup>
     <Compile Include="FormatCompilerTester.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UpcastDictionaryTester.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\mustache-sharp\mustache-sharp.csproj">

mustache-sharp/Scope.cs

@@ -125,7 +125,7 @@ namespace Mustache
 
         private static IDictionary<string, object> toLookup(object value)
         {
-            IDictionary<string, object> lookup = value as IDictionary<string, object>;
+            IDictionary<string, object> lookup = UpcastDictionary.Create(value);
             if (lookup == null)
             {
                 lookup = new PropertyDictionary(value);

mustache-sharp/UpcastDictionary.cs

@@ -0,0 +1,167 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+
+namespace Mustache
+{
+    internal static class UpcastDictionary
+    {
+        public static IDictionary<string, object> Create(object source)
+        {
+            if (source == null)
+            {
+                return null;
+            }
+            IDictionary<string, object> sourceDictionary = source as IDictionary<string, object>;
+            if (sourceDictionary != null)
+            {
+                return sourceDictionary;
+            }
+            Type sourceType = source.GetType();
+            if (!sourceType.IsGenericType)
+            {
+                return null;
+            }
+            Type[] argumentTypes = sourceType.GetGenericArguments();
+            if (argumentTypes.Length != 2)
+            {
+                return null;
+            }
+            Type keyType = argumentTypes[0];
+            if (keyType != typeof(string))
+            {
+                return null;
+            }
+            Type valueType = argumentTypes[1];
+            Type genericType = typeof(IDictionary<,>).MakeGenericType(typeof(string), valueType);
+            if (!genericType.IsAssignableFrom(sourceType))
+            {
+                return null;
+            }
+            Type upcastType = typeof(UpcastDictionary<>).MakeGenericType(valueType);
+            return (IDictionary<string, object>)Activator.CreateInstance(upcastType, source);
+        }
+    }
+
+    internal class UpcastDictionary<TValue> : IDictionary<string, object>
+    {
+        private readonly IDictionary<string, TValue> dictionary;
+
+        public UpcastDictionary(IDictionary<string, TValue> dictionary)
+        {
+            this.dictionary = dictionary;
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        void IDictionary<string, object>.Add(string key, object value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public bool ContainsKey(string key)
+        {
+            return dictionary.ContainsKey(key);
+        }
+
+        public ICollection<string> Keys
+        {
+            get { return dictionary.Keys; }
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        bool IDictionary<string, object>.Remove(string key)
+        {
+            throw new NotSupportedException();
+        }
+
+        public bool TryGetValue(string key, out object value)
+        {
+            TValue result;
+            if (dictionary.TryGetValue(key, out result))
+            {
+                value = result;
+                return true;
+            }
+            else
+            {
+                value = null;
+                return false;
+            }
+        }
+
+        public ICollection<object> Values
+        {
+            get { return dictionary.Values.Cast<object>().ToArray(); }
+        }
+
+        public object this[string key]
+        {
+            get
+            {
+                return dictionary[key];
+            }
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            set
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        void ICollection<KeyValuePair<string, object>>.Add(KeyValuePair<string, object> item)
+        {
+            throw new NotSupportedException();
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        void ICollection<KeyValuePair<string, object>>.Clear()
+        {
+            throw new NotSupportedException();
+        }
+
+        bool ICollection<KeyValuePair<string, object>>.Contains(KeyValuePair<string, object> item)
+        {
+            if (!(item.Value is TValue))
+            {
+                return false;
+            }
+            KeyValuePair<string, TValue> pair = new KeyValuePair<string,TValue>(item.Key, (TValue)item.Value);
+            ICollection<KeyValuePair<string, TValue>> collection = dictionary;
+            return dictionary.Contains(pair);
+        }
+
+        void ICollection<KeyValuePair<string, object>>.CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
+        {
+            var pairs = dictionary.Select(p => new KeyValuePair<string, object>(p.Key, p.Value)).ToArray();
+            pairs.CopyTo(array, arrayIndex);
+        }
+
+        public int Count
+        {
+            get { return dictionary.Count; }
+        }
+
+        bool ICollection<KeyValuePair<string, object>>.IsReadOnly
+        {
+            get { return true; }
+        }
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, object> item)
+        {
+            throw new NotSupportedException();
+        }
+
+        public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+        {
+            return dictionary.Select(p => new KeyValuePair<string, object>(p.Key, p.Value)).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}

mustache-sharp/mustache-sharp.csproj

@@ -40,6 +40,7 @@
     <Compile Include="ContentTagDefinition.cs" />
     <Compile Include="Context.cs" />
     <Compile Include="ContextParameter.cs" />
+    <Compile Include="UpcastDictionary.cs" />
     <Compile Include="VariableFoundEventArgs.cs" />
     <Compile Include="SetTagDefinition.cs" />
     <Compile Include="NewlineTagDefinition.cs" />