library/io.github.baole.konture

Package-level declarations

Types

data class AnnotationArgumentDeclaration(val name: String?, val value: String)

data class AnnotationDeclaration(val name: String, val fqName: String, val arguments: List<AnnotationArgumentDeclaration> = emptyList())

Represents a parsed Kotlin annotation declared on a class.

ClassDeclaration

data class ClassDeclaration(val name: String, val fqName: String, val packageName: String, val isInterface: Boolean, val isAbstract: Boolean, val annotations: List<AnnotationDeclaration>, val imports: List<String>, val referencedTypes: Set<String>, val filePath: String, val visibility: Visibility = Visibility.PUBLIC, val modifiers: Set<Modifier> = emptySet(), val supertypes: List<String> = emptyList(), val primaryConstructor: ConstructorDeclaration? = null, val secondaryConstructors: List<ConstructorDeclaration> = emptyList(), val functions: List<FunctionDeclaration> = emptyList(), val properties: List<PropertyDeclaration> = emptyList(), val companionObject: ClassDeclaration? = null, val kdocText: String? = null, val importAliases: Map<String, String> = emptyMap(), val isEnum: Boolean = false)

Represents a parsed Kotlin class, interface, or object declaration.

ClassDeclarationShouldContext

class ClassDeclarationShouldContext

Context receiver for writing declarative assertions on a ClassDeclaration element. Provides easy access to all element properties and custom helper assertions.

ClassesRuleBuilder

class ClassesRuleBuilder(graph: ProjectGraph = Konture.projectGraph)

A builder for compiling and verifying architectural rules on Kotlin classes.

ClassesShould

class ClassesShould

Fluent API for defining assertion rules on Kotlin classes.

ClassesThat

class ClassesThat

Fluent API for defining filtering conditions on Kotlin classes.

ConstructorDeclaration

data class ConstructorDeclaration(val visibility: Visibility, val parameters: List<ParameterDeclaration>, val annotations: List<AnnotationDeclaration>)

Dependency

data class Dependency(val configuration: String, val targetBuildId: String, val targetPath: String)

Represents a declared project-to-project dependency edge at runtime.

FileDeclaration

data class FileDeclaration(val name: String, val packageName: String, val imports: List<String> = emptyList(), val classes: List<ClassDeclaration> = emptyList(), val topLevelFunctions: List<FunctionDeclaration> = emptyList(), val topLevelProperties: List<PropertyDeclaration> = emptyList(), val kdocText: String? = null, val filePath: String = "", val importAliases: Map<String, String> = emptyMap())

FileDeclarationContext

data class FileDeclarationContext(val declaration: FileDeclaration, val modulePath: String)

Context wrapper for verifying source file declarations.

FileDeclarationShouldContext

class FileDeclarationShouldContext

Context receiver for writing declarative assertions on a FileDeclarationContext element. Provides easy access to all element properties and custom helper assertions.

FilesRuleBuilder

class FilesRuleBuilder(graph: ProjectGraph = Konture.projectGraph)

A builder for compiling and verifying architectural rules on Kotlin source files.

FilesShould

class FilesShould

FilesThat

class FilesThat

FunctionAssertionScope

class FunctionAssertionScope

FunctionDeclaration

data class FunctionDeclaration(val name: String, val visibility: Visibility, val modifiers: Set<Modifier>, val returnType: String, val parameters: List<ParameterDeclaration>, val annotations: List<AnnotationDeclaration>, val kdocText: String?, val isExtension: Boolean)

FunctionDeclarationContext

data class FunctionDeclarationContext(val declaration: FunctionDeclaration, val packageName: String, val className: String?, val modulePath: String, val filePath: String)

Context wrapper for verifying function declarations.

FunctionDeclarationShouldContext

class FunctionDeclarationShouldContext

Context receiver for writing declarative assertions on a FunctionDeclarationContext element. Provides easy access to all element properties and custom helper assertions.

FunctionsRuleBuilder

class FunctionsRuleBuilder(graph: ProjectGraph = Konture.projectGraph)

A builder for compiling and verifying architectural rules on Kotlin function declarations.

FunctionsShould

class FunctionsShould

