@@ -31,25 +31,25 @@ import java.util.concurrent.LinkedBlockingQueue
31
31
open class ClassApiExporterHelper {
32
32
33
33
@Inject
34
- protected val jvmClassHelper: JvmClassHelper ? = null
34
+ protected lateinit var jvmClassHelper: JvmClassHelper
35
35
36
36
@Inject
37
- protected val ruleComputer: RuleComputer ? = null
37
+ protected lateinit var ruleComputer: RuleComputer
38
38
39
39
@Inject
40
- private val docHelper: DocHelper ? = null
40
+ private lateinit var docHelper: DocHelper
41
41
42
42
@Inject
43
- protected val psiClassHelper: PsiClassHelper ? = null
43
+ protected lateinit var psiClassHelper: PsiClassHelper
44
44
45
45
@Inject
46
- private val linkExtractor: LinkExtractor ? = null
46
+ private lateinit var linkExtractor: LinkExtractor
47
47
48
48
@Inject
49
- private val linkResolver: LinkResolver ? = null
49
+ private lateinit var linkResolver: LinkResolver
50
50
51
51
@Inject
52
- protected val duckTypeHelper: DuckTypeHelper ? = null
52
+ protected lateinit var duckTypeHelper: DuckTypeHelper
53
53
54
54
@Inject
55
55
protected lateinit var actionContext: ActionContext
@@ -58,7 +58,7 @@ open class ClassApiExporterHelper {
58
58
protected lateinit var logger: Logger
59
59
60
60
@Inject
61
- protected val classExporter: ClassExporter ? = null
61
+ protected lateinit var classExporter: ClassExporter
62
62
63
63
@Inject
64
64
protected lateinit var messagesHelper: MessagesHelper
@@ -69,7 +69,7 @@ open class ClassApiExporterHelper {
69
69
companion object : Log ()
70
70
71
71
fun extractParamComment (psiMethod : PsiMethod ): MutableMap <String , Any ?>? {
72
- val subTagMap = docHelper!! .getSubTagMapOfDocComment(psiMethod, " param" )
72
+ val subTagMap = docHelper.getSubTagMapOfDocComment(psiMethod, " param" )
73
73
if (subTagMap.isEmpty()) {
74
74
return null
75
75
}
@@ -82,36 +82,34 @@ open class ClassApiExporterHelper {
82
82
if (value.notNullOrBlank()) {
83
83
84
84
val options: ArrayList <HashMap <String , Any ?>> = ArrayList ()
85
- val comment = linkExtractor!! .extract(value, psiMethod, object : AbstractLinkResolve () {
85
+ val comment = linkExtractor.extract(value, psiMethod, object : AbstractLinkResolve () {
86
86
87
87
override fun linkToPsiElement (plainText : String , linkTo : Any? ): String? {
88
-
89
- psiClassHelper!! .resolveEnumOrStatic(
88
+ psiClassHelper.resolveEnumOrStatic(
90
89
plainText,
91
90
parameters.firstOrNull { it.name == name } ? : psiMethod,
92
91
name
93
- )
94
- ?.let { options.addAll(it) }
92
+ )?.let { options.addAll(it) }
95
93
96
94
return super .linkToPsiElement(plainText, linkTo)
97
95
}
98
96
99
97
override fun linkToClass (plainText : String , linkClass : PsiClass ): String? {
100
- return linkResolver!! .linkToClass(linkClass)
98
+ return linkResolver.linkToClass(linkClass)
101
99
}
102
100
103
101
override fun linkToType (plainText : String , linkType : PsiType ): String? {
104
- return jvmClassHelper!! .resolveClassInType(linkType)?.let {
105
- linkResolver!! .linkToClass(it)
102
+ return jvmClassHelper.resolveClassInType(linkType)?.let {
103
+ linkResolver.linkToClass(it)
106
104
}
107
105
}
108
106
109
107
override fun linkToField (plainText : String , linkField : PsiField ): String? {
110
- return linkResolver!! .linkToProperty(linkField)
108
+ return linkResolver.linkToProperty(linkField)
111
109
}
112
110
113
111
override fun linkToMethod (plainText : String , linkMethod : PsiMethod ): String? {
114
- return linkResolver!! .linkToMethod(linkMethod)
112
+ return linkResolver.linkToMethod(linkMethod)
115
113
}
116
114
117
115
override fun linkToUnresolved (plainText : String ): String {
@@ -124,7 +122,6 @@ open class ClassApiExporterHelper {
124
122
methodParamComment[" $name @options" ] = options
125
123
}
126
124
}
127
-
128
125
}
129
126
130
127
return methodParamComment
@@ -137,7 +134,7 @@ open class ClassApiExporterHelper {
137
134
cls : PsiClass , handle : (ExplicitMethod ) -> Unit ,
138
135
) {
139
136
actionContext.runInReadUI {
140
- val methods = duckTypeHelper!! .explicit(cls)
137
+ val methods = duckTypeHelper.explicit(cls)
141
138
.methods()
142
139
.filter { ! shouldIgnore(it) }
143
140
actionContext.runAsync {
@@ -158,28 +155,28 @@ open class ClassApiExporterHelper {
158
155
}
159
156
160
157
protected open fun shouldIgnore (explicitElement : ExplicitMethod ): Boolean {
161
- if (ignoreIrregularApiMethod() && (jvmClassHelper!! .isBasicMethod(explicitElement.psi().name)
158
+ if (ignoreIrregularApiMethod() && (jvmClassHelper.isBasicMethod(explicitElement.psi().name)
162
159
|| explicitElement.psi().hasModifierProperty(" static" )
163
160
|| explicitElement.psi().isConstructor)
164
161
) {
165
162
return true
166
163
}
167
- return ruleComputer!! .computer(ClassExportRuleKeys .IGNORE , explicitElement) ? : false
164
+ return ruleComputer.computer(ClassExportRuleKeys .IGNORE , explicitElement) ? : false
168
165
}
169
166
170
167
protected open fun shouldIgnore (psiMethod : PsiMethod ): Boolean {
171
- if (ignoreIrregularApiMethod() && (jvmClassHelper!! .isBasicMethod(psiMethod.name)
168
+ if (ignoreIrregularApiMethod() && (jvmClassHelper.isBasicMethod(psiMethod.name)
172
169
|| psiMethod.hasModifierProperty(" static" )
173
170
|| psiMethod.isConstructor)
174
171
) {
175
172
return true
176
173
}
177
- return ruleComputer!! .computer(ClassExportRuleKeys .IGNORE , psiMethod) ? : false
174
+ return ruleComputer.computer(ClassExportRuleKeys .IGNORE , psiMethod) ? : false
178
175
}
179
176
180
177
fun foreachPsiMethod (cls : PsiClass , handle : (PsiMethod ) -> Unit ) {
181
178
actionContext.runInReadUI {
182
- jvmClassHelper!! .getAllMethods(cls)
179
+ jvmClassHelper.getAllMethods(cls)
183
180
.asSequence()
184
181
.filter { ! shouldIgnore(it) }
185
182
.forEach(handle)
@@ -193,7 +190,7 @@ open class ClassApiExporterHelper {
193
190
}
194
191
195
192
fun export (handle : (Doc ) -> Unit ) {
196
- logger.info(" Start export api ..." )
193
+ logger.info(" Starting API export process ..." )
197
194
val psiClassQueue: BlockingQueue <PsiClass > = LinkedBlockingQueue ()
198
195
199
196
val boundary = actionContext.createBoundary()
@@ -238,11 +235,11 @@ open class ClassApiExporterHelper {
238
235
}
239
236
} else {
240
237
val classQualifiedName = actionContext.callInReadUI { psiClass.qualifiedName }
241
- LOG .info(" wait api parsing... $classQualifiedName " )
238
+ LOG .info(" Processing API for class: $classQualifiedName " )
242
239
actionContext.withBoundary {
243
- classExporter!! .export(psiClass) { handle(it) }
240
+ classExporter.export(psiClass) { handle(it) }
244
241
}
245
- LOG .info(" api parse $classQualifiedName completed. " )
242
+ LOG .info(" Successfully parsed API for class: $classQualifiedName " )
246
243
}
247
244
}
248
245
}
0 commit comments