From bdd02a3112397b711f16d411869c0c610899aebf Mon Sep 17 00:00:00 2001 From: Sergey Mashkov Date: Fri, 7 Aug 2015 12:32:17 +0300 Subject: ~ Use new property access syntax --- src/Java/JavaDocumentationBuilder.kt | 144 +++++++++++++++++------------------ 1 file changed, 71 insertions(+), 73 deletions(-) (limited to 'src/Java') diff --git a/src/Java/JavaDocumentationBuilder.kt b/src/Java/JavaDocumentationBuilder.kt index aae82c18..9717c1a6 100644 --- a/src/Java/JavaDocumentationBuilder.kt +++ b/src/Java/JavaDocumentationBuilder.kt @@ -11,11 +11,11 @@ import org.jsoup.nodes.TextNode public class JavaDocumentationBuilder(private val options: DocumentationOptions, private val refGraph: NodeReferenceGraph) { fun appendFile(file: PsiJavaFile, module: DocumentationModule) { - if (file.getClasses().all { skipElement(it) }) { + if (file.classes.all { skipElement(it) }) { return } - val packageNode = module.findOrCreatePackageNode(file.getPackageName(), emptyMap()) - packageNode.appendChildren(file.getClasses()) { build() } + val packageNode = module.findOrCreatePackageNode(file.packageName, emptyMap()) + packageNode.appendChildren(file.classes) { build() } } data class JavadocParseResult(val content: Content, val deprecatedContent: Content?) @@ -26,9 +26,9 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, var deprecatedContent: Content? = null val para = ContentParagraph() result.append(para) - para.convertJavadocElements(docComment.getDescriptionElements().dropWhile { it.getText().trim().isEmpty() }) - docComment.getTags().forEach { tag -> - when(tag.getName()) { + para.convertJavadocElements(docComment.descriptionElements.dropWhile { it.text.trim().isEmpty() }) + docComment.tags.forEach { tag -> + when(tag.name) { "see" -> result.convertSeeTag(tag) "deprecated" -> { deprecatedContent = Content() @@ -36,7 +36,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, } else -> { val subjectName = tag.getSubjectName() - val section = result.addSection(javadocSectionDisplayName(tag.getName()), subjectName) + val section = result.addSection(javadocSectionDisplayName(tag.name), subjectName) section.convertJavadocElements(tag.contentElements()) } @@ -46,10 +46,10 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, } private fun PsiDocTag.contentElements(): Iterable { - val tagValueElements = getChildren() - .dropWhile { it.getNode().getElementType() == JavaDocTokenType.DOC_TAG_NAME } + val tagValueElements = children + .dropWhile { it.node.elementType == JavaDocTokenType.DOC_TAG_NAME } .dropWhile { it is PsiWhiteSpace } - .filterNot { it.getNode().getElementType() == JavaDocTokenType.DOC_COMMENT_LEADING_ASTERISKS } + .filterNot { it.node.elementType == JavaDocTokenType.DOC_COMMENT_LEADING_ASTERISKS } return if (getSubjectName() != null) tagValueElements.dropWhile { it is PsiDocTagValue } else tagValueElements } @@ -59,7 +59,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, if (it is PsiInlineDocTag) { htmlBuilder.append(convertInlineDocTag(it)) } else { - htmlBuilder.append(it.getText()) + htmlBuilder.append(it.text) } } val doc = Jsoup.parse(htmlBuilder.toString().trimStart()) @@ -114,9 +114,9 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, } val seeSection = findSectionByTag(ContentTags.SeeAlso) ?: addSection(ContentTags.SeeAlso, null) val linkSignature = resolveLink(linkElement) - val text = ContentText(linkElement.getText()) + val text = ContentText(linkElement.text) if (linkSignature != null) { - val linkNode = ContentNodeLazyLink(tag.getValueElement()!!.getText(), { -> refGraph.lookup(linkSignature)}) + val linkNode = ContentNodeLazyLink(tag.valueElement!!.text, { -> refGraph.lookup(linkSignature)}) linkNode.append(text) seeSection.append(linkNode) } else { @@ -124,35 +124,35 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, } } - private fun convertInlineDocTag(tag: PsiInlineDocTag) = when (tag.getName()) { + private fun convertInlineDocTag(tag: PsiInlineDocTag) = when (tag.name) { "link", "linkplain" -> { val valueElement = tag.linkElement() val linkSignature = resolveLink(valueElement) if (linkSignature != null) { - val labelText = tag.getDataElements().firstOrNull { it is PsiDocToken }?.getText() ?: valueElement!!.getText() + val labelText = tag.dataElements.firstOrNull { it is PsiDocToken }?.text ?: valueElement!!.text val link = "${labelText.htmlEscape()}" - if (tag.getName() == "link") "$link" else link + if (tag.name == "link") "$link" else link } else if (valueElement != null) { - valueElement.getText() + valueElement.text } else { "" } } "code", "literal" -> { val text = StringBuilder() - tag.getDataElements().forEach { text.append(it.getText()) } + tag.dataElements.forEach { text.append(it.text) } val escaped = text.toString().trimStart().htmlEscape() - if (tag.getName() == "code") "$escaped" else escaped + if (tag.name == "code") "$escaped" else escaped } - else -> tag.getText() + else -> tag.text } private fun PsiDocTag.linkElement(): PsiElement? = - getValueElement() ?: getDataElements().firstOrNull { it !is PsiWhiteSpace } + valueElement ?: dataElements.firstOrNull { it !is PsiWhiteSpace } private fun resolveLink(valueElement: PsiElement?): String? { - val target = valueElement?.getReference()?.resolve() + val target = valueElement?.reference?.resolve() if (target != null) { return getSignature(target) } @@ -160,8 +160,8 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, } fun PsiDocTag.getSubjectName(): String? { - if (getName() == "param" || getName() == "throws" || getName() == "exception") { - return getValueElement()?.getText() + if (name == "param" || name == "throws" || name == "exception") { + return valueElement?.text } return null } @@ -188,32 +188,32 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, } private fun getSignature(element: PsiElement?) = when(element) { - is PsiClass -> element.getQualifiedName() - is PsiField -> element.getContainingClass()!!.getQualifiedName() + "#" + element.getName() + is PsiClass -> element.qualifiedName + is PsiField -> element.containingClass!!.qualifiedName + "#" + element.name is PsiMethod -> - element.getContainingClass()!!.getQualifiedName() + "#" + element.getName() + "(" + - element.getParameterList().getParameters().map { it.getType().typeSignature() }.join(",") + ")" + element.containingClass!!.qualifiedName + "#" + element.name + "(" + + element.parameterList.parameters.map { it.type.typeSignature() }.join(",") + ")" else -> null } private fun PsiType.typeSignature(): String = when(this) { - is PsiArrayType -> "Array<${getComponentType().typeSignature()}>" + is PsiArrayType -> "Array<${componentType.typeSignature()}>" else -> mapTypeName(this) } fun DocumentationNode(element: PsiNamedElement, kind: Kind, - name: String = element.getName() ?: ""): DocumentationNode { - val (docComment, deprecatedContent) = parseDocumentation((element as? PsiDocCommentOwner)?.getDocComment()) + name: String = element.name ?: ""): DocumentationNode { + val (docComment, deprecatedContent) = parseDocumentation((element as? PsiDocCommentOwner)?.docComment) val node = DocumentationNode(name, docComment, kind) if (element is PsiModifierListOwner) { node.appendModifiers(element) - val modifierList = element.getModifierList() + val modifierList = element.modifierList if (modifierList != null) { - modifierList.getAnnotations().filter { !ignoreAnnotation(it) }.forEach { + modifierList.annotations.filter { !ignoreAnnotation(it) }.forEach { val annotation = it.build() node.append(annotation, - if (it.getQualifiedName() == "java.lang.Deprecated") DocumentationReference.Kind.Deprecation else DocumentationReference.Kind.Annotation) + if (it.qualifiedName == "java.lang.Deprecated") DocumentationReference.Kind.Deprecation else DocumentationReference.Kind.Annotation) } } } @@ -224,7 +224,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, return node } - fun ignoreAnnotation(annotation: PsiAnnotation) = when(annotation.getQualifiedName()) { + fun ignoreAnnotation(annotation: PsiAnnotation) = when(annotation.qualifiedName) { "java.lang.SuppressWarnings" -> true else -> false } @@ -246,7 +246,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, (element.hasModifierProperty(PsiModifier.PRIVATE) || element.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) private fun hasSuppressTag(element: Any) = - element is PsiDocCommentOwner && element.getDocComment()?.let { it.findTagByName("suppress") != null } ?: false + element is PsiDocCommentOwner && element.docComment?.let { it.findTagByName("suppress") != null } ?: false fun DocumentationNode.appendMembers(elements: Array, buildFn: T.() -> DocumentationNode) = appendChildren(elements, DocumentationReference.Kind.Member, buildFn) @@ -256,23 +256,23 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, fun PsiClass.build(): DocumentationNode { val kind = when { - isInterface() -> DocumentationNode.Kind.Interface - isEnum() -> DocumentationNode.Kind.Enum - isAnnotationType() -> DocumentationNode.Kind.AnnotationClass + isInterface -> DocumentationNode.Kind.Interface + isEnum -> DocumentationNode.Kind.Enum + isAnnotationType -> DocumentationNode.Kind.AnnotationClass else -> DocumentationNode.Kind.Class } val node = DocumentationNode(this, kind) - getSuperTypes().filter { !ignoreSupertype(it) }.forEach { + superTypes.filter { !ignoreSupertype(it) }.forEach { node.appendType(it, Kind.Supertype) val superClass = it.resolve() if (superClass != null) { link(superClass, node, DocumentationReference.Kind.Inheritor) } } - node.appendDetails(getTypeParameters()) { build() } - node.appendMembers(getMethods()) { build() } - node.appendMembers(getFields()) { build() } - node.appendMembers(getInnerClasses()) { build() } + node.appendDetails(typeParameters) { build() } + node.appendMembers(methods) { build() } + node.appendMembers(fields) { build() } + node.appendMembers(innerClasses) { build() } register(this, node) return node } @@ -282,9 +282,9 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, fun PsiClassType.isClass(qName: String): Boolean { val shortName = qName.substringAfterLast('.') - if (getClassName() == shortName) { + if (className == shortName) { val psiClass = resolve() - return psiClass?.getQualifiedName() == qName + return psiClass?.qualifiedName == qName } return false } @@ -294,7 +294,7 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, if (!hasModifierProperty(PsiModifier.FINAL)) { node.appendTextNode("var", Kind.Modifier) } - node.appendType(getType()) + node.appendType(type) register(this, node) return node } @@ -307,27 +307,27 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, fun PsiMethod.build(): DocumentationNode { val node = DocumentationNode(this, nodeKind(), - if (isConstructor()) "" else getName()) + if (isConstructor) "" else name) - if (!isConstructor()) { - node.appendType(getReturnType()) + if (!isConstructor) { + node.appendType(returnType) } - node.appendDetails(getParameterList().getParameters()) { build() } - node.appendDetails(getTypeParameters()) { build() } + node.appendDetails(parameterList.parameters) { build() } + node.appendDetails(typeParameters) { build() } register(this, node) return node } private fun PsiMethod.nodeKind(): Kind = when { - isConstructor() -> Kind.Constructor + isConstructor -> Kind.Constructor hasModifierProperty(PsiModifier.STATIC) -> Kind.CompanionObjectFunction else -> Kind.Function } fun PsiParameter.build(): DocumentationNode { val node = DocumentationNode(this, Kind.Parameter) - node.appendType(getType()) - if (getType() is PsiEllipsisType) { + node.appendType(type) + if (type is PsiEllipsisType) { node.appendTextNode("vararg", Kind.Annotation, DocumentationReference.Kind.Annotation) } return node @@ -335,22 +335,20 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, fun PsiTypeParameter.build(): DocumentationNode { val node = DocumentationNode(this, Kind.TypeParameter) - getExtendsListTypes().forEach { node.appendType(it, Kind.UpperBound) } - getImplementsListTypes().forEach { node.appendType(it, Kind.UpperBound) } + extendsListTypes.forEach { node.appendType(it, Kind.UpperBound) } + implementsListTypes.forEach { node.appendType(it, Kind.UpperBound) } return node } fun DocumentationNode.appendModifiers(element: PsiModifierListOwner) { - val modifierList = element.getModifierList() - if (modifierList == null) { - return - } + val modifierList = element.modifierList ?: return + PsiModifier.MODIFIERS.forEach { if (it != "static" && modifierList.hasExplicitModifier(it)) { appendTextNode(it, Kind.Modifier) } } - if ((element is PsiClass || (element is PsiMethod && !element.isConstructor())) && + if ((element is PsiClass || (element is PsiMethod && !element.isConstructor)) && !element.hasModifierProperty(PsiModifier.FINAL)) { appendTextNode("open", Kind.Modifier) } @@ -367,34 +365,34 @@ public class JavaDocumentationBuilder(private val options: DocumentationOptions, val name = mapTypeName(this) val node = DocumentationNode(name, Content.Empty, kind) if (this is PsiClassType) { - node.appendDetails(getParameters()) { build(Kind.Type) } + node.appendDetails(parameters) { build(Kind.Type) } link(node, resolve()) } if (this is PsiArrayType && this !is PsiEllipsisType) { - node.append(getComponentType().build(Kind.Type), DocumentationReference.Kind.Detail) + node.append(componentType.build(Kind.Type), DocumentationReference.Kind.Detail) } return node } private fun mapTypeName(psiType: PsiType): String = when (psiType) { PsiType.VOID -> "Unit" - is PsiPrimitiveType -> psiType.getCanonicalText().capitalize() + is PsiPrimitiveType -> psiType.canonicalText.capitalize() is PsiClassType -> { val psiClass = psiType.resolve() - if (psiClass?.getQualifiedName() == "java.lang.Object") "Any" else psiType.getClassName() + if (psiClass?.qualifiedName == "java.lang.Object") "Any" else psiType.className } - is PsiEllipsisType -> mapTypeName(psiType.getComponentType()) + is PsiEllipsisType -> mapTypeName(psiType.componentType) is PsiArrayType -> "Array" - else -> psiType.getCanonicalText() + else -> psiType.canonicalText } fun PsiAnnotation.build(): DocumentationNode { - val node = DocumentationNode(getNameReferenceElement()?.getText() ?: "", Content.Empty, DocumentationNode.Kind.Annotation) - getParameterList().getAttributes().forEach { - val parameter = DocumentationNode(it.getName() ?: "value", Content.Empty, DocumentationNode.Kind.Parameter) - val value = it.getValue() + val node = DocumentationNode(nameReferenceElement?.text ?: "", Content.Empty, DocumentationNode.Kind.Annotation) + parameterList.attributes.forEach { + val parameter = DocumentationNode(it.name ?: "value", Content.Empty, DocumentationNode.Kind.Parameter) + val value = it.value if (value != null) { - val valueText = (value as? PsiLiteralExpression)?.getValue() as? String ?: value.getText() + val valueText = (value as? PsiLiteralExpression)?.value as? String ?: value.text val valueNode = DocumentationNode(valueText, Content.Empty, DocumentationNode.Kind.Value) parameter.append(valueNode, DocumentationReference.Kind.Detail) } -- cgit