FunctionsThat

class FunctionsThat

Konture

object Konture

Main entry point for Konture. All architecture assertion builders, scoping builders, and graph configurations are extended from or accessible through this object.

KontureContext

class KontureContext(projectGraph: ProjectGraph)

DSL Context wrapper that allows defining and verifying multiple independent rule suites.

KontureDsl

@DslMarker

annotation class KontureDsl

DSL Marker for Konture DSL structures.

KontureFileScope

class KontureFileScope(val files: List<FileDeclaration>)

Represents a scope containing a set of Kotlin files for checking file-level rules.

KontureScope

class KontureScope(val classes: List<ClassDeclaration>)

Represents a scope containing a set of classes for writing architecture rules in a Konsist-inspired fluent DSL.

LayeredArchitectureBuilder

class LayeredArchitectureBuilder(graph: ProjectGraph = Konture.projectGraph)

A builder class implementing the Layered Architecture DSL.

LayeredArchitectureDsl

class LayeredArchitectureDsl(projectGraph: ProjectGraph)

Type-safe, nested DSL for defining and verifying layered architecture rules.

Modifier

enum Modifier : Enum<Modifier>

Module

data class Module(val buildId: String, val path: String, val projectDir: String, val appliedPlugins: List<String>, val sourceSets: List<SourceSet>, val dependencies: List<Dependency>, val files: List<FileDeclaration> = emptyList())

Represents a single Gradle module/project and all its structural and source declarations.

ModuleShouldContext

class ModuleShouldContext

Context receiver for writing declarative assertions on a Module element. Provides easy access to all element properties and custom helper assertions.

ModulesRuleBuilder

class ModulesRuleBuilder(graph: ProjectGraph = Konture.projectGraph)

A builder for compiling and verifying architectural rules on project modules.

ModulesShould

class ModulesShould

Fluent API for defining assertion rules on Gradle modules.

ModulesThat

class ModulesThat

Fluent API for defining filtering conditions on Gradle modules.

ParameterDeclaration

data class ParameterDeclaration(val name: String, val type: String, val hasDefaultValue: Boolean, val annotations: List<AnnotationDeclaration>)

ProjectGraph

data class ProjectGraph(val builds: Map<String, List<Module>>, externalDependenciesLoader: () -> DependencyGraphModel = { DependencyGraphModel() })

Represents the complete structural graph of the multi-project/composite build. It provides core querying capabilities, circular dependency verification, and access to the parsed class/declaration hierarchy of the entire workspace.

PropertiesRuleBuilder

class PropertiesRuleBuilder(graph: ProjectGraph = Konture.projectGraph)

A builder for compiling and verifying architectural rules on Kotlin property declarations.

PropertiesShould

class PropertiesShould

PropertiesThat

class PropertiesThat

PropertyAssertionScope

class PropertyAssertionScope

PropertyDeclaration

data class PropertyDeclaration(val name: String, val visibility: Visibility, val modifiers: Set<Modifier>, val type: String, val isVal: Boolean, val annotations: List<AnnotationDeclaration>, val kdocText: String?, val isExtension: Boolean = false)

PropertyDeclarationContext

data class PropertyDeclarationContext(val declaration: PropertyDeclaration, val packageName: String, val className: String?, val modulePath: String, val filePath: String)

Context wrapper for verifying property declarations.

PropertyDeclarationShouldContext

class PropertyDeclarationShouldContext

Context receiver for writing declarative assertions on a PropertyDeclarationContext element. Provides easy access to all element properties and custom helper assertions.

SourceSet

data class SourceSet(val name: String, val kind: String, val production: Boolean, val srcDirs: List<String>, val kotlinFiles: List<String>, val platforms: List<String> = emptyList())

Represents a source set within a module at test runtime.

Visibility

enum Visibility : Enum<Visibility>

Properties

annotations

val FunctionDeclarationContext.annotations: List<AnnotationDeclaration>

Delegates annotations property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.annotations: List<AnnotationDeclaration>

Delegates annotations property to the underlying PropertyDeclaration.

classes

val FileDeclarationContext.classes: List<ClassDeclaration>

Delegates classes property to the underlying FileDeclaration.

