def test_unscoped_injectables_are_available_in_any_scope():
Greeting = zuice.key("Greeting")
Name = zuice.key("Name")
class Greeter(zuice.Base):
_greeting = zuice.dependency(Greeting)
_name = zuice.dependency(Name)
def hello(self):
return "{0} {1}".format(self._greeting, self._name)
bindings = Bindings()
bindings.bind(Greeting).to_instance("Hello")
injector = Injector(bindings)
greeter = injector.get(Greeter, {Name: "Bob"})
assert greeter.hello() == "Hello Bob"
def test_can_retrieve_scoped_value_when_scoped_value_is_set_alongside_other_values(self):
x = []
Name = zuice.key("Name")
Greeting = zuice.key("Greeting")
def count(injector):
name = injector.get(Name)
x.append(name)
return x
counter = zuice.key("counter")
bindings = Bindings()
with bindings.scope(Name) as scope_bindings:
scope_bindings.bind(counter).to_provider(count)
injector = Injector(bindings)
assert_equal(["Bob"], injector.get(counter, {Name: "Bob", Greeting: "hello"}))
def test_scoped_injectables_cannot_depend_on_injectables_in_separate_scope():
Name = zuice.key("Name")
class Greeter(zuice.Base):
_name = zuice.dependency(Name)
bindings = Bindings()
bindings.bind(Greeter).singleton()
injector = Injector(bindings)
error = assert_raises(NoSuchBindingException, lambda: injector.get(Greeter, {Name: "Bob"}))
def test_bindings_can_scope_provider_to_value(self):
x = []
Name = zuice.key("Name")
def count(injector):
name = injector.get(Name)
x.append(name)
return x
counter = zuice.key("counter")
bindings = Bindings()
with bindings.scope(Name) as scope_bindings:
scope_bindings.bind(counter).to_provider(count)
injector = Injector(bindings)
assert_equal(["Bob"], injector.get(counter, {Name: "Bob"}))
assert_equal(["Bob"], injector.get(counter, {Name: "Bob"}))
assert_equal(["Bob", "Jim"], injector.get(counter, {Name: "Jim"}))
def test_original_bindings_are_prefered_to_zero_arg_constructors():
class Unit(object):
pass
unit = Unit()
bindings = Bindings()
bindings.bind(Unit).to_instance(unit)
injector = Injector(bindings)
assert injector.get(Unit, {zuice.key("a"): "a"}) is unit
def test_bindings_can_change_lifetime_of_provider_to_singleton(self):
x = [0]
def count(injector):
x[0] += 1
return x[0]
counter = zuice.key("counter")
bindings = Bindings()
bindings.bind(counter).to_provider(count).singleton()
injector = Injector(bindings)
assert_equal(1, injector.get(counter))
assert_equal(1, injector.get(counter))
def test_can_set_bindings_for_keys_in_call_to_injected_factory():
Name = zuice.key("Name")
class Greeter(zuice.Base):
_name = zuice.dependency(Name)
def hello(self):
return "Hello {0}".format(self._name)
injector = Injector(Bindings())
factory = injector.get(zuice.factory(Greeter))
greeter = factory({Name: "Bob"})
assert greeter.hello() == "Hello Bob"
import zuice
import dodge
from . import builtins, name_resolution, nodes
ModuleName = zuice.key("ModuleName")
FuncName = zuice.key("FuncName")
class ClassBuilderTransform(zuice.Base):
_name_resolver = zuice.dependency(name_resolution.NameResolver)
_module_name = zuice.dependency(ModuleName)
_func_name = zuice.dependency(FuncName)
def __call__(self, module_node):
references = self._name_resolver.resolve(module_node)
return self._transform(module_node, references)
def _transform(self, node, references):
if self._is_class_builder_assignment(node, references):
return self._transform_assignment(node, references)
else:
return self._map_nodes(node, references)
def _is_class_builder_assignment(self, node, references):
if not isinstance(node, nodes.Assignment):
return False
if not isinstance(node.value, nodes.Call):
return False
class TransformingSourceTree(object):
def __init__(self, source_tree, transform):
self._source_tree = source_tree
self._transform = transform
def module(self, path):
module = self._source_tree.module(path)
if module is None:
return None
else:
return LocalModule(module.path, self._transform(module.node))
class FileSystemSourceTree(object):
def module(self, path):
if not os.path.exists(path) or not os.path.isfile(path):
return None
with open(path) as source_file:
module_node = parser.parse(source_file.read(), filename=path)
return LocalModule(path, module_node)
class CircularImportError(Exception):
pass
SourceTree = zuice.key("SourceTree")
import zuice
Builtins = zuice.key("Builtins")
InitialDeclarations = zuice.key("InitialDeclarations")
BuiltinModules = zuice.key("BuiltinModules")
def test_can_set_bindings_for_keys_in_call_to_get():
Name = zuice.key("Name")
injector = Injector(Bindings())
assert_equal("Bob", injector.get(Name, {Name: "Bob"}))
def is_module(value):
return isinstance(value, _Module)
class TypeLookup(object):
def __init__(self, types):
assert isinstance(types, NodeDict)
self._types = types
def type_of(self, node):
return self._types.get(node)
TypeLookupFactory = zuice.key("TypeLookupFactory")
from ..builtin_types import (
none_type,
int_type, int_meta_type,
bool_type, bool_meta_type,
str_type, str_meta_type,
list_type, list_meta_type,
dict_type, dict_meta_type,
tuple_type,
slice_type, is_tuple,
iterable,
iterator,
has_len,
exception_type, exception_meta_type,
