From b95715d1fcbfa815a25348259508bd8cb2f528df Mon Sep 17 00:00:00 2001 From: Lukas Eder Date: Fri, 13 May 2022 16:00:59 +0200 Subject: [PATCH] [jOOQ/jOOQ#13558] Add a PrefixSuffixGeneratorStrategy to jOOQ-codegen --- .../AbstractDelegatingGeneratorStrategy.java | 182 ++++++++++++++++ .../codegen/GeneratorStrategyWrapper.java | 110 +--------- .../java/org/jooq/codegen/JavaGenerator.java | 10 + .../PrefixSuffixGeneratorStrategy.java | 200 ++++++++++++++++++ 4 files changed, 395 insertions(+), 107 deletions(-) create mode 100644 jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractDelegatingGeneratorStrategy.java create mode 100644 jOOQ-codegen/src/main/java/org/jooq/codegen/PrefixSuffixGeneratorStrategy.java diff --git a/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractDelegatingGeneratorStrategy.java b/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractDelegatingGeneratorStrategy.java new file mode 100644 index 0000000000..dac2b4b38e --- /dev/null +++ b/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractDelegatingGeneratorStrategy.java @@ -0,0 +1,182 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Other licenses: + * ----------------------------------------------------------------------------- + * Commercial licenses for this work are available. These replace the above + * ASL 2.0 and offer limited warranties, support, maintenance, and commercial + * database integrations. + * + * For more information, please visit: http://www.jooq.org/licenses + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + */ +package org.jooq.codegen; + +import java.util.List; +import java.util.Locale; + +import org.jooq.meta.Definition; +import org.jooq.meta.EnumDefinition; + +/** + * A {@link GeneratorStrategy} that delegates to another one. + * + * @author Lukas Eder + */ +public abstract class AbstractDelegatingGeneratorStrategy extends AbstractGeneratorStrategy { + + protected final GeneratorStrategy delegate; + + public AbstractDelegatingGeneratorStrategy() { + this(new DefaultGeneratorStrategy()); + } + + public AbstractDelegatingGeneratorStrategy(GeneratorStrategy delegate) { + this.delegate = delegate; + } + + @Override + public String getTargetDirectory() { + return delegate.getTargetDirectory(); + } + + @Override + public void setTargetDirectory(String directory) { + delegate.setTargetDirectory(directory); + } + + @Override + public String getTargetPackage() { + return delegate.getTargetPackage(); + } + + @Override + public void setTargetPackage(String packageName) { + delegate.setTargetPackage(packageName); + } + + @Override + public Locale getTargetLocale() { + return delegate.getTargetLocale(); + } + + @Override + public void setTargetLocale(Locale targetLocale) { + delegate.setTargetLocale(targetLocale); + } + + @Override + public Language getTargetLanguage() { + return delegate.getTargetLanguage(); + } + + @Override + public void setTargetLanguage(Language targetLanguage) { + delegate.setTargetLanguage(targetLanguage); + } + + @Override + public void setInstanceFields(boolean instanceFields) { + delegate.setInstanceFields(instanceFields); + } + + @Override + public boolean getInstanceFields() { + return delegate.getInstanceFields(); + } + + @Override + public void setJavaBeansGettersAndSetters(boolean javaBeansGettersAndSetters) { + delegate.setJavaBeansGettersAndSetters(javaBeansGettersAndSetters); + } + + @Override + public boolean getJavaBeansGettersAndSetters() { + return delegate.getJavaBeansGettersAndSetters(); + } + + @Override + public void setUseTableNameForUnambiguousFKs(boolean useTableNameForUnambiguousFKs) { + delegate.setUseTableNameForUnambiguousFKs(useTableNameForUnambiguousFKs); + } + + @Override + public boolean getUseTableNameForUnambiguousFKs() { + return delegate.getUseTableNameForUnambiguousFKs(); + } + + @Override + public String getJavaEnumLiteral(EnumDefinition definition, String literal) { + return delegate.getJavaEnumLiteral(definition, literal); + } + + @Override + public String getGlobalReferencesJavaClassExtends(Definition container, Class objectType) { + return delegate.getGlobalReferencesJavaClassExtends(container, objectType); + } + + @Override + public String getJavaClassExtends(Definition definition, Mode mode) { + return delegate.getJavaClassExtends(definition, mode); + } + + @Override + public List getGlobalReferencesJavaClassImplements(Definition container, Class objectType) { + return delegate.getGlobalReferencesJavaClassImplements(container, objectType); + } + + @Override + public List getJavaClassImplements(Definition definition, Mode mode) { + return delegate.getJavaClassImplements(definition, mode); + } + + @Override + public String getGlobalReferencesJavaClassName(Definition container, Class objectType) { + return delegate.getGlobalReferencesJavaClassName(container, objectType); + } + + @Override + public String getGlobalReferencesJavaPackageName(Definition container, Class objectType) { + return delegate.getGlobalReferencesJavaPackageName(container, objectType); + } + + @Override + public String getGlobalReferencesFileHeader(Definition container, Class objectType) { + return delegate.getGlobalReferencesFileHeader(container, objectType); + } + + @Override + public String getFileHeader(Definition definition, Mode mode) { + return delegate.getFileHeader(definition, mode); + } + + @Override + public String getOverloadSuffix(Definition definition, Mode mode, String overloadIndex) { + return delegate.getOverloadSuffix(definition, mode, overloadIndex); + } +} diff --git a/jOOQ-codegen/src/main/java/org/jooq/codegen/GeneratorStrategyWrapper.java b/jOOQ-codegen/src/main/java/org/jooq/codegen/GeneratorStrategyWrapper.java index 7488a70915..36dca498be 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/codegen/GeneratorStrategyWrapper.java +++ b/jOOQ-codegen/src/main/java/org/jooq/codegen/GeneratorStrategyWrapper.java @@ -49,7 +49,6 @@ import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; -import java.util.Locale; import java.util.Map; import java.util.Set; @@ -79,96 +78,15 @@ import org.jooq.tools.StringUtils; * * @author Lukas Eder */ -class GeneratorStrategyWrapper extends AbstractGeneratorStrategy { +class GeneratorStrategyWrapper extends AbstractDelegatingGeneratorStrategy { private final Map, Map>> reservedColumns = new HashMap<>(); - final Generator generator; - final GeneratorStrategy delegate; GeneratorStrategyWrapper(Generator generator, GeneratorStrategy delegate) { + super(delegate); + this.generator = generator; - this.delegate = delegate; - } - - @Override - public String getTargetDirectory() { - return delegate.getTargetDirectory(); - } - - @Override - public void setTargetDirectory(String directory) { - delegate.setTargetDirectory(directory); - } - - @Override - public String getTargetPackage() { - return delegate.getTargetPackage(); - } - - @Override - public void setTargetPackage(String packageName) { - delegate.setTargetPackage(packageName); - } - - @Override - public Locale getTargetLocale() { - return delegate.getTargetLocale(); - } - - @Override - public void setTargetLocale(Locale targetLocale) { - delegate.setTargetLocale(targetLocale); - } - - @Override - public Language getTargetLanguage() { - return delegate.getTargetLanguage(); - } - - @Override - public void setTargetLanguage(Language targetLanguage) { - delegate.setTargetLanguage(targetLanguage); - } - - @Override - public void setInstanceFields(boolean instanceFields) { - delegate.setInstanceFields(instanceFields); - } - - @Override - public boolean getInstanceFields() { - return delegate.getInstanceFields(); - } - - @Override - public void setJavaBeansGettersAndSetters(boolean javaBeansGettersAndSetters) { - delegate.setJavaBeansGettersAndSetters(javaBeansGettersAndSetters); - } - - @Override - public boolean getJavaBeansGettersAndSetters() { - return delegate.getJavaBeansGettersAndSetters(); - } - - @Override - public void setUseTableNameForUnambiguousFKs(boolean useTableNameForUnambiguousFKs) { - delegate.setUseTableNameForUnambiguousFKs(useTableNameForUnambiguousFKs); - } - - @Override - public boolean getUseTableNameForUnambiguousFKs() { - return delegate.getUseTableNameForUnambiguousFKs(); - } - - @Override - public String getGlobalReferencesFileHeader(Definition container, Class objectType) { - return delegate.getGlobalReferencesFileHeader(container, objectType); - } - - @Override - public String getFileHeader(Definition definition, Mode mode) { - return delegate.getFileHeader(definition, mode); } @Override @@ -344,23 +262,6 @@ class GeneratorStrategyWrapper extends AbstractGeneratorStrategy { return result; } - @Override - public String getGlobalReferencesJavaClassExtends(Definition container, Class objectType) { - return delegate.getGlobalReferencesJavaClassExtends(container, objectType); - } - - @Override - public String getJavaClassExtends(Definition definition, Mode mode) { - - // [#1243] Only POJO mode can accept super classes - return delegate.getJavaClassExtends(definition, mode); - } - - @Override - public List getGlobalReferencesJavaClassImplements(Definition container, Class objectType) { - return delegate.getGlobalReferencesJavaClassImplements(container, objectType); - } - @Override public List getJavaClassImplements(Definition definition, Mode mode) { @@ -453,9 +354,4 @@ class GeneratorStrategyWrapper extends AbstractGeneratorStrategy { return identifier; } - - @Override - public String getOverloadSuffix(Definition definition, Mode mode, String overloadIndex) { - return delegate.getOverloadSuffix(definition, mode, overloadIndex); - } } diff --git a/jOOQ-codegen/src/main/java/org/jooq/codegen/JavaGenerator.java b/jOOQ-codegen/src/main/java/org/jooq/codegen/JavaGenerator.java index 597a3b90d1..81cde9e57e 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/codegen/JavaGenerator.java +++ b/jOOQ-codegen/src/main/java/org/jooq/codegen/JavaGenerator.java @@ -6691,6 +6691,16 @@ public class JavaGenerator extends AbstractGenerator { + + + + + + + + + + diff --git a/jOOQ-codegen/src/main/java/org/jooq/codegen/PrefixSuffixGeneratorStrategy.java b/jOOQ-codegen/src/main/java/org/jooq/codegen/PrefixSuffixGeneratorStrategy.java new file mode 100644 index 0000000000..96c8de6550 --- /dev/null +++ b/jOOQ-codegen/src/main/java/org/jooq/codegen/PrefixSuffixGeneratorStrategy.java @@ -0,0 +1,200 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Other licenses: + * ----------------------------------------------------------------------------- + * Commercial licenses for this work are available. These replace the above + * ASL 2.0 and offer limited warranties, support, maintenance, and commercial + * database integrations. + * + * For more information, please visit: http://www.jooq.org/licenses + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + */ +package org.jooq.codegen; + +import java.util.function.Consumer; +import java.util.function.Function; + +import org.jooq.meta.Definition; +import org.jooq.tools.StringUtils; + +/** + * A {@link GeneratorStrategy} that delegates to another, adding a prefix and/or + * suffix to some identifiers. + * + * @author Lukas Eder + */ +public class PrefixSuffixGeneratorStrategy extends AbstractDelegatingGeneratorStrategy { + + private String javaIdentifierPrefix; + private String javaIdentifierSuffix; + private String javaSetterNamePrefix; + private String javaSetterNameSuffix; + private String javaGetterNamePrefix; + private String javaGetterNameSuffix; + private String javaMethodNamePrefix; + private String javaMethodNameSuffix; + private String javaClassNamePrefix; + private String javaClassNameSuffix; + private String javaPackageNamePrefix; + private String javaPackageNameSuffix; + private String javaMemberNamePrefix; + private String javaMemberNameSuffix; + + static GeneratorStrategy wrap( + GeneratorStrategy delegate, + Function configuration + ) { + return delegate instanceof GeneratorStrategyWrapper + ? new GeneratorStrategyWrapper(((GeneratorStrategyWrapper) delegate).generator, configuration.apply(new PrefixSuffixGeneratorStrategy(((GeneratorStrategyWrapper) delegate).delegate))) + : configuration.apply(new PrefixSuffixGeneratorStrategy(delegate)); + } + + public PrefixSuffixGeneratorStrategy(GeneratorStrategy delegate) { + super(delegate); + } + + public PrefixSuffixGeneratorStrategy withJavaIdentifierPrefix(String prefix) { + this.javaIdentifierPrefix = prefix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaIdentifierSuffix(String suffix) { + this.javaIdentifierSuffix = suffix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaSetterNamePrefix(String prefix) { + this.javaSetterNamePrefix = prefix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaSetterNameSuffix(String suffix) { + this.javaSetterNameSuffix = suffix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaGetterNamePrefix(String prefix) { + this.javaGetterNamePrefix = prefix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaGetterNameSuffix(String suffix) { + this.javaGetterNameSuffix = suffix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaMethodNamePrefix(String prefix) { + this.javaMethodNamePrefix = prefix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaMethodNameSuffix(String suffix) { + this.javaMethodNameSuffix = suffix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaClassNamePrefix(String prefix) { + this.javaClassNamePrefix = prefix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaClassNameSuffix(String suffix) { + this.javaClassNameSuffix = suffix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaPackageNamePrefix(String prefix) { + this.javaPackageNamePrefix = prefix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaPackageNameSuffix(String suffix) { + this.javaPackageNameSuffix = suffix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaMemberNamePrefix(String prefix) { + this.javaMemberNamePrefix = prefix; + return this; + } + + public PrefixSuffixGeneratorStrategy withJavaMemberNameSuffix(String suffix) { + this.javaMemberNameSuffix = suffix; + return this; + } + + @Override + public String getJavaIdentifier(Definition definition) { + return StringUtils.defaultIfNull(javaIdentifierPrefix, "") + + delegate.getJavaIdentifier(definition) + + StringUtils.defaultIfNull(javaIdentifierSuffix, ""); + } + + @Override + public String getJavaSetterName(Definition definition, Mode mode) { + return StringUtils.defaultIfNull(javaSetterNamePrefix, "") + + delegate.getJavaSetterName(definition, mode) + + StringUtils.defaultIfNull(javaSetterNameSuffix, ""); + } + + @Override + public String getJavaGetterName(Definition definition, Mode mode) { + return StringUtils.defaultIfNull(javaGetterNamePrefix, "") + + delegate.getJavaGetterName(definition, mode) + + StringUtils.defaultIfNull(javaGetterNameSuffix, ""); + } + + @Override + public String getJavaMethodName(Definition definition, Mode mode) { + return StringUtils.defaultIfNull(javaMethodNamePrefix, "") + + delegate.getJavaMethodName(definition, mode) + + StringUtils.defaultIfNull(javaMethodNameSuffix, ""); + } + + @Override + public String getJavaClassName(Definition definition, Mode mode) { + return StringUtils.defaultIfNull(javaClassNamePrefix, "") + + delegate.getJavaClassName(definition, mode) + + StringUtils.defaultIfNull(javaClassNameSuffix, ""); + } + + @Override + public String getJavaPackageName(Definition definition, Mode mode) { + return StringUtils.defaultIfNull(javaPackageNamePrefix, "") + + delegate.getJavaPackageName(definition, mode) + + StringUtils.defaultIfNull(javaPackageNameSuffix, ""); + } + + @Override + public String getJavaMemberName(Definition definition, Mode mode) { + return StringUtils.defaultIfNull(javaMemberNamePrefix, "") + + delegate.getJavaMemberName(definition, mode) + + StringUtils.defaultIfNull(javaMemberNameSuffix, ""); + } +}