fileScope

val Konture.fileScope: KontureFileScope

Retrieves a file-level functional KontureFileScope representing all files in the project.

imports

val FileDeclarationContext.imports: List<String>

Delegates imports property to the underlying FileDeclaration.

isExtension

val FunctionDeclarationContext.isExtension: Boolean

Delegates isExtension property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.isExtension: Boolean

Delegates isExtension property to the underlying PropertyDeclaration.

isVal

val PropertyDeclarationContext.isVal: Boolean

Delegates isVal property to the underlying PropertyDeclaration.

isVar

val PropertyDeclarationContext.isVar: Boolean

Delegates isVar property to the underlying PropertyDeclaration.

kdocText

val FunctionDeclarationContext.kdocText: String?

Delegates kdocText property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.kdocText: String?

Delegates kdocText property to the underlying PropertyDeclaration.

modifiers

val FunctionDeclarationContext.modifiers: Set<Modifier>

Delegates modifiers property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.modifiers: Set<Modifier>

Delegates modifiers property to the underlying PropertyDeclaration.

name

val FileDeclarationContext.name: String

Delegates name property to the underlying FileDeclaration.

val FunctionDeclarationContext.name: String

Delegates name property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.name: String

Delegates name property to the underlying PropertyDeclaration.

packageName

val FileDeclarationContext.packageName: String

Delegates packageName property to the underlying FileDeclaration.

parameters

val FunctionDeclarationContext.parameters: List<ParameterDeclaration>

Delegates parameters property to the underlying FunctionDeclaration.

returnType

val FunctionDeclarationContext.returnType: String

Delegates returnType property to the underlying FunctionDeclaration.

scope

val Konture.scope: KontureScope

Retrieves a class-level functional KontureScope representing the entire project.

topLevelFunctions

val FileDeclarationContext.topLevelFunctions: List<FunctionDeclaration>

Delegates topLevelFunctions property to the underlying FileDeclaration.

topLevelProperties

val FileDeclarationContext.topLevelProperties: List<PropertyDeclaration>

Delegates topLevelProperties property to the underlying FileDeclaration.

type

val PropertyDeclarationContext.type: String

Delegates type property to the underlying PropertyDeclaration.

visibility

val FunctionDeclarationContext.visibility: Visibility

Delegates visibility property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.visibility: Visibility

Delegates visibility property to the underlying PropertyDeclaration.

Functions

architecture

fun Konture.architecture(block: KontureContext.() -> Unit)

Unified multi-rule block supporting modules, classes, and layered architecture validations. Runs every declared suite and aggregates all violations before failing.

assertAreAbstract

fun KontureScope.assertAreAbstract()

Asserts that all class declarations in the scope represent abstract classes or interfaces.

fun List<ClassDeclaration>.assertAreAbstract()

Asserts that all class declarations represent abstract classes or interfaces.

assertAreAssignableTo

fun KontureScope.assertAreAssignableTo(vararg superTypes: String)

Asserts that all class declarations in the scope extend or implement any of the specified supertypes.

fun List<ClassDeclaration>.assertAreAssignableTo(vararg superTypes: String)

Asserts that all class declarations extend or implement any of the specified supertypes.

assertAreData

fun KontureScope.assertAreData()

Asserts that all class declarations in the scope are data classes.

fun List<ClassDeclaration>.assertAreData()

Asserts that all class declarations are data classes.

assertAreEnums

fun KontureScope.assertAreEnums()

Asserts that all class declarations in the scope represent enum classes.

fun List<ClassDeclaration>.assertAreEnums()

Asserts that all class declarations represent enum classes.

assertAreInline

fun KontureScope.assertAreInline()

Asserts that all class declarations in the scope are inline/value classes.

fun List<ClassDeclaration>.assertAreInline()

Asserts that all class declarations are inline/value classes.

assertAreInterfaces

fun KontureScope.assertAreInterfaces()

Asserts that all class declarations in the scope represent interfaces.

fun List<ClassDeclaration>.assertAreInterfaces()

Asserts that all class declarations represent interfaces.

assertAreInternal

fun KontureScope.assertAreInternal()

Asserts that all class declarations in the scope are internal.

