protevus/platform
protevus/platform
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

update: updating 34 pass 4 fail

Browse source
This commit is contained in:
Patrick Stewart 2024-12-22 20:15:18 -07:00
parent a29fc17434
commit ffc5e02146
2 changed files with 99 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

84
packages/service_container/lib/src/container.dart
View file

@ -320,36 +320,34 @@ class Container implements ContainerContract, Map<String, dynamic> {
void bindMethod(dynamic method, Function callback) {
_methodBindings[_parseBindMethod(method)] = (container, params) {
try {
var callbackMirror = reflect(callback);
var functionMirror =
callbackMirror.type.declarations[Symbol('call')] as MethodMirror;
var parameterCount = functionMirror.parameters.length;
var args = [];
if (parameterCount > 0) args.add(container);
if (parameterCount > 1) {
if (params is List) {
return Function.apply(callback, [container, ...params]);
args.addAll(params);
} else if (params != null) {
return callback(container, params);
} else {
return callback(container);
args.add(params);
}
}
// Ensure we have the correct number of arguments
while (args.length < parameterCount) {
args.add(null);
}
// Trim excess arguments if we have too many
if (args.length > parameterCount) {
args = args.sublist(0, parameterCount);
}
return Function.apply(callback, args);
} catch (e) {
try {
// Try calling with just the container
return callback(container);
} catch (e) {
try {
// Try calling without any arguments
return callback();
} catch (e) {
try {
// Try calling with just the params
if (params is List) {
return Function.apply(callback, params);
} else if (params != null) {
return callback(params);
}
} catch (e) {
// If all attempts fail, throw an exception
throw BindingResolutionException(
'Failed to call bound method: $e');
}
}
}
throw BindingResolutionException('Failed to call bound method: $e');
}
};
}
@ -535,11 +533,30 @@ class Container implements ContainerContract, Map<String, dynamic> {
_resolvingCallbacks.clear();
_afterResolvingCallbacks.clear();
_afterResolvingAttributeCallbacks.clear();
// Ensure all resolved flags are reset
for (var key in _resolved.keys.toList()) {
_resolved[key] = false;
}
}
@override
bool resolved(String abstract) {
return _resolved.containsKey(abstract) && _resolved[abstract]!;
abstract = _getAlias(abstract);
return _resolved.containsKey(abstract) || _instances.containsKey(abstract);
}
bool isAlias(String name) {
return _aliases.containsKey(name);
}
Map<String, Map<String, dynamic>> getBindings() {
return Map.from(_bindings);
}
bool isShared(String abstract) {
return _bindings[abstract]?['shared'] == true ||
_instances.containsKey(abstract);
}
@override
@ -651,19 +668,6 @@ class Container implements ContainerContract, Map<String, dynamic> {
return _extenders[abstract] ?? [];
}
Map<String, Map<String, dynamic>> getBindings() {
return Map.from(_bindings);
}
bool isAlias(String name) {
return _aliases.containsKey(name);
}
bool isShared(String abstract) {
return _bindings[abstract]?['shared'] == true ||
_instances.containsKey(abstract);
}
// Implement Map methods
@override

53
packages/service_container/test/container_test.dart
View file

@ -194,6 +194,59 @@ void main() {
var secondInstantiation = container.makeScoped('class');
expect(firstInstantiation, same(secondInstantiation));
});
test('testForgetInstanceForgetsInstance', () {
var containerConcreteStub = ContainerConcreteStub();
container.instance('ContainerConcreteStub', containerConcreteStub);
expect(container.isShared('ContainerConcreteStub'), isTrue);
container.forgetInstance('ContainerConcreteStub');
expect(container.isShared('ContainerConcreteStub'), isFalse);
});
test('testForgetInstancesForgetsAllInstances', () {
var stub1 = ContainerConcreteStub();
var stub2 = ContainerConcreteStub();
var stub3 = ContainerConcreteStub();
container.instance('Instance1', stub1);
container.instance('Instance2', stub2);
container.instance('Instance3', stub3);
expect(container.isShared('Instance1'), isTrue);
expect(container.isShared('Instance2'), isTrue);
expect(container.isShared('Instance3'), isTrue);
container.forgetInstances();
expect(container.isShared('Instance1'), isFalse);
expect(container.isShared('Instance2'), isFalse);
expect(container.isShared('Instance3'), isFalse);
});
test('testContainerFlushFlushesAllBindingsAliasesAndResolvedInstances', () {
container.bind('ConcreteStub', (Container c) => ContainerConcreteStub(),
shared: true);
container.alias('ConcreteStub', 'ContainerConcreteStub');
container.make('ConcreteStub');
expect(container.resolved('ConcreteStub'), isTrue);
expect(container.isAlias('ContainerConcreteStub'), isTrue);
expect(container.getBindings().containsKey('ConcreteStub'), isTrue);
expect(container.isShared('ConcreteStub'), isTrue);
container.flush();
expect(container.resolved('ConcreteStub'), isFalse);
expect(container.isAlias('ContainerConcreteStub'), isFalse);
expect(container.getBindings().isEmpty, isTrue);
expect(container.isShared('ConcreteStub'), isFalse);
});
test('testResolvedResolvesAliasToBindingNameBeforeChecking', () {
container.bind('ConcreteStub', (Container c) => ContainerConcreteStub(),
shared: true);
container.alias('ConcreteStub', 'foo');
expect(container.resolved('ConcreteStub'), isFalse);
expect(container.resolved('foo'), isFalse);
container.make('ConcreteStub');
expect(container.resolved('ConcreteStub'), isTrue);
expect(container.resolved('foo'), isTrue);
});
});
}