Don’t you mind opening an issue @Czar? Apparently there is a test case for that scenario and is green at the moment: https://github.com/arturbosch/detekt/blob/daf3b2a9151a8c98ac99df58c5dfc51a5fc9a5be/detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/WildcardImportSpec.kt#L48-L53

Does anyone knows where I can find the list of correctable rules ?

@gammax yes

Is there a way to use detekt to find unused

internal

(rather than

private

) properties?

Does anyone tries to change the indentation to 2. I have tried in config file but looks like detekt is not considering anything from “Formatting Block”

formatting:
  active: true
  android: false
  autoCorrect: true
  ImportOrdering:
    active: false
    autoCorrect: true
  Indentation:
    active: true
    autoCorrect: true
    indentSize: 2
    continuationIndentSize: 2

when I see something like this online it's making me think I need to do a lot of refactoring

But I guess that is the score for a method? What is the project score I got of

68

in relation to?

Thanks for the replies Artur. This makes sense, I had a look at the

AbstractProcessor.kt

and thought it may add up the complexity of all the methods of all the files. Our score of 68 is only over 39 functions, so it seems low enough - it's a new service, so fairly small. What do you think about reporting on average McCabe complexity per method in the detekt report? As the sum is only relevant to the project, but an average would be comparable to other applications.

apologies if this has been asked before: couldn't find in search. Is there a setting for enforcing explicit return type declaration on all functions? I think this would help my team's readability. Specifically this often gets omitted in Single Expression Functions

fun myFun(a,b) = logic()

. Rather than police improper usage of single expression i thought it'd just be easier to enforce return types across the board.

Hi there! Do you know any project with A LOT of detekt warnings? I need one to test some things.

