java/java-impl/src/com/intellij/refactoring/introduceparameterobject/ParameterObjectBuilder.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.refactoring.introduceparameterobject;
  17
  18 import com.intellij.openapi.project.Project;
  19 import com.intellij.openapi.util.text.StringUtil;
  20 import com.intellij.psi.*;
  21 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
  22 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
  23 import com.intellij.psi.codeStyle.VariableKind;
  24 import com.intellij.psi.javadoc.PsiDocComment;
  25 import org.jetbrains.annotations.NonNls;
  26
  27 import java.util.ArrayList;
  28 import java.util.Iterator;
  29 import java.util.List;
  30
  31 class ParameterObjectBuilder {
  32     private String className = null;
  33     private String packageName = null;
  34     private final List<ParameterSpec> fields = new ArrayList<ParameterSpec>(5);
  35     private final List<PsiTypeParameter> typeParams = new ArrayList<PsiTypeParameter>();
  36     private Project myProject;
  37   private JavaCodeStyleManager myJavaCodeStyleManager ;
  38
  39   public void setClassName(String className) {
  40         this.className = className;
  41     }
  42
  43     public void setPackageName(String packageName) {
  44         this.packageName = packageName;
  45     }
  46
  47     public void addField(PsiParameter variable, String name, PsiType type, boolean setterRequired) {
  48         final ParameterSpec field = new ParameterSpec(variable, name, type, setterRequired);
  49         fields.add(field);
  50     }
  51
  52     public void setTypeArguments(List<PsiTypeParameter> typeParams) {
  53         this.typeParams.clear();
  54         this.typeParams.addAll(typeParams);
  55     }
  56
  57   public void setProject(final Project project) {
  58     myProject = project;
  59     myJavaCodeStyleManager = JavaCodeStyleManager.getInstance(myProject);
  60   }
  61
  62   public String buildBeanClass() {
  63         @NonNls final StringBuffer out = new StringBuffer(1024);
  64         if (packageName.length() > 0) out.append("package " + packageName + ';');
  65         out.append('\n');
  66         out.append("public class " + className);
  67         if (!typeParams.isEmpty()) {
  68             out.append('<');
  69             boolean first = true;
  70             for (PsiTypeParameter typeParam : typeParams) {
  71                 if (!first) {
  72                     out.append(',');
  73                 }
  74                 out.append(typeParam.getText());
  75                 first = false;
  76             }
  77             out.append('>');
  78         }
  79         out.append('\n');
  80
  81         out.append('{');
  82         outputFields(out);
  83         outputConstructor(out);
  84         outputGetters(out);
  85         outputSetters(out);
  86         out.append("}\n");
  87         return out.toString();
  88     }
  89
  90     private void outputSetters(StringBuffer out) {
  91         for (final ParameterSpec field : fields) {
  92             outputSetter(field, out);
  93         }
  94     }
  95
  96     private void outputGetters(StringBuffer out) {
  97         for (final ParameterSpec field : fields) {
  98             outputGetter(field, out);
  99         }
 100     }
 101
 102     private void outputFields(StringBuffer out) {
 103         for (final ParameterSpec field : fields) {
 104             outputField(field, out);
 105         }
 106     }
 107
 108     private void outputSetter(ParameterSpec field, @NonNls StringBuffer out) {
 109         if (!field.isSetterRequired()) {
 110             return;
 111         }
 112       final PsiParameter parameter = field.getParameter();
 113       final PsiType type = field.getType();
 114         final String typeText;
 115         if (parameter.isVarArgs()) {
 116             typeText = ((PsiArrayType) type).getComponentType().getCanonicalText() + "...";
 117         } else {
 118             typeText = type.getCanonicalText();
 119         }
 120         final String name = calculateStrippedName(field.getName());
 121         final String capitalizedName = StringUtil.capitalize(name);
 122         final String parameterName =
 123                 myJavaCodeStyleManager.propertyNameToVariableName(name, VariableKind.PARAMETER);
 124
 125         out.append("\tpublic void set" + capitalizedName + '(');
 126         outputAnnotationString(parameter, out);
 127         out.append(CodeStyleSettingsManager.getSettings(myProject).GENERATE_FINAL_PARAMETERS?"final " : "");
 128         out.append(' ' +typeText + ' ' + parameterName + ")\n");
 129         out.append("\t{\n");
 130         final String fieldName = myJavaCodeStyleManager.propertyNameToVariableName(name, VariableKind.FIELD);
 131       generateFieldAssignment(out, parameterName, fieldName);
 132       out.append("\t}\n");
 133     }
 134
 135   private static void generateFieldAssignment(final StringBuffer out, final String parameterName, final String fieldName) {
 136     if (fieldName.equals(parameterName)) {
 137         out.append("\t\tthis." + fieldName + " = " + parameterName + ";\n");
 138     } else {
 139         out.append("\t\t" + fieldName + " = " + parameterName + ";\n");
 140     }
 141   }
 142
 143   @NonNls
 144     private String calculateStrippedName(String name) {
 145         return myJavaCodeStyleManager.variableNameToPropertyName(name, VariableKind.PARAMETER);
 146     }
 147
 148     private void outputGetter(ParameterSpec field, @NonNls StringBuffer out) {
 149         final PsiParameter parameter = field.getParameter();
 150         final PsiType type = field.getType();
 151         final String typeText;
 152         if (parameter.isVarArgs()) {
 153             typeText = ((PsiArrayType) type).getComponentType().getCanonicalText() + "[]";
 154         } else {
 155             typeText = type.getCanonicalText();
 156         }
 157         final String name = calculateStrippedName(field.getName());
 158         final String capitalizedName = StringUtil.capitalize(name);
 159         if (PsiType.BOOLEAN.equals(type)) {
 160             out.append('\t');
 161             outputAnnotationString(parameter, out);
 162             out.append(" public "+ typeText + " is" + capitalizedName + "()\n");
 163         } else {
 164             out.append('\t');
 165             outputAnnotationString(parameter, out);
 166             out.append(" public " +typeText + " get" + capitalizedName + "()\n");
 167         }
 168         out.append("\t{\n");
 169         final String fieldName = myJavaCodeStyleManager.propertyNameToVariableName(name, VariableKind.FIELD);
 170         out.append("\t\treturn " + fieldName + ";\n");
 171         out.append("\t}\n");
 172     }
 173
 174     private void outputConstructor(@NonNls StringBuffer out) {
 175         out.append("\tpublic " + className + '(');
 176         for (Iterator<ParameterSpec> iterator = fields.iterator(); iterator.hasNext();) {
 177             final ParameterSpec field = iterator.next();
 178             final PsiParameter parameter = field.getParameter();
 179             outputAnnotationString(parameter, out);
 180             out.append(CodeStyleSettingsManager.getSettings(myProject).GENERATE_FINAL_PARAMETERS ? " final " : "");
 181
 182             final PsiType type = field.getType();
 183             final String typeText;
 184             if (parameter.isVarArgs()) {
 185               typeText = ((PsiArrayType) type).getComponentType().getCanonicalText() + "...";
 186             } else {
 187               typeText = type.getCanonicalText();
 188             }
 189             final String name = calculateStrippedName(field.getName());
 190             final String parameterName =
 191               myJavaCodeStyleManager.propertyNameToVariableName(name, VariableKind.PARAMETER);
 192             out.append(' ' +typeText + ' ' + parameterName);
 193             if (iterator.hasNext()) {
 194                 out.append(", ");
 195             }
 196         }
 197         out.append(")\n");
 198         out.append("\t{\n");
 199         for (final ParameterSpec field : fields) {
 200             final String name = calculateStrippedName(field.getName());
 201             final String fieldName = myJavaCodeStyleManager.propertyNameToVariableName(name, VariableKind.FIELD);
 202             final String parameterName =
 203             myJavaCodeStyleManager.propertyNameToVariableName(name, VariableKind.PARAMETER);
 204           generateFieldAssignment(out, parameterName, fieldName);
 205         }
 206         out.append("\t}\n");
 207     }
 208
 209     private void outputField(ParameterSpec field, StringBuffer out) {
 210         final PsiParameter parameter = field.getParameter();
 211         final PsiDocComment docComment = getJavadocForVariable(parameter);
 212         if (docComment != null) {
 213             out.append(docComment.getText());
 214             out.append('\n');
 215         }
 216         final PsiType type = field.getType();
 217         final String typeText;
 218         if (parameter.isVarArgs()) {
 219             final PsiType componentType = ((PsiArrayType) type).getComponentType();
 220             typeText = componentType.getCanonicalText() + "[]";
 221         } else {
 222             typeText = type.getCanonicalText();
 223         }
 224         final String name = calculateStrippedName(field.getName());
 225         @NonNls String modifierString = "private ";
 226         if (!field.isSetterRequired()) {
 227             modifierString += "final ";
 228         }
 229         outputAnnotationString(parameter, out);
 230         out.append('\t' + modifierString + typeText + ' ' + myJavaCodeStyleManager.propertyNameToVariableName(name, VariableKind.FIELD) + ";\n");
 231     }
 232
 233     private void outputAnnotationString(PsiParameter parameter, StringBuffer out) {
 234         final PsiModifierList modifierList = parameter.getModifierList();
 235         final PsiAnnotation[] annotations = modifierList.getAnnotations();
 236         for (PsiAnnotation annotation : annotations) {
 237             final PsiJavaCodeReferenceElement reference = annotation.getNameReferenceElement();
 238             if (reference == null) {
 239                 continue;
 240             }
 241             final PsiClass annotationClass = (PsiClass) reference.resolve();
 242             if (annotationClass != null) {
 243                 final PsiAnnotationParameterList parameterList = annotation.getParameterList();
 244                 final String annotationText = '@' + annotationClass.getQualifiedName() + parameterList.getText();
 245                 out.append(annotationText);
 246             }
 247         }
 248     }
 249
 250     private static PsiDocComment getJavadocForVariable(PsiVariable variable) {
 251         final PsiElement[] children = variable.getChildren();
 252         for (PsiElement child : children) {
 253             if (child instanceof PsiDocComment) {
 254                 return (PsiDocComment) child;
 255             }
 256         }
 257         return null;
 258     }
 259
 260 }
 261