From b6d899c407c4211b8dee45f69fef62281756beb6 Mon Sep 17 00:00:00 2001 From: Rafael Winterhalter Date: Tue, 9 Nov 2021 08:47:15 +0100 Subject: [PATCH] Reintroduce base name resolver in suffixing random strategy and deprecate it to provide binary compatibility. --- .../java/net/bytebuddy/NamingStrategy.java | 118 +++++++++++++++++- .../net/bytebuddy/NamingStrategyTest.java | 8 +- 2 files changed, 120 insertions(+), 6 deletions(-) diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/NamingStrategy.java b/byte-buddy-dep/src/main/java/net/bytebuddy/NamingStrategy.java index d0d3460a0aa..169edc37227 100644 --- a/byte-buddy-dep/src/main/java/net/bytebuddy/NamingStrategy.java +++ b/byte-buddy-dep/src/main/java/net/bytebuddy/NamingStrategy.java @@ -346,7 +346,7 @@ class SuffixingRandom extends Suffixing { * @param suffix The suffix for the generated class. */ public SuffixingRandom(String suffix) { - this(suffix, BaseNameResolver.ForUnnamedType.INSTANCE); + this(suffix, Suffixing.BaseNameResolver.ForUnnamedType.INSTANCE); } /** @@ -359,7 +359,7 @@ public SuffixingRandom(String suffix) { * no prefix is added. */ public SuffixingRandom(String suffix, String javaLangPackagePrefix) { - this(suffix, BaseNameResolver.ForUnnamedType.INSTANCE, javaLangPackagePrefix); + this(suffix, Suffixing.BaseNameResolver.ForUnnamedType.INSTANCE, javaLangPackagePrefix); } /** @@ -368,8 +368,21 @@ public SuffixingRandom(String suffix, String javaLangPackagePrefix) { * * @param suffix The suffix for the generated class. * @param baseNameResolver The base name resolver that is queried for locating the base name. + * @deprecated Use {@link SuffixingRandom#SuffixingRandom(String, Suffixing.BaseNameResolver)}. */ + @Deprecated public SuffixingRandom(String suffix, BaseNameResolver baseNameResolver) { + this(suffix, (Suffixing.BaseNameResolver) baseNameResolver); + } + + /** + * Creates an immutable naming strategy with a given suffix but moves types that subclass types within + * the {@code java.lang} package into Byte Buddy's package namespace. + * + * @param suffix The suffix for the generated class. + * @param baseNameResolver The base name resolver that is queried for locating the base name. + */ + public SuffixingRandom(String suffix, Suffixing.BaseNameResolver baseNameResolver) { this(suffix, baseNameResolver, BYTE_BUDDY_RENAME_PACKAGE); } @@ -382,8 +395,24 @@ public SuffixingRandom(String suffix, BaseNameResolver baseNameResolver) { * @param javaLangPackagePrefix The fallback namespace for type's that subclass types within the * {@code java.*} namespace. If The prefix is set to the empty string, * no prefix is added. + * @deprecated Use {@link SuffixingRandom#SuffixingRandom(String, Suffixing.BaseNameResolver, String)}. */ + @Deprecated public SuffixingRandom(String suffix, BaseNameResolver baseNameResolver, String javaLangPackagePrefix) { + this(suffix, (Suffixing.BaseNameResolver) baseNameResolver, javaLangPackagePrefix); + } + + /** + * Creates an immutable naming strategy with a given suffix but moves types that subclass types within + * the {@code java.lang} package into a given namespace. + * + * @param suffix The suffix for the generated class. + * @param baseNameResolver The base name resolver that is queried for locating the base name. + * @param javaLangPackagePrefix The fallback namespace for type's that subclass types within the + * {@code java.*} namespace. If The prefix is set to the empty string, + * no prefix is added. + */ + public SuffixingRandom(String suffix, Suffixing.BaseNameResolver baseNameResolver, String javaLangPackagePrefix) { this(suffix, baseNameResolver, javaLangPackagePrefix, new RandomString()); } @@ -397,8 +426,25 @@ public SuffixingRandom(String suffix, BaseNameResolver baseNameResolver, String * {@code java.*} namespace. If The prefix is set to the empty string, * no prefix is added. * @param randomString The random string instance to use. + * @deprecated Use {@link SuffixingRandom#SuffixingRandom(String, Suffixing.BaseNameResolver, String, RandomString)}. */ + @Deprecated public SuffixingRandom(String suffix, BaseNameResolver baseNameResolver, String javaLangPackagePrefix, RandomString randomString) { + this(suffix, (Suffixing.BaseNameResolver) baseNameResolver, javaLangPackagePrefix, randomString); + } + + /** + * Creates an immutable naming strategy with a given suffix but moves types that subclass types within + * the {@code java.lang} package into a given namespace. + * + * @param suffix The suffix for the generated class. + * @param baseNameResolver The base name resolver that is queried for locating the base name. + * @param javaLangPackagePrefix The fallback namespace for type's that subclass types within the + * {@code java.*} namespace. If The prefix is set to the empty string, + * no prefix is added. + * @param randomString The random string instance to use. + */ + public SuffixingRandom(String suffix, Suffixing.BaseNameResolver baseNameResolver, String javaLangPackagePrefix, RandomString randomString) { super(suffix, baseNameResolver, javaLangPackagePrefix); this.randomString = randomString; } @@ -407,6 +453,74 @@ public SuffixingRandom(String suffix, BaseNameResolver baseNameResolver, String protected String name(TypeDescription superClass) { return super.name(superClass) + "$" + randomString.nextString(); } + + /** + * A base name resolver is responsible for resolving a name onto which the suffix is appended. + * + * @deprecated Use {@link Suffixing.BaseNameResolver}. + */ + @Deprecated + public interface BaseNameResolver extends Suffixing.BaseNameResolver { + + /** + * Uses the unnamed type's super type's name as the resolved name. + * + * @deprecated Use {@link Suffixing.BaseNameResolver.ForUnnamedType}. + */ + @Deprecated + enum ForUnnamedType implements BaseNameResolver { + + /** + * The singleton instance. + */ + INSTANCE; + + /** + * {@inheritDoc} + */ + public String resolve(TypeDescription typeDescription) { + return typeDescription.getName(); + } + } + + /** + * Uses a specific type's name as the resolved name. + * + * @deprecated Use {@link Suffixing.BaseNameResolver.ForGivenType}. + */ + @Deprecated + @HashCodeAndEqualsPlugin.Enhance + class ForGivenType extends Suffixing.BaseNameResolver.ForGivenType implements BaseNameResolver { + + /** + * Creates a new base name resolver that resolves a using the name of a given type. + * + * @param typeDescription The type description which represents the resolved name. + */ + public ForGivenType(TypeDescription typeDescription) { + super(typeDescription); + } + } + + /** + * A base name resolver that simply returns a fixed value. + * + * @deprecated Use {@link Suffixing.BaseNameResolver.ForFixedValue}. + */ + @Deprecated + @HashCodeAndEqualsPlugin.Enhance + class ForFixedValue extends Suffixing.BaseNameResolver.ForFixedValue implements BaseNameResolver { + + /** + * Creates a new base name resolver for a fixed name. + * + * @param name The fixed name + */ + public ForFixedValue(String name) { + super(name); + } + } + } } /** diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/NamingStrategyTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/NamingStrategyTest.java index 4ac7d82379e..7258c8c26f4 100644 --- a/byte-buddy-dep/src/test/java/net/bytebuddy/NamingStrategyTest.java +++ b/byte-buddy-dep/src/test/java/net/bytebuddy/NamingStrategyTest.java @@ -22,7 +22,7 @@ public class NamingStrategyTest { public TestRule mockitoRule = new MockitoRule(this); @Mock - private NamingStrategy.SuffixingRandom.BaseNameResolver baseNameResolver; + private NamingStrategy.Suffixing.BaseNameResolver baseNameResolver; @Mock private TypeDescription.Generic typeDescription; @@ -143,10 +143,10 @@ public void testSuffixingRandomRedefine() throws Exception { @Test public void testBaseNameResolvers() throws Exception { - assertThat(new NamingStrategy.SuffixingRandom.BaseNameResolver.ForFixedValue(FOO).resolve(rawTypeDescription), is(FOO)); + assertThat(new NamingStrategy.Suffixing.BaseNameResolver.ForFixedValue(FOO).resolve(rawTypeDescription), is(FOO)); when(rawTypeDescription.getName()).thenReturn(FOO); - assertThat(new NamingStrategy.SuffixingRandom.BaseNameResolver.ForGivenType(rawTypeDescription).resolve(rawTypeDescription), is(FOO)); - assertThat(NamingStrategy.SuffixingRandom.BaseNameResolver.ForUnnamedType.INSTANCE.resolve(rawTypeDescription), is(FOO)); + assertThat(new NamingStrategy.Suffixing.BaseNameResolver.ForGivenType(rawTypeDescription).resolve(rawTypeDescription), is(FOO)); + assertThat(NamingStrategy.Suffixing.BaseNameResolver.ForUnnamedType.INSTANCE.resolve(rawTypeDescription), is(FOO)); } @Test