Comment on page
Declaration Query And Filter
Query and filter declarations using Konsist API
Declaration querying allows to retrieval of declarations of a given type. It is the middle step of the Konsist config preceded by scope retrieval (Create The Scope) and followed by the verification (Declaration Assert) step.
Typically, verification has performed a collection of declarations such as methods marked with particular annotations or classes located within a single package.
Every Create The Scope contains a set of declarations (Declaration) such as classes (
KoClass
), properties (KoProperty
), functions (KoFunction
), etc. The KoScope
class provides a set of methods to access Kotlin declarations. Each method returns a list representing a declaration subset:Method | Description |
files() | returns all files present in the scope |
packages() | returns all packages present in the scope |
imports() | returns all imports present in the scope |
classes() | returns all classes present in the scope |
interfaces() | returns all interfaces present in the scope |
objects() | returns all objects present in the scope |
functions() | returns all functions present in the scope |
properties() | returns all properties present in the scope |
companionObjects() | returns all companion objects present in the scope |
typeAliases() | returns all type aliases present in the scope |
declarations() | returns all declarations present in the scope |
To get all classes from the given scope use
KoScope.classes()
method:koScope
.classes()
Here is an example of querying all properties defined inside classes:
koScope
.classes()
.properties()
.assertTrue {
//...
}
More granular filtering can be applied to additionally filter classes annotated with certain attributes like classes annotated with
UseCase
annotation.Konsist is compatible with Kotlin Collection processing API, so the
filter
method can be used to filter the content of the List<KoClass>
: Here filter return classes annotated with UseCase
annotation:koScope
.classes()
.filter { it.hasAnnotationOf<UseCase>() }
.assertTrue {
//...
}
Konsist provides a set of
with...
extensions to simplify the filtering syntax. The above snippet can be improved:koScope
.classes()
.withAllAnnotationsOf(UseCase::class)
.assertTrue {
//...
}
The
.
withAllAnnotationsOf
(Annotation1::class, Annotation2::class)
filter classes heaving all annotations present (Annotation1
and Annotation2
).The
.
withSomeAnnotationsOf
(Annotation1::class, Annotation2::class) filter
classes heavingat least one annotation
(Annotation1
or Annotation2
).
Multiple conditions can be chained to perform more specific filtering. The below snippet filters classes with the
BaseUseCase
parent class that resides in the usecase
package:koScope
.classes()
.withAllAnnotationsOf(UseCase::class)
.resideInPackage("..usecase")
.assertTrue {
//...
}
It is also possible to filter declarations by using certain aspects e.g. visibility modifiers. Usage of
providers
allows verifying the visibility of different declaration types such as classes, functions, properties, etc:koScope
.declarations()
.declarations<KoVisibilityModifierProvider>()
.assertTrue { it.hasInternalModifier() }
Queuing and filtering stages can be mixed to perform more specific checks. The below snippet filters classes reside in the
controller
package retrieves all properties, and filters properties with Inject
annotation:koScope
.classes() // query all classes
.resideInPackage("..controller") // filter classes in 'controller' package
.properties() // query all properties
.withAnnotationOf<Inject>() // filter classes in 'controller' package
.assertTrue {
//...
}
To print all declarations within use the
print()
method:koScope
.classes()
.properties()
.print()
Last modified 1mo ago