@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;
}
@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;
}
@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;
}
@Override
public boolean hasInterface(final String type) {
for (String name : getInterfaces()) {
if (Types.areEquivalent(name, type)) {
return true;
}
}
return false;
}
@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;
}
@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;
}
@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;
}
private boolean validImport(final String type) {
return !Strings.isNullOrEmpty(type) && !Types.isPrimitive(type);
}
@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;
}
