def describe_compositing_GuiceData_instances():
class GrandDaddy(object): pass
g_data = GuiceData.from_class(GrandDaddy)
g_data.init = object()
g_data.methods = {'g_method': object(),'method': object()}
class Daddy(GrandDaddy): pass
d_data = GuiceData.from_class(Daddy)
d_data.init = object()
d_data.methods = {'d_method': object(),'method': object()}
class Son(Daddy): pass
s_data = GuiceData.from_class(Son)
s_data.init = object()
s_data.methods = {'s_method': object()}
data = GuiceData.composite_from_class(Son)
def should_have_create_a_new_GuiceData_instance():
assert isinstance(data, GuiceData)
assert data not in (g_data, d_data, s_data)
def should_have_all_unique_methods():
assert data.methods['g_method'] == g_data.methods['g_method']
assert data.methods['d_method'] == d_data.methods['d_method']
assert data.methods['s_method'] == s_data.methods['s_method']
def should_use_the_last_method_defined():
assert data.methods['method'] == d_data.methods['method']
def describe_when_using_builtin_types():
data0 = GuiceData.from_class(object)
data1 = GuiceData.from_class(object)
def should_have_gotten_GuiceData_instances():
assert isinstance(data0, GuiceData)
assert isinstance(data1, GuiceData)
def should_return_new_instance_each_time():
assert data0 is not data1
def should_not_be_storing_instance():
assert not hasattr(object, '__guice__')
def get(self):
kwargs = {}
method_name = method.__name__
guice_data = _GuiceData.from_class(module.__class__)
injectable_args = guice_data.methods.get(method_name, {})
for name, guicearg in injectable_args.items():
kwargs[name] = self._injector.get_instance(
guicearg.datatype, guicearg.annotation)
return method(**kwargs)
def get(self):
kwargs = {}
method_name = method.__name__
guice_data = _GuiceData.from_class(module.__class__)
injectable_args = guice_data.methods.get(method_name, {})
for name, guicearg in injectable_args.items():
kwargs[name] = self._injector.get_instance(
guicearg.datatype, guicearg.annotation)
return method(**kwargs)
def describe_with_instance_attached():
existing_data = GuiceData()
class Dummy(object):
__guice__ = existing_data
data = GuiceData.from_class(Dummy)
def should_return_existing_instance():
assert existing_data is data
def describe_without_instance_attached():
class Dummy(object): pass
data = GuiceData.from_class(Dummy)
def should_return_a_GuiceData_instance():
assert isinstance(data, GuiceData)
def should_save_create_class_attribute():
assert Dummy.__guice__ is data
def AssistProvider(cls):
guice_data = GuiceData.from_class(cls)
if not getattr(guice_data, 'assisted', False):
raise AssistError('AssistProvider can only by used on '
'@assisted_inject-ed classes')
class _AssistProvider(object):
@inject(injector=Injector)
def __init__(self, injector):
self._injector = injector
def get(self):
return build_factory(self._injector, cls)
return _AssistProvider
def AssistProvider(cls):
guice_data = GuiceData.from_class(cls)
if not getattr(guice_data, 'assisted', False):
raise AssistError('AssistProvider can only by used on '
'@assisted_inject-ed classes')
class _AssistProvider(object):
@inject(injector=Injector)
def __init__(self, injector):
self._injector = injector
def get(self):
return build_factory(self._injector, cls)
return _AssistProvider
def build_factory(injector, cls):
guice_data = GuiceData.from_class(cls)
providers = {}
for name, guicearg in guice_data.init.items():
providers[name] = injector.get_provider(guicearg.datatype,
guicearg.annotation)
all_args = inspect.getargspec(cls.__init__).args[1:]
needed_args = set(all_args) - set(providers.keys())
class DynamicFactory(object):
def create(self, **kwargs):
if set(kwargs.keys()) - needed_args:
raise TypeError(
'TODO: error message here about too many values')
for name, provider in providers.items():
kwargs[name] = provider.get()
return cls(**kwargs)
return DynamicFactory()
def build_factory(injector, cls):
guice_data = GuiceData.from_class(cls)
providers = {}
for name, guicearg in guice_data.init.items():
providers[name] = injector.get_provider(guicearg.datatype,
guicearg.annotation)
all_args = inspect.getargspec(cls.__init__).args[1:]
needed_args = set(all_args) - set(providers.keys())
class DynamicFactory(object):
def create(self, **kwargs):
if set(kwargs.keys()) - needed_args:
raise TypeError('TODO: error message here about too many values')
for name, provider in providers.items():
kwargs[name] = provider.get()
return cls(**kwargs)
return DynamicFactory()
