polishing

switch ObjectDefinitionValueResolver & related infrastructure code from using RootObjectDefinition to IObjectDefinition
fixed SPRNET-1073
added PropertyOrFieldNode tests for injecting transparent proxies
added new CollectionUtils.FindValuesOfType() method for filtering collections

src/Spring/Spring.Core/Expressions/PropertyOrFieldNode.cs

@@ -342,8 +342,8 @@ namespace Spring.Expressions
                     throw new ArgumentException("Invalid value [" + newValue + "] for property or field '" +
                                                 this.memberName + "' of primitive type ["
                                                 + targetType + "]");
-                }
-                else if (newValue == null || targetType.IsAssignableFrom(newValue.GetType()))
+                }
+                else if (newValue == null || ObjectUtils.IsAssignable(targetType, newValue)) // targetType.IsAssignableFrom(newValue.GetType())
                 {
                     SetPropertyOrFieldValueInternal(context, newValue);
                 }

src/Spring/Spring.Core/Objects/Factory/Support/IManagedCollection.cs

@@ -21,7 +21,8 @@
 #region Imports
 
 using System;
-using System.Collections;
+using System.Collections;
+using Spring.Objects.Factory.Config;
 
 #endregion
 
@@ -130,7 +131,7 @@ namespace Spring.Objects.Factory.Support
 		/// this managed collection.
 		/// </param>
 		/// <returns>A fully resolved collection.</returns>
-		ICollection Resolve(string objectName, RootObjectDefinition definition,
+		ICollection Resolve(string objectName, IObjectDefinition definition,
 			string propertyName, ManagedCollectionElementResolver resolver);
 	}
 
@@ -160,5 +161,5 @@ namespace Spring.Objects.Factory.Support
 	/// </param>
 	/// <returns>A fully resolved element.</returns>
 	public delegate object ManagedCollectionElementResolver(
-		string name, RootObjectDefinition definition, string argumentName, object element);
+		string name, IObjectDefinition definition, string argumentName, object element);
 }

src/Spring/Spring.Core/Objects/Factory/Support/ManagedDictionary.cs

@@ -31,6 +31,7 @@ using System.Globalization;
 using Spring.Core;
 using Spring.Core.TypeConversion;
 using Spring.Core.TypeResolution;
+using Spring.Objects.Factory.Config;
 using Spring.Util;
 
 #endregion
