library/io.github.baole.konture

Package-level declarations

Types

AnnotationArgumentDeclaration

@Serializable

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

Represents an argument passed to a Kotlin annotation.

AnnotationDeclaration

@Serializable

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

Represents a parsed Kotlin annotation declared on a class.

ArchitectureLayerPolicy

class ArchitectureLayerPolicy

First-class, declarative architectural-layer policy DSL.

ArchitectureSourceSetPolicy

class ArchitectureSourceSetPolicy

First-class, declarative source-set architecture policy DSL.

ClassDeclaration

@Serializable

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, val sourceLine: Int = -1)

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, sourceSets: SourceSetSelector = SourceSets.production())

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

class ClassesShould : ClassesShouldPackageAssertions, ClassesShouldMetadataAssertions, ClassesShouldDependencyAssertions, ClassesShouldCompositeAssertions

Fluent API for defining assertion rules on Kotlin classes.

ClassesShouldCompositeAssertions

interface ClassesShouldCompositeAssertions

Fluent API for defining assertion rules on Kotlin classes.

ClassesShouldDependencyAssertions

interface ClassesShouldDependencyAssertions

Fluent API for defining assertion rules on Kotlin classes.

ClassesShouldMetadataAssertions

interface ClassesShouldMetadataAssertions

Fluent API for defining assertion rules on Kotlin classes.

ClassesShouldPackageAssertions

interface ClassesShouldPackageAssertions

Fluent API for defining assertion rules on Kotlin classes.

class ClassesThat : ClassesThatPackageFilter, ClassesThatNameFilter, ClassesThatStructureFilter, ClassesThatMetadataFilter, ClassesThatCompositeFilter

Fluent API for filtering Kotlin classes in architecture rules.

ClassesThatCompositeFilter

interface ClassesThatCompositeFilter : ClassesThatScope

Trait interface for composite, logical and custom predicate filtering on classes.

ClassesThatMetadataFilter

interface ClassesThatMetadataFilter : ClassesThatScope

Trait interface for metadata, annotations, modifiers and visibility filtering on classes.

ClassesThatNameFilter

interface ClassesThatNameFilter : ClassesThatScope

Trait interface for name matching and naming pattern filtering on classes.

ClassesThatPackageFilter

interface ClassesThatPackageFilter : ClassesThatScope

Trait interface for package and module residency filtering on classes.

ClassesThatScope

interface ClassesThatScope

Common scope interface providing access to ClassesRuleBuilder.

ClassesThatStructureFilter

interface ClassesThatStructureFilter : ClassesThatScope

Trait interface for structural, hierarchy, member and type assignability filtering on classes.

typealias ClassSelector = KontureScope

Typealias for class scope selector.

ClassSelectorShould

class ClassSelectorShould

Fluent assertion receiver for sequential assertions on a ClassSelector.

ConstructorDeclaration

@Serializable

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

Represents a constructor declaration of a Kotlin class.

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

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

FileDeclaration

@Serializable

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(), val sourceSets: List<SourceSetId> = emptyList(), val usages: List<SourceUsage> = emptyList(), val annotations: List<AnnotationDeclaration> = emptyList())

Represents a source file declaration containing classes, functions, properties, and imports.

FileDeclarationContext

data class FileDeclarationContext(val declaration: FileDeclaration, val modulePath: String, val sourceSet: SourceSetId? = null)

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.

typealias FileSelector = KontureFileScope

Typealias for file scope selector.

FileSelectorShould

class FileSelectorShould

Fluent assertion receiver for sequential assertions on a FileSelector.

FilesRuleBuilder

class FilesRuleBuilder(graph: ProjectGraph = Konture.projectGraph, sourceSets: SourceSetSelector = SourceSets.production())

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

class FilesShould : FilesShouldPathAssertions, FilesShouldContentAssertions, FilesShouldCompositeAssertions

Assertion builder for checking rule expectations on Kotlin file declarations.

FilesShouldCompositeAssertions

interface FilesShouldCompositeAssertions

Composite condition assertions for file rules.

FilesShouldContentAssertions

interface FilesShouldContentAssertions

Content-based assertions for file rules.

FilesShouldPathAssertions

interface FilesShouldPathAssertions

Path and package assertions for file rules.

class FilesThat

Filter builder for selecting file declarations matching specific conditions.

interface FilesThatScope

Common scope interface providing access to FilesRuleBuilder.

FunctionAssertionScope

class FunctionAssertionScope

Assertion scope DSL for configuring rule expectations on Kotlin functions.

FunctionDeclaration

@Serializable

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, val sourceStartOffset: Int = -1, val sourceEndOffset: Int = -1, val resolvedReturnType: String? = null, val sourceLine: Int = -1, val receiverType: String? = null)

Represents a parsed function declaration within a Kotlin source file.

FunctionDeclarationContext

data class FunctionDeclarationContext(val declaration: FunctionDeclaration, val packageName: String, val className: String?, val modulePath: String, val filePath: String, val sourceSet: SourceSetId? = null, val usages: List<SourceUsage> = emptyList())

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.

FunctionSelector

typealias FunctionSelector = KontureFunctionScope

Typealias for function scope selector.

FunctionSelectorShould

class FunctionSelectorShould

Fluent assertion receiver for sequential assertions on a FunctionSelector.

FunctionsRuleBuilder

class FunctionsRuleBuilder(graph: ProjectGraph = Konture.projectGraph, sourceSets: SourceSetSelector = SourceSets.production())

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

FunctionsShould

class FunctionsShould : FunctionsShouldCallAssertions, FunctionsShouldNameAssertions, FunctionsShouldModifierAssertions, FunctionsShouldSignatureAssertions, FunctionsShouldDependencyAssertions, FunctionsShouldCompositeAssertions

Assertion builder for checking rule expectations on Kotlin function declarations.

FunctionsShouldCallAssertions

interface FunctionsShouldCallAssertions

Member call assertions for function rules.

FunctionsShouldCompositeAssertions

interface FunctionsShouldCompositeAssertions

Composite condition assertions for function rules.

FunctionsShouldDependencyAssertions

interface FunctionsShouldDependencyAssertions

Package dependency assertions for function rules.

FunctionsShouldModifierAssertions

interface FunctionsShouldModifierAssertions

Modifier and visibility assertions for function rules.

FunctionsShouldNameAssertions

interface FunctionsShouldNameAssertions

Naming and package assertions for function rules.

FunctionsShouldSignatureAssertions

interface FunctionsShouldSignatureAssertions

Signature and type assertions for function rules.

class FunctionsThat : FunctionsThatPackageFilter, FunctionsThatNameFilter, FunctionsThatStructureFilter, FunctionsThatModifierFilter, FunctionsThatDependencyFilter, FunctionsThatCompositeFilter

Fluent API for filtering Kotlin functions in architecture rules.

FunctionsThatCompositeFilter

interface FunctionsThatCompositeFilter : FunctionsThatScope

Trait interface for composite, logical and custom predicate filtering on functions.

FunctionsThatDependencyFilter

interface FunctionsThatDependencyFilter : FunctionsThatScope

Trait interface for filtering functions by package dependencies.

FunctionsThatModifierFilter

interface FunctionsThatModifierFilter : FunctionsThatScope

Trait interface for modifiers, annotations, visibility and modifier filtering on functions.

FunctionsThatNameFilter

interface FunctionsThatNameFilter : FunctionsThatScope

Trait interface for name matching and naming pattern filtering on functions.

FunctionsThatPackageFilter

interface FunctionsThatPackageFilter : FunctionsThatScope

Trait interface for package and module residency filtering on functions.

FunctionsThatScope

interface FunctionsThatScope

Common scope interface providing access to FunctionsRuleBuilder.

FunctionsThatStructureFilter

interface FunctionsThatStructureFilter : FunctionsThatScope

Trait interface for structural, parameter, return type and declaration location filtering on functions.

HtmlViolationFormatter

object HtmlViolationFormatter

Formatter for building semantic HTML error reports from architecture violation reports.

HumanReadableViolationFormatter

object HumanReadableViolationFormatter

Formatter for building human-readable error messages from architecture violation reports.

object Konture

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

class KontureContext(projectGraph: ProjectGraph)

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

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.

KontureFunctionScope

class KontureFunctionScope(val functions: List<FunctionDeclarationContext>)

Represents a scope containing a set of function declaration contexts for checking function-level rules in a Konsist-inspired fluent DSL.

KontureModuleScope

class KontureModuleScope(val modules: List<Module>)

Represents a functional scope containing a set of Gradle Module structures for inspection and assertions.

KonturePropertyScope

class KonturePropertyScope(val properties: List<PropertyDeclarationContext>)

Represents a scope containing a set of property declaration contexts for checking property-level rules in a Konsist-inspired fluent DSL.

class KontureScope(val classes: List<ClassDeclaration>)

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

