Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Support running diktat without configuration #1837

Merged
merged 12 commits into from
Nov 30, 2023
Merged
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion .github/workflows/dependencies.yml
Original file line number Diff line number Diff line change
@@ -38,13 +38,13 @@ jobs:
use-gradlew: true
gradle-build-module: |-
:diktat-api
:diktat-common
:diktat-common-test
:diktat-ktlint-engine
:diktat-gradle-plugin
:diktat-maven-plugin
:diktat-rules
:diktat-ruleset
:diktat-runner
:diktat-dev-ksp
:diktat-cli
gradle-build-configuration: |-
16 changes: 16 additions & 0 deletions diktat-api/src/main/kotlin/com/saveourtool/diktat/Constants.kt
Original file line number Diff line number Diff line change
@@ -0,0 +1,16 @@
/**
* This file contains common constants for Diktat
*/

package com.saveourtool.diktat

/**
* Common application name, that is used in plugins and can be used to Suppress all diktat inspections on the
* particular code block with @Suppress("diktat")
*/
const val DIKTAT = "diktat"

/**
* Default file name for config file
*/
const val DIKTAT_ANALYSIS_CONF = "diktat-analysis.yml"
Original file line number Diff line number Diff line change
@@ -4,39 +4,22 @@ import com.saveourtool.diktat.api.DiktatProcessorListener
import com.saveourtool.diktat.api.DiktatReporterCreationArguments
import java.io.InputStream
import java.nio.file.Path
import kotlin.io.path.inputStream