@@ -89,7 +90,7 @@ namespace Spring.Objects.Factory.Support
 		/// </param>
 		/// <returns>A fully resolved collection.</returns>
 		public ICollection Resolve(
-			string objectName, RootObjectDefinition definition,
+			string objectName, IObjectDefinition definition,
 			string propertyName, ManagedCollectionElementResolver resolver)
 		{
             IDictionary dictionary;

src/Spring/Spring.Core/Objects/Factory/Support/ManagedList.cs

@@ -30,6 +30,7 @@ using System.Globalization;
 using Spring.Core;
 using Spring.Core.TypeConversion;
 using Spring.Core.TypeResolution;
+using Spring.Objects.Factory.Config;
 using Spring.Util;
 
 #endregion
@@ -75,7 +76,7 @@ namespace Spring.Objects.Factory.Support
         /// this managed collection.
         /// </param>
         /// <returns>A fully resolved collection.</returns>
-        public ICollection Resolve(string objectName, RootObjectDefinition definition, string propertyName, ManagedCollectionElementResolver resolver)
+        public ICollection Resolve(string objectName, IObjectDefinition definition, string propertyName, ManagedCollectionElementResolver resolver)
         {
             IList list;
 

src/Spring/Spring.Core/Objects/Factory/Support/ManagedSet.cs

@@ -27,6 +27,7 @@ using Spring.Collections;
 using Spring.Core;
 using Spring.Core.TypeConversion;
 using Spring.Core.TypeResolution;
+using Spring.Objects.Factory.Config;
 using Spring.Util;
 
 #endregion
@@ -72,7 +73,7 @@ namespace Spring.Objects.Factory.Support
         /// this managed collection.
         /// </param>
         /// <returns>A fully resolved collection.</returns>
-        public ICollection Resolve(string objectName, RootObjectDefinition definition, string propertyName, ManagedCollectionElementResolver resolver)
+        public ICollection Resolve(string objectName, IObjectDefinition definition, string propertyName, ManagedCollectionElementResolver resolver)
         {
             ISet set = new HybridSet();
             

src/Spring/Spring.Core/Objects/Factory/Support/ObjectDefinitionValueResolver.cs

@@ -1,7 +1,7 @@
 #region License
 
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,10 +25,8 @@ using System.Globalization;
 using System.Runtime.Remoting;
 using Common.Logging;
 using Spring.Core.TypeConversion;
-using Spring.Core.TypeResolution;
 using Spring.Expressions;
 using Spring.Objects.Factory.Config;
-using Spring.Util;
 
 namespace Spring.Objects.Factory.Support
 {
@@ -47,23 +45,16 @@ namespace Spring.Objects.Factory.Support
         private readonly ILog log;
 
         private readonly AbstractObjectFactory objectFactory;
-        private readonly string objectName;
-        private readonly IObjectDefinition objectDefinition;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ObjectDefinitionValueResolver"/> class.
         /// </summary>
         /// <param name="objectFactory">The object factory.</param>
-        /// <param name="objectName">Name of the object.</param>
-        /// <param name="objectDefinition">The object definition.</param>
-        public ObjectDefinitionValueResolver(AbstractObjectFactory objectFactory, string objectName,
-                                             IObjectDefinition objectDefinition)
+        public ObjectDefinitionValueResolver(AbstractObjectFactory objectFactory)
         {
             this.log = LogManager.GetLogger(this.GetType());
 
             this.objectFactory = objectFactory;
-            this.objectName = objectName;
-            this.objectDefinition = objectDefinition;
         }
 
         /// <summary>
@@ -116,9 +107,25 @@ namespace Spring.Objects.Factory.Support
         /// <param name="argumentValue">
         /// The value of the property that is being resolved.
         /// </param>
-        public virtual object ResolveValueIfNecessary(string name, RootObjectDefinition definition, string argumentName, object argumentValue)
+        public virtual object ResolveValueIfNecessary(string name, IObjectDefinition definition, string argumentName, object argumentValue)
         {
             object resolvedValue = null;
+            resolvedValue = ResolvePropertyValue(name, definition, argumentName, argumentValue);
+            return resolvedValue;
+        }
+
+        /// <summary>
+        /// TODO
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="definition"></param>
+        /// <param name="argumentName"></param>
+        /// <param name="argumentValue"></param>
+        /// <returns></returns>
+        private object ResolvePropertyValue(string name, IObjectDefinition definition, string argumentName, object argumentValue)
+        {
+            object resolvedValue = null;
+            
             // we must check the argument value to see whether it requires a runtime
             // reference to another object to be resolved.
             // if it does, we'll attempt to instantiate the object and set the reference.
@@ -254,7 +261,7 @@ namespace Spring.Objects.Factory.Support
         /// <returns>
         /// The resolved object as defined by the inner object definition.
         /// </returns>
-        protected object ResolveInnerObjectDefinition(string name, string innerObjectName, string argumentName, IObjectDefinition definition,
+        protected virtual object ResolveInnerObjectDefinition(string name, string innerObjectName, string argumentName, IObjectDefinition definition,
                                                       bool singletonOwner)
         {
             RootObjectDefinition mod = objectFactory.GetMergedObjectDefinition(innerObjectName, definition);
@@ -324,7 +331,7 @@ namespace Spring.Objects.Factory.Support
         /// The runtime reference containing the value of the property.
         /// </param>
         /// <returns>A reference to another object in the factory.</returns>
-        protected object ResolveReference(IConfigurableObjectDefinition definition, string name, string argumentName, RuntimeObjectReference reference)
+        protected virtual object ResolveReference(IObjectDefinition definition, string name, string argumentName, RuntimeObjectReference reference)
         {
             #region Instrumentation
             if (log.IsDebugEnabled)

src/Spring/Spring.Core/Spring.Core.2008.csproj

@@ -575,6 +575,7 @@
     <Compile Include="Objects\Factory\Config\ObjectDefinitionHolder.cs" />
     <Compile Include="Objects\Factory\Config\ObjectDefinitionVisitor.cs" />
     <Compile Include="Objects\Factory\Config\ObjectRole.cs" />
+    <Compile Include="Objects\Factory\Config\ResolvePropertyValueHandler.cs" />
     <Compile Include="Objects\Factory\Config\ResourceHandlerConfigurer.cs" />
     <Compile Include="Objects\Factory\Config\SharedStateAwareProcessor.cs" />
     <Compile Include="Objects\Factory\Config\SmartInstantiationAwareObjectPostProcessor.cs" />

src/Spring/Spring.Core/Util/CollectionUtils.cs

@@ -303,6 +303,30 @@ namespace Spring.Util
             return val;
         }
 
+        /// <summary>
+        /// Finds a value of the given type in the given collection.
+        /// </summary>
+        /// <param name="collection">The collection to search.</param>
+        /// <param name="type">The type to look for.</param>
+        /// <returns>a collection of matching values of the given type found, empty if none found, or null if the input collection was null.</returns>
+        public static ICollection FindValuesOfType(IEnumerable collection, Type type)
+        {
+            if (IsEmpty(collection))
+            {
+                return null;
+            }
+            Type typeToUse = (type != null ? type : typeof(object));
+            ArrayList results = new ArrayList();
+            foreach (object obj in collection)
+            {
+                if (typeToUse.IsAssignableFrom(obj.GetType()))
+                {
+                    results.Add(obj);
+                }
+            }
+            return results;
+        }
+
         /// <summary>
         /// Find a value of one of the given types in the given Collection, 
         /// searching the Collection for a value of the first type, then

src/Spring/Spring.Core/Util/ObjectUtils.cs

@@ -296,7 +296,7 @@ namespace Spring.Util
 
         /// <summary>
         /// Determine if the given <see cref="System.Type"/> is assignable from the
-        /// given value, assuming setting by reflection.
+        /// given value, assuming setting by reflection and taking care of transparent proxies.
         /// </summary>
         /// <remarks>
         /// <p>

src/Spring/Spring.Core/Validation/IValidationErrors.cs

@@ -53,7 +53,7 @@ namespace Spring.Validation
         /// <param name="errorsToMerge">
         /// The validation errors to merge; can be <see lang="null"/>.
         /// </param>
-        void MergeErrors(ValidationErrors errorsToMerge);
+        void MergeErrors(IValidationErrors errorsToMerge);
 
         /// <summary>
         /// Gets the list of errors for the supplied error <paramref name="provider"/>.

test/Spring/Spring.Core.Tests/Expressions/PropertyOrFieldNodeTests.cs

@@ -1,7 +1,7 @@
 #region License
 
 /*
- * Copyright <20> 2002-2008 the original author or authors.
+ * Copyright <20> 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,12 +18,9 @@
 
 #endregion
 
-#region Imports
-
 using System;
 using NUnit.Framework;
-
-#endregion
+using Spring.Objects;
 
 namespace Spring.Expressions
 {
@@ -31,13 +28,15 @@ namespace Spring.Expressions
     /// Tests the behavior of PropertyOrFieldNode expression node
     /// </summary>
     /// <author>Erich Eichinger</author>
-    /// <version>$Id: $</version>
     [TestFixture]
     public class PropertyOrFieldNodeTests
     {
         private class BaseClass
         {
+            private ITestObject objectProp;
+
             public string StringProp { get { return "BaseStringProp"; }}
+            public ITestObject ObjectProp { get { return objectProp; } set { objectProp = value; } }
         }
 
         private class DerivedClass : BaseClass
@@ -54,5 +53,21 @@ namespace Spring.Expressions
 
             Assert.AreEqual(new DateTime(2008,1,1), ((IExpression) pofNode).GetValue(new DerivedClass()));
         }
+
+        [Test]
+        public void CanSetTransparentProxy()
+        {
+            PropertyOrFieldNode pofNode = new PropertyOrFieldNode();
+            pofNode.Text = "ObjectProp";
+
+            BaseClass ouc = new BaseClass();
+            TestTransparentProxyFactory tpf = new TestTransparentProxyFactory(null, typeof(ITestObject), null);
+            object tpo = tpf.GetTransparentProxy();
+            Assert.IsTrue( tpo is ITestObject );
+            ITestObject itpo = tpo as ITestObject;
+            Assert.IsNotNull(itpo);
+            pofNode.SetValue( ouc, null, itpo);
+            Assert.AreSame( tpo, ouc.ObjectProp );
+        }
     }
 }

test/Spring/Spring.Core.Tests/Objects/Factory/Support/ManagedDictionaryTests.cs

@@ -23,6 +23,8 @@ using System.Collections;
 using NUnit.Framework;
 #if NET_2_0
 using System.Collections.Generic;
+using Spring.Objects.Factory.Config;
+
 #endif
 
 namespace Spring.Objects.Factory.Support
@@ -48,7 +50,7 @@ namespace Spring.Objects.Factory.Support
             dict2.ValueTypeName = typeof(InternalType).FullName;
 
             IDictionary resolved = (IDictionary) dict2.Resolve("other", new RootObjectDefinition(typeof (object)), "prop",
-                                                               delegate(string name, RootObjectDefinition definition, string argumentName, object element)
+                                                               delegate(string name, IObjectDefinition definition, string argumentName, object element)
                                                                    {
                                                                        if ("stringValue".Equals(element))
                                                                        {
@@ -69,7 +71,7 @@ namespace Spring.Objects.Factory.Support
 
             dict.ValueTypeName = "System.Collections.Generic.List<[string]>";
             IDictionary resolved = (IDictionary) dict.Resolve("somename", new RootObjectDefinition(typeof(object)), "prop",
-                                                              delegate(string name, RootObjectDefinition definition, string argumentName, object element)
+                                                              delegate(string name, IObjectDefinition definition, string argumentName, object element)
                                                                   {
                                                                       if ("value".Equals(element))
                                                                       {

test/Spring/Spring.Core.Tests/Objects/TestTransparentProxyFactory.cs

@@ -0,0 +1,114 @@
+#region License
+
+/*
+ * Copyright 2002-2009 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#endregion
+
+using System;
+using System.Reflection;
+using System.Runtime.Remoting;
+using System.Runtime.Remoting.Messaging;
+using System.Runtime.Remoting.Proxies;
+
+namespace Spring.Objects
+{
+    /// <summary>
+    /// </summary>
+    /// <author>Erich Eichinger</author>
+    public class TestTransparentProxyFactory : RealProxy, IRemotingTypeInfo
+    {
+        public delegate object InvokeCallback(object proxy, object targetInstance, MethodInfo targetMethod, object[] arguments);
+
+        private object targetInstance;
+        private Type targetType;
+        private InvokeCallback invokeHandler;
+
+        public object TargetInstance
+        {
+            get { return targetInstance; }
+            set { targetInstance = value; }
+        }
+
+        public Type TargetType
+        {
+            get { return targetType; }
+            set { targetType = value; }
+        }
+
+        public InvokeCallback InvokeHandler
+        {
+            get { return invokeHandler; }
+            set { invokeHandler = value; }
+        }
+
+        public TestTransparentProxyFactory(object targetInstance, Type targetType, InvokeCallback invokeHandler)
+            : base(typeof(MarshalByRefObject))
+        {
+            this.targetInstance = targetInstance;
+            this.targetType = targetType;
+            this.invokeHandler = invokeHandler;
+        }
+
+        public override IMessage Invoke(IMessage msg)
+        {
+            if (msg is IMethodCallMessage)
+            {
+                IMethodCallMessage callMsg = (IMethodCallMessage)msg;
+
+                // obtain method with same name & signature from target instance
+                MethodInfo targetMethod = targetInstance.GetType().GetMethod(callMsg.MethodName, (Type[])callMsg.MethodSignature);
+
+                // invoke
+                object result;
+                if (invokeHandler != null)
+                {
+                    result = invokeHandler(this, targetInstance, targetMethod, callMsg.Args);
+                }
+                else
+                {
+                    result = targetMethod.Invoke(targetInstance, callMsg.Args);
+                }
+
+                // create result msg
+                return new ReturnMessage(result, null, 0, null, callMsg);
+            }
+            throw new NotSupportedException();
+        }
+
+        public virtual bool CanCastTo(Type fromType, object o)
+        {
+            // we accept ALL messages...
+            return fromType.IsAssignableFrom(fromType);
+        }
+
+        public virtual string TypeName
+        {
+            get { return targetInstance.GetType().AssemblyQualifiedName; }
+            set { throw new System.NotSupportedException(); }
+        }
+
+        public static TestTransparentProxyFactory GetProxy(object transparentProxy )
+        {
+            return (TestTransparentProxyFactory) RemotingServices.GetRealProxy(transparentProxy);
+        }
+
+        public static object GetTargetInstance( object transparentProxy )
+        {
+            return GetProxy(transparentProxy).targetInstance;
+        }
+    }
+}

test/Spring/Spring.Core.Tests/Spring.Core.Tests.2008.csproj

@@ -630,6 +630,7 @@
     <Compile Include="Objects\TestObjectList.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Objects\TestTransparentProxyFactory.cs" />
     <Compile Include="Objects\TypeMismatchExceptionTests.cs">
       <SubType>Code</SubType>
     </Compile>