Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Harmonize use of generate

Browse Source 
This commit harmonizes the use of the "generate" keyword for anything
related to code generation. Previously, there was a mix of "generate"
and "write."

See gh-28047
This commit is contained in:
Stephane Nicoll
2022-03-04 10:00:57 +01:00
parent ea19b92deb
commit 97986b368a
6 changed files with 151 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
spring-beans/src/test/java/org/springframework/beans/factory/generator/BeanParameterGeneratorTests.java
View File

@@ -41,6 +41,7 @@ import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.core.ResolvableType;
import org.springframework.core.io.ResourceLoader;
import org.springframework.javapoet.support.CodeSnippet;
import org.springframework.lang.Nullable;
import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat;
@@ -59,21 +60,21 @@ class BeanParameterGeneratorTests {
private final BeanParameterGenerator generator = new BeanParameterGenerator();
@Test
void writeCharArray() {
void generateCharArray() {
char[] value = new char[] { 'v', 'a', 'l', 'u', 'e' };
assertThat(write(value, ResolvableType.forArrayComponent(ResolvableType.forClass(char.class))))
assertThat(generate(value, ResolvableType.forArrayComponent(ResolvableType.forClass(char.class))))
.isEqualTo("new char[] { 'v', 'a', 'l', 'u', 'e' }");
}
@Test
void writeStringArray() {
void generateStringArray() {
String[] value = new String[] { "a", "test" };
assertThat(write(value, ResolvableType.forArrayComponent(ResolvableType.forClass(String.class))))
assertThat(generate(value, ResolvableType.forArrayComponent(ResolvableType.forClass(String.class))))
.isEqualTo("new String[] { \"a\", \"test\" }");
}
@Test
void writeStringList() {
void generateStringList() {
List<String> value = List.of("a", "test");
CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(List.class, String.class));
assertThat(code.getSnippet()).isEqualTo(
@@ -82,7 +83,7 @@ class BeanParameterGeneratorTests {
}
@Test
void writeStringManagedList() {
void generateStringManagedList() {
ManagedList<String> value = ManagedList.of("a", "test");
CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(List.class, String.class));
assertThat(code.getSnippet()).isEqualTo(
@@ -91,7 +92,7 @@ class BeanParameterGeneratorTests {
}
@Test
void writeEmptyList() {
void generateEmptyList() {
List<String> value = List.of();
CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(List.class, String.class));
assertThat(code.getSnippet()).isEqualTo("Collections.emptyList()");
@@ -99,7 +100,7 @@ class BeanParameterGeneratorTests {
}
@Test
void writeStringSet() {
void generateStringSet() {
Set<String> value = Set.of("a", "test");
CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(Set.class, String.class));
assertThat(code.getSnippet()).startsWith("Set.of(").contains("a").contains("test");
@@ -107,7 +108,7 @@ class BeanParameterGeneratorTests {
}
@Test
void writeStringManagedSet() {
void generateStringManagedSet() {
Set<String> value = ManagedSet.of("a", "test");
CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(Set.class, String.class));
assertThat(code.getSnippet()).isEqualTo(
@@ -116,7 +117,7 @@ class BeanParameterGeneratorTests {
}
@Test
void writeEmptySet() {
void generateEmptySet() {
Set<String> value = Set.of();
CodeSnippet code = codeSnippet(value, ResolvableType.forClassWithGenerics(Set.class, String.class));
assertThat(code.getSnippet()).isEqualTo("Collections.emptySet()");
@@ -124,39 +125,39 @@ class BeanParameterGeneratorTests {
}
@Test
void writeMap() {
void generateMap() {
Map<String, Object> value = new LinkedHashMap<>();
value.put("name", "Hello");
value.put("counter", 42);
assertThat(write(value)).isEqualTo("Map.of(\"name\", \"Hello\", \"counter\", 42)");
assertThat(generate(value)).isEqualTo("Map.of(\"name\", \"Hello\", \"counter\", 42)");
}
@Test
void writeMapWithEnum() {
void generateMapWithEnum() {
Map<String, Object> value = new HashMap<>();
value.put("unit", ChronoUnit.DAYS);
assertThat(write(value)).isEqualTo("Map.of(\"unit\", ChronoUnit.DAYS)");
assertThat(generate(value)).isEqualTo("Map.of(\"unit\", ChronoUnit.DAYS)");
}
@Test
void writeEmptyMap() {
assertThat(write(Map.of())).isEqualTo("Map.of()");
void generateEmptyMap() {
assertThat(generate(Map.of())).isEqualTo("Map.of()");
}
@Test
void writeString() {
assertThat(write("test", ResolvableType.forClass(String.class))).isEqualTo("\"test\"");
void generateString() {
assertThat(generate("test", ResolvableType.forClass(String.class))).isEqualTo("\"test\"");
}
@Test
void writeCharEscapeBackslash() {
assertThat(write('\\', ResolvableType.forType(char.class))).isEqualTo("'\\\\'");
void generateCharEscapeBackslash() {
assertThat(generate('\\', ResolvableType.forType(char.class))).isEqualTo("'\\\\'");
}
@ParameterizedTest
@MethodSource("primitiveValues")
void writePrimitiveValue(Object value, String parameter) {
assertThat(write(value, ResolvableType.forClass(value.getClass()))).isEqualTo(parameter);
void generatePrimitiveValue(Object value, String parameter) {
assertThat(generate(value, ResolvableType.forClass(value.getClass()))).isEqualTo(parameter);
}
private static Stream<Arguments> primitiveValues() {
@@ -166,87 +167,88 @@ class BeanParameterGeneratorTests {
}
@Test
void writeEnum() {
assertThat(write(ChronoUnit.DAYS, ResolvableType.forClass(ChronoUnit.class)))
void generateEnum() {
assertThat(generate(ChronoUnit.DAYS, ResolvableType.forClass(ChronoUnit.class)))
.isEqualTo("ChronoUnit.DAYS");
}
@Test
void writeClass() {
assertThat(write(Integer.class, ResolvableType.forClass(Class.class)))
void generateClass() {
assertThat(generate(Integer.class, ResolvableType.forClass(Class.class)))
.isEqualTo("Integer.class");
}
@Test
void writeResolvableType() {
void generateResolvableType() {
ResolvableType type = ResolvableType.forClassWithGenerics(Consumer.class, Integer.class);
assertThat(write(type, type))
assertThat(generate(type, type))
.isEqualTo("ResolvableType.forClassWithGenerics(Consumer.class, Integer.class)");
}
@Test
void writeExecutableParameterTypesWithConstructor() {
void generateExecutableParameterTypesWithConstructor() {
Constructor<?> constructor = TestSample.class.getDeclaredConstructors()[0];
assertThat(CodeSnippet.process(this.generator.writeExecutableParameterTypes(constructor)))
assertThat(CodeSnippet.process(this.generator.generateExecutableParameterTypes(constructor)))
.isEqualTo("String.class, ResourceLoader.class");
}
@Test
void writeExecutableParameterTypesWithNoArgConstructor() {
void generateExecutableParameterTypesWithNoArgConstructor() {
Constructor<?> constructor = BeanParameterGeneratorTests.class.getDeclaredConstructors()[0];
assertThat(CodeSnippet.process(this.generator.writeExecutableParameterTypes(constructor)))
assertThat(CodeSnippet.process(this.generator.generateExecutableParameterTypes(constructor)))
.isEmpty();
}
@Test
void writeExecutableParameterTypesWithMethod() {
void generateExecutableParameterTypesWithMethod() {
Method method = ReflectionUtils.findMethod(TestSample.class, "createBean", String.class, Integer.class);
assertThat(CodeSnippet.process(this.generator.writeExecutableParameterTypes(method)))
assertThat(CodeSnippet.process(this.generator.generateExecutableParameterTypes(method)))
.isEqualTo("String.class, Integer.class");
}
@Test
void writeNull() {
assertThat(write(null)).isEqualTo("null");
void generateNull() {
assertThat(generate(null)).isEqualTo("null");
}
@Test
void writeBeanReference() {
void generateBeanReference() {
BeanReference beanReference = mock(BeanReference.class);
given(beanReference.getBeanName()).willReturn("testBean");
assertThat(write(beanReference)).isEqualTo("new RuntimeBeanReference(\"testBean\")");
assertThat(generate(beanReference)).isEqualTo("new RuntimeBeanReference(\"testBean\")");
}
@Test
void writeBeanDefinitionCallsConsumer() {
void generateBeanDefinitionCallsConsumer() {
BeanParameterGenerator customGenerator = new BeanParameterGenerator(
((beanDefinition, builder) -> builder.add("test")));
assertThat(CodeSnippet.process(customGenerator.writeParameterValue(new RootBeanDefinition()))).isEqualTo("test");
assertThat(CodeSnippet.process(customGenerator.generateParameterValue(
new RootBeanDefinition()))).isEqualTo("test");
}
@Test
void writeBeanDefinitionWithoutConsumerFails() {
void generateBeanDefinitionWithoutConsumerFails() {
BeanParameterGenerator customGenerator = new BeanParameterGenerator();
assertThatIllegalStateException().isThrownBy(() -> customGenerator
.writeParameterValue(new RootBeanDefinition()));
.generateParameterValue(new RootBeanDefinition()));
}
@Test
void writeUnsupportedParameter() {
assertThatIllegalArgumentException().isThrownBy(() -> write(new StringWriter()))
void generateUnsupportedParameter() {
assertThatIllegalArgumentException().isThrownBy(() -> generate(new StringWriter()))
.withMessageContaining(StringWriter.class.getName());
}
private String write(Object value) {
return CodeSnippet.process(this.generator.writeParameterValue(value));
private String generate(@Nullable Object value) {
return CodeSnippet.process(this.generator.generateParameterValue(value));
}
private String write(Object value, ResolvableType resolvableType) {
private String generate(Object value, ResolvableType resolvableType) {
return codeSnippet(value, resolvableType).getSnippet();
}
private CodeSnippet codeSnippet(Object value, ResolvableType resolvableType) {
return CodeSnippet.of(this.generator.writeParameterValue(value, () -> resolvableType));
return CodeSnippet.of(this.generator.generateParameterValue(value, () -> resolvableType));
}

76
spring-beans/src/test/java/org/springframework/beans/factory/generator/InjectionGeneratorTests.java
View File

@@ -45,119 +45,119 @@ class InjectionGeneratorTests {
private final ProtectedAccess protectedAccess = new ProtectedAccess();
@Test
void writeInstantiationForConstructorWithNoArgUseShortcut() {
void generateInstantiationForConstructorWithNoArgUseShortcut() {
Constructor<?> constructor = SimpleBean.class.getDeclaredConstructors()[0];
assertThat(writeInstantiation(constructor).lines())
assertThat(generateInstantiation(constructor).lines())
.containsExactly("new InjectionGeneratorTests.SimpleBean()");
}
@Test
void writeInstantiationForConstructorWithNonGenericParameter() {
void generateInstantiationForConstructorWithNonGenericParameter() {
Constructor<?> constructor = SimpleConstructorBean.class.getDeclaredConstructors()[0];
assertThat(writeInstantiation(constructor).lines()).containsExactly(
assertThat(generateInstantiation(constructor).lines()).containsExactly(
"instanceContext.create(beanFactory, (attributes) -> new InjectionGeneratorTests.SimpleConstructorBean(attributes.get(0), attributes.get(1)))");
}
@Test
void writeInstantiationForConstructorWithGenericParameter() {
void generateInstantiationForConstructorWithGenericParameter() {
Constructor<?> constructor = GenericConstructorBean.class.getDeclaredConstructors()[0];
assertThat(writeInstantiation(constructor).lines()).containsExactly(
assertThat(generateInstantiation(constructor).lines()).containsExactly(
"instanceContext.create(beanFactory, (attributes) -> new InjectionGeneratorTests.GenericConstructorBean(attributes.get(0)))");
}
@Test
void writeInstantiationForAmbiguousConstructor() throws Exception {
void generateInstantiationForAmbiguousConstructor() throws Exception {
Constructor<?> constructor = AmbiguousConstructorBean.class.getDeclaredConstructor(String.class, Number.class);
assertThat(writeInstantiation(constructor).lines()).containsExactly(
assertThat(generateInstantiation(constructor).lines()).containsExactly(
"instanceContext.create(beanFactory, (attributes) -> new InjectionGeneratorTests.AmbiguousConstructorBean(attributes.get(0, String.class), attributes.get(1, Number.class)))");
}
@Test
void writeInstantiationForConstructorInInnerClass() {
void generateInstantiationForConstructorInInnerClass() {
Constructor<?> constructor = InnerClass.class.getDeclaredConstructors()[0];
assertThat(writeInstantiation(constructor).lines()).containsExactly(
assertThat(generateInstantiation(constructor).lines()).containsExactly(
"beanFactory.getBean(InjectionGeneratorTests.SimpleConstructorBean.class).new InnerClass()");
}
@Test
void writeInstantiationForMethodWithNoArgUseShortcut() {
assertThat(writeInstantiation(method(SimpleBean.class, "name")).lines()).containsExactly(
void generateInstantiationForMethodWithNoArgUseShortcut() {
assertThat(generateInstantiation(method(SimpleBean.class, "name")).lines()).containsExactly(
"beanFactory.getBean(InjectionGeneratorTests.SimpleBean.class).name()");
}
@Test
void writeInstantiationForStaticMethodWithNoArgUseShortcut() {
assertThat(writeInstantiation(method(SimpleBean.class, "number")).lines()).containsExactly(
void generateInstantiationForStaticMethodWithNoArgUseShortcut() {
assertThat(generateInstantiation(method(SimpleBean.class, "number")).lines()).containsExactly(
"InjectionGeneratorTests.SimpleBean.number()");
}
@Test
void writeInstantiationForMethodWithNonGenericParameter() {
assertThat(writeInstantiation(method(SampleBean.class, "source", Integer.class)).lines()).containsExactly(
void generateInstantiationForMethodWithNonGenericParameter() {
assertThat(generateInstantiation(method(SampleBean.class, "source", Integer.class)).lines()).containsExactly(
"instanceContext.create(beanFactory, (attributes) -> beanFactory.getBean(InjectionGeneratorTests.SampleBean.class).source(attributes.get(0)))");
}
@Test
void writeInstantiationForStaticMethodWithNonGenericParameter() {
assertThat(writeInstantiation(method(SampleBean.class, "staticSource", Integer.class)).lines()).containsExactly(
void generateInstantiationForStaticMethodWithNonGenericParameter() {
assertThat(generateInstantiation(method(SampleBean.class, "staticSource", Integer.class)).lines()).containsExactly(
"instanceContext.create(beanFactory, (attributes) -> InjectionGeneratorTests.SampleBean.staticSource(attributes.get(0)))");
}
@Test
void writeInstantiationForMethodWithGenericParameters() {
assertThat(writeInstantiation(method(SampleBean.class, "source", ObjectProvider.class)).lines()).containsExactly(
void generateInstantiationForMethodWithGenericParameters() {
assertThat(generateInstantiation(method(SampleBean.class, "source", ObjectProvider.class)).lines()).containsExactly(
"instanceContext.create(beanFactory, (attributes) -> beanFactory.getBean(InjectionGeneratorTests.SampleBean.class).source(attributes.get(0)))");
}
@Test
void writeInjectionForUnsupportedMember() {
assertThatIllegalArgumentException().isThrownBy(() -> writeInjection(mock(Member.class), false));
void generateInjectionForUnsupportedMember() {
assertThatIllegalArgumentException().isThrownBy(() -> generateInjection(mock(Member.class), false));
}
@Test
void writeInjectionForNonRequiredMethodWithNonGenericParameters() {
void generateInjectionForNonRequiredMethodWithNonGenericParameters() {
Method method = method(SampleBean.class, "sourceAndCounter", String.class, Integer.class);
assertThat(writeInjection(method, false)).isEqualTo("""
assertThat(generateInjection(method, false)).isEqualTo("""
instanceContext.method("sourceAndCounter", String.class, Integer.class)
.resolve(beanFactory, false).ifResolved((attributes) -> bean.sourceAndCounter(attributes.get(0), attributes.get(1)))""");
}
@Test
void writeInjectionForRequiredMethodWithGenericParameter() {
void generateInjectionForRequiredMethodWithGenericParameter() {
Method method = method(SampleBean.class, "nameAndCounter", String.class, ObjectProvider.class);
assertThat(writeInjection(method, true)).isEqualTo("""
assertThat(generateInjection(method, true)).isEqualTo("""
instanceContext.method("nameAndCounter", String.class, ObjectProvider.class)
.invoke(beanFactory, (attributes) -> bean.nameAndCounter(attributes.get(0), attributes.get(1)))""");
}
@Test
void writeInjectionForNonRequiredMethodWithGenericParameter() {
void generateInjectionForNonRequiredMethodWithGenericParameter() {
Method method = method(SampleBean.class, "nameAndCounter", String.class, ObjectProvider.class);
assertThat(writeInjection(method, false)).isEqualTo("""
assertThat(generateInjection(method, false)).isEqualTo("""
instanceContext.method("nameAndCounter", String.class, ObjectProvider.class)
.resolve(beanFactory, false).ifResolved((attributes) -> bean.nameAndCounter(attributes.get(0), attributes.get(1)))""");
}
@Test
void writeInjectionForRequiredField() {
void generateInjectionForRequiredField() {
Field field = field(SampleBean.class, "counter");
assertThat(writeInjection(field, true)).isEqualTo("""
assertThat(generateInjection(field, true)).isEqualTo("""
instanceContext.field("counter", Integer.class)
.invoke(beanFactory, (attributes) -> bean.counter = attributes.get(0))""");
}
@Test
void writeInjectionForNonRequiredField() {
void generateInjectionForNonRequiredField() {
Field field = field(SampleBean.class, "counter");
assertThat(writeInjection(field, false)).isEqualTo("""
assertThat(generateInjection(field, false)).isEqualTo("""
instanceContext.field("counter", Integer.class)
.resolve(beanFactory, false).ifResolved((attributes) -> bean.counter = attributes.get(0))""");
}
@Test
void writeInjectionForRequiredPrivateField() {
void generateInjectionForRequiredPrivateField() {
Field field = field(SampleBean.class, "source");
assertThat(writeInjection(field, true)).isEqualTo("""
assertThat(generateInjection(field, true)).isEqualTo("""
instanceContext.field("source", String.class)
.invoke(beanFactory, (attributes) -> {
Field sourceField = ReflectionUtils.findField(InjectionGeneratorTests.SampleBean.class, "source", String.class);
@@ -215,12 +215,12 @@ class InjectionGeneratorTests {
return field;
}
private String writeInstantiation(Executable creator) {
return CodeSnippet.process(code -> code.add(new InjectionGenerator().writeInstantiation(creator)));
private String generateInstantiation(Executable creator) {
return CodeSnippet.process(code -> code.add(new InjectionGenerator().generateInstantiation(creator)));
}
private String writeInjection(Member member, boolean required) {
return CodeSnippet.process(code -> code.add(new InjectionGenerator().writeInjection(member, required)));
private String generateInjection(Member member, boolean required) {
return CodeSnippet.process(code -> code.add(new InjectionGenerator().generateInjection(member, required)));
}
private void analyzeProtectedAccess(Member member) {