/**
* Arguments for [DiktatRunner]
*
* @property configInputStream an input stream with config to load Diktat's rules
* @property configInputStream an input stream with config to load Diktat's rules or null to use default configs
* @property sourceRootDir a common root dir for all provided [files]
* @property files a collection of files which needs to be fixed
* @property baselineFile an optional path to file with baseline
* @property reporterArgsList list of arguments to create reporters to report result
* @property loggingListener listener to log diktat runner phases, [DiktatProcessorListener.empty] by default
*/
data class DiktatRunnerArguments(
val configInputStream: InputStream,
val configInputStream: InputStream?,
val sourceRootDir: Path?,
val files: Collection<Path>,
val baselineFile: Path?,
val reporterArgsList: List<DiktatReporterCreationArguments> = emptyList(),
val loggingListener: DiktatProcessorListener = DiktatProcessorListener.empty,
) {
constructor(
configFile: Path,
sourceRootDir: Path?,
files: Collection<Path>,
baselineFile: Path?,
reporterArgsList: List<DiktatReporterCreationArguments> = emptyList(),
loggingListener: DiktatProcessorListener = DiktatProcessorListener.empty,
) : this(
configFile.inputStream(),
sourceRootDir,
files,
baselineFile,
reporterArgsList,
loggingListener,
)
}
)
Original file line number Diff line number Diff line change
@@ -33,7 +33,7 @@ class DiktatRunnerFactory(
* @return an instance of [DiktatRunner] created using [args]
*/
override fun invoke(args: DiktatRunnerArguments): DiktatRunner {
val diktatRuleConfigs = diktatRuleConfigReader(args.configInputStream)
val diktatRuleConfigs = args.configInputStream?.let { diktatRuleConfigReader(it) }.orEmpty()
val diktatRuleSet = diktatRuleSetFactory(diktatRuleConfigs)
val processor = diktatProcessorFactory(diktatRuleSet)
val (baseline, baselineGenerator) = resolveBaseline(args.baselineFile, args.sourceRootDir)
Original file line number Diff line number Diff line change
@@ -17,3 +17,37 @@ data class DiktatRuleConfig(
val configuration: Map<String, String> = emptyMap(),
val ignoreAnnotated: Set<String> = emptySet(),
)

/**
* Finds [DiktatRuleConfig] for particular [DiktatRuleNameAware] object.
*
* @param rule a [DiktatRuleNameAware] which configuration will be returned
* @return [DiktatRuleConfig] for a particular rule if it is found, else null
*/
fun List<DiktatRuleConfig>.findByRuleName(rule: DiktatRuleNameAware): DiktatRuleConfig? = this.find { it.name == rule.ruleName() }

/**
* checking if in yml config particular rule is enabled or disabled
* (!) the default value is "true" (in case there is no config specified)
*
* @param rule a [DiktatRuleNameAware] which is being checked
* @return true if rule is enabled in configuration, else false
*/
fun List<DiktatRuleConfig>.isRuleEnabled(rule: DiktatRuleNameAware): Boolean {
val ruleMatched = findByRuleName(rule)
return ruleMatched?.enabled ?: true
}

/**
* @param rule diktat inspection
* @param annotations set of annotations that are annotating a block of code
* @return true if the code block is marked with annotation that is in `ignored list` in the rule
*/
fun List<DiktatRuleConfig>.isAnnotatedWithIgnoredAnnotation(rule: DiktatRuleNameAware, annotations: Set<String>): Boolean =
findByRuleName(rule)
?.ignoreAnnotated
?.map { it.trim() }
?.map { it.trim('"') }
?.intersect(annotations)
?.isNotEmpty()
?: false
Original file line number Diff line number Diff line change
@@ -0,0 +1,11 @@
package com.saveourtool.diktat.api

/**
* This interface represents *name* of individual inspection in rule set.
*/
interface DiktatRuleNameAware {
/**
* @return name of this [DiktatRule]
*/
fun ruleName(): String
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,20 @@
/**
* Contains typealias for legacy support
*/

package com.saveourtool.diktat.common.config.rules

import com.saveourtool.diktat.api.DiktatRuleConfig
import com.saveourtool.diktat.api.DiktatRuleNameAware

const val DIKTAT_CONF_PROPERTY = "diktat.config.path"

/**
* this constant will be used everywhere in the code to mark usage of Diktat ruleset
*
* Should be removed from Diktat's code and should be presented only in `diktat-ruleset`
*/
const val DIKTAT_RULE_SET_ID = "diktat-ruleset"

typealias RulesConfig = DiktatRuleConfig
typealias Rule = DiktatRuleNameAware
1 change: 1 addition & 0 deletions diktat-cli/build.gradle.kts
Original file line number Diff line number Diff line change
@@ -26,6 +26,7 @@ dependencies {
testImplementation(projects.diktatKtlintEngine)
testImplementation(projects.diktatRules)
testImplementation(projects.diktatCommonTest)
testImplementation(libs.kaml)
testImplementation(libs.junit.jupiter)
testImplementation(libs.junit.platform.suite)
testImplementation(libs.assertj.core)
Original file line number Diff line number Diff line change
@@ -1,13 +1,13 @@
package com.saveourtool.diktat.cli

import com.saveourtool.diktat.DIKTAT
import com.saveourtool.diktat.DIKTAT_ANALYSIS_CONF
import com.saveourtool.diktat.DiktatRunnerArguments
import com.saveourtool.diktat.ENGINE_INFO
import com.saveourtool.diktat.api.DiktatProcessorListener
import com.saveourtool.diktat.api.DiktatReporterCreationArguments
import com.saveourtool.diktat.api.DiktatReporterFactory
import com.saveourtool.diktat.api.DiktatReporterType
import com.saveourtool.diktat.common.config.rules.DIKTAT
import com.saveourtool.diktat.common.config.rules.DIKTAT_ANALYSIS_CONF
import com.saveourtool.diktat.util.isKotlinCodeOrScript
import com.saveourtool.diktat.util.tryToPathIfExists
import com.saveourtool.diktat.util.walkByGlob
@@ -22,6 +22,7 @@ import java.nio.file.Path
import java.nio.file.Paths

import kotlin.io.path.createDirectories
import kotlin.io.path.exists
import kotlin.io.path.inputStream
import kotlin.io.path.outputStream
import kotlin.system.exitProcess
@@ -86,7 +87,7 @@ data class DiktatProperties(
sourceRootDir = sourceRootDir,
)
return DiktatRunnerArguments(
configInputStream = Paths.get(config).inputStream(),
configInputStream = Paths.get(config).takeIf { it.exists() }?.inputStream(),
sourceRootDir = sourceRootDir,
files = getFiles(sourceRootDir),
baselineFile = null,
Original file line number Diff line number Diff line change
@@ -2,7 +2,7 @@ package com.saveourtool.diktat.smoke

import com.saveourtool.diktat.api.DiktatError
import com.saveourtool.diktat.ktlint.format
import com.saveourtool.diktat.ruleset.rules.DiktatRuleConfigReaderImpl
import com.saveourtool.diktat.ruleset.config.DiktatRuleConfigYamlReader
import com.saveourtool.diktat.ruleset.rules.DiktatRuleSetFactoryImpl
import com.saveourtool.diktat.test.framework.processing.TestComparatorUnit
import org.junit.jupiter.api.Assertions
@@ -42,7 +42,7 @@ class DiktatSmokeTest : DiktatSmokeTestBase() {
function = { testFile ->
format(
ruleSetSupplier = {
val diktatRuleConfigReader = DiktatRuleConfigReaderImpl()
val diktatRuleConfigReader = DiktatRuleConfigYamlReader()
val diktatRuleSetFactory = DiktatRuleSetFactoryImpl()
diktatRuleSetFactory(diktatRuleConfigReader(config.inputStream()))
},
Original file line number Diff line number Diff line change
@@ -10,13 +10,12 @@ import com.saveourtool.diktat.api.DiktatError
import com.saveourtool.diktat.common.config.rules.DIKTAT_COMMON
import com.saveourtool.diktat.common.config.rules.DIKTAT_RULE_SET_ID
import com.saveourtool.diktat.common.config.rules.RulesConfig
import com.saveourtool.diktat.common.config.rules.RulesConfigReader
import com.saveourtool.diktat.ruleset.config.DiktatRuleConfigYamlReader
import com.saveourtool.diktat.ruleset.constants.Warnings
import com.saveourtool.diktat.ruleset.constants.Warnings.EMPTY_BLOCK_STRUCTURE_ERROR
import com.saveourtool.diktat.ruleset.constants.Warnings.FILE_NAME_MATCH_CLASS
import com.saveourtool.diktat.ruleset.constants.Warnings.HEADER_MISSING_IN_NON_SINGLE_CLASS_FILE
import com.saveourtool.diktat.ruleset.constants.Warnings.KDOC_NO_EMPTY_TAGS
import com.saveourtool.diktat.ruleset.constants.Warnings.KDOC_WITHOUT_PARAM_TAG
import com.saveourtool.diktat.ruleset.constants.Warnings.MISSING_KDOC_CLASS_ELEMENTS
import com.saveourtool.diktat.ruleset.constants.Warnings.MISSING_KDOC_ON_FUNCTION
import com.saveourtool.diktat.ruleset.constants.Warnings.MISSING_KDOC_TOP_LEVEL
@@ -37,7 +36,6 @@ import com.saveourtool.diktat.ruleset.utils.indentation.IndentationConfig.Compan
import com.charleskorn.kaml.Yaml
import com.charleskorn.kaml.YamlConfiguration
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test
@@ -77,7 +75,7 @@ abstract class DiktatSmokeTestBase {
*/
@Suppress("UnsafeCallOnNullableType")
private fun prepareOverriddenRulesConfig(rulesToDisable: List<Warnings> = emptyList(), rulesToOverride: RuleToConfig = emptyMap()): Path {
val rulesConfig = RulesConfigReader().read(Paths.get(DEFAULT_CONFIG_PATH).inputStream())!!
val rulesConfig = DiktatRuleConfigYamlReader().invoke(Paths.get(DEFAULT_CONFIG_PATH).inputStream())
.toMutableList()
.also { rulesConfig ->
rulesToDisable.forEach { warning ->
1 change: 0 additions & 1 deletion diktat-common-test/build.gradle.kts
Original file line number Diff line number Diff line change
@@ -7,7 +7,6 @@ plugins {
project.description = "Diktat common for tests"

dependencies {
api(projects.diktatCommon)
implementation(libs.kotlin.logging)
implementation(libs.junit.jupiter.api)
implementation(libs.assertj.core)
19 changes: 0 additions & 19 deletions diktat-common/build.gradle.kts

This file was deleted.

This file was deleted.

This file was deleted.

8 changes: 0 additions & 8 deletions diktat-common/src/test/resources/log4j2.properties

This file was deleted.

Original file line number Diff line number Diff line change
@@ -5,6 +5,7 @@ import org.gradle.api.Action
import org.gradle.api.model.ObjectFactory
import org.gradle.api.tasks.InputFile
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.Optional
import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity
import org.gradle.api.tasks.util.PatternFilterable
@@ -51,11 +52,12 @@ open class DiktatExtension @Inject constructor(

/**
* Path to diktat yml config file. Can be either absolute or relative to project's root directory.
* Default value: `diktat-analysis.yml` in rootDir.
* Default value: `diktat-analysis.yml` in rootDir if it exists or default (empty) configuration
*/
@get:InputFile
@get:Optional
@get:PathSensitive(PathSensitivity.RELATIVE)
lateinit var diktatConfigFile: File
var diktatConfigFile: File? = null

/**
* Configure input files for diktat task
Original file line number Diff line number Diff line change
@@ -53,6 +53,7 @@ abstract class DiktatTaskBase(
/**
* Config file
*/
@get:Optional
@get:InputFile
abstract val configFile: RegularFileProperty

@@ -132,7 +133,7 @@ abstract class DiktatTaskBase(
}
}
DiktatRunnerArguments(
configInputStream = configFile.get().asFile.inputStream(),
configInputStream = configFile.map { it.asFile.inputStream() }.orNull,
sourceRootDir = sourceRootDir,
files = actualInputs.files.map { it.toPath() },
baselineFile = baselineFile.map { it.asFile.toPath() }.orNull,
@@ -203,7 +204,7 @@ abstract class DiktatTaskBase(
*/
fun TaskProvider<out DiktatTaskBase>.configure(extension: DiktatExtension) {
configure { task ->
task.configFile.set(task.project.file(extension.diktatConfigFile))
extension.diktatConfigFile?.let { diktatConfigFile -> task.configFile.set(task.project.file(diktatConfigFile)) }
extension.baseline?.let { baseline -> task.baselineFile.set(task.project.file(baseline)) }
task.ignoreFailures = extension.ignoreFailures
task.reporters.all.addAll(extension.reporters.all)
1 change: 0 additions & 1 deletion diktat-ktlint-engine/build.gradle.kts
Original file line number Diff line number Diff line change
@@ -10,7 +10,6 @@ project.description = "This module builds diktat-api implementation using ktlint

dependencies {
api(projects.diktatApi)
implementation(projects.diktatCommon)
implementation(libs.ktlint.cli.reporter.core)
implementation(libs.ktlint.rule.engine)
implementation(libs.ktlint.rule.engine.core)
Original file line number Diff line number Diff line change
@@ -87,8 +87,8 @@ abstract class DiktatBaseMojo : AbstractMojo() {
* @throws MojoExecutionException if an exception in __KtLint__ has been thrown
*/
override fun execute() {
val configFile = resolveConfig() ?: throw MojoExecutionException("Configuration file $diktatConfigFile doesn't exist")
log.info("Running diKTat plugin with configuration file $configFile and inputs $inputs" +
val configFile = resolveConfig()
log.info("Running diKTat plugin with ${configFile?.let { "configuration file $it" } ?: "default configuration" } and inputs $inputs" +
if (excludes.isNotEmpty()) " and excluding $excludes" else ""
)

@@ -104,7 +104,7 @@ abstract class DiktatBaseMojo : AbstractMojo() {

val reporterArgsList = reporters.map { it.toCreationArguments(mavenProject, sourceRootDir) }
val args = DiktatRunnerArguments(
configInputStream = configFile.inputStream(),
configInputStream = configFile?.inputStream(),
sourceRootDir = sourceRootDir,
files = files(),
baselineFile = baseline?.toPath(),
3 changes: 2 additions & 1 deletion diktat-rules/build.gradle.kts
Original file line number Diff line number Diff line change
@@ -10,10 +10,11 @@ plugins {
project.description = "The main diktat ruleset"

dependencies {
api(projects.diktatCommon)
api(projects.diktatApi)
implementation(libs.kotlin.stdlib.jdk8)
implementation(libs.kotlin.compiler.embeddable)
// kaml is used to read configs from YAML file
implementation(libs.kaml)
// guava is used for string case utils
implementation(libs.guava)
implementation(libs.kotlin.logging)
Original file line number Diff line number Diff line change
@@ -0,0 +1,35 @@
/**
* This file contains aliases to support old names and util methods
*/

package com.saveourtool.diktat.common.config.rules

import com.saveourtool.diktat.api.DiktatRuleConfig
import com.saveourtool.diktat.api.DiktatRuleNameAware
import com.saveourtool.diktat.api.findByRuleName

/**
* Name of common configuration
*/
const val DIKTAT_COMMON = "DIKTAT_COMMON"

typealias RuleConfiguration = com.saveourtool.diktat.ruleset.config.RuleConfiguration
typealias CommonConfiguration = com.saveourtool.diktat.ruleset.config.CommonConfiguration

/**
* Get [DiktatRuleConfig] for particular [DiktatRuleNameAware] object.
*
* @param rule a [DiktatRuleNameAware] which configuration will be returned
* @return [DiktatRuleConfig] for a particular rule if it is found, else null
*/
fun List<DiktatRuleConfig>.getRuleConfig(rule: DiktatRuleNameAware): DiktatRuleConfig? = this.findByRuleName(rule)

/**
* @return common configuration from list of all rules configuration
*/
fun List<DiktatRuleConfig>.getCommonConfiguration(): CommonConfiguration = CommonConfiguration(getCommonConfig()?.configuration)

/**
* Get [DiktatRuleConfig] representing common configuration part that can be used in any rule
*/
private fun List<DiktatRuleConfig>.getCommonConfig() = find { it.name == DIKTAT_COMMON }
Original file line number Diff line number Diff line change
@@ -0,0 +1,56 @@
package com.saveourtool.diktat.ruleset.config

import com.saveourtool.diktat.api.DiktatRuleConfig
import com.saveourtool.diktat.api.DiktatRuleConfigReader
import com.saveourtool.diktat.common.config.rules.DIKTAT_COMMON
import com.saveourtool.diktat.ruleset.constants.Warnings
import io.github.oshai.kotlinlogging.KotlinLogging
import org.jetbrains.kotlin.org.jline.utils.Levenshtein
import java.io.IOException
import java.io.InputStream
import kotlin.jvm.Throws

/**
* This class is used to read input stream in any format that you will specify.
* Usage:
* 1) implement this class with implementing the method:
* a. parse - implement parser for your file format (for example parse it to a proper json)
* 2) Use your new class MyReader().read(someInputStream)
*/
abstract class AbstractDiktatRuleConfigReader : DiktatRuleConfigReader {
/**
* @param inputStream - input stream
* @return list of [DiktatRuleConfig] if resource has been parsed successfully
*/
override fun invoke(inputStream: InputStream): List<DiktatRuleConfig> =
read(inputStream)?.onEach(::validate).orEmpty()

private fun read(inputStream: InputStream): List<DiktatRuleConfig>? = try {
parse(inputStream)
} catch (e: IOException) {
log.error(e) {
"Cannot read config from input stream due to: "
}
null
}

/**
* you can specify your own parser, in example for parsing stream as a json
*
* @param inputStream a [InputStream] representing loaded content
* @return resource parsed as list of [DiktatRuleConfig]
* @throws IOException
*/
@Throws(IOException::class)
protected abstract fun parse(inputStream: InputStream): List<DiktatRuleConfig>

private fun validate(config: DiktatRuleConfig) =
require(config.name == DIKTAT_COMMON || config.name in Warnings.names) {
val closestMatch = Warnings.names.minByOrNull { Levenshtein.distance(it, config.name) }
"Warning name <${config.name}> in configuration file is invalid, did you mean <$closestMatch>?"
}

companion object {
private val log = KotlinLogging.logger {}
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,83 @@
package com.saveourtool.diktat.ruleset.config

import io.github.oshai.kotlinlogging.KLogger
import io.github.oshai.kotlinlogging.KotlinLogging
import java.util.Locale
import java.util.concurrent.atomic.AtomicInteger

/**
* class returns the list of common configurations that we have read from a configuration map
*
* @param configuration map of common configuration
*/
data class CommonConfiguration(private val configuration: Map<String, String>?) {
/**
* List of directory names which will be used to detect test sources
*/
val testAnchors: List<String> by lazy {
val testDirs = (configuration ?: emptyMap()).getOrDefault("testDirs", "test").split(',').map { it.trim() }
if (testDirs.any { !it.lowercase(Locale.getDefault()).endsWith("test") }) {
log.error { "test directory names should end with `test`" }
}
testDirs
}

/**
* Start of package name, which shoould be common, e.g. org.example.myproject
*/
val domainName: String? by lazy {
configuration?.get("domainName")
}

/**
* Get disable chapters from configuration
*/
val disabledChapters: String? by lazy {
configuration?.get("disabledChapters")
}

/**
* Get version of kotlin from configuration
*/
val kotlinVersion: KotlinVersion by lazy {
configuration?.get("kotlinVersion")?.kotlinVersion() ?: run {
if (visitorCounter.incrementAndGet() == 1) {
log.error { "Kotlin version not specified in the configuration file. Will be using ${KotlinVersion.CURRENT} version" }
}
KotlinVersion.CURRENT
}
}

/**
* Get source directories from configuration
*/
val srcDirectories: List<String> by lazy {
configuration?.get("srcDirectories")?.split(",")?.map { it.trim() } ?: listOf("main")
}

companion object {
internal val log: KLogger = KotlinLogging.logger {}

/**
* Counter that helps not to raise multiple warnings about kotlin version
*/
var visitorCounter = AtomicInteger(0)
}
}

/**
* Parse string into KotlinVersion
*
* @return KotlinVersion from configuration
*/
internal fun String.kotlinVersion(): KotlinVersion {
require(this.contains("^(\\d+\\.)(\\d+)\\.?(\\d+)?$".toRegex())) {
"Kotlin version format is incorrect"
}
val versions = this.split(".").map { it.toInt() }
return if (versions.size == 2) {
KotlinVersion(versions[0], versions[1])
} else {
KotlinVersion(versions[0], versions[1], versions[2])
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,22 @@
package com.saveourtool.diktat.ruleset.config

import com.saveourtool.diktat.common.config.rules.RulesConfig
import com.charleskorn.kaml.Yaml
import com.charleskorn.kaml.YamlConfiguration
import com.charleskorn.kaml.decodeFromStream
import java.io.InputStream

/**
* class returns the list of configurations that we have read from a yml: diktat-analysis.yml
*/
class DiktatRuleConfigYamlReader : AbstractDiktatRuleConfigReader() {
private val yamlSerializer by lazy { Yaml(configuration = YamlConfiguration(strictMode = true)) }

/**
* Parse resource file into list of [RulesConfig]
*
* @param inputStream a [InputStream] representing loaded rules config file
* @return list of [RulesConfig]
*/
override fun parse(inputStream: InputStream): List<RulesConfig> = yamlSerializer.decodeFromStream<List<RulesConfig>>(inputStream)
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,7 @@
package com.saveourtool.diktat.ruleset.config

/**
* Configuration that allows customizing additional options of particular rules.
* @property config a map of strings with configuration options for a particular rule
*/
open class RuleConfiguration(protected val config: Map<String, String>)
Original file line number Diff line number Diff line change
@@ -1,9 +1,9 @@
package com.saveourtool.diktat.ruleset.constants

import com.saveourtool.diktat.api.DiktatErrorEmitter
import com.saveourtool.diktat.api.isRuleEnabled
import com.saveourtool.diktat.common.config.rules.Rule
import com.saveourtool.diktat.common.config.rules.RulesConfig
import com.saveourtool.diktat.common.config.rules.isRuleEnabled
import com.saveourtool.diktat.ruleset.generation.EnumNames
import com.saveourtool.diktat.ruleset.utils.isSuppressed
import org.jetbrains.kotlin.com.intellij.lang.ASTNode
Original file line number Diff line number Diff line change
@@ -1,14 +1,14 @@
package com.saveourtool.diktat.ruleset.rules

import com.saveourtool.diktat.api.DiktatErrorEmitter
import com.saveourtool.diktat.api.DiktatRuleNameAware
import com.saveourtool.diktat.api.isRuleEnabled
import com.saveourtool.diktat.common.config.rules.RulesConfig
import com.saveourtool.diktat.common.config.rules.isRuleEnabled
import com.saveourtool.diktat.ruleset.utils.getFilePathSafely

import io.github.oshai.kotlinlogging.KotlinLogging
import org.jetbrains.kotlin.com.intellij.lang.ASTNode

private typealias DiktatConfigRule = com.saveourtool.diktat.common.config.rules.Rule
private typealias DiktatRuleApi = com.saveourtool.diktat.api.DiktatRule

/**
@@ -22,7 +22,7 @@ private typealias DiktatRuleApi = com.saveourtool.diktat.api.DiktatRule
abstract class DiktatRule(
override val id: String,
val configRules: List<RulesConfig>,
private val inspections: List<DiktatConfigRule>,
private val inspections: List<DiktatRuleNameAware>,
) : DiktatRuleApi {
/**
* Default value is false

This file was deleted.

Original file line number Diff line number Diff line change
@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.KtNodeTypes.DESTRUCTURING_DECLARATION
import org.jetbrains.kotlin.KtNodeTypes.DESTRUCTURING_DECLARATION_ENTRY
import org.jetbrains.kotlin.KtNodeTypes.FUNCTION_TYPE
import org.jetbrains.kotlin.KtNodeTypes.OBJECT_DECLARATION
import org.jetbrains.kotlin.KtNodeTypes.PROPERTY
import org.jetbrains.kotlin.KtNodeTypes.REFERENCE_EXPRESSION
import org.jetbrains.kotlin.KtNodeTypes.TYPE_PARAMETER
import org.jetbrains.kotlin.KtNodeTypes.TYPE_REFERENCE
Original file line number Diff line number Diff line change
@@ -12,10 +12,10 @@

package com.saveourtool.diktat.ruleset.utils

import com.saveourtool.diktat.common.config.rules.DIKTAT
import com.saveourtool.diktat.DIKTAT
import com.saveourtool.diktat.api.isAnnotatedWithIgnoredAnnotation
import com.saveourtool.diktat.common.config.rules.Rule
import com.saveourtool.diktat.common.config.rules.RulesConfig
import com.saveourtool.diktat.common.config.rules.isAnnotatedWithIgnoredAnnotation
import com.saveourtool.diktat.ruleset.rules.chapter1.PackageNaming

import org.jetbrains.kotlin.KtNodeTypes
Original file line number Diff line number Diff line change
@@ -1,20 +1,17 @@
package com.saveourtool.diktat.test
package com.saveourtool.diktat.ruleset.config

import com.saveourtool.diktat.common.config.rules.DIKTAT_COMMON
import com.saveourtool.diktat.common.config.rules.RulesConfig
import com.saveourtool.diktat.common.config.rules.RulesConfigReader
import com.saveourtool.diktat.common.config.rules.getCommonConfiguration
import com.saveourtool.diktat.common.config.rules.kotlinVersion
import org.junit.jupiter.api.Test
import java.nio.file.Paths
import kotlin.io.path.inputStream

class ConfigReaderTest {
class DiktatRuleConfigYamlReaderTest {
@Test
fun `testing json reading`() {
val rulesConfigList: List<RulesConfig>? = RulesConfigReader()
.read(Paths.get("src/test/resources/test-rules-config.yml").inputStream())
requireNotNull(rulesConfigList)
val rulesConfigList: List<RulesConfig> = DiktatRuleConfigYamlReader()
.invoke(Paths.get("src/test/resources/test-rules-config.yml").inputStream())
assert(rulesConfigList.any { it.name == "CLASS_NAME_INCORRECT" && it.enabled })
assert(rulesConfigList.find { it.name == "CLASS_NAME_INCORRECT" }?.configuration == emptyMap<String, String>())
assert(rulesConfigList.find { it.name == "DIKTAT_COMMON" }
@@ -23,9 +20,8 @@ class ConfigReaderTest {

@Test
fun `testing kotlin version`() {
val rulesConfigList: List<RulesConfig>? = RulesConfigReader()
.read(Paths.get("src/test/resources/test-rules-config.yml").inputStream())
requireNotNull(rulesConfigList)
val rulesConfigList: List<RulesConfig> = DiktatRuleConfigYamlReader()
.invoke(Paths.get("src/test/resources/test-rules-config.yml").inputStream())
assert(rulesConfigList.getCommonConfiguration().kotlinVersion == kotlinVersion)
assert(rulesConfigList.getCommonConfiguration().testAnchors.contains("androidUnitTest"))
assert(rulesConfigList.find { it.name == DIKTAT_COMMON }
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
package com.saveourtool.diktat.ruleset.smoke

import com.saveourtool.diktat.ruleset.rules.DiktatRuleConfigReaderImpl
import com.saveourtool.diktat.ruleset.config.DiktatRuleConfigYamlReader
import com.saveourtool.diktat.ruleset.rules.DiktatRuleSetFactoryImpl
import com.saveourtool.diktat.test.framework.util.deleteIfExistsSilently

@@ -76,6 +76,6 @@ class RulesConfigValidationTest {

companion object {
private val diktatRuleSetFactory = DiktatRuleSetFactoryImpl()
private val diktatRuleConfigReader = DiktatRuleConfigReaderImpl()
private val diktatRuleConfigReader = DiktatRuleConfigYamlReader()
}
}
Original file line number Diff line number Diff line change
@@ -2,9 +2,9 @@ package com.saveourtool.diktat.ruleset.utils

import com.saveourtool.diktat.common.config.rules.DIKTAT_COMMON
import com.saveourtool.diktat.common.config.rules.RulesConfig
import com.saveourtool.diktat.common.config.rules.RulesConfigReader
import com.saveourtool.diktat.ruleset.config.kotlinVersion
import com.saveourtool.diktat.ruleset.config.DiktatRuleConfigYamlReader
import com.saveourtool.diktat.common.config.rules.getRuleConfig
import com.saveourtool.diktat.common.config.rules.kotlinVersion
import com.saveourtool.diktat.ruleset.constants.Warnings

import com.charleskorn.kaml.Yaml
@@ -114,7 +114,7 @@ class RulesConfigYamlTest {
Paths.get(nameConfig).takeIf { it.exists() }?.inputStream()
?: javaClass.classLoader.getResourceAsStream(nameConfig)
}
?.let { RulesConfigReader().read(it) }
?.let { DiktatRuleConfigYamlReader().invoke(it) }
?: emptyList()

private fun readAllRulesFromCode() =
Original file line number Diff line number Diff line change
@@ -6,7 +6,7 @@ package com.saveourtool.diktat.util

import com.saveourtool.diktat.api.DiktatRuleSet
import com.saveourtool.diktat.common.config.rules.RulesConfig
import com.saveourtool.diktat.common.config.rules.RulesConfigReader
import com.saveourtool.diktat.ruleset.config.DiktatRuleConfigYamlReader
import com.saveourtool.diktat.ruleset.rules.DiktatRule
import com.saveourtool.diktat.ruleset.rules.DiktatRuleSetFactoryImpl
import com.saveourtool.diktat.test.framework.util.filterContentMatches
@@ -64,7 +64,7 @@ class DiktatRuleSetFactoryImplTest {
rulesConfigList: List<RulesConfig>?,
): DiktatRuleSet = run {
rulesConfigList ?: Companion::class.java.classLoader.getResourceAsStream("diktat-analysis.yml")
?.let { RulesConfigReader().read(it) }
?.let { DiktatRuleConfigYamlReader().invoke(it) }
.orEmpty()
}
.let(ruleSupplier)
Original file line number Diff line number Diff line change
@@ -51,8 +51,6 @@
enabled: true
- name: MISSING_KDOC_CLASS_ELEMENTS
enabled: true
- name: BLANK_LINE_AFTER_KDOC
enabled: true
- name: KDOC_WITHOUT_PARAM_TAG
enabled: true
- name: KDOC_WITHOUT_RETURN_TAG
@@ -90,7 +88,7 @@
copyrightText: Copyright (c) This is an example. 2012-2020. All rights reserved.
- name: HEADER_NOT_BEFORE_PACKAGE
enabled: true
- name: HEADER_CONTAINS_DATE_OR_AUTHOR
- name: KDOC_CONTAINS_DATE_OR_AUTHOR
enabled: true
- name: FILE_IS_TOO_LONG
enabled: true
Original file line number Diff line number Diff line change
@@ -1,9 +1,10 @@
package com.saveourtool.diktat.ruleset.rules

import com.saveourtool.diktat.common.config.rules.DIKTAT_ANALYSIS_CONF
import com.saveourtool.diktat.DIKTAT_ANALYSIS_CONF
import com.saveourtool.diktat.common.config.rules.DIKTAT_CONF_PROPERTY
import com.saveourtool.diktat.common.config.rules.DIKTAT_RULE_SET_ID
import com.saveourtool.diktat.ktlint.KtLintRuleWrapper.Companion.toKtLint
import com.saveourtool.diktat.ruleset.config.DiktatRuleConfigYamlReader
import com.pinterest.ktlint.cli.ruleset.core.api.RuleSetProviderV3
import com.pinterest.ktlint.logger.api.initKtLintKLogger
import com.pinterest.ktlint.rule.engine.core.api.RuleProvider
@@ -26,7 +27,7 @@ import java.io.InputStream
class DiktatRuleSetProviderV3Spi : RuleSetProviderV3(
id = RuleSetId(DIKTAT_RULE_SET_ID),
) {
private val diktatRuleConfigReader = DiktatRuleConfigReaderImpl()
private val diktatRuleConfigReader = DiktatRuleConfigYamlReader()
private val diktatRuleSetFactory = DiktatRuleSetFactoryImpl()

init {
1 change: 0 additions & 1 deletion diktat-runner/build.gradle.kts
Original file line number Diff line number Diff line change
@@ -15,7 +15,6 @@ project.description = "This module contains runner for diktat"

dependencies {
api(projects.diktatApi)
api(projects.diktatCommon)
implementation(projects.diktatKtlintEngine)
implementation(projects.diktatRules)
}
Original file line number Diff line number Diff line change
@@ -11,7 +11,7 @@ import com.saveourtool.diktat.api.DiktatRuleSetFactory
import com.saveourtool.diktat.ktlint.DiktatBaselineFactoryImpl
import com.saveourtool.diktat.ktlint.DiktatProcessorFactoryImpl
import com.saveourtool.diktat.ktlint.DiktatReporterFactoryImpl
import com.saveourtool.diktat.ruleset.rules.DiktatRuleConfigReaderImpl
import com.saveourtool.diktat.ruleset.config.DiktatRuleConfigYamlReader
import com.saveourtool.diktat.ruleset.rules.DiktatRuleSetFactoryImpl
import generated.KTLINT_VERSION

@@ -23,7 +23,7 @@ const val ENGINE_INFO: String = "Ktlint: $KTLINT_VERSION"
/**
* @return initialized [DiktatRuleConfigReader]
*/
val diktatRuleConfigReader: DiktatRuleConfigReader = DiktatRuleConfigReaderImpl()
val diktatRuleConfigReader: DiktatRuleConfigReader = DiktatRuleConfigYamlReader()

/**
* @return initialized [DiktatRuleSetFactory]
1 change: 0 additions & 1 deletion settings.gradle.kts
Original file line number Diff line number Diff line change
@@ -47,7 +47,6 @@ plugins {

includeBuild("gradle/plugins")
include("diktat-api")
include("diktat-common")
include("diktat-common-test")
include("diktat-ktlint-engine")
include("diktat-gradle-plugin")