fun List<ClassDeclaration>.assertAreInternal()

Asserts that all class declarations are internal.

assertArePrivate

fun KontureScope.assertArePrivate()

Asserts that all class declarations in the scope are private.

fun List<ClassDeclaration>.assertArePrivate()

Asserts that all class declarations are private.

assertAreProtected

fun KontureScope.assertAreProtected()

Asserts that all class declarations in the scope are protected.

fun List<ClassDeclaration>.assertAreProtected()

Asserts that all class declarations are protected.

assertArePublic

fun KontureScope.assertArePublic()

Asserts that all class declarations in the scope are public.

fun List<ClassDeclaration>.assertArePublic()

Asserts that all class declarations are public.

assertAreSealed

fun KontureScope.assertAreSealed()

Asserts that all class declarations in the scope are sealed classes.

fun List<ClassDeclaration>.assertAreSealed()

Asserts that all class declarations are sealed classes.

assertFileNameMatchesClassName

fun KontureFileScope.assertFileNameMatchesClassName(additionalMessage: String? = null)

fun List<FileDeclaration>.assertFileNameMatchesClassName(additionalMessage: String? = null)

assertHasKDoc

fun KontureFileScope.assertHasKDoc(additionalMessage: String? = null)

fun KontureScope.assertHasKDoc(additionalMessage: String? = null)

@JvmName(name = "assertClassesHasKDoc")

fun List<ClassDeclaration>.assertHasKDoc(additionalMessage: String? = null)

@JvmName(name = "assertFilesHasKDoc")

fun List<FileDeclaration>.assertHasKDoc(additionalMessage: String? = null)

assertHaveAnnotationOf

fun KontureScope.assertHaveAnnotationOf(vararg annotationFqNames: String)

Asserts that all class declarations in the scope have at least one of the specified annotations. Matches either the annotation's simple name or its fully qualified name (FQN).

fun List<ClassDeclaration>.assertHaveAnnotationOf(vararg annotationFqNames: String)

Asserts that all class declarations have at least one of the specified annotations. Matches either the annotation's simple name or its fully qualified name (FQN).

assertHaveVisibility

fun KontureScope.assertHaveVisibility(visibility: Visibility)

Asserts that all class declarations in the scope have the specified visibility.

fun List<ClassDeclaration>.assertHaveVisibility(visibility: Visibility)

Asserts that all class declarations have the specified visibility.

assertNameEndingWith

fun KontureFileScope.assertNameEndingWith(vararg suffixes: String)

Asserts that all file declarations in the scope have names ending with any of the specified suffixes.

fun KontureScope.assertNameEndingWith(vararg suffixes: String)

Asserts that all class declarations in the scope have names ending with any of the specified suffixes.

fun List<ClassDeclaration>.assertNameEndingWith(vararg suffixes: String)

Asserts that all class declarations have names ending with any of the specified suffixes.

fun List<FileDeclaration>.assertNameEndingWith(vararg suffixes: String)

Asserts that all file declarations have names ending with any of the specified suffixes.

assertNameMatching

fun KontureFileScope.assertNameMatching(vararg patterns: String)

Asserts that all file declarations in the scope have names matching any of the specified glob patterns.

fun KontureScope.assertNameMatching(vararg patterns: String)

Asserts that all class declarations in the scope have names matching any of the specified glob patterns. Supports '*' wildcards.

fun List<ClassDeclaration>.assertNameMatching(vararg patterns: String)

Asserts that all class declarations have names matching any of the specified glob patterns. Supports '*' wildcards.

fun List<FileDeclaration>.assertNameMatching(vararg patterns: String)

Asserts that all file declarations have names matching any of the specified glob patterns.

assertNameStartingWith

fun KontureFileScope.assertNameStartingWith(vararg prefixes: String)

Asserts that all file declarations in the scope have names starting with any of the specified prefixes.

fun KontureScope.assertNameStartingWith(vararg prefixes: String)

Asserts that all class declarations in the scope have names starting with any of the specified prefixes.

fun List<ClassDeclaration>.assertNameStartingWith(vararg prefixes: String)

Asserts that all class declarations have names starting with any of the specified prefixes.

