Skip to content

Commit

Permalink
added support for Include.name and Include.replace functionality proj…
Browse files Browse the repository at this point in the history 
…ectlombok#504
  • Loading branch information
@mplushnikov
mplushnikov committed Oct 20, 2018
1 parent 505f44b commit a00cb1f
Show file tree
Hide file tree
Showing 16 changed files with 386 additions and 255 deletions.
26 changes: 5 additions & 21 deletions src/main/java/de/plushnikov/intellij/plugin/action/delombok/BaseDelombokHandler.java
View file
Expand Up @@ -3,25 +3,7 @@
import com.intellij.openapi.command.undo.UndoUtil;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.JavaPsiFacade;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiClassType;
import com.intellij.psi.PsiCodeBlock;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiElementFactory;
import com.intellij.psi.PsiField;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiJavaCodeReferenceElement;
import com.intellij.psi.PsiJavaFile;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiModifier;
import com.intellij.psi.PsiModifierList;
import com.intellij.psi.PsiNameValuePair;
import com.intellij.psi.PsiParameter;
import com.intellij.psi.PsiType;
import com.intellij.psi.PsiTypeParameterList;
import com.intellij.psi.PsiTypeParameterListOwner;
import com.intellij.psi.*;
import com.intellij.psi.codeStyle.CodeStyleManager;
import com.intellij.psi.codeStyle.JavaCodeStyleManager;
import de.plushnikov.intellij.plugin.processor.AbstractProcessor;
Expand Down Expand Up @@ -171,14 +153,16 @@ private PsiMethod rebuildMethod(@NotNull Project project, @NotNull PsiMethod fro

for (PsiParameter parameter : fromMethod.getParameterList().getParameters()) {
PsiParameter param = elementFactory.createParameter(parameter.getName(), parameter.getType());
if (parameter.getModifierList() != null) {
final PsiModifierList parameterModifierList = parameter.getModifierList();
if (parameterModifierList != null) {
PsiModifierList modifierList = param.getModifierList();
for (PsiAnnotation originalAnnotation : parameter.getModifierList().getAnnotations()) {
for (PsiAnnotation originalAnnotation : parameterModifierList.getAnnotations()) {
final PsiAnnotation annotation = modifierList.addAnnotation(originalAnnotation.getQualifiedName());
for (PsiNameValuePair nameValuePair : originalAnnotation.getParameterList().getAttributes()) {
annotation.setDeclaredAttributeValue(nameValuePair.getName(), nameValuePair.getValue());
}
}
modifierList.setModifierProperty(PsiModifier.FINAL, parameterModifierList.hasModifierProperty(PsiModifier.FINAL));
}
resultMethod.getParameterList().add(param);
}
Expand Down
12 changes: 0 additions & 12 deletions src/main/java/de/plushnikov/intellij/plugin/processor/AbstractProcessor.java
View file
Expand Up @@ -7,12 +7,9 @@
import com.intellij.psi.PsiField;
import com.intellij.psi.PsiModifierList;
import com.intellij.psi.PsiModifierListOwner;
import com.intellij.psi.PsiType;
import com.intellij.util.ArrayUtil;
import de.plushnikov.intellij.plugin.lombokconfig.ConfigDiscovery;
import de.plushnikov.intellij.plugin.lombokconfig.ConfigKey;
import de.plushnikov.intellij.plugin.processor.field.AccessorsInfo;
import de.plushnikov.intellij.plugin.thirdparty.LombokUtils;
import de.plushnikov.intellij.plugin.util.LombokProcessorUtil;
import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil;
import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil;
Expand Down Expand Up @@ -90,15 +87,6 @@ public List<? super PsiElement> process(@NotNull PsiClass psiClass) {
@NotNull
public abstract Collection<PsiAnnotation> collectProcessedAnnotations(@NotNull PsiClass psiClass);

protected String getGetterName(final @NotNull PsiField psiField) {
final AccessorsInfo accessorsInfo = AccessorsInfo.build(psiField);

final String psiFieldName = psiField.getName();
final boolean isBoolean = PsiType.BOOLEAN.equals(psiField.getType());

return LombokUtils.toGetterName(accessorsInfo, psiFieldName, isBoolean);
}

protected void filterToleratedElements(@NotNull Collection<? extends PsiModifierListOwner> definedMethods) {
definedMethods.removeIf(definedMethod -> PsiAnnotationSearchUtil.isAnnotatedWith(definedMethod, Tolerate.class));
}
Expand Down
100 changes: 6 additions & 94 deletions src/main/java/de/plushnikov/intellij/plugin/processor/clazz/AbstractClassProcessor.java
View file
Expand Up @@ -18,24 +18,17 @@
import de.plushnikov.intellij.plugin.processor.clazz.constructor.AbstractConstructorClassProcessor;
import de.plushnikov.intellij.plugin.quickfix.PsiQuickFixFactory;
import de.plushnikov.intellij.plugin.thirdparty.LombokUtils;
import de.plushnikov.intellij.plugin.util.LombokProcessorUtil;
import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil;
import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil;
import de.plushnikov.intellij.plugin.util.PsiClassUtil;
import de.plushnikov.intellij.plugin.util.PsiMethodUtil;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;
import lombok.Value;
import org.jetbrains.annotations.NotNull;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
Expand Down Expand Up @@ -66,7 +59,7 @@ public List<? super PsiElement> process(@NotNull PsiClass psiClass) {
PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, getSupportedAnnotationClasses());
if (null != psiAnnotation) {
if (validate(psiAnnotation, psiClass, ProblemEmptyBuilder.getInstance())) {
result = new ArrayList<PsiElement>();
result = new ArrayList<>();
generatePsiElements(psiClass, psiAnnotation, result);
}
}
Expand Down Expand Up @@ -111,7 +104,7 @@ public Collection<LombokProblem> verifyAnnotation(@NotNull PsiAnnotation psiAnno

protected abstract void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target);

protected void validateOfParam(PsiClass psiClass, ProblemBuilder builder, PsiAnnotation psiAnnotation, Collection<String> ofProperty) {
void validateOfParam(PsiClass psiClass, ProblemBuilder builder, PsiAnnotation psiAnnotation, Collection<String> ofProperty) {
for (String fieldName : ofProperty) {
if (!StringUtil.isEmptyOrSpaces(fieldName)) {
PsiField fieldByName = psiClass.findFieldByName(fieldName, false);
Expand All @@ -124,7 +117,7 @@ protected void validateOfParam(PsiClass psiClass, ProblemBuilder builder, PsiAnn
}
}

protected void validateExcludeParam(PsiClass psiClass, ProblemBuilder builder, PsiAnnotation psiAnnotation, Collection<String> excludeProperty) {
void validateExcludeParam(PsiClass psiClass, ProblemBuilder builder, PsiAnnotation psiAnnotation, Collection<String> excludeProperty) {
for (String fieldName : excludeProperty) {
if (!StringUtil.isEmptyOrSpaces(fieldName)) {
PsiField fieldByName = psiClass.findFieldByName(fieldName, false);
Expand All @@ -146,88 +139,13 @@ protected void validateExcludeParam(PsiClass psiClass, ProblemBuilder builder, P
private String calcNewPropertyValue(Collection<String> allProperties, String fieldName) {
String result = null;
if (!allProperties.isEmpty() && (allProperties.size() > 1 || !allProperties.contains(fieldName))) {
result = allProperties.stream().filter(((Predicate<String>) fieldName::equals).negate()).collect(Collectors.joining("\",\"", "{\"", "\"}"));
result = allProperties.stream().filter(((Predicate<String>) fieldName::equals).negate())
.collect(Collectors.joining("\",\"", "{\"", "\"}"));
}
return result;
}

protected Collection<PsiField> filterFields(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, boolean filterTransient) {
final boolean explicitOf = PsiAnnotationUtil.hasDeclaredProperty(psiAnnotation, "of");
final boolean explicitExclude = PsiAnnotationUtil.hasDeclaredProperty(psiAnnotation, "exclude");
final boolean onlyExplicitlyIncluded = PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "onlyExplicitlyIncluded", false);

final String annotationFQN = psiAnnotation.getQualifiedName();
final String annotationIncludeFQN = annotationFQN + ".Include";
final String annotationExcludeFQN = annotationFQN + ".Exclude";

//Having both exclude and of generates a warning; the exclude parameter will be ignored in that case.
final Collection<String> ofProperty;
final Collection<String> excludeProperty;
if (!explicitOf) {
excludeProperty = makeSet(PsiAnnotationUtil.getAnnotationValues(psiAnnotation, "exclude", String.class));
ofProperty = Collections.emptyList();
} else {
ofProperty = makeSet(PsiAnnotationUtil.getAnnotationValues(psiAnnotation, "of", String.class));
excludeProperty = Collections.emptyList();
}

final Collection<PsiField> psiFields = PsiClassUtil.collectClassFieldsIntern(psiClass);

final Collection<PsiField> result = new ArrayList<PsiField>(psiFields.size());

for (PsiField classField : psiFields) {
if (!PsiAnnotationSearchUtil.isAnnotatedWith(classField, annotationIncludeFQN)) {
if (!onlyExplicitlyIncluded) {
if (classField.hasModifierProperty(PsiModifier.STATIC) || (filterTransient && classField.hasModifierProperty(PsiModifier.TRANSIENT))) {
continue;
}
final String fieldName = classField.getName();
if (null == fieldName) {
continue;
}
if (explicitExclude && excludeProperty.contains(fieldName)) {
continue;
}
if (explicitOf && !ofProperty.contains(fieldName)) {
continue;
}

if (fieldName.startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER) && !ofProperty.contains(fieldName)) {
continue;
}

if (PsiAnnotationSearchUtil.isAnnotatedWith(classField, annotationExcludeFQN)) {
continue;
}
result.add(classField);
}
} else {
result.add(classField);
}
}
return result;
}

protected String buildAttributeNameString(boolean doNotUseGetters, @NotNull PsiField classField, @NotNull PsiClass psiClass) {
final String fieldName = classField.getName();
if (doNotUseGetters) {
return fieldName;
} else {
final String getterName = getGetterName(classField);

final boolean hasGetter;
if (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Data.class, Value.class, lombok.experimental.Value.class, Getter.class)) {
final PsiAnnotation getterLombokAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, Getter.class);
hasGetter = null == getterLombokAnnotation || null != LombokProcessorUtil.getMethodModifier(getterLombokAnnotation);
} else {
hasGetter = PsiMethodUtil.hasMethodByName(PsiClassUtil.collectClassMethodsIntern(psiClass), getterName);
}

return hasGetter ? getterName + "()" : fieldName;
}
}

protected boolean shouldGenerateNoArgsConstructor(@NotNull PsiClass psiClass, @NotNull AbstractConstructorClassProcessor argsConstructorProcessor) {
boolean shouldGenerateNoArgsConstructor(@NotNull PsiClass psiClass, @NotNull AbstractConstructorClassProcessor argsConstructorProcessor) {
boolean result = ConfigDiscovery.getInstance().getBooleanLombokConfigProperty(ConfigKey.NO_ARGS_CONSTRUCTOR_EXTRA_PRIVATE, psiClass);
if (result) {
result = !PsiClassUtil.hasSuperClass(psiClass);
Expand All @@ -244,10 +162,4 @@ protected boolean shouldGenerateNoArgsConstructor(@NotNull PsiClass psiClass, @N
return result;
}

private Collection<String> makeSet(@NotNull Collection<String> exclude) {
if (exclude.isEmpty()) {
return Collections.emptySet();
}
return new HashSet<String>(exclude);
}
}

0 comments on commit a00cb1f

Please sign in to comment.