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,