DEV Community

Rodrigo Sicarelli
Rodrigo Sicarelli

Posted on • Updated on

Android Plataforma - Parte 15: Cuidando do código com Detekt, Klint e Spotless

#kotlin #android #gradle

🌱 Branch: 15/enhancing-code-quality

🔗 Repositório: github.com/rsicarelli/kotlin-gradle-android-platform

⬅️ Artigo Anterior: Parte 14: Aderindo a funcionalidades experimentais do compilador do Kotlin

➡️ Próximo Artigo: Parte 16: Considerações finais

No último artigo, abordamos a capacidade de nossa plataforma aderir a funcionalidades experimentais em diferentes módulos.

Agora, vamos explorar a garantia da qualidade do código através da integração de plugins.

Por que focar em automatizar verificações do código?

Quando se trabalha em equipe, é vital ter padrões de estilo e nomenclatura para manter a consistência. Estabelecer um padrão sólido ajuda a reduzir a sobrecarga de decisões e facilita a colaboração.

Pense assim: ao se juntar a uma orquestra, seguimos a pessoa contudora que dita ritmo da música. É o mesmo com nosso módulos; seguimos padrões preestabelecidos e acordados pelo time de forma automatizada.

Essa prática é especialmente útil para quando uma pessoa nova entra no time, além de que os acordos fiquem documentados e codificados, abertos para colaboração.

Incluíndo análise de código estático com Detekt

O Detekt é talvez a ferramenta mais famosa em Kotlin para analisar o código e garantir que algumas práticas são aplicadas.

Não iremos focar muito nas suas funcionalidades, vamos direto pra implementação

Passo a passo

1 - Vamos começar declarando o detekt no nossos libs.versions.toml:

[versions]
detekt = "1.23.1"
detektCompose = "0.2.3"

[libraries]
gradlePlugin-detekt = { module = "io.gitlab.arturbosch.detekt:detekt-gradle-plugin", version.ref = "detekt" }

detektRules-compose = { module = "io.nlopez.compose.rules:detekt", version.ref = "detektCompose" }
detektRules-formatting = { module = "io.gitlab.arturbosch.detekt:detekt-formatting", version.ref = "detekt" }
detektRules-libraries = { module = "io.gitlab.arturbosch.detekt:detekt-rules-libraries", version.ref = "detekt" }

[plugins]
arturbosch-detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
Enter fullscreen mode Exit fullscreen mode

2 - Sincronize o projeto. Navegue até build-logic/build.gradle.kts e vamos compilar a dependencia do detekt na nossa plataforma:

dependencies {
    compileOnly(libs.gradlePlugin.android)
    compileOnly(libs.gradlePlugin.kotlin)
    compileOnly(libs.gradlePlugin.detekt)
}
Enter fullscreen mode Exit fullscreen mode

3 - Sincronize o projeto. Agora, vamos declarar nossa DSL do DetektOptions.

Crie um arquivo DetektOptions em build-logic/src/../options

data class DetektOptions(
    val parallel: Boolean,
    val buildUponDefaultConfig: Boolean,
    val configFileNames: List<String>,
    val includes: List<String>,
    val excludes: List<String>
)

class DetektOptionsBuilder {

    var parallel: Boolean = true
    var configFiles: List<String> = listOf(".detekt.yml, .detekt-compose.yml")
    var buildUponDefaultConfig: Boolean = true
    var includes: List<String> = listOf("**/*.kt", "**/*.kts")
    var excludes: List<String> = listOf(".*/resources/.*", ".*/build/.*")

    internal fun build(): DetektOptions = DetektOptions(
        parallel = parallel,
        configFileNames = configFiles,
        includes = includes,
        excludes = excludes,
        buildUponDefaultConfig = buildUponDefaultConfig
    )
}
Enter fullscreen mode Exit fullscreen mode

4 - Em seguida, crie um novo arquivo detekt.kt em build-logic/src/.../decorations e declare uma função applyDetekt()

Essa configurações impoe que:

  1. Esse plugin só poderá ser chamado no build.gradle.kts da raíz
  2. Exista um arquivo .detekt.yml na raíz do projeto
  3. Exista um arquivo .detekt-compose.yml na raíz do projeto 
import com.rsicarelli.kplatform.options.DetektOptions
import io.gitlab.arturbosch.detekt.Detekt
import io.gitlab.arturbosch.detekt.extensions.DetektExtension
import org.gradle.api.Project
import org.gradle.api.artifacts.MinimalExternalModuleDependency
import org.gradle.kotlin.dsl.DependencyHandlerScope
import org.gradle.kotlin.dsl.configure
import org.gradle.kotlin.dsl.dependencies
import org.gradle.kotlin.dsl.withType