KontureSliceScope

class KontureSliceScope(val slices: List<Slice>)

Represents a functional scope containing a set of derived Slice objects for inspection and assertions.

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.

LayerSelectorDsl

class LayerSelectorDsl

Selector DSL used within ArchitectureLayerPolicy.selector to define a layer's member modules and/or packages.

@Serializable

enum Modifier : Enum<Modifier>

Represents declaration modifiers in Kotlin source code (e.g. abstract, open, sealed, suspend, override).

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.

typealias ModuleSelector = KontureModuleScope

Typealias for module scope selector.

ModuleSelectorShould

class ModuleSelectorShould

Fluent assertion receiver for sequential assertions on a ModuleSelector.

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, sourceSets: SourceSetSelector? = null)

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

class ModulesShould : ModulesShouldDependencyAssertions, ModulesShouldInboundDependencyAssertions, ModulesShouldExternalDependencyAssertions, ModulesShouldStructureAssertions, ModulesShouldCompositeAssertions

Fluent API for defining assertion rules on Gradle modules.

ModulesShouldCompositeAssertions

interface ModulesShouldCompositeAssertions

Composite condition assertions for Gradle module rules.

ModulesShouldDependencyAssertions

interface ModulesShouldDependencyAssertions

Outbound dependency assertions for Gradle module rules.

ModulesShouldExternalDependencyAssertions

interface ModulesShouldExternalDependencyAssertions

External dependency assertions for Gradle module rules.

ModulesShouldInboundDependencyAssertions

interface ModulesShouldInboundDependencyAssertions

Inbound dependency assertions for Gradle module rules.

ModulesShouldStructureAssertions

interface ModulesShouldStructureAssertions

Structural assertions for Gradle module rules.

class ModulesThat

Fluent API for defining filtering conditions on Gradle modules.

ModulesThatScope

interface ModulesThatScope

Common scope interface providing access to ModulesRuleBuilder.

enum OutputFormat : Enum<OutputFormat>

Output format modes for formatting architecture violation reports.

ParameterDeclaration

@Serializable

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

Represents a parameter in a function or constructor declaration.

PlatformPackages

object PlatformPackages

Known default platform namespaces used for platform-independence checks in Kotlin Multiplatform projects.

ProblemMatcherViolationFormatter

object ProblemMatcherViolationFormatter

Formatter for building IDE and CI problem-matcher compatible error outputs from architecture violation reports.

ProgrammaticSuppression

sealed class ProgrammaticSuppression

Programmatic suppression descriptor.

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, sourceSets: SourceSetSelector = SourceSets.production())

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

PropertiesShould

class PropertiesShould : PropertiesShouldModifierAssertions, PropertiesShouldTypeAssertions, PropertiesShouldDependencyAssertions, PropertiesShouldCompositeAssertions

Assertion builder for checking rule expectations on Kotlin property declarations.

PropertiesShouldCompositeAssertions

interface PropertiesShouldCompositeAssertions

Composite condition assertions for property rules.

PropertiesShouldDependencyAssertions

interface PropertiesShouldDependencyAssertions

Package dependency assertions for property rules.

PropertiesShouldModifierAssertions

interface PropertiesShouldModifierAssertions

Modifier and visibility assertions for property rules.

PropertiesShouldTypeAssertions

interface PropertiesShouldTypeAssertions

Type and package assertions for property rules.

class PropertiesThat

Filter builder for selecting property declarations matching specific conditions.

PropertiesThatScope

interface PropertiesThatScope

Common scope interface providing access to PropertiesRuleBuilder.

PropertyAssertionScope

class PropertyAssertionScope

Assertion scope DSL for configuring rule expectations on Kotlin properties.

PropertyDeclaration

@Serializable

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, val resolvedType: String? = null, val sourceLine: Int = -1, val receiverType: String? = null)

Represents a property declaration within a Kotlin class or source file.

PropertyDeclarationContext

data class PropertyDeclarationContext(val declaration: PropertyDeclaration, val packageName: String, val className: String?, val modulePath: String, val filePath: String, val sourceSet: SourceSetId? = null, val usages: List<SourceUsage> = emptyList())

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.

PropertySelector

typealias PropertySelector = KonturePropertyScope

Typealias for property scope selector.

PropertySelectorShould

class PropertySelectorShould

Fluent assertion receiver for sequential assertions on a PropertySelector.

ResolutionConfidence

@Serializable

enum ResolutionConfidence : Enum<ResolutionConfidence>

Confidence level of a resolved symbol usage in source code analysis.

class RuleBuilder(val id: String, projectGraph: ProjectGraph = Konture.projectGraph)

DSL builder for configuring named architecture rules with metadata and sub-rule blocks.

class RuleDefinition

Encapsulates a named architecture rule with its metadata and evaluation logic.

typealias RuleMetadata = io.github.baole.konture.core.model.RuleMetadata

Encapsulates a reusable collection of architectural rules and policies.

class RuleSetBuilder(var name: String? = null)

DSL builder for configuring a reusable RuleSet.

RuleSuppressionBuilder

class RuleSuppressionBuilder

DSL builder for configuring programmatic violation suppressions with mandatory audit reasons.

interface SatisfyContext<T>

Receiver context provided inside satisfy custom predicate assertion blocks.

data class Slice(val key: String, val packages: Set<String>, val classes: List<ClassDeclaration>)

A group of packages sharing the same slice key, derived from a slice pattern's capture group.

typealias SliceSelector = KontureSliceScope

Typealias for slice scope selector.

SliceSelectorShould

class SliceSelectorShould

Fluent assertion receiver for sequential assertions on a SliceSelector.

SliceShouldContext

class SliceShouldContext

Context receiver for writing declarative assertions on a SliceGraph.

SlicesRuleBuilder

class SlicesRuleBuilder(graph: ProjectGraph = Konture.projectGraph, sourceSets: SourceSetSelector = SourceSets.production())

A builder for compiling and verifying architectural rules on slices — groups of packages derived from a package pattern with a capture group.

class SlicesShould(builder: SlicesRuleBuilder)

Assertions that the slices derived by SlicesRuleBuilder must satisfy.

class SlicesThat

Filter builder for selecting architectural slices matching specific conditions.

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

Represents a source set within a module at test runtime.

@Serializable

data class SourceSetId(val modulePath: String, val name: String, val kind: SourceSetKind, val role: SourceSetRole)

A source set as exposed to architecture rules.

@Serializable

enum SourceSetKind : Enum<SourceSetKind>

Broad technology stack classification of a source set.

@Serializable

enum SourceSetRole : Enum<SourceSetRole>

Indicates whether a source set contains production or test code.

object SourceSets

Factory methods for selecting captured Kotlin source sets.

SourceSetSelector

class SourceSetSelector

Immutable selector used by source-backed Konture entry points.

@Serializable

data class SourceUsage(val kind: UsageKind, val targetFqName: String, val filePath: String, val line: Int, val column: Int, val enclosingFunction: String? = null, val enclosingClass: String? = null, val enclosingProperty: String? = null, val rawExpression: String = targetFqName, val sourceSets: List<SourceSetId> = emptyList(), val possibleTargetFqNames: List<String> = emptyList(), val unresolvedPossibleUsage: Boolean = false, val confidence: ResolutionConfidence = if (unresolvedPossibleUsage) { ResolutionConfidence.POSSIBLE } else { ResolutionConfidence.RESOLVED }, val sourceStartOffset: Int = -1, val sourceEndOffset: Int = -1, val enclosingFunctionStartOffset: Int = -1, val enclosingFunctionEndOffset: Int = -1)

A resolved (or conservatively possible) Kotlin source usage.

@Serializable

enum UsageKind : Enum<UsageKind>

Category of source code usage (e.g. function call or class reference).

@Serializable

enum Visibility : Enum<Visibility>

Represents the visibility modifier of a Kotlin declaration (public, internal, protected, or private).

Properties

val FunctionDeclarationContext.annotations: List<AnnotationDeclaration>

Delegates annotations property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.annotations: List<AnnotationDeclaration>

Delegates annotations property to the underlying PropertyDeclaration.

val FileDeclarationContext.classes: List<ClassDeclaration>

Delegates classes property to the underlying FileDeclaration.

val Konture.classScope: KontureScope

Synonym for scope representing class-level functional scope for the entire project.

val Konture.fileScope: KontureFileScope

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

val Konture.functionScope: KontureFunctionScope

Retrieves a function-level functional KontureFunctionScope representing all functions in the project.

val FileDeclarationContext.imports: List<String>

Delegates imports property to the underlying FileDeclaration.

val FunctionDeclarationContext.isExtension: Boolean

Delegates isExtension property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.isExtension: Boolean

Delegates isExtension property to the underlying PropertyDeclaration.

val PropertyDeclarationContext.isVal: Boolean