fun List<FileDeclaration>.assertNameStartingWith(vararg prefixes: String)

Asserts that all file declarations have names starting with any of the specified prefixes.

assertNoCycles

fun Konture.assertNoCycles()

Verifies that there are no package or module dependency cycles in the project. Throws an AssertionError if a cycle is detected.

assertNoWildcardImports

fun KontureFileScope.assertNoWildcardImports(additionalMessage: String? = null)

fun List<FileDeclaration>.assertNoWildcardImports(additionalMessage: String? = null)

assertOnlyBeAccessedByAnyPackage

fun KontureScope.assertOnlyBeAccessedByAnyPackage(vararg packagePatterns: String, allClasses: List<ClassDeclaration> = Konture.projectGraph.getAllModules().flatMap { it.classes })

Asserts that the selected classes in the scope are only accessed by classes residing in packages matching the specified patterns.

fun List<ClassDeclaration>.assertOnlyBeAccessedByAnyPackage(vararg packagePatterns: String, allClasses: List<ClassDeclaration> = Konture.projectGraph.getAllModules().flatMap { it.classes })

Asserts that the selected classes are only accessed by classes residing in packages matching the specified patterns.

assertOnlyDependOnClassesInAnyPackage

fun KontureScope.assertOnlyDependOnClassesInAnyPackage(vararg packagePatterns: String, allClasses: List<ClassDeclaration> = Konture.projectGraph.getAllModules().flatMap { it.classes })

Asserts that the selected classes in the scope depend only on classes residing in packages matching the specified patterns.

fun List<ClassDeclaration>.assertOnlyDependOnClassesInAnyPackage(vararg packagePatterns: String, allClasses: List<ClassDeclaration> = Konture.projectGraph.getAllModules().flatMap { it.classes })

Asserts that the selected classes depend only on classes residing in packages matching the specified patterns.

assertOnlyOneClassPerFile

fun KontureFileScope.assertOnlyOneClassPerFile(additionalMessage: String? = null)

fun List<FileDeclaration>.assertOnlyOneClassPerFile(additionalMessage: String? = null)

assertResideInAPackage

fun KontureFileScope.assertResideInAPackage(vararg packagePatterns: String)

Asserts that all file declarations in the scope reside in packages matching any of the specified patterns. Matches using standard Kotlin package wildcard matching (e.g. "..domain..").

fun KontureScope.assertResideInAPackage(vararg packagePatterns: String)

Asserts that all class declarations in the scope reside in packages matching any of the specified patterns. Matches using standard Kotlin package wildcard matching (e.g. "..domain..").

fun List<ClassDeclaration>.assertResideInAPackage(vararg packagePatterns: String)

Asserts that all class declarations reside in packages matching any of the specified patterns. Matches using standard Kotlin package wildcard matching (e.g. "..domain..").

fun List<FileDeclaration>.assertResideInAPackage(vararg packagePatterns: String)

Asserts that all file declarations reside in packages matching any of the specified patterns. Matches using standard Kotlin package wildcard matching (e.g. "..domain..").

assertTrue

fun KontureFileScope.assertTrue(additionalMessage: String? = null, predicate: (FileDeclaration) -> Boolean)

fun KontureScope.assertTrue(additionalMessage: String? = null, predicate: (ClassDeclaration) -> Boolean)

@JvmName(name = "assertClassesTrue")

fun List<ClassDeclaration>.assertTrue(additionalMessage: String? = null, predicate: (ClassDeclaration) -> Boolean)

@JvmName(name = "assertFilesTrue")

fun List<FileDeclaration>.assertTrue(additionalMessage: String? = null, predicate: (FileDeclaration) -> Boolean)

classes

fun Konture.classes(): ClassesRuleBuilder

Access the class-level declarative assertion rule builder. Allows filtering and assertion of class structure, modifiers, annotations, visibility, and dependencies.

fun KontureScope.classes(): KontureScope

fun List<ClassDeclaration>.classes(): List<ClassDeclaration>

Filters the list of class declarations to include only normal classes (excluding interface definitions).

fun Konture.classes(block: ClassesRuleBuilder.() -> Unit)

