Esempio n. 1
0
  @Override
  public O addInterface(final String type) {
    if (!this.hasInterface(type)) {
      Type interfaceType =
          JDTHelper.getInterfaces(
                  JavaParser.parse(
                          JavaInterfaceImpl.class,
                          "public interface Mock extends " + Types.toSimpleName(type) + " {}")
                      .getBodyDeclaration())
              .get(0);

      if (this.hasInterface(Types.toSimpleName(type)) || this.hasImport(Types.toSimpleName(type))) {
        interfaceType =
            JDTHelper.getInterfaces(
                    JavaParser.parse(
                            JavaInterfaceImpl.class,
                            "public interface Mock extends " + type + " {}")
                        .getBodyDeclaration())
                .get(0);
      }

      this.addImport(type);

      ASTNode node = ASTNode.copySubtree(unit.getAST(), interfaceType);
      JDTHelper.getInterfaces(getBodyDeclaration()).add((Type) node);
    }
    return (O) this;
  }
Esempio n. 2
0
 @Override
 public boolean hasImport(final String type) {
   String resultType = type;
   if (Types.isArray(type)) {
     resultType = Types.stripArray(type);
   }
   if (Types.isGeneric(type)) {
     resultType = Types.stripGenerics(type);
   }
   return getImport(resultType) != null;
 }
Esempio n. 3
0
 @Override
 public boolean requiresImport(final String type) {
   String resultType = type;
   if (Types.isArray(resultType)) {
     resultType = Types.stripArray(type);
   }
   if (Types.isGeneric(resultType)) {
     resultType = Types.stripGenerics(resultType);
   }
   if (!validImport(resultType) || hasImport(resultType) || Types.isJavaLang(resultType)) {
     return false;
   }
   return true;
 }
Esempio n. 4
0
 @Override
 public boolean hasInterface(final String type) {
   for (String name : getInterfaces()) {
     if (Types.areEquivalent(name, type)) {
       return true;
     }
   }
   return false;
 }
Esempio n. 5
0
 @Override
 public O removeInterface(final String type) {
   List<Type> interfaces = JDTHelper.getInterfaces(getBodyDeclaration());
   for (Type i : interfaces) {
     if (Types.areEquivalent(i.toString(), type)) {
       interfaces.remove(i);
       break;
     }
   }
   return (O) this;
 }
Esempio n. 6
0
  @Override
  public Import addImport(final String className) {
    String strippedClassName = Types.stripGenerics(Types.stripArray(className));
    Import imprt;
    if (Types.isSimpleName(strippedClassName) && !hasImport(strippedClassName)) {
      throw new IllegalArgumentException(
          "Cannot import class without a package [" + strippedClassName + "]");
    }

    if (!hasImport(strippedClassName) && validImport(strippedClassName)) {
      imprt = new ImportImpl(this).setName(strippedClassName);
      unit.imports().add(imprt.getInternal());
    } else if (hasImport(strippedClassName)) {
      imprt = getImport(strippedClassName);
    } else {
      throw new IllegalArgumentException(
          "Attempted to import the illegal type [" + strippedClassName + "]");
    }
    return imprt;
  }
Esempio n. 7
0
 @Override
 public List<String> getInterfaces() {
   List<String> result = new ArrayList<String>();
   List<Type> superTypes = JDTHelper.getInterfaces(getBodyDeclaration());
   for (Type type : superTypes) {
     String name = JDTHelper.getTypeName(type);
     if (Types.isSimpleName(name) && this.hasImport(name)) {
       Import imprt = this.getImport(name);
       String pkg = imprt.getPackage();
       if (!Strings.isNullOrEmpty(pkg)) {
         name = pkg + "." + name;
       }
     }
     result.add(name);
   }
   return result;
 }
Esempio n. 8
0
 private boolean validImport(final String type) {
   return !Strings.isNullOrEmpty(type) && !Types.isPrimitive(type);
 }
Esempio n. 9
0
  @Override
  public String resolveType(final String type) {
    String original = type;
    String result = type;

    // Strip away any characters that might hinder the type matching process
    if (Types.isArray(result)) {
      original = Types.stripArray(result);
      result = Types.stripArray(result);
    }

    if (Types.isGeneric(result)) {
      original = Types.stripGenerics(result);
      result = Types.stripGenerics(result);
    }

    if (Types.isPrimitive(result)) {
      return result;
    }

    // Check for direct import matches first since they are the fastest and least work-intensive
    if (Types.isSimpleName(result)) {
      if (!hasImport(type) && Types.isJavaLang(type)) {
        result = "java.lang." + result;
      }

      if (result.equals(original)) {
        for (Import imprt : getImports()) {
          if (Types.areEquivalent(result, imprt.getQualifiedName())) {
            result = imprt.getQualifiedName();
            break;
          }
        }
      }
    }

    // If we didn't match any imports directly, we might have a wild-card/on-demand import.
    if (Types.isSimpleName(result)) {
      for (Import imprt : getImports()) {
        if (imprt.isWildcard()) {
          // TODO warn if no wild-card resolvers are configured
          // TODO Test wild-card/on-demand import resolving
          for (WildcardImportResolver r : getImportResolvers()) {
            result = r.resolve(this, result);
            if (Types.isQualified(result)) break;
          }
        }
      }
    }

    // No import matches and no wild-card/on-demand import matches means this class is in the same
    // package.
    if (Types.isSimpleName(result)) {
      if (getPackage() != null) result = getPackage() + "." + result;
    }

    return result;
  }