Delegates isVal property to the underlying PropertyDeclaration.

val PropertyDeclarationContext.isVar: Boolean

Delegates isVar property to the underlying PropertyDeclaration.

val FunctionDeclarationContext.kdocText: String?

Delegates kdocText property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.kdocText: String?

Delegates kdocText property to the underlying PropertyDeclaration.

val FunctionDeclarationContext.modifiers: Set<Modifier>

Delegates modifiers property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.modifiers: Set<Modifier>

Delegates modifiers property to the underlying PropertyDeclaration.

val Konture.moduleScope: KontureModuleScope

Retrieves a module-level functional KontureModuleScope representing all modules in the project.

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.

val FileDeclarationContext.packageName: String

Delegates packageName property to the underlying FileDeclaration.

val FunctionDeclarationContext.parameters: List<ParameterDeclaration>

Delegates parameters property to the underlying FunctionDeclaration.

val Konture.propertyScope: KonturePropertyScope

Retrieves a property-level functional KonturePropertyScope representing all properties in the project.

val FunctionDeclarationContext.returnType: String

Delegates returnType property to the underlying FunctionDeclaration.

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.

val PropertyDeclarationContext.type: String

Delegates type property to the underlying PropertyDeclaration.

val FunctionDeclarationContext.visibility: Visibility

Delegates visibility property to the underlying FunctionDeclaration.

val PropertyDeclarationContext.visibility: Visibility

Delegates visibility property to the underlying PropertyDeclaration.

Functions

inline fun <T : Annotation> ClassesShould.annotatedWith(): ClassesRuleBuilder

Asserts that classes have annotation type parameter T.

inline fun <T : Annotation> ClassesThat.annotatedWith(): ClassesRuleBuilder

Filters classes having annotation type parameter T.

inline fun <T : Annotation> FilesShould.annotatedWith(): FilesRuleBuilder

Asserts that files are annotated with the annotation type parameter T.

inline fun <T : Annotation> FilesThat.annotatedWith(): FilesRuleBuilder

Filters files annotated with the annotation type parameter T.

infix fun ClassesShould.annotatedWith(annotation: KClass<out Annotation>): ClassesRuleBuilder

Asserts that classes have the specified annotation class.

infix fun ClassesThat.annotatedWith(annotation: KClass<out Annotation>): ClassesRuleBuilder

Filters classes having the specified annotation class.

infix fun FilesShould.annotatedWith(annotation: KClass<out Annotation>): FilesRuleBuilder

Asserts that files are annotated with the specified annotation class.

infix fun FilesThat.annotatedWith(annotation: KClass<out Annotation>): FilesRuleBuilder

Filters files annotated with the specified annotation class.

fun List<FunctionDeclarationContext>.annotatedWith(annotationName: String): List<FunctionDeclarationContext>

Filters functions annotated with annotationName.

fun List<PropertyDeclarationContext>.annotatedWith(annotationName: String): List<PropertyDeclarationContext>

Filters properties annotated with annotationName.

annotatedWithAllOf

fun ClassesShould.annotatedWithAllOf(vararg annotations: KClass<out Annotation>): ClassesRuleBuilder

Asserts that classes have all of the specified annotations.

fun ClassesThat.annotatedWithAllOf(vararg annotations: KClass<out Annotation>): ClassesRuleBuilder

Filters classes having all of the specified annotations.

annotatedWithAnyOf

fun ClassesShould.annotatedWithAnyOf(vararg annotations: KClass<out Annotation>): ClassesRuleBuilder

Asserts that classes have any of the specified annotations.

fun ClassesThat.annotatedWithAnyOf(vararg annotations: KClass<out Annotation>): ClassesRuleBuilder

Filters classes having any of the specified annotations.

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

Top-level entry point for defining and running architecture rule blocks.

fun architecture(graph: ProjectGraph, block: KontureContext.() -> Unit)

Top-level entry point for defining and running architecture rule blocks against a specific ProjectGraph.

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.

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

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

architectureRules

fun architectureRules(block: RuleSetBuilder.() -> Unit): RuleSet

Top-level builder function for defining a reusable RuleSet.

fun architectureRules(name: String? = null, block: RuleSetBuilder.() -> Unit): RuleSet

Top-level builder function for defining a reusable, named RuleSet.

architectureRules

fun Konture.architectureRules(block: RuleSetBuilder.() -> Unit): RuleSet

Builder function on Konture for defining a reusable RuleSet.

fun Konture.architectureRules(name: String? = null, block: RuleSetBuilder.() -> Unit): RuleSet

Builder function on Konture for defining a reusable, named RuleSet.

areAnnotatedWith

inline fun <T : Annotation> PropertiesThat.areAnnotatedWith(): PropertiesRuleBuilder

Filters properties annotated with annotation type parameter T.

infix fun FunctionsThat.areAnnotatedWith(annotation: KClass<out Annotation>): FunctionsRuleBuilder

Filters functions annotated with the specified annotation class.

infix fun PropertiesThat.areAnnotatedWith(annotation: KClass<out Annotation>): PropertiesRuleBuilder

Filters properties annotated with annotation.

areAssignableFrom

inline fun <T : Any> ClassesThat.areAssignableFrom(): ClassesRuleBuilder

Filters classes that are assignable from type parameter T.

infix fun ClassesThat.areAssignableFrom(subType: KClass<*>): ClassesRuleBuilder

Filters classes that are assignable from the specified subType.

areAssignableTo

inline fun <T : Any> ClassesThat.areAssignableTo(): ClassesRuleBuilder

Filters classes that are assignable to type parameter T.

@JvmName(name = "areAssignableToKClasses")

infix fun ClassesThat.areAssignableTo(superTypes: List<KClass<*>>): ClassesRuleBuilder

Filters classes assignable to superTypes.

infix fun ClassesThat.areAssignableTo(superType: KClass<*>): ClassesRuleBuilder

Filters classes that are assignable to the specified superType.

areAssignableToAllOf

fun ClassesThat.areAssignableToAllOf(vararg superTypes: KClass<*>): ClassesRuleBuilder

Filters classes that are assignable to all of the specified superTypes.

areAssignableToAnyOf

fun ClassesThat.areAssignableToAnyOf(vararg superTypes: KClass<*>): ClassesRuleBuilder

Filters classes that are assignable to any of the specified superTypes.

areNotAssignableFrom

inline fun <T : Any> ClassesThat.areNotAssignableFrom(): ClassesRuleBuilder

Filters classes that are not assignable from type parameter T.

areNotAssignableTo

inline fun <T : Any> ClassesThat.areNotAssignableTo(): ClassesRuleBuilder

Filters classes that are not assignable to type parameter T.

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, allClasses: List<ClassDeclaration> = Konture.projectGraph.getAllModules().flatMap { it.classes })

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

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

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

fun KontureScope.assertAreAssignableTo(first: KClass<*>, vararg additional: KClass<*>, allClasses: List<ClassDeclaration> = Konture.projectGraph.getAllModules().flatMap { it.classes })

Asserts that classes in a KontureScope are assignable to first and additional supertypes.

fun List<ClassDeclaration>.assertAreAssignableTo(first: KClass<*>, vararg additional: KClass<*>, allClasses: List<ClassDeclaration> = Konture.projectGraph.getAllModules().flatMap { it.classes })

Asserts that a list of class declarations are assignable to first and additional supertypes.

assertAreAssignableToType

inline fun <T : Any> KontureScope.assertAreAssignableToType(vararg additional: KClass<*>, allClasses: List<ClassDeclaration> = Konture.projectGraph.getAllModules().flatMap { it.classes })

Asserts that classes in a KontureScope are assignable to type parameter T.

inline fun <T : Any> List<ClassDeclaration>.assertAreAssignableToType(vararg additional: KClass<*>, allClasses: List<ClassDeclaration> = Konture.projectGraph.getAllModules().flatMap { it.classes })

Asserts that a list of class declarations are assignable to type parameter T.

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.

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)

Asserts that file names in this scope match their primary class names.

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

Asserts that file names match their primary class names.

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

Asserts that files in this scope have KDoc documentation.

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

Asserts that all functions in this scope have KDoc documentation.

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

Asserts that all classes in this scope have KDoc documentation.

@JvmName(name = "assertClassesHasKDoc")

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

Asserts that all classes in this list have KDoc documentation.

@JvmName(name = "assertFilesHasKDoc")

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

Asserts that files in this list have KDoc documentation.

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 KontureScope.assertHaveAnnotationOf(vararg annotations: KClass<out Annotation>)

Asserts that classes in a KontureScope have the specified annotations.

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).

fun List<ClassDeclaration>.assertHaveAnnotationOf(vararg annotations: KClass<out Annotation>)

Asserts that a list of class declarations have the specified annotations.

assertHaveAnnotationOfType