Define and run class dependency/structural rules inside a block-based DSL context. Automatically checks the rules at the end of the block.

containsClassWith

fun FileDeclarationContext.containsClassWith(predicate: (ClassDeclaration) -> Boolean): Boolean

Helper extension to check if a file contains a class matching the predicate.

dataClasses

fun KontureScope.dataClasses(): KontureScope

fun List<ClassDeclaration>.dataClasses(): List<ClassDeclaration>

files

fun Konture.files(): FilesRuleBuilder

Access the file-level declarative assertion rule builder. Allows filtering and assertion of source files and their imports, package, or wildcard usages.

fun Konture.files(block: FilesRuleBuilder.() -> Unit)

Define and run source file dependency/structural rules inside a block-based DSL context. Automatically checks the rules at the end of the block.

fileScopeFromModule

fun Konture.fileScopeFromModule(path: String): KontureFileScope

Retrieves a file-level functional KontureFileScope scoped to a specific module path.

fileScopeFromPackage

fun Konture.fileScopeFromPackage(packageName: String): KontureFileScope

Retrieves a file-level functional KontureFileScope scoped to a specific package name.

functions

fun Konture.functions(): FunctionsRuleBuilder

Access the function-level declarative assertion rule builder. Allows filtering and assertion of function declarations (both top-level and nested member functions).

fun Konture.functions(block: FunctionsRuleBuilder.() -> Unit)

Define and run function dependency/structural rules inside a block-based DSL context. Automatically checks the rules at the end of the block.

hasAllAnnotations

fun ClassDeclaration.hasAllAnnotations(vararg names: String): Boolean

fun ClassDeclaration.hasAllAnnotations(names: List<String>): Boolean

Helper extension to check if a class is annotated with all of the specified annotations.

fun FunctionDeclarationContext.hasAllAnnotations(vararg names: String): Boolean

fun FunctionDeclarationContext.hasAllAnnotations(names: List<String>): Boolean

Helper extension to check if a function has all of the specified annotations.

fun PropertyDeclarationContext.hasAllAnnotations(vararg names: String): Boolean

fun PropertyDeclarationContext.hasAllAnnotations(names: List<String>): Boolean

Helper extension to check if a property has all of the specified annotations.

hasAnnotation

fun ClassDeclaration.hasAnnotation(name: String): Boolean

Helper extension to check if a class is annotated with the given annotation.

fun FunctionDeclarationContext.hasAnnotation(name: String): Boolean

Helper extension to check if a function has the specified annotation.

fun PropertyDeclarationContext.hasAnnotation(name: String): Boolean

Helper extension to check if a property has the specified annotation.

hasAnyAnnotation

fun ClassDeclaration.hasAnyAnnotation(vararg names: String): Boolean

fun ClassDeclaration.hasAnyAnnotation(names: List<String>): Boolean

Helper extension to check if a class is annotated with any of the specified annotations.

fun FunctionDeclarationContext.hasAnyAnnotation(vararg names: String): Boolean

fun FunctionDeclarationContext.hasAnyAnnotation(names: List<String>): Boolean

Helper extension to check if a function has any of the specified annotations.

fun PropertyDeclarationContext.hasAnyAnnotation(vararg names: String): Boolean

fun PropertyDeclarationContext.hasAnyAnnotation(names: List<String>): Boolean

Helper extension to check if a property has any of the specified annotations.

hasImport

fun FileDeclarationContext.hasImport(predicate: (String) -> Boolean): Boolean

Helper extension to check if a file imports the specified match.

hasImportContaining

fun FileDeclarationContext.hasImportContaining(vararg segments: String): Boolean

Helper extension to check if a file imports any match containing target segments.

inlineClasses

fun KontureScope.inlineClasses(): KontureScope

fun List<ClassDeclaration>.inlineClasses(): List<ClassDeclaration>

interfaces

fun KontureScope.interfaces(): KontureScope

fun List<ClassDeclaration>.interfaces(): List<ClassDeclaration>

Filters the list of class declarations to include only interface definitions.

internal

fun KontureScope.internal(): KontureScope

fun List<ClassDeclaration>.internal(): List<ClassDeclaration>

layered

