Merge pull request #17 from jhionan/master

feature(unregister): fixes some appointments from PR #15

Author: escamoteur

lib/get_it.dart

@@ -136,6 +136,22 @@ class GetIt {
       _factoriesByName[instanceName] = serviceFactory;
     }
   }
+
+  /// Unregister by Type [T] or by name [instanceName]
+  /// if you need to dispose any resources you can do it using [disposingFunction] function
+  /// that provides a instance of your class to be disposed
+  void unregister<T>([String instanceName, Function(T) disposingFunction]) {
+    assert(
+        _factoriesByName.containsKey(instanceName) || _factories.containsKey(T),
+        'Nor Type ${T.toString()} or instance Name must not be null');
+    if (instanceName == null) {
+      disposingFunction(get<T>());
+      _factories.remove(T);
+    } else {
+      disposingFunction(get(instanceName));
+      _factoriesByName.remove(instanceName);
+    }
+  }
 }
 
 enum _ServiceFactoryType { alwaysNew, constant, lazy }

test/get_it_test.dart

@@ -3,13 +3,18 @@ import 'package:test/test.dart';
 import 'package:get_it/get_it.dart';
 
 int constructorCounter;
+int disposeCounter;
 
 abstract class TestBaseClass {}
 
 class TestClass extends TestBaseClass {
   TestClass() {
     constructorCounter++;
   }
+
+  dispose() {
+    disposeCounter++;
+  }
 }
 
 void main() {
@@ -51,7 +56,6 @@ void main() {
     GetIt.I.reset();
   });
 
-
   test('register constant', () {
     var getIt = GetIt.instance;
     constructorCounter = 0;
@@ -92,9 +96,8 @@ void main() {
     GetIt.I.reset();
   });
 
-
-    test('register lazy singleton two instances of GetIt', () {
-    GetIt.allowMultipleInstances=true;
+  test('register lazy singleton two instances of GetIt', () {
+    GetIt.allowMultipleInstances = true;
     var secondGetIt = GetIt.asNewInstance();
 
     constructorCounter = 0;
@@ -115,11 +118,9 @@ void main() {
     expect(instance1, isNot(instanceSecondGetIt));
     expect(constructorCounter, 2);
 
-
     GetIt.I.reset();
   });
 
-
   test('trying to access not registered type', () {
     var getIt = GetIt.instance;
 
@@ -192,4 +193,52 @@ void main() {
     expect(() => getIt('not there'), throwsA(TypeMatcher<Exception>()));
     GetIt.I.reset();
   });
+
+  test('unregister by type', () {
+    var getIt = GetIt.instance;
+    disposeCounter = 0;
+    constructorCounter = 0;
+
+    getIt.registerSingleton<TestClass>(TestClass());
+
+    var instance1 = getIt.get<TestClass>();
+
+    expect(instance1 is TestClass, true);
+
+    var instance2 = getIt.get<TestClass>();
+
+    expect(instance1, instance2);
+
+    expect(constructorCounter, 1);
+
+    getIt.unregister<TestClass>(disposal: (testClass) {
+      testClass.dispose();
+    });
+
+    expect(disposeCounter, 1);
+
+    expect(() => getIt.get<TestClass>(), throwsA(TypeMatcher<Exception>()));
+  });
+
+  test('unregister by name', () {
+    var getIt = GetIt.instance;
+    disposeCounter = 0;
+    constructorCounter = 0;
+
+    getIt.registerSingleton<TestClass>(TestClass(), 'instanceName');
+
+    var instance1 = getIt.get('instanceName');
+
+    expect(instance1 is TestClass, true);
+
+    getIt.unregister<TestClass>(
+        instanceName: 'instanceName',
+        disposal: (testClass) {
+          testClass.dispose();
+        });
+
+    expect(disposeCounter, 1);
+
+    expect(() => getIt('instanceName'), throwsA(TypeMatcher<Exception>()));
+  });
 }