Also, why doesn’t detekt like my constant names? According to the style guide (https://kotlinlang.org/docs/reference/coding-conventions.html#naming-rules) constant property names should be UPPER_SNAKE_CASE.

In one of my sample apps, I'm trying to move all of my static analysis checks into the root project, where previously I had them in each of two modules. I put this off because I keep facing some issue that when I put the static analysis plugin inside it's own gradle file, detekt never seems to be able to find my config file and I believe that causes it to fall back on detekt's default config file. I have a PR up on the sample app highlighting the code change, if anyone could help take a look some time, but this isn't urgent. https://github.com/AdamMc331/PokeDex/pull/54/files#r336759846

I’m wondering what’s wrong with an empty function block. I have a class with a

stop()

method that currently doesn’t do anything. I want the API to say that the

stop()

method should be called when it is no longer needed. It’s not the caller’s business whether any instructions are there or not. There may be in the future. Or is this a case of YAGNI?

Hello people, aiming to update to detekt 1.1.1 today + change the detekt level to be a unique top level task (gradle cache is nice but on clean but on CI we jumped from 30 seconds to 2:30 due to an increase amount of modules). Is the best way still to do this https://github.com/arturbosch/detekt/issues/1295#issuecomment-516015993 or the detektAll task from detekt project itself? Asked a while back and got it to work (only if you didn't have any baseline) so asking to see if there is any updates or someone can share some experience trying this out https://kotlinlang.slack.com/archives/C88E12QH4/p1566002344009600

any configuration example for MPP?

Question, what is the difference in detekt between filters and excludes?

filters = ".*build.*,.*/resources/"
excludes = ["**/build/**", "**/resources/**"]

Managed to do the top level task that runs in around 20 seconds compared per module where it was taking 2 to 3 minutes. In my top level build gradle I ended up having

plugins {
    id "io.gitlab.arturbosch.detekt" version "1.1.1"
}

dependencies {
    detektPlugins "io.gitlab.arturbosch.detekt:detekt-formatting:1.1.1"
}

task detektAll(type: io.gitlab.arturbosch.detekt.Detekt) {
    description = "Runs detekt for the entire project."

    input = files("$projectDir")
    config = files("$rootDir/config/detekt/detekt.yml")
    parallel = false
    includes = ["**/*.kt", "**/*.kts"]
    excludes = ["**/resources/**", "**/build/**", "**/buildSrc/**", "**/test/**/*.kt"]
    baseline = file("$rootDir/config/detekt/baseline.xml")
    reports {
        xml { enabled = false }
        html { enabled = false }
        txt { enabled = false }
    }
}

The detektFormat has

disableDefaultRuleSets

&

buildUponDefaultConfig

which I'm not sure if I should apply. Also noticed that there is no need for a detekt format task if you just set

autoCorrect

to true in the detektAll Only thing I find a bit confusing is that if it can fix all the issues it will fix them but still fail. While on ktlintFormat it would only fail if it is not able to fix any of the issues. The reason I say it is confusing is because I can have 5 issues that only 3 have been fixed but all will be marked as failure. Which leaves the developer in the situation to not know for which ones to look because some of them might have already been fixed. On the other hand for CI this is great because even if it is able to fix them it will fail and sends a clear message of: you have detektIssues run it locally, commit & push

Hello team, is it expected that even after autocorrecting something the task still fails? If after correcting the only issue (which has autoCorrect true) wouldn't it make sense to not have a build failure?

Hi guys, are any of the maintainers going to be at KotlinConf?

High level question: is there any way to have detekt enforce that you use named arguments? Specifically, I was thinking this would be helpful for methods or constructors that have say at least 3 arguments. I haven't found anything in the detekt config that relates to this, but I'm also not sure if it's possible - how would static analysis know if the method I'm calling supports named arguments - it might not if it's a java interrop, right?

Hi folks. I’m trying to use

Duration

type https://okkotlin.com/duration/ but it got flagged by the

MagicNumber

rule. Just wondering whether anyone knows how to configure the

MagicNumber

to exclude if I extract the whole

Duration

into a constant like below?

@ExperimentalTime
class Operation {
    companion object {
        val DEFAULT_TIMEOUT = 3.seconds
    }

    @ExperimentalTime
    fun read(timeout: Duration = DEFAULT_TIMEOUT) {
    }
}

So w/ that example, detekt still complains that

3

should be constant.

This is somehow related to Kotlin update 1.3.50 -> 1.3.60 because I get this also using 1.3.60 and Detekt 1.0.1

detekt 1.2.0 Spring Boot 2.2.1 Kotlin 1.3.60 I have

kotlin.spring

plugin applied and a class annotated with

@Configuration

, but

ProtectedMemberInFinalClass

is still triggered. The class is effectively open due to `kotlin.spring`plugin and this worked before on detekt 1.0.1, Boot 2.2.0.RC1, Kotlin 1.3.50. Should I try to downgrade them one by one to find which version upgrade caused this or is it a known issue?

got a regression updating from 1.2.0 to 1.2.1

Could not set unknown property 'filters' for object of type io.gitlab.arturbosch.detekt.extensions.DetektExtension.

is this on purpose?

Hello people, after updating from 1.1.1 to 1.2.1 when running

detektAll

a centric baseline is ignored. I switched to

build.gradle.kts

to ensure that wasn't the issue and was checking detekt project and it is set the same way (and also have the same path)

baseline.set(file("$rootDir/config/detekt/baseline.xml"))

Was there any change regarding baseline? I don't seem to find it looking through 1.2.0 and 1.2.1

Can I disable a rule only in IntelliJ, without affecting gradle build and committing anything? So far I've thought of following options (both of which I don't like): 1. copy-paste my detekt.yml from the project to a place outside project, make the change I want, configure plugin with that file while leaving gradle config intact. Negative here is that I have to be on lookout for additional changes to detekt.yml from the repo and not forget to update my local file 2. change the file in the project and move it to a separate "local only" changelist to avoid commiting it. Downside: bit risky, at some point can still commit it unintentionally, e.g. from command line. I need this to suppress ForbiddenComments for

todo:

, but only in IntelliJ, because I use

todo:

comments when working on a changeset. Showing those as errors kinda messes with the flow. On the other hand I wouldn't want to commit them, so I need them to be reported when I run gradle check

In a simple entity update situation, where there's an entity

class MyEntity {
  val id: Long? = null
  var prop1: String? = null
  var prop2: String? = null
// ...
  var propN: String? = null
}

and an update command:

class UpdateEntityCommand {
  val myEntityId: Long
  var prop1: String? = null
  var prop2: String? = null
// ...
  var propN: String? = null
}

the handler should only change property of the entity if corresponding property of the command is not

null

:

class MyHandler(private val repo: MyEntityRepository) {
  fun handle(command: UpdateEntityCommand) {
    with(repository.getOne(command.myEntityId)) {
      // (1)
      if (command.prop1 != null) prop1 = command.prop1
      // (2)
      command.prop2?.let { prop2 = it }
      // (3)
      ifNotNull(command.propN) { propN = it }
    }
  }
}

If all the properties are set using method (1) or (3), detekt is happy, if method (2) is used, detekt is complaining about

"ComplexMethod"

Should I report this to the issue tracker, or is it as it should be? If the latter, I wonder why?

abstract class MemoryCache<T> {

    private val cachedValue = AtomicReference<T>()

    fun getOrEmpty(): Maybe<T> = Maybe.fromCallable { cachedValue.get() }

    fun set(value: T) {
        this.cachedValue.set(value)
    }

    fun invalidate() {
        cachedValue.set(null)
    }
}

This class has concrete methods

can you share also value of detekt findings in your project?