fun Konture.layered(block: LayeredArchitectureDsl.() -> Unit)

Define and run a nested, type-safe layered architecture specification. Automatically checks the layered rules at the end of the block.

layeredArchitecture

fun Konture.layeredArchitecture(): LayeredArchitectureBuilder

Access the layered-architecture rule builder. Allows defining high-level layers and declaring directional access constraints between them.

minus

operator fun KontureFileScope.minus(other: KontureFileScope): KontureFileScope

operator fun KontureScope.minus(other: KontureScope): KontureScope

modules

fun Konture.modules(): ModulesRuleBuilder

Access the modules-level declarative assertion rule builder. Allows filtering and assertion of architectural module structures and dependencies.

fun Konture.modules(block: ModulesRuleBuilder.() -> Unit)

Define and run module dependency rules inside a block-based DSL context. Automatically checks the rules at the end of the block.

plus

operator fun KontureFileScope.plus(other: KontureFileScope): KontureFileScope

operator fun KontureScope.plus(other: KontureScope): KontureScope

private

fun KontureScope.private(): KontureScope

fun List<ClassDeclaration>.private(): List<ClassDeclaration>

properties

fun Konture.properties(): PropertiesRuleBuilder

Access the property-level declarative assertion rule builder. Allows filtering and assertion of property declarations (both top-level and class properties).

fun Konture.properties(block: PropertiesRuleBuilder.() -> Unit)

Define and run property dependency/structural rules inside a block-based DSL context. Automatically checks the rules at the end of the block.

protected

fun KontureScope.protected(): KontureScope

fun List<ClassDeclaration>.protected(): List<ClassDeclaration>

public

fun KontureScope.public(): KontureScope

fun List<ClassDeclaration>.public(): List<ClassDeclaration>

scopeFromModule

fun Konture.scopeFromModule(path: String): KontureScope

Retrieves a class-level functional KontureScope scoped to a specific module path.

scopeFromPackage

fun Konture.scopeFromPackage(packageName: String): KontureScope

Retrieves a class-level functional KontureScope scoped to a specific package name.

sealedClasses

fun KontureScope.sealedClasses(): KontureScope

fun List<ClassDeclaration>.sealedClasses(): List<ClassDeclaration>

should

fun ClassesRuleBuilder.should(assertion: ClassDeclarationShouldContext.() -> Any?): ClassesRuleBuilder

Asserts rules on filtered classes using a lambda block that provides a ClassDeclarationShouldContext receiver.

fun FilesRuleBuilder.should(assertion: FileDeclarationShouldContext.() -> Any?): FilesRuleBuilder

Asserts rules on filtered files using a lambda block that provides a FileDeclarationShouldContext receiver. Supports both imperative assertions and Boolean predicate matches.

fun FunctionsRuleBuilder.should(assertion: FunctionDeclarationShouldContext.() -> Any?): FunctionsRuleBuilder

Asserts rules on filtered functions using a lambda block that provides a FunctionDeclarationShouldContext receiver. Supports both imperative assertions and Boolean predicate matches.

fun ModulesRuleBuilder.should(assertion: ModuleShouldContext.() -> Any?): ModulesRuleBuilder

Asserts rules on filtered modules using a lambda block that provides a ModuleShouldContext receiver. Supports both imperative assertions and Boolean predicate matches.

fun PropertiesRuleBuilder.should(assertion: PropertyDeclarationShouldContext.() -> Any?): PropertiesRuleBuilder

Asserts rules on filtered properties using a lambda block that provides a PropertyDeclarationShouldContext receiver. Supports both imperative assertions and Boolean predicate matches.

that

fun ClassesRuleBuilder.that(predicate: ClassDeclaration.() -> Boolean): ClassesRuleBuilder

Filters classes in this rule using a concise lambda predicate evaluated on each ClassDeclaration.

fun FilesRuleBuilder.that(predicate: FileDeclarationContext.() -> Boolean): FilesRuleBuilder

Filters files in this rule using a concise lambda predicate evaluated on each FileDeclarationContext.

fun FunctionsRuleBuilder.that(predicate: FunctionDeclarationContext.() -> Boolean): FunctionsRuleBuilder