inline fun <T : Annotation> KontureScope.assertHaveAnnotationOfType()

Asserts that classes in a KontureScope have annotation type parameter T.

inline fun <T : Annotation> List<ClassDeclaration>.assertHaveAnnotationOfType()

Asserts that a list of class declarations have annotation type parameter T.

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.

fun Konture.assertNoCycles()

fun Konture.assertNoCycles(includeTestConfigurations: Boolean)

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

assertNotBeAccessedByAnyPackage

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

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

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

Asserts that the selected classes are not accessed by any class residing in packages matching the specified patterns.

assertNotDependOnClassesInAnyPackage

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

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

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

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

assertNotResideInAModule

fun KontureFileScope.assertNotResideInAModule(modulePath: String, graph: ProjectGraph = Konture.projectGraph)

Filter or assertion criteria for assert not reside in a module.

fun List<FileDeclaration>.assertNotResideInAModule(modulePath: String, graph: ProjectGraph = Konture.projectGraph)

Filter or assertion criteria for list.

assertNoWildcardImports

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

Asserts that no file in this scope contains wildcard imports.

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

Asserts that no file in this list contains wildcard imports.

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)

Asserts that files in this scope contain at most one class.

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

Asserts that files in this list contain at most one class.

assertResideInAModule

fun KontureFileScope.assertResideInAModule(modulePath: String, graph: ProjectGraph = Konture.projectGraph)

Filter or assertion criteria for assert reside in a module.

fun List<FileDeclaration>.assertResideInAModule(modulePath: String, graph: ProjectGraph = Konture.projectGraph)

Filter or assertion criteria for list.

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..").

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

Asserts that all files in this scope satisfy predicate.

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

Asserts that all functions in this scope satisfy the given predicate.

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

Asserts that all properties in this scope satisfy the given predicate.

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

Asserts that all classes in this scope satisfy predicate.

@JvmName(name = "assertClassesTrue")

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

Asserts that all classes in this list satisfy predicate.

@JvmName(name = "assertFilesTrue")

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

Asserts that all files in this list satisfy predicate.

beAnnotatedWith

inline fun <T : Annotation> FunctionsShould.beAnnotatedWith(): FunctionsRuleBuilder

Asserts that functions are annotated with the annotation specified by type parameter T.

inline fun <T : Annotation> PropertiesShould.beAnnotatedWith(): PropertiesRuleBuilder

Asserts that properties are annotated with annotation type parameter T.

infix fun FunctionsShould.beAnnotatedWith(annotation: KClass<out Annotation>): FunctionsRuleBuilder

Asserts that functions are annotated with the specified annotation class.

infix fun PropertiesShould.beAnnotatedWith(annotation: KClass<out Annotation>): PropertiesRuleBuilder

Asserts that properties are annotated with annotation.

beAssignableFrom

inline fun <T : Any> ClassesShould.beAssignableFrom(): ClassesRuleBuilder

Asserts that classes are assignable from type parameter T.

infix fun ClassesShould.beAssignableFrom(subType: KClass<*>): ClassesRuleBuilder

Asserts that classes are assignable from the specified subType.

inline fun <T : Any> ClassesShould.beAssignableTo(): ClassesRuleBuilder

Asserts that classes are assignable to type parameter T.

infix fun ClassesShould.beAssignableTo(superType: KClass<*>): ClassesRuleBuilder

Asserts that classes are assignable to the specified superType.

beAssignableToAllOf

fun ClassesShould.beAssignableToAllOf(vararg superTypes: KClass<*>): ClassesRuleBuilder

Asserts that classes are assignable to all of the specified superTypes.

beAssignableToAnyOf

fun ClassesShould.beAssignableToAnyOf(vararg superTypes: KClass<*>): ClassesRuleBuilder

Asserts that classes are assignable to any of the specified superTypes.

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

Filters classes in this scope to normal classes.

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

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

fun Konture.classes(sourceSets: SourceSetSelector): ClassesRuleBuilder

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

Filter or assertion criteria for classes.

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.

fun Konture.classScope(sourceSets: SourceSetSelector): KontureScope

Filter or assertion criteria for class scope.

classScopeFromModule

fun Konture.classScopeFromModule(path: String): KontureScope

fun Konture.classScopeFromModule(path: String, sourceSets: SourceSetSelector): KontureScope

Filter or assertion criteria for class scope from module.

classScopeFromPackage

fun Konture.classScopeFromPackage(packageName: String): KontureScope

Synonym for scopeFromPackage retrieving a class-level functional KontureScope.

fun Konture.classScopeFromPackage(packageName: String, sourceSets: SourceSetSelector): KontureScope

Synonym for scopeFromPackage retrieving a class-level functional KontureScope with source set filter.

inline fun <T : Any> ModulesShould.containClass(): ModulesRuleBuilder

Asserts that modules contain the class specified by type parameter T.

inline fun <T : Any> ModulesThat.containClass(): ModulesRuleBuilder

Filters modules containing the class specified by type parameter T.

containClassesWithAnnotation

inline fun <T : Annotation> ModulesShould.containClassesWithAnnotation(): ModulesRuleBuilder

Asserts that modules contain classes annotated with annotation type parameter T.

inline fun <T : Annotation> ModulesThat.containClassesWithAnnotation(): ModulesRuleBuilder

Filters modules containing classes annotated with annotation type parameter T.

inline fun <T : Annotation> SlicesShould.containClassesWithAnnotation(): SlicesRuleBuilder

Asserts that slices contain classes with annotation type parameter T.

containingClass

fun KontureFileScope.containingClass(fqName: String): KontureFileScope

Filters files in this scope to include only those containing class fqName.

fun KontureFileScope.containingClass(type: KClass<*>): KontureFileScope

Filters files in this scope to include only those containing class type.

containsClassWith

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

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

fun KontureScope.dataClasses(): KontureScope

Filters classes in this scope to data classes.

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

Filters class declarations to data classes.

dependingOnModule

fun List<Module>.dependingOnModule(targetModulePath: String): List<Module>

Filters modules that depend on targetModulePath.

dependOnPackageOf

inline fun <T : Any> FunctionsShould.dependOnPackageOf(): FunctionsRuleBuilder

Asserts that functions depend on package of T.

inline fun <T : Any> FunctionsThat.dependOnPackageOf(): FunctionsRuleBuilder

Filters functions depending on package of T.

inline fun <T : Any> PropertiesShould.dependOnPackageOf(): PropertiesRuleBuilder

Asserts that properties depend on package of T.

inline fun <T : Any> PropertiesThat.dependOnPackageOf(): PropertiesRuleBuilder

Filters properties depending on package of T.

extensionFunctions

fun KontureFunctionScope.extensionFunctions(): KontureFunctionScope

Filters functions in this scope to include only extension functions.

fun List<FunctionDeclarationContext>.extensionFunctions(): List<FunctionDeclarationContext>

Filters the list of functions to include only extension functions.

extensionProperties

fun KonturePropertyScope.extensionProperties(): KonturePropertyScope

Filters properties in this scope to include only extension properties.

fun List<PropertyDeclarationContext>.extensionProperties(): List<PropertyDeclarationContext>

Filters the list of properties to include only extension properties.

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(sourceSets: SourceSetSelector): FilesRuleBuilder

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

Filter or assertion criteria for files.

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.

fun Konture.fileScope(sourceSets: SourceSetSelector): KontureFileScope

Filter or assertion criteria for file scope.

fileScopeFromModule

fun Konture.fileScopeFromModule(path: String): KontureFileScope

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

fun Konture.fileScopeFromModule(path: String, sourceSets: SourceSetSelector): KontureFileScope

Filter or assertion criteria for file scope from module.

fileScopeFromPackage

fun Konture.fileScopeFromPackage(packageName: String): KontureFileScope

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

fun Konture.fileScopeFromPackage(packageName: String, sourceSets: SourceSetSelector): KontureFileScope

Filter or assertion criteria for file scope from package.

fileScopeFromPackageOf

inline fun <T : Any> Konture.fileScopeFromPackageOf(): KontureFileScope

Obtains a file scope containing files in the package of type parameter T.

fun Konture.fileScopeFromPackageOf(type: KClass<*>): KontureFileScope

Obtains a file scope containing files in the package of type.

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(sourceSets: SourceSetSelector): FunctionsRuleBuilder

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

Filter or assertion criteria for 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.

fun Konture.functionScope(sourceSets: SourceSetSelector): KontureFunctionScope

Filter or assertion criteria for function scope.

functionScopeFromModule

fun Konture.functionScopeFromModule(path: String): KontureFunctionScope

Retrieves a function-level functional KontureFunctionScope scoped to a specific module path.

fun Konture.functionScopeFromModule(path: String, sourceSets: SourceSetSelector): KontureFunctionScope

Retrieves a function-level functional KontureFunctionScope scoped to a specific module path and source set.

