diff --git a/src/main/java/com/github/junkfactory/innerbuilder/JavaInnerBuilderHandler.java b/src/main/java/com/github/junkfactory/innerbuilder/JavaInnerBuilderHandler.java index 9a3be77..724ce22 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/JavaInnerBuilderHandler.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/JavaInnerBuilderHandler.java @@ -6,6 +6,7 @@ import com.github.junkfactory.innerbuilder.generators.PsiParams; import com.github.junkfactory.innerbuilder.generators.Utils; import com.github.junkfactory.innerbuilder.ui.JavaInnerBuilderOption; +import com.github.junkfactory.innerbuilder.ui.JavaInnerBuilderOptionSelector; import com.intellij.ide.util.PropertiesComponent; import com.intellij.lang.LanguageCodeInsightActionHandler; import com.intellij.openapi.application.ApplicationManager; @@ -16,14 +17,13 @@ import com.intellij.psi.JavaPsiFacade; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiJavaFile; +import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.util.AstLoadingFilter; import org.jetbrains.annotations.NotNull; import java.util.EnumSet; import java.util.Set; -import static com.github.junkfactory.innerbuilder.ui.JavaInnerBuilderOptionSelector.selectFieldsAndOptions; - class JavaInnerBuilderHandler implements LanguageCodeInsightActionHandler { private static final GeneratorFactory generatorFactory = GeneratorFactory.create(); @@ -48,7 +48,7 @@ public boolean startInWriteAction() { } private static boolean isApplicable(final PsiFile file, final Editor editor) { - return FieldCollector.builder() + return file instanceof PsiJavaFile && FieldCollector.builder() .file(file) .editor(editor) .build() @@ -77,7 +77,11 @@ public void invoke(@NotNull final Project project, @NotNull final Editor editor, return; } - var selectedFields = selectFieldsAndOptions(existingFields, project); + var optionsDialog = JavaInnerBuilderOptionSelector.builder() + .project(project) + .members(existingFields) + .build(); + var selectedFields = optionsDialog.selectFieldsAndOptions(); if (selectedFields.isEmpty()) { return; } @@ -86,6 +90,7 @@ public void invoke(@NotNull final Project project, @NotNull final Editor editor, .file(file) .selectedFields(selectedFields) .factory(JavaPsiFacade.getElementFactory(project)) + .codeStyleManager(JavaCodeStyleManager.getInstance(project)) .build(); var generatorParams = GeneratorParams.builder() .project(project) diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/AbstractGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/AbstractGenerator.java index 741a937..47db588 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/generators/AbstractGenerator.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/AbstractGenerator.java @@ -2,12 +2,17 @@ import com.intellij.psi.PsiClass; import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiJavaFile; import com.intellij.psi.PsiMethod; +import com.intellij.psi.PsiType; +import com.intellij.psi.util.PsiUtil; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -abstract class AbstractGenerator implements Runnable { +import java.util.Objects; + +abstract class AbstractGenerator { @NonNls static final String BUILDER_CLASS_NAME = "Builder"; @@ -19,6 +24,10 @@ abstract class AbstractGenerator implements Runnable { static final String EMPTY = ""; @NonNls static final String SPACE = " "; + @NonNls + static final String THIS_DOT = "this."; + @NonNls + static final String RETURN_THIS = "return this;"; protected final GeneratorFactory generatorFactory; protected final GeneratorParams generatorParams; @@ -49,6 +58,12 @@ protected PsiElement addMethod(@NotNull final PsiClass target, @Nullable final P return existingMethod; } + protected boolean addImport(PsiType psiType) { + var psiClass = Objects.requireNonNull(PsiUtil.resolveClassInType(psiType), + "Unable to resolve " + psiType.toString()); + return generatorParams.psi().codeStyleManager().addImport((PsiJavaFile) generatorParams.psi().file(), psiClass); + } + private PsiMethod findConstructor(PsiClass target, PsiMethod newMethod) { for (var constructor : target.getConstructors()) { if (Utils.areParameterListsEqual(constructor.getParameterList(), newMethod.getParameterList())) { diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderClassGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderClassGenerator.java index 7f65292..176f7a3 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderClassGenerator.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderClassGenerator.java @@ -4,7 +4,7 @@ import com.intellij.psi.PsiModifier; import com.intellij.psi.util.PsiUtil; -class BuilderClassGenerator extends AbstractGenerator { +class BuilderClassGenerator extends AbstractGenerator implements Generator { private final BuilderClassParams builderClassParams; @@ -16,18 +16,18 @@ class BuilderClassGenerator extends AbstractGenerator { } @Override - public void run() { + public GenerationResult generate() { //builder constructor var builderClass = builderClassParams.builderClass(); var builderConstructor = generateBuilderConstructor(); addMethod(builderClass, null, builderConstructor, false); var fieldsGenerator = generatorFactory.createBuilderFieldsGenerator(generatorParams, builderClassParams); - fieldsGenerator.run(); + fieldsGenerator.generate(); var methodsGenerator = generatorFactory.createBuilderMethodsGenerator(generatorParams, builderClassParams, fieldsGenerator); - methodsGenerator.run(); + return methodsGenerator.generate(); } private PsiMethod generateBuilderConstructor() { diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderFieldsGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderFieldsGenerator.java index 92c6fde..c0d9c16 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderFieldsGenerator.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderFieldsGenerator.java @@ -27,13 +27,14 @@ public List getFields() { } @Override - public void run() { + public GenerationResult generate() { PsiField lastAddedField = null; for (var fieldMember : generatorParams.psi().selectedFields()) { lastAddedField = createOrUpdateField(builderClassParams.builderClass(), fieldMember, lastAddedField); fields.add(lastAddedField); } cleanupFields(builderClassParams.builderClass()); + return GenerationResult.NO_RESULT; } private void cleanupFields(PsiClass builderClass) { @@ -44,8 +45,8 @@ private void cleanupFields(PsiClass builderClass) { } } - private PsiField createOrUpdateField(final PsiClass builderClass, final PsiFieldMember member, - @Nullable final PsiElement last) { + private PsiField createOrUpdateField(PsiClass builderClass, PsiFieldMember member, + @Nullable PsiElement last) { var psiFactory = generatorParams.psi().factory(); var field = member.getElement(); var fieldName = field.getName(); diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderMethodsGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderMethodsGenerator.java index 6cb4462..102467f 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderMethodsGenerator.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderMethodsGenerator.java @@ -2,6 +2,7 @@ import com.github.junkfactory.innerbuilder.ui.JavaInnerBuilderOption; import com.intellij.openapi.util.text.StringUtil; +import com.intellij.psi.PsiClass; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiField; import com.intellij.psi.PsiMethod; @@ -15,6 +16,9 @@ class BuilderMethodsGenerator extends AbstractGenerator implements MethodsGenera private final BuilderClassParams builderClassParams; private final FieldsGenerator fieldsGenerator; + private final GenerationResult generationResult; + + private boolean isPublic; BuilderMethodsGenerator(GeneratorFactory generatorFactory, GeneratorParams generatorParams, @@ -23,11 +27,15 @@ class BuilderMethodsGenerator extends AbstractGenerator implements MethodsGenera super(generatorFactory, generatorParams); this.builderClassParams = builderClassParams; this.fieldsGenerator = fieldsGenerator; + this.generationResult = new GenerationResult(); } @Override - public void run() { + public GenerationResult generate() { var builderClass = builderClassParams.builderClass(); + var targetClass = builderClassParams.targetClass(); + var targetModifierList = Objects.requireNonNull(targetClass.getModifierList()); + isPublic = targetModifierList.hasModifierProperty(PsiModifier.PUBLIC); PsiElement lastAddedElement = null; for (var field : fieldsGenerator.getFields()) { var setterMethod = generateFieldMethod(field); @@ -41,8 +49,9 @@ public void run() { addMethod(builderClass, lastAddedElement, validateMethod, false); } - var buildMethod = generateBuildMethod(); + var buildMethod = generateBuildMethod(targetClass); addMethod(builderClass, null, buildMethod, builderClassParams.targetClass().isRecord()); + return generationResult; } private PsiMethod generateValidateMethod() { @@ -71,36 +80,76 @@ private PsiMethod generatePutToMap(PsiField field, PsiMethod fieldPutMethod) { //resolve the generic type of the map via the parameter type of the put method var param1 = Objects.requireNonNull(fieldPutMethod.getParameterList().getParameter(0)); var param1Type = Utils.resolveGenericParameterType(field.getType(), param1); + var importAdded = addImport(param1Type); + var param2 = Objects.requireNonNull(fieldPutMethod.getParameterList().getParameter(1)); var param2Type = Utils.resolveGenericParameterType(field.getType(), param2); + importAdded = addImport(param2Type) || importAdded; + if (importAdded) { + generationResult.set(GenerationResult.Code.IMPORTS_ADDED); + } - //now build the put method var methodName = "putTo" + StringUtil.capitalize(field.getName()); - var methodText = """ - public %s %s(%s key, %s value) { - this.%s.put(key, value); - return this; - }""".formatted(BUILDER_CLASS_NAME, methodName, param1Type.getPresentableText(), - param2Type.getPresentableText(), field.getName()); + var methodText = new StringBuilder(); + if (isPublic) { + methodText.append(PsiModifier.PUBLIC).append(' '); + } + methodText.append(BUILDER_CLASS_NAME) + .append(' ') + .append(methodName) + .append('(') + .append(param1Type.getPresentableText()) + .append(' ') + .append(param1.getName().toLowerCase()) + .append(", ") + .append(param2Type.getPresentableText()) + .append(' ') + .append(param2.getName().toLowerCase()) + .append(") {") + .append(THIS_DOT) + .append(field.getName()) + .append(".put(") + .append(param1.getName().toLowerCase()) + .append(", ") + .append(param2.getName().toLowerCase()) + .append(");") + .append(RETURN_THIS) + .append('}'); var psiElementFactory = generatorParams.psi().factory(); - return psiElementFactory.createMethodFromText(methodText, field); + return psiElementFactory.createMethodFromText(methodText.toString(), field); } private PsiMethod generateAddToCollection(PsiField field, PsiMethod fieldAddMethod) { //resolve the generic type of the collection via the parameter type of the add method var param = Objects.requireNonNull(fieldAddMethod.getParameterList().getParameter(0)); var paramType = Utils.resolveGenericParameterType(field.getType(), param); + if (addImport(paramType)) { + generationResult.set(GenerationResult.Code.IMPORTS_ADDED); + } - //now build the add method var methodName = "addTo" + StringUtil.capitalize(field.getName()); - var methodText = """ - public %s %s(%s %s) { - this.%s.add(%s); - return this; - }""".formatted(BUILDER_CLASS_NAME, methodName, paramType.getPresentableText(), - param.getName().toLowerCase(), field.getName(), param.getName()); + var methodText = new StringBuilder(); + if (isPublic) { + methodText.append(PsiModifier.PUBLIC).append(' '); + } + methodText.append(BUILDER_CLASS_NAME) + .append(' ') + .append(methodName) + .append('(') + .append(paramType.getPresentableText()) + .append(' ') + .append(param.getName().toLowerCase()) + .append(") {") + .append(THIS_DOT) + .append(field.getName()) + .append(".add(") + .append(param.getName()) + .append(");") + .append(RETURN_THIS) + .append('}'); + var psiElementFactory = generatorParams.psi().factory(); - return psiElementFactory.createMethodFromText(methodText, field); + return psiElementFactory.createMethodFromText(methodText.toString(), field); } private PsiMethod generateBuilderSetter(PsiField field) { @@ -108,21 +157,31 @@ private PsiMethod generateBuilderSetter(PsiField field) { var fieldName = Utils.hasOneLetterPrefix(field.getName()) ? Character.toLowerCase(field.getName().charAt(1)) + field.getName().substring(2) : field.getName(); - var methodText = """ - public %s %s(%s %s) { - this.%s = %s; - return this; - }""".formatted(BUILDER_CLASS_NAME, fieldName, fieldType.getPresentableText(), - fieldName, field.getName(), fieldName); + var methodText = new StringBuilder(); + if (isPublic) { + methodText.append(PsiModifier.PUBLIC).append(' '); + } + methodText.append(BUILDER_CLASS_NAME) + .append(' ') + .append(fieldName) + .append('(') + .append(fieldType.getPresentableText()) + .append(' ') + .append(fieldName) + .append(") {") + .append(THIS_DOT) + .append(field.getName()) + .append(" = ") + .append(fieldName) + .append(";") + .append(RETURN_THIS) + .append('}'); + var psiElementFactory = generatorParams.psi().factory(); - return psiElementFactory.createMethodFromText(methodText, field); + return psiElementFactory.createMethodFromText(methodText.toString(), field); } - private PsiMethod generateBuildMethod() { - var targetClass = builderClassParams.targetClass(); - var targetModifierList = Objects.requireNonNull(targetClass.getModifierList()); - boolean isPublic = targetModifierList.hasModifierProperty(PsiModifier.PUBLIC); - + private PsiMethod generateBuildMethod(PsiClass targetClass) { var buildMethod = new StringBuilder() .append(isPublic ? PsiModifier.PUBLIC : EMPTY) .append(isPublic ? SPACE : EMPTY) @@ -149,4 +208,5 @@ private PsiMethod generateBuildMethod() { return generatorParams.psi().factory().createMethodFromText(buildMethod.toString(), targetClass); } + } diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/FieldsGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/FieldsGenerator.java index 061a333..e6eed20 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/generators/FieldsGenerator.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/FieldsGenerator.java @@ -4,6 +4,6 @@ import java.util.List; -public interface FieldsGenerator extends Runnable { +public interface FieldsGenerator extends Generator { List getFields(); } diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/GenerationResult.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/GenerationResult.java new file mode 100644 index 0000000..a35a636 --- /dev/null +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/GenerationResult.java @@ -0,0 +1,37 @@ +package com.github.junkfactory.innerbuilder.generators; + +import java.util.BitSet; + +public class GenerationResult { + + static final GenerationResult NO_RESULT = new GenerationResult(); + + public enum Code { + IMPORTS_ADDED, + ANNOTATIONS_ADDED + } + + private final BitSet result; + + GenerationResult() { + this.result = new BitSet(); + } + + void set(Code code) { + result.set(code.ordinal()); + } + + public boolean isEmpty() { + return !result.isEmpty(); + } + + public boolean did(Code code) { + return result.get(code.ordinal()); + } + + public void when(Code code, Runnable runnable) { + if (did(code)) { + runnable.run(); + } + } +} diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/Generator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/Generator.java new file mode 100644 index 0000000..dfca240 --- /dev/null +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/Generator.java @@ -0,0 +1,10 @@ +package com.github.junkfactory.innerbuilder.generators; + +public interface Generator extends Runnable { + + GenerationResult generate(); + + default void run() { + generate(); + } +} diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/GeneratorFactory.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/GeneratorFactory.java index d44716a..447511a 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/generators/GeneratorFactory.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/GeneratorFactory.java @@ -6,10 +6,10 @@ static GeneratorFactory create() { return new InnerBuilderGeneratorFactory(); } - Runnable createInnerBuilderGenerator(GeneratorParams generatorParams); + Generator createInnerBuilderGenerator(GeneratorParams generatorParams); - Runnable createBuilderClassGenerator(GeneratorParams generatorParams, - BuilderClassParams builderClassParams); + Generator createBuilderClassGenerator(GeneratorParams generatorParams, + BuilderClassParams builderClassParams); FieldsGenerator createBuilderFieldsGenerator(GeneratorParams generatorParams, BuilderClassParams builderClassParams); diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/InnerBuilderGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/InnerBuilderGenerator.java index 2ec88b9..d422a73 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/generators/InnerBuilderGenerator.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/InnerBuilderGenerator.java @@ -4,11 +4,11 @@ import com.intellij.codeInsight.generation.PsiFieldMember; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiField; +import com.intellij.psi.PsiJavaFile; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiModifier; import com.intellij.psi.PsiType; import com.intellij.psi.codeStyle.CodeStyleManager; -import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.psi.util.PropertyUtilBase; import com.intellij.psi.util.PsiUtil; import org.jetbrains.annotations.NotNull; @@ -16,18 +16,22 @@ import java.util.Collection; import java.util.Objects; -class InnerBuilderGenerator extends AbstractGenerator { +import static com.github.junkfactory.innerbuilder.generators.GenerationResult.Code.ANNOTATIONS_ADDED; +import static com.github.junkfactory.innerbuilder.generators.GenerationResult.Code.IMPORTS_ADDED; +import static com.github.junkfactory.innerbuilder.generators.GenerationResult.NO_RESULT; + +class InnerBuilderGenerator extends AbstractGenerator implements Generator { InnerBuilderGenerator(GeneratorFactory generatorFactory, GeneratorParams generatorParams) { super(generatorFactory, generatorParams); } @Override - public void run() { + public GenerationResult generate() { var file = generatorParams.psi().file(); var targetClass = Utils.getStaticOrTopLevelClass(file, generatorParams.editor()); if (targetClass == null || BUILDER_CLASS_NAME.equals(targetClass.getName())) { - return; + return NO_RESULT; } var psiElementFactory = generatorParams.psi().factory(); var builderClass = findOrCreateBuilderClass(targetClass); @@ -54,11 +58,13 @@ public void run() { .builderClass(builderClass) .builderType(builderType) .build(); - generatorFactory.createBuilderClassGenerator(generatorParams, params).run(); + var result = generatorFactory.createBuilderClassGenerator(generatorParams, params).generate(); - var project = generatorParams.project(); - JavaCodeStyleManager.getInstance(project).shortenClassReferences(file); - CodeStyleManager.getInstance(project).reformat(builderClass); + var codeStyleManager = generatorParams.psi().codeStyleManager(); + result.when(ANNOTATIONS_ADDED, () -> codeStyleManager.shortenClassReferences(file)); + result.when(IMPORTS_ADDED, () -> codeStyleManager.removeRedundantImports((PsiJavaFile) file)); + CodeStyleManager.getInstance(generatorParams.project()).reformat(builderClass); + return result; } private PsiMethod generateToBuilderMethod(PsiClass targetClass, diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/InnerBuilderGeneratorFactory.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/InnerBuilderGeneratorFactory.java index d5097ab..f782cc3 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/generators/InnerBuilderGeneratorFactory.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/InnerBuilderGeneratorFactory.java @@ -2,13 +2,13 @@ class InnerBuilderGeneratorFactory implements GeneratorFactory { @Override - public Runnable createInnerBuilderGenerator(GeneratorParams generatorParams) { + public Generator createInnerBuilderGenerator(GeneratorParams generatorParams) { return new InnerBuilderGenerator(this, generatorParams); } @Override - public Runnable createBuilderClassGenerator(GeneratorParams generatorParams, - BuilderClassParams builderClassParams) { + public Generator createBuilderClassGenerator(GeneratorParams generatorParams, + BuilderClassParams builderClassParams) { return new BuilderClassGenerator(this, generatorParams, builderClassParams); } diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/MethodsGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/MethodsGenerator.java index 1287522..228b8de 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/generators/MethodsGenerator.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/MethodsGenerator.java @@ -1,4 +1,4 @@ package com.github.junkfactory.innerbuilder.generators; -public interface MethodsGenerator extends Runnable { +public interface MethodsGenerator extends Generator { } diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/PsiParams.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/PsiParams.java index a30e4e0..d1569b0 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/generators/PsiParams.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/generators/PsiParams.java @@ -3,12 +3,14 @@ import com.intellij.codeInsight.generation.PsiFieldMember; import com.intellij.psi.PsiElementFactory; import com.intellij.psi.PsiFile; +import com.intellij.psi.codeStyle.JavaCodeStyleManager; import java.util.List; public record PsiParams(PsiFile file, List selectedFields, - PsiElementFactory factory) { + PsiElementFactory factory, + JavaCodeStyleManager codeStyleManager) { public static Builder builder() { return new Builder(); @@ -18,6 +20,7 @@ public static final class Builder { private PsiFile file; private List selectedFields; private PsiElementFactory factory; + private JavaCodeStyleManager codeStyleManager; private Builder() { } @@ -37,8 +40,13 @@ public Builder factory(PsiElementFactory factory) { return this; } + public Builder codeStyleManager(JavaCodeStyleManager codeStyleManager) { + this.codeStyleManager = codeStyleManager; + return this; + } + public PsiParams build() { - return new PsiParams(file, selectedFields, factory); + return new PsiParams(file, selectedFields, factory, codeStyleManager); } } } diff --git a/src/main/java/com/github/junkfactory/innerbuilder/ui/JavaInnerBuilderOptionSelector.java b/src/main/java/com/github/junkfactory/innerbuilder/ui/JavaInnerBuilderOptionSelector.java index f8d6a15..ea95583 100644 --- a/src/main/java/com/github/junkfactory/innerbuilder/ui/JavaInnerBuilderOptionSelector.java +++ b/src/main/java/com/github/junkfactory/innerbuilder/ui/JavaInnerBuilderOptionSelector.java @@ -17,10 +17,21 @@ public class JavaInnerBuilderOptionSelector { - private static final DropdownListCellRenderer RENDERER = new DropdownListCellRenderer(); - private static final List OPTIONS = createGeneratorOptions(); + private final DropdownListCellRenderer renderer = new DropdownListCellRenderer(); - private static List createGeneratorOptions() { + private final List members; + private final Project project; + + private JavaInnerBuilderOptionSelector(Builder builder) { + members = builder.members; + project = builder.project; + } + + public static Builder builder() { + return new Builder(); + } + + private List createGeneratorOptions() { var options = new ArrayList(); options.add(new CheckboxSelectorOption( JavaInnerBuilderOption.WITH_TO_BUILDER_METHOD, @@ -33,11 +44,7 @@ private static List createGeneratorOptions() { return options; } - private JavaInnerBuilderOptionSelector() { - } - - public static List selectFieldsAndOptions(final List members, - final Project project) { + public List selectFieldsAndOptions() { if (members == null || members.isEmpty()) { return List.of(); } @@ -64,25 +71,26 @@ public static List selectFieldsAndOptions(final List(); comboBox.setEditable(false); - comboBox.setRenderer(RENDERER); + comboBox.setRenderer(renderer); selectorOption.values().forEach(comboBox::addItem); comboBox.setSelectedItem(setSelectedComboBoxItem(propertiesComponent, selectorOption)); @@ -110,14 +118,14 @@ private static JComponent buildDropdown(PropertiesComponent propertiesComponent, return labeledComponent; } - private static void setPropertiesComponentValue(PropertiesComponent propertiesComponent, - DropdownSelectorOption selectorOption, ItemEvent itemEvent) { + private void setPropertiesComponentValue(PropertiesComponent propertiesComponent, + DropdownSelectorOption selectorOption, ItemEvent itemEvent) { var value = (DropdownSelectorOptionValue) itemEvent.getItem(); propertiesComponent.setValue(selectorOption.option().getProperty(), value.option().getProperty()); } - private static DropdownSelectorOptionValue setSelectedComboBoxItem(PropertiesComponent propertiesComponent, - DropdownSelectorOption selectorOption) { + private DropdownSelectorOptionValue setSelectedComboBoxItem(PropertiesComponent propertiesComponent, + DropdownSelectorOption selectorOption) { var selectedValue = propertiesComponent.getValue(selectorOption.option().getProperty()); var selectorOptionValue = selectorOption.values() .stream() @@ -130,4 +138,26 @@ private static DropdownSelectorOptionValue setSelectedComboBoxItem(PropertiesCom } return selectorOptionValue; } + + public static final class Builder { + private List members; + private Project project; + + private Builder() { + } + + public Builder members(List members) { + this.members = members; + return this; + } + + public Builder project(Project project) { + this.project = project; + return this; + } + + public JavaInnerBuilderOptionSelector build() { + return new JavaInnerBuilderOptionSelector(this); + } + } }