From 4563ce2c4ede00705634ce6a755d4f54ddcb5ed7 Mon Sep 17 00:00:00 2001 From: Struchkov Mark Date: Mon, 23 Jan 2023 14:25:25 +0300 Subject: [PATCH] v.0.0.6 --- pom.xml | 8 +- .../creator/CreatorClassSimpleMode.java | 58 +++++++++ .../{ => creator}/CreatorClassTableMode.java | 26 ++-- .../domain/mode/simple/ClassSimpleDto.java | 44 +++++++ .../domain/mode/simple/SimpleFieldDto.java | 24 ++++ .../domain/mode/table/ClassTableDto.java | 6 +- .../mode/table/JoinElemCollectionDto.java | 4 +- .../domain/mode/table/JoinFieldDto.java | 4 +- .../domain/mode/table/JoinTableContainer.java | 4 +- ...TableDto.java => SimpleTableFieldDto.java} | 8 +- .../generator/GeneratorSimpleMode.java | 45 +++++++ .../generator/GeneratorTableMode.java | 114 ++++++++++++++++ .../processor/FieldNameProcessor.java | 122 ++---------------- .../utils/fieldconstants/util/Generator.java | 26 ++++ 14 files changed, 353 insertions(+), 140 deletions(-) create mode 100644 src/main/java/dev/struchkov/haiti/utils/fieldconstants/creator/CreatorClassSimpleMode.java rename src/main/java/dev/struchkov/haiti/utils/fieldconstants/{ => creator}/CreatorClassTableMode.java (87%) create mode 100644 src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/simple/ClassSimpleDto.java create mode 100644 src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/simple/SimpleFieldDto.java rename src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/{SimpleFieldTableDto.java => SimpleTableFieldDto.java} (70%) create mode 100644 src/main/java/dev/struchkov/haiti/utils/fieldconstants/generator/GeneratorSimpleMode.java create mode 100644 src/main/java/dev/struchkov/haiti/utils/fieldconstants/generator/GeneratorTableMode.java create mode 100644 src/main/java/dev/struchkov/haiti/utils/fieldconstants/util/Generator.java diff --git a/pom.xml b/pom.xml index a89bc05..0cfddb2 100644 --- a/pom.xml +++ b/pom.xml @@ -5,13 +5,13 @@ 4.0.0 dev.struchkov.haiti - haiti - 0.0.4 + haiti-dependencies + 2.0.0 dev.struchkov.haiti.utils haiti-utils-field-constants - 0.0.5-SNAPSHOT + 0.0.6 Haiti Field Name Constants Utils Generating class field names @@ -22,7 +22,7 @@ - 11 + 17 ${java.version} ${java.version} UTF-8 diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/creator/CreatorClassSimpleMode.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/creator/CreatorClassSimpleMode.java new file mode 100644 index 0000000..d34fe85 --- /dev/null +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/creator/CreatorClassSimpleMode.java @@ -0,0 +1,58 @@ +package dev.struchkov.haiti.utils.fieldconstants.creator; + +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple.SimpleFieldDto; +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.SimpleTableFieldDto; +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple.ClassSimpleDto; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.tools.JavaFileObject; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.Collection; + +import static dev.struchkov.haiti.utils.Exceptions.utilityClass; +import static java.text.MessageFormat.format; + +/** + * // TODO: 20.06.2021 Добавить описание. + * + * @author upagge 20.06.2021 + */ +public final class CreatorClassSimpleMode { + + private CreatorClassSimpleMode() { + utilityClass(); + } + + public static void record(ClassSimpleDto classDto, ProcessingEnvironment environment) { + JavaFileObject builderFile = null; + try { + builderFile = environment.getFiler().createSourceFile(classDto.getClassName()); + } catch (IOException e) { + e.printStackTrace(); + } + + try (PrintWriter out = new PrintWriter(builderFile.openWriter())) { + out.println("package " + classDto.getClassPackage() + ";"); + out.println(); + out.println(); + out.print(format("public class {0} '{'", classDto.getClassName())); + out.println(); + out.println(); + generateSimpleNames(classDto.getSimpleFields(), out); + out.println("}"); + out.println(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + + private static void generateSimpleNames(Collection fields, PrintWriter out) { + for (SimpleFieldDto field : fields) { + out.println(format(" public static final String {0} = \"{1}\";", field.getFieldName(), field.getFieldName())); + } + out.println(); + } + +} diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/CreatorClassTableMode.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/creator/CreatorClassTableMode.java similarity index 87% rename from src/main/java/dev/struchkov/haiti/utils/fieldconstants/CreatorClassTableMode.java rename to src/main/java/dev/struchkov/haiti/utils/fieldconstants/creator/CreatorClassTableMode.java index 06234a4..6a79582 100644 --- a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/CreatorClassTableMode.java +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/creator/CreatorClassTableMode.java @@ -1,10 +1,11 @@ -package dev.struchkov.haiti.utils.fieldconstants; +package dev.struchkov.haiti.utils.fieldconstants.creator; +import dev.struchkov.haiti.utils.Checker; import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.ClassTableDto; import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinElemCollectionDto; import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinFieldDto; import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinTableContainer; -import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.SimpleFieldTableDto; +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.SimpleTableFieldDto; import javax.annotation.processing.ProcessingEnvironment; import javax.tools.JavaFileObject; @@ -13,6 +14,7 @@ import java.io.PrintWriter; import java.util.Collection; import java.util.List; +import static dev.struchkov.haiti.utils.Checker.checkNotEmpty; import static dev.struchkov.haiti.utils.Exceptions.utilityClass; import static java.text.MessageFormat.format; @@ -63,19 +65,21 @@ public final class CreatorClassTableMode { } } - private static void generateTableName(String tableName, Collection fields, PrintWriter out) { + private static void generateTableName(String tableName, Collection fields, PrintWriter out) { if (tableName != null) { final boolean isTableNameField = fields.stream().anyMatch(simpleFieldTableDto -> simpleFieldTableDto.getFieldStringName().equalsIgnoreCase(TABLE_NAME_DEFAULT)); out.println(format(" public static final String {0} = \"{1}\";", isTableNameField ? TABLE_NAME_DB : TABLE_NAME_DEFAULT, tableName)); + out.println(); } - out.println(); } - private static void generateSimpleNames(Collection fields, PrintWriter out) { - for (SimpleFieldTableDto field : fields) { + private static void generateSimpleNames(Collection fields, PrintWriter out) { + for (SimpleTableFieldDto field : fields) { out.println(format(" public static final String {0} = \"{1}\";", field.getFieldStringName(), field.getFieldName())); } - out.println(); + if (checkNotEmpty(fields)) { + out.println(); + } } private static void generateJoinNames(List joinFields, PrintWriter out) { @@ -88,7 +92,9 @@ public final class CreatorClassTableMode { ) ); } - out.println(); + if (checkNotEmpty(joinFields)) { + out.println(); + } } private static void generateElementCollectionNames(List joinElemCollections, PrintWriter out) { @@ -101,7 +107,9 @@ public final class CreatorClassTableMode { out.println(format(" JoinTable.ofLeft(\"{0}\", \"{1}\", \"{2}\")", secondContainer.getTable(), secondContainer.getBaseId(), secondContainer.getReference())); out.println(" };"); } - out.println(); + if (checkNotEmpty(joinElemCollections)) { + out.println(); + } } } diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/simple/ClassSimpleDto.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/simple/ClassSimpleDto.java new file mode 100644 index 0000000..91d058b --- /dev/null +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/simple/ClassSimpleDto.java @@ -0,0 +1,44 @@ +package dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple; + +import java.util.List; + +public class ClassSimpleDto { + + private String classPackage; + private String className; + private String tableName; + private List simpleFields; + + public String getClassPackage() { + return classPackage; + } + + public void setClassPackage(String classPackage) { + this.classPackage = classPackage; + } + + public String getClassName() { + return className; + } + + public void setClassName(String className) { + this.className = className; + } + + public String getTableName() { + return tableName; + } + + public void setTableName(String tableName) { + this.tableName = tableName; + } + + public List getSimpleFields() { + return simpleFields; + } + + public void setSimpleFields(List simpleFields) { + this.simpleFields = simpleFields; + } + +} diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/simple/SimpleFieldDto.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/simple/SimpleFieldDto.java new file mode 100644 index 0000000..af041a9 --- /dev/null +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/simple/SimpleFieldDto.java @@ -0,0 +1,24 @@ +package dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple; + +/** + * // TODO: 07.06.2021 Добавить описание. + * + * @author upagge 07.06.2021 + */ +public class SimpleFieldDto { + + private final String fieldName; + + private SimpleFieldDto(String fieldName) { + this.fieldName = fieldName; + } + + public static SimpleFieldDto of(String fieldName) { + return new SimpleFieldDto(fieldName); + } + + public String getFieldName() { + return fieldName; + } + +} diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/ClassTableDto.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/ClassTableDto.java index 31ec372..1d0e870 100644 --- a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/ClassTableDto.java +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/ClassTableDto.java @@ -7,7 +7,7 @@ public class ClassTableDto { private String classPackage; private String className; private String tableName; - private List simpleFields; + private List simpleFields; private List joinFields; private List joinElemCollections; @@ -35,11 +35,11 @@ public class ClassTableDto { this.tableName = tableName; } - public List getSimpleFields() { + public List getSimpleFields() { return simpleFields; } - public void setSimpleFields(List simpleFields) { + public void setSimpleFields(List simpleFields) { this.simpleFields = simpleFields; } diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinElemCollectionDto.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinElemCollectionDto.java index e7e702b..6aeb686 100644 --- a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinElemCollectionDto.java +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinElemCollectionDto.java @@ -1,6 +1,6 @@ package dev.struchkov.haiti.utils.fieldconstants.domain.mode.table; -import dev.struchkov.haiti.utils.Assert; +import dev.struchkov.haiti.utils.Inspector; public class JoinElemCollectionDto { @@ -15,7 +15,7 @@ public class JoinElemCollectionDto { } public static JoinElemCollectionDto of(String fieldName, JoinTableContainer firstContainer, JoinTableContainer secondContainer) { - Assert.isNotNull(fieldName, firstContainer, secondContainer); + Inspector.isNotNull(fieldName, firstContainer, secondContainer); return new JoinElemCollectionDto(fieldName, firstContainer, secondContainer); } diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinFieldDto.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinFieldDto.java index 9039029..975b988 100644 --- a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinFieldDto.java +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinFieldDto.java @@ -1,6 +1,6 @@ package dev.struchkov.haiti.utils.fieldconstants.domain.mode.table; -import dev.struchkov.haiti.utils.Assert; +import dev.struchkov.haiti.utils.Inspector; public class JoinFieldDto { @@ -13,7 +13,7 @@ public class JoinFieldDto { } public static JoinFieldDto of(String fieldName, JoinTableContainer container) { - Assert.isNotNull(fieldName, container); + Inspector.isNotNull(fieldName, container); return new JoinFieldDto(fieldName, container); } diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinTableContainer.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinTableContainer.java index aa68ca8..56dddc7 100644 --- a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinTableContainer.java +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/JoinTableContainer.java @@ -1,6 +1,6 @@ package dev.struchkov.haiti.utils.fieldconstants.domain.mode.table; -import dev.struchkov.haiti.utils.Assert; +import dev.struchkov.haiti.utils.Inspector; public class JoinTableContainer { @@ -15,7 +15,7 @@ public class JoinTableContainer { } public static JoinTableContainer of(String table, String baseId, String reference) { - Assert.isNotNull(table, baseId, reference); + Inspector.isNotNull(table, baseId, reference); return new JoinTableContainer(table, baseId, reference); } diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/SimpleFieldTableDto.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/SimpleTableFieldDto.java similarity index 70% rename from src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/SimpleFieldTableDto.java rename to src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/SimpleTableFieldDto.java index be9f2e7..340ae8c 100644 --- a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/SimpleFieldTableDto.java +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/domain/mode/table/SimpleTableFieldDto.java @@ -5,18 +5,18 @@ package dev.struchkov.haiti.utils.fieldconstants.domain.mode.table; * * @author upagge 07.06.2021 */ -public class SimpleFieldTableDto { +public class SimpleTableFieldDto { private final String fieldStringName; private final String fieldName; - private SimpleFieldTableDto(String fieldStringName, String fieldName) { + private SimpleTableFieldDto(String fieldStringName, String fieldName) { this.fieldStringName = fieldStringName; this.fieldName = fieldName; } - public static SimpleFieldTableDto of(String fieldStringName, String fieldName) { - return new SimpleFieldTableDto(fieldStringName, fieldName); + public static SimpleTableFieldDto of(String fieldStringName, String fieldName) { + return new SimpleTableFieldDto(fieldStringName, fieldName); } public String getFieldStringName() { diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/generator/GeneratorSimpleMode.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/generator/GeneratorSimpleMode.java new file mode 100644 index 0000000..9545017 --- /dev/null +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/generator/GeneratorSimpleMode.java @@ -0,0 +1,45 @@ +package dev.struchkov.haiti.utils.fieldconstants.generator; + +import dev.struchkov.haiti.utils.fieldconstants.creator.CreatorClassSimpleMode; +import dev.struchkov.haiti.utils.fieldconstants.domain.Mode; +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple.ClassSimpleDto; +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.simple.SimpleFieldDto; +import dev.struchkov.haiti.utils.fieldconstants.util.Generator; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import java.util.ArrayList; +import java.util.List; + +public class GeneratorSimpleMode { + + public static void generate(ProcessingEnvironment processingEnv, Element annotatedElement) { + final String annotatedElementName = annotatedElement.getSimpleName().toString(); + + final String newClassName = annotatedElementName + Mode.SIMPLE.getDefaultPostfix(); + + final List allFields = annotatedElement.getEnclosedElements().stream() + .filter(Generator::isField) + .filter(Generator::isNotIgnoreField) + .toList(); + + final List simpleFields = getSimpleFields(allFields); + + final ClassSimpleDto newClass = new ClassSimpleDto(); + newClass.setClassName(newClassName); + newClass.setSimpleFields(simpleFields); + newClass.setClassPackage(Generator.getPackage(annotatedElement)); + + CreatorClassSimpleMode.record(newClass, processingEnv); + } + + private static List getSimpleFields(List allFields) { + final List resultList = new ArrayList<>(); + for (Element field : allFields) { + final String fieldName = field.getSimpleName().toString(); + resultList.add(SimpleFieldDto.of(fieldName)); + } + return resultList; + } + +} diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/generator/GeneratorTableMode.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/generator/GeneratorTableMode.java new file mode 100644 index 0000000..124bbd5 --- /dev/null +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/generator/GeneratorTableMode.java @@ -0,0 +1,114 @@ +package dev.struchkov.haiti.utils.fieldconstants.generator; + +import dev.struchkov.haiti.utils.fieldconstants.annotation.field.ElementCollectionField; +import dev.struchkov.haiti.utils.fieldconstants.annotation.field.JoinField; +import dev.struchkov.haiti.utils.fieldconstants.annotation.setting.TableModeSettings; +import dev.struchkov.haiti.utils.fieldconstants.creator.CreatorClassTableMode; +import dev.struchkov.haiti.utils.fieldconstants.domain.Mode; +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.ClassTableDto; +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinElemCollectionDto; +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinFieldDto; +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinTableContainer; +import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.SimpleTableFieldDto; +import dev.struchkov.haiti.utils.fieldconstants.util.Generator; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.persistence.CollectionTable; +import javax.persistence.Column; +import javax.persistence.ElementCollection; +import javax.persistence.Table; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + +import static dev.struchkov.haiti.utils.Checker.checkNotNull; + +public class GeneratorTableMode { + + public static void generate(ProcessingEnvironment processingEnv, TableModeSettings tableSettings, Element annotatedElement) { + final String annotatedElementName = annotatedElement.getSimpleName().toString(); + + final Table anTable = annotatedElement.getAnnotation(Table.class); + final String newClassName = annotatedElementName + Mode.TABLE.getDefaultPostfix(); + + final List allFields = annotatedElement.getEnclosedElements().stream() + .filter(Generator::isField) + .filter(Generator::isNotIgnoreField) + .collect(Collectors.toList()); + + final List simpleFields = getSimpleFields(allFields, anTable, tableSettings); + final List joinFields = getJoinFields(allFields); + final List elementCollectionFields = getElementCollectionsFields(anTable, allFields); + + final ClassTableDto newClass = new ClassTableDto(); + newClass.setClassName(newClassName); + newClass.setSimpleFields(simpleFields); + newClass.setJoinFields(joinFields); + newClass.setJoinElemCollections(elementCollectionFields); + newClass.setClassPackage(Generator.getPackage(annotatedElement)); + newClass.setTableName(checkNotNull(anTable) ? anTable.name() : null); + CreatorClassTableMode.record(newClass, processingEnv); + } + + private static List getElementCollectionsFields(Table tableName, List allFields) { + if (checkNotNull(tableName)) { + return allFields.stream() + .filter( + field -> field.getAnnotation(ElementCollectionField.class) != null && + field.getAnnotation(CollectionTable.class) != null && + field.getAnnotation(Column.class) != null + ) + .map(field -> { + final String fieldName = field.getSimpleName().toString(); + final ElementCollectionField elementCollectionField = field.getAnnotation(ElementCollectionField.class); + final CollectionTable collectionTable = field.getAnnotation(CollectionTable.class); + final Column column = field.getAnnotation(Column.class); + + final JoinTableContainer firstContainer = JoinTableContainer.of(collectionTable.name(), tableName + "." + elementCollectionField.parentId(), collectionTable.joinColumns()[0].name()); + final JoinTableContainer secondContainer = JoinTableContainer.of(elementCollectionField.childTable(), column.name(), elementCollectionField.childReference()); + return JoinElemCollectionDto.of(fieldName, firstContainer, secondContainer); + }).collect(Collectors.toList()); + } + return Collections.emptyList(); + } + + private static List getJoinFields(List allFields) { + return allFields.stream() + .filter( + field -> field.getAnnotation(JoinField.class) != null && + field.getAnnotation(ElementCollection.class) == null + ) + .map(field -> { + final String fieldName = field.getSimpleName().toString(); + final JoinField joinField = field.getAnnotation(JoinField.class); + final JoinTableContainer joinContainer = JoinTableContainer.of(joinField.table(), joinField.baseId(), joinField.reference()); + return JoinFieldDto.of(fieldName, joinContainer); + }) + .collect(Collectors.toList()); + } + + private static List getSimpleFields(List allFields, Table anTable, TableModeSettings tableSettings) { + final boolean prefixTableForColumn = tableSettings.prefixTableForColumn(); + final List resultList = new ArrayList<>(); + allFields.stream() + .filter( + field -> field.getAnnotation(Column.class) != null && + field.getAnnotation(ElementCollection.class) == null + ) + .forEach( + field -> { + final String fieldName = field.getSimpleName().toString(); + final String columnName = field.getAnnotation(Column.class).name(); + if (prefixTableForColumn && checkNotNull(anTable)) { + final String tableNameAndColumnName = anTable.name() + "." + columnName; + resultList.add(SimpleTableFieldDto.of("t_" + fieldName, tableNameAndColumnName)); + } + resultList.add(SimpleTableFieldDto.of(fieldName, columnName)); + } + ); + return resultList; + } + +} diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/processor/FieldNameProcessor.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/processor/FieldNameProcessor.java index 5790748..0506f7f 100644 --- a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/processor/FieldNameProcessor.java +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/processor/FieldNameProcessor.java @@ -1,18 +1,11 @@ package dev.struchkov.haiti.utils.fieldconstants.processor; import com.google.auto.service.AutoService; -import dev.struchkov.haiti.utils.fieldconstants.CreatorClassTableMode; import dev.struchkov.haiti.utils.fieldconstants.annotation.FieldNames; -import dev.struchkov.haiti.utils.fieldconstants.annotation.field.ElementCollectionField; -import dev.struchkov.haiti.utils.fieldconstants.annotation.field.IgnoreField; -import dev.struchkov.haiti.utils.fieldconstants.annotation.field.JoinField; import dev.struchkov.haiti.utils.fieldconstants.annotation.setting.TableModeSettings; import dev.struchkov.haiti.utils.fieldconstants.domain.Mode; -import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.ClassTableDto; -import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinElemCollectionDto; -import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinFieldDto; -import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.JoinTableContainer; -import dev.struchkov.haiti.utils.fieldconstants.domain.mode.table.SimpleFieldTableDto; +import dev.struchkov.haiti.utils.fieldconstants.generator.GeneratorSimpleMode; +import dev.struchkov.haiti.utils.fieldconstants.generator.GeneratorTableMode; import javax.annotation.processing.AbstractProcessor; import javax.annotation.processing.Processor; @@ -22,19 +15,10 @@ import javax.annotation.processing.SupportedSourceVersion; import javax.lang.model.SourceVersion; import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; -import javax.lang.model.type.TypeMirror; -import javax.persistence.CollectionTable; -import javax.persistence.Column; -import javax.persistence.ElementCollection; -import javax.persistence.Table; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; import java.util.Set; -import java.util.stream.Collectors; @SupportedAnnotationTypes("dev.struchkov.haiti.utils.fieldconstants.annotation.FieldNames") -@SupportedSourceVersion(SourceVersion.RELEASE_11) +@SupportedSourceVersion(SourceVersion.RELEASE_17) @AutoService(Processor.class) public class FieldNameProcessor extends AbstractProcessor { @@ -43,110 +27,20 @@ public class FieldNameProcessor extends AbstractProcessor { for (TypeElement annotation : set) { Set annotatedElements = roundEnvironment.getElementsAnnotatedWith(annotation); for (Element annotatedElement : annotatedElements) { - final TypeMirror mirror = annotatedElement.asType(); - final String annotatedElementName = annotatedElement.getSimpleName().toString(); final FieldNames settings = annotatedElement.getAnnotation(FieldNames.class); - final Set modes = Arrays.stream(settings.mode()).collect(Collectors.toUnmodifiableSet()); + final Set modes = Set.of(settings.mode()); if (modes.contains(Mode.TABLE)) { final TableModeSettings tableSettings = settings.tableSettings(); - generateTableMode(tableSettings, annotatedElement, mirror, annotatedElementName); + GeneratorTableMode.generate(processingEnv, tableSettings, annotatedElement); + } + if (modes.contains(Mode.SIMPLE)) { + GeneratorSimpleMode.generate(processingEnv, annotatedElement); } } } return true; } - private void generateTableMode(TableModeSettings tableSettings, Element annotatedElement, TypeMirror mirror, String annotatedElementName) { - final Table anTable = annotatedElement.getAnnotation(Table.class); - final String newClassName = annotatedElementName + Mode.TABLE.getDefaultPostfix(); - - final List allFields = annotatedElement.getEnclosedElements().stream() - .filter(this::isField) - .filter(this::isNotIgnoreField) - .collect(Collectors.toList()); - - final List simpleFields = getSimpleFields(allFields, anTable, tableSettings); - final List joinFields = getJoinFields(allFields); - final List elementCollectionFields = getElementCollectionsFields(anTable.name(), allFields); - - final ClassTableDto newClass = new ClassTableDto(); - newClass.setClassName(newClassName); - newClass.setSimpleFields(simpleFields); - newClass.setJoinFields(joinFields); - newClass.setJoinElemCollections(elementCollectionFields); - newClass.setClassPackage(getPackage(mirror)); - newClass.setTableName(anTable.name()); - CreatorClassTableMode.record(newClass, processingEnv); - } - - private List getElementCollectionsFields(String tableName, List allFields) { - return allFields.stream() - .filter( - field -> field.getAnnotation(ElementCollectionField.class) != null && - field.getAnnotation(CollectionTable.class) != null && - field.getAnnotation(Column.class) != null - ) - .map(field -> { - final String fieldName = field.getSimpleName().toString(); - final ElementCollectionField elementCollectionField = field.getAnnotation(ElementCollectionField.class); - final CollectionTable collectionTable = field.getAnnotation(CollectionTable.class); - final Column column = field.getAnnotation(Column.class); - - final JoinTableContainer firstContainer = JoinTableContainer.of(collectionTable.name(), tableName + "." + elementCollectionField.parentId(), collectionTable.joinColumns()[0].name()); - final JoinTableContainer secondContainer = JoinTableContainer.of(elementCollectionField.childTable(), column.name(), elementCollectionField.childReference()); - return JoinElemCollectionDto.of(fieldName, firstContainer, secondContainer); - }).collect(Collectors.toList()); - } - - private List getJoinFields(List allFields) { - return allFields.stream() - .filter( - field -> field.getAnnotation(JoinField.class) != null && - field.getAnnotation(ElementCollection.class) == null - ) - .map(field -> { - final String fieldName = field.getSimpleName().toString(); - final JoinField joinField = field.getAnnotation(JoinField.class); - final JoinTableContainer joinContainer = JoinTableContainer.of(joinField.table(), joinField.baseId(), joinField.reference()); - return JoinFieldDto.of(fieldName, joinContainer); - }) - .collect(Collectors.toList()); - } - - private List getSimpleFields(List allFields, Table anTable, TableModeSettings tableSettings) { - final boolean prefixTableForColumn = tableSettings.prefixTableForColumn(); - final List resultList = new ArrayList<>(); - allFields.stream() - .filter( - field -> field.getAnnotation(Column.class) != null && - field.getAnnotation(ElementCollection.class) == null - ) - .forEach( - field -> { - final String fieldName = field.getSimpleName().toString(); - final String columnName = field.getAnnotation(Column.class).name(); - if (prefixTableForColumn) { - final String tableNameAndColumnName = anTable.name() + "." + columnName; - resultList.add(SimpleFieldTableDto.of("t_" + fieldName, tableNameAndColumnName)); - } - resultList.add(SimpleFieldTableDto.of(fieldName, columnName)); - } - ); - return resultList; - } - - private boolean isNotIgnoreField(Element element) { - return element.getAnnotation(IgnoreField.class) == null; - } - - public boolean isField(Element element) { - return element != null && element.getKind().isField(); - } - - public static String getPackage(TypeMirror typeMirror) { - final String[] split = typeMirror.toString().split("\\."); - return String.join(".", Arrays.copyOf(split, split.length - 1)); - } } diff --git a/src/main/java/dev/struchkov/haiti/utils/fieldconstants/util/Generator.java b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/util/Generator.java new file mode 100644 index 0000000..0bcc190 --- /dev/null +++ b/src/main/java/dev/struchkov/haiti/utils/fieldconstants/util/Generator.java @@ -0,0 +1,26 @@ +package dev.struchkov.haiti.utils.fieldconstants.util; + +import dev.struchkov.haiti.utils.fieldconstants.annotation.field.IgnoreField; + +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; + +public class Generator { + + public static boolean isNotIgnoreField(Element element) { + return element.getAnnotation(IgnoreField.class) == null; + } + + public static boolean isField(Element element) { + return element != null && element.getKind().isField(); + } + + public static String getPackage(Element element) { + Element packageElem = element.getEnclosingElement(); + while (!ElementKind.PACKAGE.equals(packageElem.getKind())) { + packageElem = packageElem.getEnclosingElement(); + } + return packageElem.asType().toString(); + } + +}