functionScopeFromPackage

fun Konture.functionScopeFromPackage(packageName: String): KontureFunctionScope

Retrieves a function-level functional KontureFunctionScope scoped to a specific package name.

fun Konture.functionScopeFromPackage(packageName: String, sourceSets: SourceSetSelector): KontureFunctionScope

Retrieves a function-level functional KontureFunctionScope scoped to a specific package name and source set.

functionScopeFromPackageOf

inline fun <T : Any> Konture.functionScopeFromPackageOf(): KontureFunctionScope

Obtains a function scope containing functions in the package of type parameter T.

fun Konture.functionScopeFromPackageOf(type: KClass<*>): KontureFunctionScope

Obtains a function scope containing functions in the package of type.

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.

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.

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.

haveAllAnnotationsOf

fun FunctionsShould.haveAllAnnotationsOf(vararg annotations: KClass<out Annotation>): FunctionsRuleBuilder

Asserts that functions have all of the specified annotations.

fun FunctionsThat.haveAllAnnotationsOf(vararg annotations: KClass<out Annotation>): FunctionsRuleBuilder

Filters functions having all of the specified annotations.

fun PropertiesShould.haveAllAnnotationsOf(vararg annotations: KClass<out Annotation>): PropertiesRuleBuilder

Asserts that properties have all of the specified annotations.

fun PropertiesThat.haveAllAnnotationsOf(vararg annotations: KClass<out Annotation>): PropertiesRuleBuilder

Filters properties having all of the specified annotations.

haveAnnotationOf

inline fun <T : Annotation> FunctionsThat.haveAnnotationOf(): FunctionsRuleBuilder

Filters functions having annotation specified by annotation type parameter T.

inline fun <T : Annotation> PropertiesThat.haveAnnotationOf(): PropertiesRuleBuilder

Filters properties having annotation specified by annotation type parameter T.

fun FunctionAssertionScope.haveAnnotationOf(annotation: KClass<out Annotation>)

Asserts that functions in this assertion scope have the specified annotation class.

infix fun FunctionsShould.haveAnnotationOf(annotation: KClass<out Annotation>): FunctionsRuleBuilder

Asserts that functions have the specified annotation class.

infix fun FunctionsThat.haveAnnotationOf(annotation: KClass<out Annotation>): FunctionsRuleBuilder

Filters functions having the specified annotation class.

infix fun PropertiesShould.haveAnnotationOf(annotation: KClass<out Annotation>): PropertiesRuleBuilder

Asserts that properties have the specified annotation class.

infix fun PropertiesThat.haveAnnotationOf(annotation: KClass<out Annotation>): PropertiesRuleBuilder

Filters properties having the specified annotation class.

fun PropertyAssertionScope.haveAnnotationOf(annotation: KClass<out Annotation>)

Asserts that properties in this assertion scope have the specified annotation class.

haveAnnotationOfType

inline fun <T : Annotation> FunctionAssertionScope.haveAnnotationOfType()

Asserts that functions in this assertion scope have the annotation specified by T.

inline fun <T : Annotation> FunctionsShould.haveAnnotationOfType(): FunctionsRuleBuilder

Asserts that functions have the annotation type parameter T.

inline fun <T : Annotation> FunctionsThat.haveAnnotationOfType(): FunctionsRuleBuilder

Filters functions having the annotation type parameter T.

inline fun <T : Annotation> PropertiesShould.haveAnnotationOfType(): PropertiesRuleBuilder

Asserts that properties have annotation type parameter T.

inline fun <T : Annotation> PropertiesThat.haveAnnotationOfType(): PropertiesRuleBuilder

Filters properties having annotation type parameter T.

inline fun <T : Annotation> PropertyAssertionScope.haveAnnotationOfType()

Asserts that properties in this assertion scope have the annotation specified by T.

haveAnnotationWithArgument

fun ClassesShould.haveAnnotationWithArgument(annotation: KClass<out Annotation>, argName: String?, argValue: String): ClassesRuleBuilder

Asserts that classes have an annotation annotation with argument argName equal to argValue.

fun ClassesThat.haveAnnotationWithArgument(annotation: KClass<out Annotation>, argName: String?, argValue: String): ClassesRuleBuilder

Filters classes having an annotation annotation with argument argName equal to argValue.

fun FunctionsShould.haveAnnotationWithArgument(annotation: KClass<out Annotation>, argName: String?, argValue: String): FunctionsRuleBuilder

Asserts that functions have an annotation annotation with an argument argName equal to argValue.

fun FunctionsThat.haveAnnotationWithArgument(annotation: KClass<out Annotation>, argName: String?, argValue: String): FunctionsRuleBuilder

Filters functions having an annotation annotation with an argument argName equal to argValue.

fun PropertiesShould.haveAnnotationWithArgument(annotation: KClass<out Annotation>, argName: String?, argValue: String): PropertiesRuleBuilder

Asserts that properties have an annotation annotation with argument argName equal to argValue.

fun PropertiesThat.haveAnnotationWithArgument(annotation: KClass<out Annotation>, argName: String?, argValue: String): PropertiesRuleBuilder

Filters properties having an annotation annotation with argument argName equal to argValue.

haveAnyAnnotationOf

fun FunctionsShould.haveAnyAnnotationOf(vararg annotations: KClass<out Annotation>): FunctionsRuleBuilder

Asserts that functions have any of the specified annotations.

fun FunctionsThat.haveAnyAnnotationOf(vararg annotations: KClass<out Annotation>): FunctionsRuleBuilder

Filters functions having any of the specified annotations.

fun PropertiesShould.haveAnyAnnotationOf(vararg annotations: KClass<out Annotation>): PropertiesRuleBuilder

Asserts that properties have any of the specified annotations.

fun PropertiesThat.haveAnyAnnotationOf(vararg annotations: KClass<out Annotation>): PropertiesRuleBuilder

Filters properties having any of the specified annotations.

haveAnyParameterTypeOf

inline fun <T : Any> FunctionsShould.haveAnyParameterTypeOf(): FunctionsRuleBuilder

Asserts that selected functions have a parameter of raw type T.

inline fun <T : Any> PropertiesShould.haveImportOf(): PropertiesRuleBuilder

Asserts that properties have an import of type parameter T.

inline fun <T : Any> PropertiesThat.haveImportOf(): PropertiesRuleBuilder

Filters properties that have an import of type parameter T.

haveNameEndingWith

fun KontureFileScope.haveNameEndingWith(suffix: String): KontureFileScope

Filter or assertion criteria for have name ending with.

fun KontureFunctionScope.haveNameEndingWith(suffix: String): KontureFunctionScope

Filters functions in this scope ending with suffix.

fun KonturePropertyScope.haveNameEndingWith(suffix: String): KonturePropertyScope

Filters properties in this scope ending with suffix.

fun KontureScope.haveNameEndingWith(suffix: String): KontureScope

Filters classes in this scope ending with suffix.

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

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

@JvmName(name = "haveFileNameEndingWith")

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

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

fun List<FunctionDeclarationContext>.haveNameEndingWith(suffix: String): List<FunctionDeclarationContext>

Filters the list of functions to include only those whose names end with suffix.

fun List<PropertyDeclarationContext>.haveNameEndingWith(suffix: String): List<PropertyDeclarationContext>

Filters the list of properties to include only those whose names end with suffix.

haveNameStartingWith

fun KontureFileScope.haveNameStartingWith(prefix: String): KontureFileScope

Filter or assertion criteria for have name starting with.

fun KontureFunctionScope.haveNameStartingWith(prefix: String): KontureFunctionScope

Filters functions in this scope starting with prefix.

fun KonturePropertyScope.haveNameStartingWith(prefix: String): KonturePropertyScope

Filters properties in this scope starting with prefix.

fun KontureScope.haveNameStartingWith(prefix: String): KontureScope

Filters classes in this scope starting with prefix.

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

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

@JvmName(name = "haveFileNameStartingWith")

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

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

fun List<FunctionDeclarationContext>.haveNameStartingWith(prefix: String): List<FunctionDeclarationContext>

Filters the list of functions to include only those whose names start with prefix.

fun List<PropertyDeclarationContext>.haveNameStartingWith(prefix: String): List<PropertyDeclarationContext>

Filters the list of properties to include only those whose names start with prefix.

haveParameterOf

@JvmName(name = "haveParameterOfKClasses")

infix fun FunctionsThat.haveParameterOf(types: List<KClass<*>>): FunctionsRuleBuilder

Filters functions having parameters of the specified types.

inline fun <T : Any> FunctionsThat.haveReturnType(): FunctionsRuleBuilder

Filters functions having return type specified by type parameter T.

fun FunctionAssertionScope.haveReturnType(type: KClass<*>)

Asserts that functions in this assertion scope have the specified return type.

haveReturnTypeOf

