Add UnbindByInstance method on binder [Resolves #59 and #60]

src/Assets/Adic/CHANGELOG.txt

@@ -8,6 +8,7 @@ http://intentor.com.br/
 Version 2.20.3 (2016-10-??)
 
 Framework
+- Added UnbindByInstance method on binder. [Issues #59 and #60]
 - Fix singleton binding adding type instead of value when binging different types. [Issue #45]
 
 Unity Binding Extension

src/Assets/Adic/Scripts/Framework/Binding/Binder.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Adic.Injection;
 using Adic.Exceptions;
 
 namespace Adic.Binding {
@@ -14,7 +15,13 @@ public class Binder : IBinder {
 		/// <summary>Occurs before a binding is removed.</summary>
 		public event BindingRemovedHandler beforeRemoveBinding;
 		/// <summary>Occurs after a binding is removed.</summary>
-		public event BindingRemovedHandler afterRemoveBinding;
+        public event BindingRemovedHandler afterRemoveBinding;
+
+        /// <summary>
+        /// Checks whether a binding can be removed.
+        /// </summary>
+        /// <param name="binding">Binding to be evaluated.</param>
+        public delegate bool CanRemoveBindingHandler(BindingInfo binding);
 
 		/// <summary>Type bindings of the binder.</summary>
 		protected Dictionary<Type, IList<BindingInfo>> typeBindings = new Dictionary<Type, IList<BindingInfo>>();
@@ -260,29 +267,46 @@ public void Unbind(Type type) {
 		/// </summary>
 		/// <param name="identifier">The identifier to be unbound.</param>
 		public void Unbind(object identifier) {
-			var bindingsToRemove = new List<BindingInfo>();
+            this.Unbind(binding => binding.identifier != null && binding.identifier.Equals(identifier));  
+		}
 
-			foreach (var entry in this.typeBindings) {
-				for (var bindingIndex = 0; bindingIndex < entry.Value.Count; bindingIndex++) {
-					var binding = entry.Value[bindingIndex];
-					bindingsToRemove.Clear();
-
-					if (binding.identifier != null && binding.identifier.Equals(identifier)) {						
-						bindingsToRemove.Add(binding);
+        /// <summary>
+        /// Unbinds any bindings that holds the given instance, either as a value or on conditions.
+        /// </summary>
+        /// <param name="instance">Instance.</param>
+        public void UnbindInstance(object instance) {
+            this.Unbind(binding => binding.value == instance
+                || (binding.condition != null && binding.condition(new InjectionContext() { parentInstance = instance })));
+        }
 
-						if (this.beforeRemoveBinding != null) {
-							this.beforeRemoveBinding(this, binding.type, bindingsToRemove);
-						}
+        /// <summary>
+        /// Unbinds bindings using a given condition.
+        /// </summary>
+        /// <param name="canRemoveBinding">Condition to check for bindings removal.</param>
+        protected void Unbind(CanRemoveBindingHandler canRemoveBinding) {
+            var bindingsToRemove = new List<BindingInfo>();
 
-						entry.Value.RemoveAt(bindingIndex--);						
-
-						if (this.afterRemoveBinding != null) {
-							this.afterRemoveBinding(this, binding.type, bindingsToRemove);
-						}
-					}
-				}
-			}
-		}
+            foreach (var entry in this.typeBindings) {
+                for (var bindingIndex = 0; bindingIndex < entry.Value.Count; bindingIndex++) {
+                    var binding = entry.Value[bindingIndex];
+                    bindingsToRemove.Clear();
+
+                    if (canRemoveBinding(binding)) {                      
+                        bindingsToRemove.Add(binding);
+
+                        if (this.beforeRemoveBinding != null) {
+                            this.beforeRemoveBinding(this, binding.type, bindingsToRemove);
+                        }
+
+                        entry.Value.RemoveAt(bindingIndex--);                       
+
+                        if (this.afterRemoveBinding != null) {
+                            this.afterRemoveBinding(this, binding.type, bindingsToRemove);
+                        }
+                    }
+                }
+            }
+        }
 
 		/// <summary>
 		/// Resolves the binding provider.

src/Assets/Adic/Scripts/Framework/Binding/IBinder.cs

@@ -99,6 +99,12 @@ public interface IBinder : IBindingCreator {
 		/// Unbinds any bindings to a certain <paramref name="identifier"/>.
 		/// </summary>
 		/// <param name="identifier">The identifier to be unbound.</param>
-		void Unbind(object identifier);
+        void Unbind(object identifier);
+
+        /// <summary>
+        /// Unbinds any bindings that holds the given instance, either as a value or on conditions.
+        /// </summary>
+        /// <param name="instance">Instance.</param>
+        void UnbindInstance(object instance);
 	}
 }

src/Assets/Adic/Scripts/Framework/Container/InjectionContainer.cs

@@ -299,6 +299,10 @@ public void Unbind(Type type) {
 
 		public void Unbind(object identifier) {
 			this.binder.Unbind(identifier);
-		}
+        }
+
+        public void UnbindInstance(object instance) {
+            this.binder.UnbindInstance(instance);
+        }
 	}
 }

src/Assets/Tests/Editor/BinderTests.cs

@@ -153,7 +153,23 @@ public void TestUnbindByIdentifier() {
 			Assert.AreEqual(typeof(MockClassToDepend), bindings[0].type);
 			Assert.AreEqual(typeof(IMockInterface), bindings[1].type);
 			Assert.AreEqual("Mock2", bindings[1].identifier);
-		}
+        }
+
+        [Test]
+        public void TestUnbindByInstance() {
+            var binder = new Binder();
+
+            var instance = new MockIClassWithAttributes();
+
+            binder.Bind<MockClassToDepend>().ToSelf();
+            binder.Bind<MockClassToDepend>().ToSelf().WhenIntoInstance(instance);
+            binder.Bind<IMockInterface>().To(instance).As("Mock1");
+            binder.UnbindInstance(instance);
+
+            var bindings = binder.GetBindings();
+            Assert.AreEqual(1, bindings.Count);
+            Assert.AreEqual(typeof(MockClassToDepend), bindings[0].type);
+        }
 
 		[Test]
 		public void TestUnbindSingleton() {