use of com.google.gwt.inject.rebind.util.InjectorMethod in project google-gin by gwtplus.
the class BindConstantBindingTest method assertCreationStatements.
/**
* Verifies that invoking binding.getCreationStatements() produces no helper
* methods, does not invoke any methods on the write context, and produces the
* given statements.
*/
private void assertCreationStatements(Binding binding, String expectedStatements) throws NoSourceNameException {
InjectorWriteContext writeContextMock = createMock(InjectorWriteContext.class);
replay(writeContextMock);
List<InjectorMethod> methods = new ArrayList<InjectorMethod>();
String actualStatements = binding.getCreationStatements(null, methods).getSource(writeContextMock);
assertEquals(expectedStatements, actualStatements);
assertEquals(0, methods.size());
verify(writeContextMock);
}
use of com.google.gwt.inject.rebind.util.InjectorMethod in project google-gin by gwtplus.
the class GinjectorBindingsOutputterTest method testOutputStaticInjections.
// Verify that outputting static injections creates and dispatches to the
// correct fragment classes.
public void testOutputStaticInjections() throws Exception {
PrintWriter printWriter = new PrintWriter(new ByteArrayOutputStream());
GeneratorContext ctx = createMock(GeneratorContext.class, "ctx");
expect(ctx.tryCreate((TreeLogger) anyObject(), (String) anyObject(), (String) anyObject())).andStubReturn(printWriter);
Capture<FieldLiteral<SuperClass>> fieldCapture = new Capture<FieldLiteral<SuperClass>>();
Capture<MethodLiteral<SuperClass, Method>> methodCapture = new Capture<MethodLiteral<SuperClass, Method>>();
NameGenerator nameGenerator = createMock(NameGenerator.class, "nameGenerator");
expect(nameGenerator.convertToValidMemberName("injectStatic_com.google.gwt.inject.rebind.output." + "GinjectorBindingsOutputterTest$SubClass")).andStubReturn("test_injectSubClass");
expect(nameGenerator.convertToValidMemberName("injectStatic_com.google.gwt.inject.rebind.output.subpackage." + "SubPackageClass")).andStubReturn("test_injectSubPackageClass");
SourceWriteUtil sourceWriteUtil = createMock(SourceWriteUtil.class, "sourceWriteUtil");
expect(sourceWriteUtil.createFieldInjection(capture(fieldCapture), (String) anyObject(), (NameGenerator) anyObject(), (List<InjectorMethod>) anyObject())).andReturn(SourceSnippets.forText(""));
MethodCallUtil methodCallUtil = createMock(MethodCallUtil.class, "methodCallUtil");
expect(methodCallUtil.createMethodCallWithInjection(capture(methodCapture), (String) anyObject(), (NameGenerator) anyObject(), (List<InjectorMethod>) anyObject())).andReturn(SourceSnippets.forText(""));
GinjectorBindings bindings = createMock(GinjectorBindings.class, "bindings");
expect(bindings.getNameGenerator()).andStubReturn(nameGenerator);
expect(bindings.getStaticInjectionRequests()).andStubReturn(Arrays.<Class<?>>asList(SubClass.class, SubPackageClass.class));
String ginjectorPackageName = "com.google.gwt.inject.rebind.output";
String ginjectorClassName = "GinjectorFragmentOutputterTest$FakeGinjector";
GinjectorFragmentOutputter.Factory fragmentOutputterFactory = createMock(GinjectorFragmentOutputter.Factory.class, "fragmentOutputterFactory");
GinjectorFragmentOutputter fragmentOutputter = createMock(GinjectorFragmentOutputter.class, "fragmentOutputter");
GinjectorFragmentOutputter fragmentOutputterSubpackage = createMock(GinjectorFragmentOutputter.class, "fragmentOutputterSubpackage");
expect(fragmentOutputterFactory.create(bindings, new FragmentPackageName(null, "com.google.gwt.inject.rebind.output"), ginjectorPackageName, ginjectorClassName)).andStubReturn(fragmentOutputter);
expect(fragmentOutputterFactory.create(bindings, new FragmentPackageName(null, "com.google.gwt.inject.rebind.output.subpackage"), ginjectorPackageName, ginjectorClassName)).andStubReturn(fragmentOutputterSubpackage);
fragmentOutputter.outputMethod((InjectorMethod) anyObject());
fragmentOutputterSubpackage.outputMethod((InjectorMethod) anyObject());
fragmentOutputter.invokeInInitializeStaticInjections("test_injectSubClass");
fragmentOutputterSubpackage.invokeInInitializeStaticInjections("test_injectSubPackageClass");
replay();
GinjectorBindingsOutputter outputter = new GinjectorBindingsOutputter(ctx, null, fragmentOutputterFactory, new TestFragmentPackageNameFactory(), null, TreeLogger.NULL, methodCallUtil, null, null);
GinjectorBindingsOutputter.FragmentMap fragments = new GinjectorBindingsOutputter.FragmentMap(bindings, ginjectorPackageName, ginjectorClassName, fragmentOutputterFactory);
outputter.outputStaticInjections(bindings, fragments, sourceWriteUtil);
verify();
TypeLiteral<SuperClass> superClass = TypeLiteral.get(SuperClass.class);
assertEquals(superClass, methodCapture.getValue().getDeclaringType());
assertEquals(superClass, fieldCapture.getValue().getDeclaringType());
}
use of com.google.gwt.inject.rebind.util.InjectorMethod in project google-gin by gwtplus.
the class GinjectorBindingsOutputter method outputStaticInjectionMethods.
/**
* Outputs all the static injection methods for the given class.
*/
void outputStaticInjectionMethods(Class<?> type, FragmentMap fragments, NameGenerator nameGenerator, SourceWriteUtil sourceWriteUtil) {
String methodName = nameGenerator.convertToValidMemberName("injectStatic_" + type.getName());
SourceSnippetBuilder body = new SourceSnippetBuilder();
for (InjectionPoint injectionPoint : InjectionPoint.forStaticMethodsAndFields(type)) {
Member member = injectionPoint.getMember();
try {
List<InjectorMethod> staticInjectionHelpers = new ArrayList<InjectorMethod>();
if (member instanceof Method) {
MethodLiteral<?, Method> method = MethodLiteral.get((Method) member, TypeLiteral.get(member.getDeclaringClass()));
body.append(methodCallUtil.createMethodCallWithInjection(method, null, nameGenerator, staticInjectionHelpers));
} else if (member instanceof Field) {
FieldLiteral<?> field = FieldLiteral.get((Field) member, TypeLiteral.get(member.getDeclaringClass()));
body.append(sourceWriteUtil.createFieldInjection(field, null, nameGenerator, staticInjectionHelpers));
}
outputMethods(staticInjectionHelpers, fragments);
} catch (NoSourceNameException e) {
errorManager.logError(e.getMessage(), e);
}
}
// Note that the top-level method that performs static injection will only
// invoke a bunch of other injector methods. Therefore, it doesn't matter
// which package it goes in, and we don't need to invoke getUserPackageName
// (which is good, because in practice users statically inject types that
// have no user package name because they're private inner classes!)
String packageName = type.getPackage().getName();
InjectorMethod method = SourceSnippets.asMethod(false, "private void " + methodName + "()", packageName, body.build());
GinjectorFragmentOutputter fragment = fragments.get(fragmentPackageNameFactory.create(packageName));
fragment.outputMethod(method);
fragment.invokeInInitializeStaticInjections(methodName);
}
use of com.google.gwt.inject.rebind.util.InjectorMethod in project google-gin by gwtplus.
the class GinjectorBindingsOutputter method outputMemberInjections.
/**
* Adds member injections to each fragment.
*/
private void outputMemberInjections(GinjectorBindings bindings, FragmentMap fragments, SourceWriteUtil sourceWriteUtil) {
NameGenerator nameGenerator = bindings.getNameGenerator();
for (TypeLiteral<?> type : bindings.getMemberInjectRequests()) {
if (!reachabilityAnalyzer.isReachableMemberInject(bindings, type)) {
continue;
}
List<InjectorMethod> memberInjectionHelpers = new ArrayList<InjectorMethod>();
try {
sourceWriteUtil.createMemberInjection(type, nameGenerator, memberInjectionHelpers);
outputMethods(memberInjectionHelpers, fragments);
} catch (NoSourceNameException e) {
errorManager.logError(e.getMessage(), e);
}
}
}
use of com.google.gwt.inject.rebind.util.InjectorMethod in project google-gin by gwtplus.
the class GinjectorBindingsOutputter method outputBindings.
/**
* Outputs the top-level injector for the given {@link GinjectorBindings},
* along with all of its fragments.
*
* <p>The top-level injector contains one field for each fragment of the
* injector, which stores a reference to an instance of that fragment. In
* addition, it contains a getter for every public type created by one of its
* fragments, each of which forwards to a getter in the corresponding
* fragment. In addition to being the injector's public interface, these
* getters are used by each fragment of the injector to retrieve objects
* created by other fragments.
*/
private void outputBindings(GinjectorBindings bindings, FragmentMap fragments, SourceWriter writer) {
NameGenerator nameGenerator = bindings.getNameGenerator();
// The initialize*() methods contain code that needs to run before the root
// injector is returned to the client, but after the injector hierarchy is
// fully constructed.
// Collects the text of the body of initializeEagerSingletons().
StringBuilder initializeEagerSingletonsBody = new StringBuilder();
// Collects the text of the body of initializeStaticInjections().
StringBuilder initializeStaticInjectionsBody = new StringBuilder();
SourceWriteUtil sourceWriteUtil = sourceWriteUtilFactory.create(bindings);
// Output child modules.
for (GinjectorBindings child : bindings.getChildren()) {
String className = ginjectorNameGenerator.getClassName(child);
String canonicalClassName = ginjectorNameGenerator.getCanonicalClassName(child);
String fieldName = ginjectorNameGenerator.getFieldName(child);
String getterName = nameGenerator.getChildInjectorGetterMethodName(className);
writer.beginJavaDocComment();
writer.print("Child injector for %s", child.getModule());
writer.endJavaDocComment();
writer.println("private %s %s = null;", canonicalClassName, fieldName);
writer.beginJavaDocComment();
writer.print("Getter for child injector for %s", child.getModule());
writer.endJavaDocComment();
sourceWriteUtil.writeMethod(writer, String.format("public %s %s()", canonicalClassName, getterName), String.format("if (%2$s == null) {\n" + " %2$s = new %1$s(this);\n" + "}\n\n" + "return %2$s;", canonicalClassName, fieldName));
// Ensure that the initializer initializes this child, if necessary.
outputSubInitialize(child, getterName, initializeEagerSingletonsBody, initializeStaticInjectionsBody);
}
initializeEagerSingletonsBody.append("\n");
initializeStaticInjectionsBody.append("\n");
outputInterfaceField(bindings, sourceWriteUtil, writer);
outputMemberInjections(bindings, fragments, sourceWriteUtil);
outputStaticInjections(bindings, fragments, sourceWriteUtil);
// Output the bindings in the fragments.
for (Map.Entry<Key<?>, Binding> entry : bindings.getBindings()) {
Binding binding = entry.getValue();
if (!reachabilityAnalyzer.isReachable(binding)) {
continue;
}
FragmentPackageName fragmentPackageName = fragmentPackageNameFactory.create(binding.getGetterMethodPackage());
Key<?> key = entry.getKey();
List<InjectorMethod> helperMethods = new ArrayList();
fragments.get(fragmentPackageName).writeBindingGetter(key, binding, bindings.determineScope(key), helperMethods);
outputMethods(helperMethods, fragments);
}
// Output the fragment members.
outputFragments(bindings, fragments, initializeEagerSingletonsBody, initializeStaticInjectionsBody, sourceWriteUtil, writer);
writeConstructor(bindings, sourceWriteUtil, writer);
writeInitializers(bindings, initializeEagerSingletonsBody, initializeStaticInjectionsBody, sourceWriteUtil, writer);
}
Aggregations