inline fun <T : Any> FunctionAssertionScope.haveReturnTypeOf()

Asserts that functions in this assertion scope have the return type specified by T.

inline fun <T : Any> FunctionsShould.haveReturnTypeOf(): FunctionsRuleBuilder

Asserts that selected functions have the specified raw return type.

fun PropertyAssertionScope.haveType(type: KClass<*>)

Asserts that properties in this assertion scope have the specified type type.

inline fun <T : Any> PropertiesShould.haveTypeOf(): PropertiesRuleBuilder

Asserts that properties have type specified by type parameter T.

inline fun <T : Any> PropertyAssertionScope.haveTypeOf()

Asserts that properties in this assertion scope have the type specified by T.

fun KontureScope.inlineClasses(): KontureScope

Filters classes in this scope to inline/value classes.

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

Filters class declarations to inline/value classes.

fun FileSelector.inPackage(packagePattern: String): FileSelector

Filters this file selector to include files residing in packages matching the specified pattern.

fun FunctionSelector.inPackage(packagePattern: String): FunctionSelector

Filters this function selector to include functions residing in packages matching the specified pattern.

fun ModuleSelector.inPackage(packagePattern: String): ModuleSelector

Filters this module selector to include modules residing in packages matching the specified pattern.

fun PropertySelector.inPackage(packagePattern: String): PropertySelector

Filters this property selector to include properties residing in packages matching the specified pattern.

fun ClassSelector.inPackage(packagePattern: String): ClassSelector

Filters this class selector to include classes residing in packages matching the specified pattern.

inline fun <T : Any> ClassesShould.inPackageOf(): ClassesRuleBuilder

Asserts that classes reside in the package of type parameter T.

inline fun <T : Any> ClassesThat.inPackageOf(): ClassesRuleBuilder

Filters classes residing in the package of type parameter T.

inline fun <T : Any> FilesShould.inPackageOf(): FilesRuleBuilder

Asserts that files are in the package of the type parameter T.

inline fun <T : Any> FilesThat.inPackageOf(): FilesRuleBuilder

Filters files in the package of the type parameter T.

infix fun ClassesShould.inPackageOf(type: KClass<*>): ClassesRuleBuilder

Asserts that classes reside in the package of type.

infix fun ClassesThat.inPackageOf(type: KClass<*>): ClassesRuleBuilder

Filters classes residing in the package of type.

infix fun FilesShould.inPackageOf(type: KClass<*>): FilesRuleBuilder

Asserts that files are in the package of the specified type.

infix fun FilesThat.inPackageOf(type: KClass<*>): FilesRuleBuilder

Filters files in the package of the specified type.

fun KontureScope.interfaces(): KontureScope

Filters classes in this scope to interfaces.

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

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

fun KontureScope.internal(): KontureScope

Filters classes in this scope to internal classes.

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

Filters class declarations to internal classes.

isEnclosedInClass

fun SourceUsage.isEnclosedInClass(classFqName: String, className: String? = null): Boolean

Returns true if this usage is enclosed in the class specified by classFqName and optional className.

isEnclosedInProperty

fun SourceUsage.isEnclosedInProperty(propertyName: String, classFqName: String? = null, className: String? = null): Boolean

Returns true if this usage is enclosed in the property specified by propertyName and optional class contexts.

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.

memberFunctions

fun KontureFunctionScope.memberFunctions(): KontureFunctionScope

Filters functions in this scope to include only member/class functions.

fun List<FunctionDeclarationContext>.memberFunctions(): List<FunctionDeclarationContext>

Filters the list of functions to include only member/class functions.

memberProperties

fun KonturePropertyScope.memberProperties(): KonturePropertyScope

Filters properties in this scope to include only member/class properties.

fun List<PropertyDeclarationContext>.memberProperties(): List<PropertyDeclarationContext>

Filters the list of properties to include only member/class properties.

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

Filter or assertion criteria for minus.

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

Subtracts the functions present in other from this KontureFunctionScope.

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

Removes modules present in other scope from this scope by path.

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

Subtracts the properties present in other from this KonturePropertyScope.

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

Subtracts classes present in other scope from this scope.

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

Removes slices present in other scope from this scope by key.

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(sourceSets: SourceSetSelector): ModulesRuleBuilder

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

Filter or assertion criteria for modules.

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.

fun Konture.moduleScope(): KontureModuleScope

fun Konture.moduleScope(sourceSets: SourceSetSelector): KontureModuleScope

Filter or assertion criteria for module scope.

moduleScopeFromModule

fun Konture.moduleScopeFromModule(pattern: String): KontureModuleScope

Retrieves a module-level functional KontureModuleScope scoped to a specific module path or pattern.

fun Konture.moduleScopeFromModule(pattern: String, sourceSets: SourceSetSelector): KontureModuleScope

Filter or assertion criteria for module scope from module.

inline fun <T : Any> ClassesShould.notCall(): ClassesRuleBuilder

Fails for every invocation of type T in the selected class.

inline fun <T : Any> FilesShould.notCall(): FilesRuleBuilder

Asserts that files do not call members of type parameter T.

inline fun <T : Any> FunctionsShouldCallAssertions.notCall(): FunctionsRuleBuilder

Fails when the selected function invokes T.

inline fun <T : Any> ModulesShould.notCall(): ModulesRuleBuilder

Asserts that modules do not call members of type parameter T.

inline fun <T : Any> PropertiesShould.notCall(): PropertiesRuleBuilder

Asserts that properties do not call members of type parameter T.

inline fun <T : Any> SlicesShould.notCall(): SlicesRuleBuilder

Asserts that slices do not call members of type parameter T.

notContainClass

inline fun <T : Any> FilesThat.notContainClass(): FilesRuleBuilder

Filters files that do not contain a class matching type parameter T.

inline fun <T : Any> ModulesShould.notContainClass(): ModulesRuleBuilder

Asserts that modules do not contain the class specified by type parameter T.

inline fun <T : Any> ModulesThat.notContainClass(): ModulesRuleBuilder

Filters modules that do not contain the class specified by type parameter T.

inline fun <T : Any> SlicesShould.notContainClass(): SlicesRuleBuilder

Asserts that slices do not contain the class specified by type parameter T.

notContainClassesWithAnnotation

inline fun <T : Annotation> FilesThat.notContainClassesWithAnnotation(): FilesRuleBuilder

Filters files that do not contain classes annotated with annotation type parameter T.

inline fun <T : Annotation> ModulesShould.notContainClassesWithAnnotation(): ModulesRuleBuilder

Asserts that modules do not contain classes annotated with annotation type parameter T.

inline fun <T : Annotation> ModulesThat.notContainClassesWithAnnotation(): ModulesRuleBuilder

Filters modules that do not contain classes annotated with annotation type parameter T.

inline fun <T : Annotation> SlicesShould.notContainClassesWithAnnotation(): SlicesRuleBuilder

Asserts that slices do not contain classes annotated with annotation type parameter T.

notDependOnClass

inline fun <T : Any> ClassesShould.notDependOnClass(): ClassesRuleBuilder

Asserts that classes do not depend on class type parameter T.

notDependOnPackageOf

inline fun <T : Any> FunctionsShould.notDependOnPackageOf(): FunctionsRuleBuilder

Asserts that functions do not depend on package of T.

inline fun <T : Any> FunctionsThat.notDependOnPackageOf(): FunctionsRuleBuilder

Filters functions not depending on package of T.

inline fun <T : Any> PropertiesShould.notDependOnPackageOf(): PropertiesRuleBuilder

Asserts that properties do not depend on package of T.

inline fun <T : Any> PropertiesThat.notDependOnPackageOf(): PropertiesRuleBuilder

Filters properties not depending on package of T.

infix fun FunctionsThat.notDependOnPackageOf(type: KClass<*>): FunctionsRuleBuilder

Filters functions not depending on package of type.

infix fun PropertiesThat.notDependOnPackageOf(type: KClass<*>): PropertiesRuleBuilder

Filters properties not depending on package of type.

notHaveImportOf

inline fun <T : Any> FilesThat.notHaveImportOf(): FilesRuleBuilder

Filters files that do not have an import of the type parameter T.

inline fun <T : Any> PropertiesShould.notHaveImportOf(): PropertiesRuleBuilder

Asserts that properties do not have an import of type parameter T.

inline fun <T : Any> PropertiesThat.notHaveImportOf(): PropertiesRuleBuilder

Filters properties that do not have an import of type parameter T.

notHaveParameterOf

inline fun <T : Any> FunctionsThat.notHaveParameterOf(): FunctionsRuleBuilder

Filters functions that do not have a parameter of type specified by type parameter T.

notHaveReturnType

inline fun <T : Any> FunctionsThat.notHaveReturnType(): FunctionsRuleBuilder

Filters functions that do not have return type specified by type parameter T.

notReferenceClass