internal fun Project.applyDetekt(
    detektOptions: DetektOptions
) {
    check(rootProject == this) { "Must be called on a root project" }

    pluginManager.apply("io.gitlab.arturbosch.detekt")

    extensions.configure<DetektExtension> {
        parallel = detektOptions.parallel
        toolVersion = libs.version("detekt")
        buildUponDefaultConfig = detektOptions.buildUponDefaultConfig
        config.setFrom(detektOptions.configFileNames.map { "$rootDir/$it" })
    }

    tasks.withType<Detekt> {
        setSource(files(projectDir))
        include(detektOptions.includes)
        exclude(detektOptions.excludes)
    }

    addDetektPlugins(listOf("compose", "formatting", "libraries"))
}

fun Project.addDetektPlugins(detektPlugins: List<String>) {
    fun DependencyHandlerScope.detektPlugin(dependency: MinimalExternalModuleDependency) {
        add("detektPlugins", dependency)
    }

    dependencies {
        detektPlugins.forEach { plugin ->
            detektPlugin(libs.findLibrary("detektRules-$plugin").get().get())
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

5 - Em seguida. vamos expor essa decoração no KPlatformPlugin.kt:

fun Project.detekt(builderAction: DetektBuilder = {}) =
    applyDetekt(DetektOptionsBuilder().apply(builderAction).build())
Enter fullscreen mode Exit fullscreen mode

6 - Sincronize o projeto. Em seguida, va até o build.gradle.kts da raiz do projeto, e inclua o plugin do detekt:

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.arturbosch.detekt) apply false
    id(libs.plugins.rsicarelli.kplatform.get().pluginId)
}
Enter fullscreen mode Exit fullscreen mode

6 - Sincronize o projeto. Em seguida, aplique a decoração detekt() no mesmo arquivo:

import com.rsicarelli.kplatform.detekt

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.arturbosch.detekt) apply false
    id(libs.plugins.rsicarelli.kplatform.get().pluginId)
}

detekt()
Enter fullscreen mode Exit fullscreen mode

7 - Vamos criar 2 arquivos na raíz do projeto: .detekt.yml e .detekt-compose.yml

8 - Sincronize o projeto. Perceba que uma série de tasks detektX foram adicionadas no projeto:

Image description

8 - Verifique que está funcionando rodando o seguinte comando.

Alternativamente, pode simplesmente dar um clique duplo na task detekt na lista de tasks do Gradle:

./gradlew detekt
Enter fullscreen mode Exit fullscreen mode

Você vai perceber que vamos ter várias penalidades.

A seguir, vamos usar o Spotless para nos ajudar a reduzir a lista de faltas.

Adicionando o Spotless

O spotless é outra ferramenta indispensável nos projetos Kotlin.

Seu objetivo é formatar seu código magicamente de acordo com um estilo de código/configurações pre estabelecidas.

Novamente, não vamos focar muito nos detalhes da biblioteca, vamos direto ao uso

Passo a passo

1 - Declare as coordenadas do spotless no libs.versions.toml

[versions]
spotless = "6.21.0"

[libraries]
gradlePlugin-spotless = { module = "com.diffplug.spotless:spotless-plugin-gradle", version.ref = "spotless" }

[plugins]
diffplug-spotless = { id = "com.diffplug.spotless", version.ref = "spotless" }
Enter fullscreen mode Exit fullscreen mode

2 - Sincronize o projeto. Em seguida, vamos criar os arquivos SpotlessOptions na pasta build-logic/src/.../options:

Aqui, nossa plataforma será capaz de:

  1. Fornecer 2 configurações padrões para o projeto: SpotlessKtsRule e SpotlessXmlRule. Isso configura o spotless para nossos arquivos Gradle com extensão .kts, além de .xml do Android.
  2. Possibilta outras configurações de arquivos, de acordo com a necessidade de cada projeto. 
data class SpotlessOptions(
    val fileRules: List<SpotlessFileRule> = listOf(SpotlessKtRule, SpotlessXmlRule),
)

interface SpotlessFileRule {

    val fileExtension: String
    val targets: List<String>
    val excludes: List<String>
}

object SpotlessKtsRule : SpotlessFileRule {

    override val fileExtension: String = "kts"
    override val targets: List<String> = listOf("**/*.kts")
    override val excludes: List<String> = listOf("**/build/**/*.kts")
}

object SpotlessXmlRule : SpotlessFileRule {