Filters functions in this rule using a concise lambda predicate evaluated on each FunctionDeclarationContext.

fun ModulesRuleBuilder.that(predicate: Module.() -> Boolean): ModulesRuleBuilder

Filters modules in this rule using a concise lambda predicate evaluated on each Module.

fun PropertiesRuleBuilder.that(predicate: PropertyDeclarationContext.() -> Boolean): PropertiesRuleBuilder

Filters properties in this rule using a concise lambda predicate evaluated on each PropertyDeclarationContext.

withAnnotationOf

fun KontureScope.withAnnotationOf(annotationFqName: String): KontureScope

fun List<ClassDeclaration>.withAnnotationOf(annotationFqName: String): List<ClassDeclaration>

Filters the list of class declarations to include only those annotated with the specified annotation.

withModifier

fun KontureScope.withModifier(modifier: Modifier): KontureScope

fun List<ClassDeclaration>.withModifier(modifier: Modifier): List<ClassDeclaration>

Filters class declarations to those containing the specified modifier.

withNameEndingWith

fun KontureFileScope.withNameEndingWith(suffix: String): KontureFileScope

fun KontureScope.withNameEndingWith(suffix: String): KontureScope

fun List<ClassDeclaration>.withNameEndingWith(suffix: String): List<ClassDeclaration>

Filters the list of class declarations to include only those whose names end with the specified suffix.

@JvmName(name = "withFileNameEndingWith")

fun List<FileDeclaration>.withNameEndingWith(suffix: String): List<FileDeclaration>

Filters the list of file declarations to include only those whose names end with the specified suffix.

withNameMatching

fun KontureFileScope.withNameMatching(pattern: String): KontureFileScope

fun KontureScope.withNameMatching(pattern: String): KontureScope

fun List<ClassDeclaration>.withNameMatching(pattern: String): List<ClassDeclaration>

Filters the list of class declarations to include only those whose simple names match the specified glob pattern. Supports '*' wildcards.

@JvmName(name = "withFileNameMatching")

fun List<FileDeclaration>.withNameMatching(pattern: String): List<FileDeclaration>

Filters the list of file declarations to include only those whose names match the specified glob pattern. Supports '*' wildcards.

withNameStartingWith

fun KontureFileScope.withNameStartingWith(prefix: String): KontureFileScope

fun KontureScope.withNameStartingWith(prefix: String): KontureScope

fun List<ClassDeclaration>.withNameStartingWith(prefix: String): List<ClassDeclaration>

Filters the list of class declarations to include only those whose names start with the specified prefix.

@JvmName(name = "withFileNameStartingWith")

fun List<FileDeclaration>.withNameStartingWith(prefix: String): List<FileDeclaration>

Filters the list of file declarations to include only those whose names start with the specified prefix.

withoutAnnotationOf

fun KontureScope.withoutAnnotationOf(annotationFqName: String): KontureScope

fun List<ClassDeclaration>.withoutAnnotationOf(annotationFqName: String): List<ClassDeclaration>

Filters the list of class declarations to exclude those annotated with the specified annotation.

withPackage

fun KontureFileScope.withPackage(packagePattern: String): KontureFileScope

fun KontureScope.withPackage(packagePattern: String): KontureScope

fun List<ClassDeclaration>.withPackage(packagePattern: String): List<ClassDeclaration>

Filters the list of class declarations to include only those residing in packages matching the specified pattern. Supports '..' segment wildcards.

@JvmName(name = "withFilePackage")

fun List<FileDeclaration>.withPackage(packagePattern: String): List<FileDeclaration>

Filters the list of file declarations to include only those residing in packages matching the specified pattern. Supports '..' wildcards.

withParentOf

fun KontureScope.withParentOf(fqName: String): KontureScope

fun List<ClassDeclaration>.withParentOf(fqName: String): List<ClassDeclaration>

Filters class declarations to those extending or implementing the specified parent type.

withVisibility

fun KontureScope.withVisibility(visibility: Visibility): KontureScope

fun List<ClassDeclaration>.withVisibility(visibility: Visibility): List<ClassDeclaration>

Filters class declarations to those matching the specified visibility.