inline fun <T : Any> ClassesShould.notReferenceClass(): ClassesRuleBuilder

Fails for every actual class/type use of type T in the selected class; imports alone do not match.

inline fun <T : Any> FilesShould.notReferenceClass(): FilesRuleBuilder

Asserts that files do not reference class type parameter T.

inline fun <T : Any> FunctionsShouldCallAssertions.notReferenceClass(): FunctionsRuleBuilder

Fails for every actual class/type use of T in the selected function.

inline fun <T : Any> ModulesShould.notReferenceClass(): ModulesRuleBuilder

Asserts that modules do not reference class type parameter T.

inline fun <T : Any> PropertiesShould.notReferenceClass(): PropertiesRuleBuilder

Asserts that properties do not reference class type parameter T.

inline fun <T : Any> SlicesShould.notReferenceClass(): SlicesRuleBuilder

Asserts that slices do not reference class type parameter T.

onlyDependOnPackageOf

inline fun <T : Any> FunctionsShould.onlyDependOnPackageOf(): FunctionsRuleBuilder

Asserts that functions only depend on package of T.

inline fun <T : Any> PropertiesShould.onlyDependOnPackageOf(): PropertiesRuleBuilder

Asserts that properties only depend on package of T.

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

Filter or assertion criteria for plus.

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

Combines two KontureFunctionScope scopes into a single unified scope.

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

Combines two module scopes into a new scope containing distinct modules by path.

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

Combines two KonturePropertyScope scopes into a single unified scope.

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

Combines two KontureScope instances into a new scope containing classes from both.

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

Combines two slice scopes into a new scope containing distinct slices by key.

fun KontureScope.private(): KontureScope

Filters classes in this scope to private classes.

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

Filters class declarations to private classes.

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(sourceSets: SourceSetSelector): PropertiesRuleBuilder

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

Filter or assertion criteria for 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.

fun Konture.propertyScope(sourceSets: SourceSetSelector): KonturePropertyScope

Filter or assertion criteria for property scope.

propertyScopeFromModule

fun Konture.propertyScopeFromModule(path: String): KonturePropertyScope

Retrieves a property-level functional KonturePropertyScope scoped to a specific module path.

fun Konture.propertyScopeFromModule(path: String, sourceSets: SourceSetSelector): KonturePropertyScope

Retrieves a property-level functional KonturePropertyScope scoped to a specific module path and source set.

propertyScopeFromPackage

fun Konture.propertyScopeFromPackage(packageName: String): KonturePropertyScope

Retrieves a property-level functional KonturePropertyScope scoped to a specific package name.

fun Konture.propertyScopeFromPackage(packageName: String, sourceSets: SourceSetSelector): KonturePropertyScope

Retrieves a property-level functional KonturePropertyScope scoped to a specific package name and source set.

propertyScopeFromPackageOf

inline fun <T : Any> Konture.propertyScopeFromPackageOf(): KonturePropertyScope

Obtains a property scope containing properties in the package of type parameter T.

fun Konture.propertyScopeFromPackageOf(type: KClass<*>): KonturePropertyScope

Obtains a property scope containing properties in the package of type.

fun KontureScope.protected(): KontureScope

Filters classes in this scope to protected classes.

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

Filters class declarations to protected classes.

fun KontureScope.public(): KontureScope

Filters classes in this scope to public classes.

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

Filters class declarations to public classes.

resideInAPackage

fun KontureFileScope.resideInAPackage(packagePattern: String): KontureFileScope

Filter or assertion criteria for reside in a package.

fun KontureFunctionScope.resideInAPackage(packagePattern: String): KontureFunctionScope

Filters functions in this scope residing in packages matching packagePattern.

fun KonturePropertyScope.resideInAPackage(packagePattern: String): KonturePropertyScope

Filters properties in this scope residing in packages matching packagePattern.

fun KontureScope.resideInAPackage(packagePattern: String): KontureScope

Filters classes in this scope residing in packages matching packagePattern.

fun List<ClassDeclaration>.resideInAPackage(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 = "resideInFileAPackage")

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

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

fun List<FunctionDeclarationContext>.resideInAPackage(packagePattern: String): List<FunctionDeclarationContext>

Filters the list of functions to include only those residing in packages matching packagePattern.

fun List<PropertyDeclarationContext>.resideInAPackage(packagePattern: String): List<PropertyDeclarationContext>

Filters the list of properties to include only those residing in packages matching packagePattern.

resideInPackageOf

inline fun <T : Any> FunctionsShould.resideInPackageOf(): FunctionsRuleBuilder

Asserts that functions reside in the package of the type parameter T.

inline fun <T : Any> FunctionsThat.resideInPackageOf(): FunctionsRuleBuilder

Filters functions residing in the package of the type parameter T.

inline fun <T : Any> PropertiesShould.resideInPackageOf(): PropertiesRuleBuilder

Asserts that properties reside in the package of type parameter T.

inline fun <T : Any> PropertiesThat.resideInPackageOf(): PropertiesRuleBuilder

Filters properties residing in the package of type parameter T.

infix fun FunctionsShould.resideInPackageOf(type: KClass<*>): FunctionsRuleBuilder

Asserts that functions reside in the package of the specified type.

infix fun FunctionsThat.resideInPackageOf(type: KClass<*>): FunctionsRuleBuilder

Filters functions residing in the package of the specified type.

infix fun PropertiesShould.resideInPackageOf(type: KClass<*>): PropertiesRuleBuilder

Asserts that properties reside in the package of type.

infix fun PropertiesThat.resideInPackageOf(type: KClass<*>): PropertiesRuleBuilder

Filters properties residing in the package of type.

residingInModule

fun List<FileDeclarationContext>.residingInModule(modulePath: String): List<FileDeclarationContext>

Filters files residing in a module matching modulePath.

fun List<FunctionDeclarationContext>.residingInModule(modulePath: String): List<FunctionDeclarationContext>

Filters functions residing in a module matching modulePath.

fun List<PropertyDeclarationContext>.residingInModule(modulePath: String): List<PropertyDeclarationContext>

Filters properties residing in a module matching modulePath.

residingInPackage

fun List<FileDeclarationContext>.residingInPackage(packagePattern: String): List<FileDeclarationContext>

Filters files residing in a package matching packagePattern.

fun List<FunctionDeclarationContext>.residingInPackage(packagePattern: String): List<FunctionDeclarationContext>

Filters functions residing in a package matching packagePattern.

fun List<PropertyDeclarationContext>.residingInPackage(packagePattern: String): List<PropertyDeclarationContext>

Filters properties residing in a package matching packagePattern.

fun rule(id: String, block: RuleBuilder.() -> Unit): RuleDefinition

Top-level builder function for defining a named architecture rule with metadata and assertions.

fun Konture.scope(sourceSets: SourceSetSelector): KontureScope

Filter or assertion criteria for scope.

scopeFromModule

fun Konture.scopeFromModule(path: String): KontureScope

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

fun Konture.scopeFromModule(path: String, sourceSets: SourceSetSelector): KontureScope

Filter or assertion criteria for scope from module.

scopeFromPackage

fun Konture.scopeFromPackage(packageName: String): KontureScope

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

fun Konture.scopeFromPackage(packageName: String, sourceSets: SourceSetSelector): KontureScope

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

scopeFromPackageOf

inline fun <T : Any> Konture.scopeFromPackageOf(): KontureScope

Obtains a scope containing all files and declarations in the package of type parameter T.

fun Konture.scopeFromPackageOf(type: KClass<*>): KontureScope

Obtains a scope containing all files and declarations in the package of type.

fun KontureScope.sealedClasses(): KontureScope

Filters classes in this scope to sealed classes.

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

Filters class declarations to sealed classes.

fun FileSelector.should(): FileSelectorShould

Returns a fluent assertion scope for sequential assertions on this FileSelector.

fun FunctionSelector.should(): FunctionSelectorShould

Returns a fluent assertion scope for sequential assertions on this FunctionSelector.

fun ModuleSelector.should(): ModuleSelectorShould

Returns a fluent assertion scope for sequential assertions on this ModuleSelector.

fun PropertySelector.should(): PropertySelectorShould

Returns a fluent assertion scope for sequential assertions on this PropertySelector.

fun ClassSelector.should(): ClassSelectorShould

Returns a fluent assertion scope for sequential assertions on this ClassSelector.

fun SliceSelector.should(): SliceSelectorShould

Returns a fluent assertion scope for sequential assertions on this SliceSelector.

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.

fun SlicesRuleBuilder.should(assertion: SliceShouldContext.() -> Any?): SlicesRuleBuilder

Asserts rules on slices using a lambda block that provides a SliceShouldContext receiver.

fun Konture.slices(): SlicesRuleBuilder

Access the slice declarative assertion rule builder. Groups packages into slices by a capture-group pattern and asserts relationships between them, such as cycle-freedom.

