コード例 #1
1
  private static void generateNameByString(
      Set<String> possibleNames,
      String value,
      NameValidator validator,
      boolean forStaticVariable,
      Project project) {
    if (!JavaPsiFacade.getInstance(project).getNameHelper().isIdentifier(value)) return;
    if (forStaticVariable) {
      StringBuilder buffer = new StringBuilder(value.length() + 10);
      char[] chars = new char[value.length()];
      value.getChars(0, value.length(), chars, 0);
      boolean wasLow = Character.isLowerCase(chars[0]);

      buffer.append(Character.toUpperCase(chars[0]));
      for (int i = 1; i < chars.length; i++) {
        if (Character.isUpperCase(chars[i])) {
          if (wasLow) {
            buffer.append('_');
            wasLow = false;
          }
        } else {
          wasLow = true;
        }

        buffer.append(Character.toUpperCase(chars[i]));
      }
      possibleNames.add(validator.validateName(buffer.toString(), true));
    } else {
      possibleNames.add(validator.validateName(value, true));
    }
  }
コード例 #2
0
 private static void generateNamesForExceptions(
     PsiType type, Set<String> possibleNames, NameValidator validator) {
   if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_LANG_ERROR)) {
     possibleNames.add(validator.validateName("error", true));
   } else if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_LANG_EXCEPTION)) {
     possibleNames.add(validator.validateName("e", true));
   }
 }
コード例 #3
0
  private static void generateNamesForCollectionType(
      PsiType type, Set<String> possibleNames, NameValidator validator) {
    PsiType componentType = getCollectionComponentType(type, validator.getProject());
    if (!(type instanceof PsiClassType) || componentType == null) return;
    PsiClass clazz = ((PsiClassType) type).resolve();
    if (clazz == null) return;
    String collectionName = clazz.getName();
    assert collectionName != null;

    String componentName = cleanTypeName(componentType.getPresentableText());
    if (componentType instanceof PsiClassType) {
      PsiClassType classType = (PsiClassType) componentType;
      PsiClass psiClass = classType.resolve();
      if (psiClass == null) return;
      componentName = psiClass.getName();
    }

    assert componentName != null;
    String candidateName = StringUtil.pluralize(GroovyNamesUtil.fromLowerLetter(componentName));
    generateCamelNames(possibleNames, validator, candidateName);

    ArrayList<String> camelizedName = GroovyNamesUtil.camelizeString(candidateName);
    candidateName = camelizedName.get(camelizedName.size() - 1);
    candidateName = collectionName.toLowerCase() + "Of" + fromUpperLetter(candidateName);
    possibleNames.add(validator.validateName(candidateName, true));
  }
コード例 #4
0
 private static void generateCamelNames(
     Set<String> possibleNames, NameValidator validator, String typeName) {
   ArrayList<String> camelTokens = GroovyNamesUtil.camelizeString(typeName);
   Collections.reverse(camelTokens);
   if (!camelTokens.isEmpty()) {
     String possibleName = "";
     for (String camelToken : camelTokens) {
       possibleName = camelToken + fromUpperLetter(possibleName);
       String candidate = validator.validateName(possibleName, true);
       // todo generify
       if (candidate.equals("class")) {
         candidate = validator.validateName("clazz", true);
       }
       if (!possibleNames.contains(candidate) && GroovyNamesUtil.isIdentifier(candidate)) {
         possibleNames.add(candidate);
       }
     }
   }
 }
コード例 #5
0
 private static void generateNameByExpr(
     GrExpression expr,
     Set<String> possibleNames,
     NameValidator validator,
     boolean forStaticVariable) {
   if (expr instanceof GrReferenceExpression
       && ((GrReferenceExpression) expr).getReferenceName() != null) {
     if (PsiUtil.isThisReference(expr)) {
       possibleNames.add(validator.validateName("thisInstance", true));
     }
     if (PsiUtil.isSuperReference(expr)) {
       possibleNames.add(validator.validateName("superInstance", true));
     }
     GrReferenceExpression refExpr = (GrReferenceExpression) expr;
     String name = refExpr.getReferenceName();
     if (name != null && name.toUpperCase().equals(name)) {
       possibleNames.add(validator.validateName(name.toLowerCase(), true));
     } else {
       generateCamelNames(possibleNames, validator, name);
     }
     if (expr.getText().equals(name)) {
       possibleNames.remove(name);
     }
   }
   if (expr instanceof GrMethodCallExpression) {
     generateNameByExpr(
         ((GrMethodCallExpression) expr).getInvokedExpression(),
         possibleNames,
         validator,
         forStaticVariable);
   }
   if (expr instanceof GrLiteral) {
     final Object value = ((GrLiteral) expr).getValue();
     if (value instanceof String) {
       generateNameByString(
           possibleNames, (String) value, validator, forStaticVariable, expr.getProject());
     }
   }
 }