    override val fileExtension: String = "xml"
    override val targets: List<String> = listOf("**/*.xml")
    override val excludes: List<String> = listOf("**/build/**/*.xml")
}

class SpotlessOptionsBuilder {

    var fileRules: List<SpotlessFileRule> = listOf(SpotlessKtRule, SpotlessXmlRule)

    internal fun build(): SpotlessOptions = SpotlessOptions(
        fileRules = fileRules
    )
}
Enter fullscreen mode Exit fullscreen mode

3 - Vamos criar um arquivo spotless.kt dentro de build-logic/src/.../decorations e declarar a função applySpotless()

Note que:

  1. Estamos aplicando o Spotless no projeto raíz. Isso faz com que as formatações também aconteçam nos scripts da raíz, assim como na plataforma build-logic
  2. Estamos aplicando o Spotless também para todos os sub projetos.
  3. Estamos utilizando o klint como regras do Spotless
  4. O plugin assume que existe um arquivo .editorconfig na raíz do projeto 
import com.diffplug.gradle.spotless.SpotlessExtension
import com.diffplug.gradle.spotless.SpotlessPlugin
import com.rsicarelli.kplatform.options.SpotlessOptions
import org.gradle.api.Project
import org.gradle.kotlin.dsl.apply
import org.gradle.kotlin.dsl.configure

internal fun Project.applySpotless(spotlessConfig: SpotlessOptions) {
    val project = this

    configureSpotlessPlugin(spotlessConfig, project)

    rootProject.subprojects {
        configureSpotlessPlugin(spotlessConfig, project)
    }
}

private fun Project.configureSpotlessPlugin(
    spotlessConfig: SpotlessOptions,
    project: Project
) {
    apply<SpotlessPlugin>()

    extensions.configure<SpotlessExtension> {
        kotlin {
            target("src/**/*.kt")
            ktlint().setEditorConfigPath("${project.rootDir}/.editorconfig")
        }

        spotlessConfig.fileRules.forEach { spotlessFileRule ->
            with(spotlessFileRule) {
                format(fileExtension) {
                    target(targets)
                    targetExclude(excludes)
                }
            }
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

4 - Crie um arquivo .editorconfig na raiz do projeto:

5 - Vamos expor essa decoração no KPlatformPlugin.kt:

fun Project.spotless(builderAction: SpotlessBuilder = { }) =
    applySpotless(SpotlessOptionsBuilder().apply(builderAction).build())
Enter fullscreen mode Exit fullscreen mode

6 - Sincronize o projeto. Em seguida, navegue até build.gradle.kts da raiz do projeto e declare o plugin do spotless:

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.arturbosch.detekt) apply false
    alias(libs.plugins.diffplug.spotless) apply false
    id(libs.plugins.rsicarelli.kplatform.get().pluginId)
}
Enter fullscreen mode Exit fullscreen mode

7 - Sincronize o projeto. Em seguida. altere o mesmo build.gradle.kts e aplique a decoração spotless():

import com.rsicarelli.kplatform.detekt
import com.rsicarelli.kplatform.spotless

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.arturbosch.detekt) apply false
    alias(libs.plugins.diffplug.spotless) apply false
    id(libs.plugins.rsicarelli.kplatform.get().pluginId)
}

detekt()
spotless()
Enter fullscreen mode Exit fullscreen mode

8 - Sincronize o projeto. Perceba que agora várias tasks spotless estarão disponíveis na lista de tarefas do Gradle:

Image description

9 - Verifque o funcionamento rodando o comando, ou clique duplo na tarefa spotlessApply na lista de tarefas do Gradle:

./gradlew spotlessApply
Enter fullscreen mode Exit fullscreen mode

Sucesso!

O Spotless vai conseguir solucionar várias faltas automaticamente pra gente. Porém, tem algumas, como por exemplo nomeação dos arquivos, que não é suportado pelo Spotless.

Aproveitando, nessa branch, adicionei várias documentações para todas nossas API's da plataforma!

No próximo artigo, iremos fechar o essa série de posts, e contar um pouquinho sobre os próximos passos!

Top comments (0)

Read next

lucasfugisawa profile image

Kotlin Design Patterns: Simplifying the Proxy Pattern

Lucas Fugisawa -

diogodanielsoaresferreira profile image

How to structure your code? Hexagonal Architecture!

Diogo Daniel Soares Ferreira -

malaquiasdev profile image

When I prefer use when then if-else in Kotlin

Mateus Malaquias -

dhanush17tech profile image

Power your Flutter App with Gemini AI ✨

Dhanush Vardhan -