fun Konture.slices(sourceSets: SourceSetSelector): SlicesRuleBuilder

fun Konture.slices(sourceSets: SourceSetSelector, block: SlicesRuleBuilder.() -> Unit)

Filter or assertion criteria for slices.

fun Konture.slices(block: SlicesRuleBuilder.() -> Unit)

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

fun Konture.sliceScope(pattern: String): KontureSliceScope

Retrieves a slice-level functional KontureSliceScope derived from a package pattern.

fun Konture.sliceScope(pattern: String, sourceSets: SourceSetSelector): KontureSliceScope

Filter or assertion criteria for slice scope.

sliceScopeFromModule

fun Konture.sliceScopeFromModule(pattern: String, modulePath: String): KontureSliceScope

Retrieves a slice-level functional KontureSliceScope derived from a module pattern.

fun Konture.sliceScopeFromModule(pattern: String, modulePath: String, sourceSets: SourceSetSelector): KontureSliceScope

Retrieves a slice-level functional KontureSliceScope derived from a module pattern and source set.

sliceScopeFromPackage

fun Konture.sliceScopeFromPackage(pattern: String, packageName: String): KontureSliceScope

Retrieves a slice-level functional KontureSliceScope derived from a package pattern.

fun Konture.sliceScopeFromPackage(pattern: String, packageName: String, sourceSets: SourceSetSelector): KontureSliceScope

Retrieves a slice-level functional KontureSliceScope derived from a package pattern and source set.

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.

fun SlicesRuleBuilder.that(predicate: Slice.() -> Boolean): SlicesRuleBuilder

Filters slices in this rule using a concise lambda predicate evaluated on each Slice.

topLevelFunctions

fun KontureFunctionScope.topLevelFunctions(): KontureFunctionScope

Filters functions in this scope to include only top-level functions.

fun List<FunctionDeclarationContext>.topLevelFunctions(): List<FunctionDeclarationContext>

Filters the list of functions to include only top-level functions.

topLevelProperties

fun KonturePropertyScope.topLevelProperties(): KonturePropertyScope

Filters properties in this scope to include only top-level properties.

fun List<PropertyDeclarationContext>.topLevelProperties(): List<PropertyDeclarationContext>

Filters the list of properties to include only top-level properties.

fun SourceSet.toSourceSetId(modulePath: String): SourceSetId

Converts this SourceSet to a SourceSetId for the specified modulePath.

fun KonturePropertyScope.valProperties(): KonturePropertyScope

Filters properties in this scope to include only read-only (val) properties.

fun List<PropertyDeclarationContext>.valProperties(): List<PropertyDeclarationContext>

Filters the list of properties to include only read-only (val) properties.

fun KonturePropertyScope.varProperties(): KonturePropertyScope

Filters properties in this scope to include only mutable (var) properties.

fun List<PropertyDeclarationContext>.varProperties(): List<PropertyDeclarationContext>

Filters the list of properties to include only mutable (var) properties.

withAnnotationOf

inline fun <T : Annotation> KontureScope.withAnnotationOf(): KontureScope

Filters classes in a KontureScope returning those with annotation type parameter T.

inline fun <T : Annotation> List<ClassDeclaration>.withAnnotationOf(): List<ClassDeclaration>

Filters a list of class declarations returning those with annotation type parameter T.

fun KontureFunctionScope.withAnnotationOf(annotationName: String): KontureFunctionScope

Filters functions in this scope to include only those with annotation annotationName.

fun KontureScope.withAnnotationOf(annotationFqName: String): KontureScope

Filters classes in this scope with annotation annotationFqName.

fun KontureScope.withAnnotationOf(annotation: KClass<out Annotation>): KontureScope

Filters classes in a KontureScope returning those with annotation annotation.

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

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

fun List<ClassDeclaration>.withAnnotationOf(annotation: KClass<out Annotation>): List<ClassDeclaration>

Filters a list of class declarations returning those with annotation annotation.

fun KontureFileScope.withImportOf(importPath: String): KontureFileScope

Filters files in this scope to include only those with import matching importPath.

fun KontureFileScope.withImportOf(type: KClass<*>): KontureFileScope

Filters files in this scope to include only those with import of class type.

fun KontureScope.withModifier(modifier: Modifier): KontureScope

Filters classes in this scope with modifier.

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

Filters class declarations to those containing the specified modifier.

fun KontureFunctionScope.withModule(modulePath: String): KontureFunctionScope

Filters functions in this scope to include only those residing in module modulePath.

fun KonturePropertyScope.withModule(modulePath: String): KonturePropertyScope

Filters properties in this scope to include only those residing in module modulePath.

fun List<FunctionDeclarationContext>.withModule(modulePath: String): List<FunctionDeclarationContext>

Filters the list of functions to include only those residing in module modulePath.

fun List<PropertyDeclarationContext>.withModule(modulePath: String): List<PropertyDeclarationContext>

Filters the list of properties to include only those residing in module modulePath.

fun KontureFileScope.withModule(modulePath: String, graph: ProjectGraph = Konture.projectGraph): KontureFileScope

Filter or assertion criteria for with module.

fun KontureScope.withModule(modulePath: String, graph: ProjectGraph = Konture.projectGraph): KontureScope

Filters classes in this scope residing in module modulePath.

fun FileSelector.withName(pattern: String): FileSelector

Filters this file selector to include files whose names match the specified pattern.

fun FunctionSelector.withName(pattern: String): FunctionSelector

Filters this function selector to include functions whose names match the specified pattern.

fun ModuleSelector.withName(pattern: String): ModuleSelector

Filters this module selector to include modules whose path matches the specified pattern.

fun PropertySelector.withName(pattern: String): PropertySelector

Filters this property selector to include properties whose names match the specified pattern.

fun ClassSelector.withName(pattern: String): ClassSelector

Filters this class selector to include classes whose simple names match the specified pattern.

fun SliceSelector.withName(pattern: String): SliceSelector

Filters this slice selector to include slices whose names match the specified pattern.

withNameMatching

fun KontureFileScope.withNameMatching(pattern: String): KontureFileScope

Filter or assertion criteria for with name matching.

fun KontureFunctionScope.withNameMatching(pattern: String): KontureFunctionScope

Filters functions in this scope matching glob pattern pattern.

fun KonturePropertyScope.withNameMatching(pattern: String): KonturePropertyScope

Filters properties in this scope matching glob pattern pattern.

fun KontureScope.withNameMatching(pattern: String): KontureScope

Filters classes in this scope matching name pattern pattern.

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.

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

Filters the list of functions to include only those matching the glob pattern pattern.

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

Filters the list of properties to include only those matching the glob pattern pattern.

withoutAnnotationOf

inline fun <T : Annotation> KontureScope.withoutAnnotationOf(): KontureScope

Filters classes in a KontureScope returning those without annotation type parameter T.

inline fun <T : Annotation> List<ClassDeclaration>.withoutAnnotationOf(): List<ClassDeclaration>

Filters a list of class declarations returning those without annotation type parameter T.

fun KontureScope.withoutAnnotationOf(annotationFqName: String): KontureScope

Filters classes in this scope without annotation annotationFqName.

fun KontureScope.withoutAnnotationOf(annotation: KClass<out Annotation>): KontureScope

Filters classes in a KontureScope returning those without annotation annotation.

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

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

fun List<ClassDeclaration>.withoutAnnotationOf(annotation: KClass<out Annotation>): List<ClassDeclaration>

Filters a list of class declarations returning those without annotation annotation.

withParameterOf

fun KontureFunctionScope.withParameterOf(paramType: String): KontureFunctionScope

Filters functions in this scope to include only those with parameter of type paramType.

inline fun <T : Any> KontureScope.withParentOf(): KontureScope

Filters classes in a KontureScope returning those with parent type parameter T.

inline fun <T : Any> List<ClassDeclaration>.withParentOf(): List<ClassDeclaration>

Filters a list of class declarations returning those extending or implementing type parameter T.

fun KontureScope.withParentOf(fqName: String): KontureScope

Filters classes in this scope with parent fqName.

fun KontureScope.withParentOf(type: KClass<*>): KontureScope

Filters classes in a KontureScope returning those with parent type.

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

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

fun List<ClassDeclaration>.withParentOf(type: KClass<*>): List<ClassDeclaration>

Filters a list of class declarations returning those extending or implementing type.

fun KontureFunctionScope.withReturnType(returnType: String): KontureFunctionScope

Filters functions in this scope to include only those with return type returnType.

fun KontureFunctionScope.withVisibility(visibility: Visibility): KontureFunctionScope

Filters functions in this scope to include only those with visibility visibility.

fun KontureScope.withVisibility(visibility: Visibility): KontureScope

Filters classes in this scope with visibility.

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

Filters class declarations to those matching the specified visibility.