コード例 #6
0
 private static void generateByType(
     PsiType type, Set<String> possibleNames, NameValidator validator) {
   String typeName = type.getPresentableText();
   generateNamesForCollectionType(type, possibleNames, validator);
   generateNamesForArrayType(type, possibleNames, validator);
   generateNamesForExceptions(type, possibleNames, validator);
   typeName = cleanTypeName(typeName);
   if (typeName.equals("String")) {
     possibleNames.add(validator.validateName("s", true));
   }
   if (typeName.equals("Closure")) {
     possibleNames.add(validator.validateName("cl", true));
   }
   if (typeName.toUpperCase().equals(typeName)) {
     possibleNames.add(
         validator.validateName(
             GroovyNamesUtil.deleteNonLetterFromString(typeName.toLowerCase()), true));
   } else if (!typeName.equals(typeName.toLowerCase())) {
     generateCamelNames(possibleNames, validator, typeName);
     possibleNames.remove(typeName);
   }
 }
コード例 #7
0
  public static String[] suggestVariableNames(
      @NotNull GrExpression expr, NameValidator validator, boolean forStaticVariable) {
    Set<String> possibleNames = new LinkedHashSet<String>();
    PsiType type = expr.getType();
    generateNameByExpr(expr, possibleNames, validator, forStaticVariable);
    if (type != null && !PsiType.VOID.equals(type)) {
      generateVariableNameByTypeInner(type, possibleNames, validator);
    }

    possibleNames.remove("");
    if (possibleNames.isEmpty()) {
      possibleNames.add(validator.validateName("var", true));
    }
    return ArrayUtil.toStringArray(possibleNames);
  }
コード例 #8
0
 private static void generateVariableNameByTypeInner(
     PsiType type, Set<String> possibleNames, NameValidator validator) {
   String unboxed = PsiTypesUtil.unboxIfPossible(type.getCanonicalText());
   if (unboxed != null && !unboxed.equals(type.getCanonicalText())) {
     String name = generateNameForBuiltInType(unboxed);
     name = validator.validateName(name, true);
     if (GroovyNamesUtil.isIdentifier(name)) {
       possibleNames.add(name);
     }
   } else if (type instanceof PsiIntersectionType) {
     for (PsiType psiType : ((PsiIntersectionType) type).getConjuncts()) {
       generateByType(psiType, possibleNames, validator);
     }
   } else {
     generateByType(type, possibleNames, validator);
   }
 }
コード例 #9
0
  private static void generateNamesForArrayType(
      PsiType type, Set<String> possibleNames, NameValidator validator) {
    int arrayDim = type.getArrayDimensions();
    if (arrayDim == 0) return;
    PsiType deepType = type.getDeepComponentType();
    String candidateName = cleanTypeName(deepType.getPresentableText());
    if (deepType instanceof PsiClassType) {
      PsiClass clazz = ((PsiClassType) deepType).resolve();
      if (clazz == null) return;
      candidateName = GroovyNamesUtil.fromLowerLetter(clazz.getName());
    }
    candidateName = StringUtil.pluralize(GroovyNamesUtil.fromLowerLetter(candidateName));
    generateCamelNames(possibleNames, validator, candidateName);

    ArrayList<String> camelizedName = GroovyNamesUtil.camelizeString(candidateName);
    candidateName = camelizedName.get(camelizedName.size() - 1);
    candidateName = "arrayOf" + fromUpperLetter(candidateName);
    possibleNames.add(validator.validateName(candidateName, true));
  }