Add task to generate pre commit hook that formats staged changes

README.md

@@ -43,9 +43,11 @@ Please note that `ktfmt-gradle` relies on `ktfmt` hence the minimum supported JD
 
 Please also note the following requirements:
 
-* **Kotlin 1.4+**. In order to reformat Kotlin 1.4 code, you need run on **Gradle to 6.8+** (This is due to Gradle 6.7 embedding Kotlin 1.3.x - See [#12660](https://github.com/gradle/gradle/issues/12660)).
+* **Kotlin 1.4+**. In order to reformat Kotlin 1.4 code, you need run on **Gradle to 6.8+** (This is due to Gradle 6.7
+  embedding Kotlin 1.3.x - See [#12660](https://github.com/gradle/gradle/issues/12660)).
 
-* **Android**. `ktfmt-gradle` relies on features from **Android Gradle Plugin 4.1+**. So make sure you bump AGP before applying this plugin.
+* **Android**. `ktfmt-gradle` relies on features from **Android Gradle Plugin 4.1+**. So make sure you bump AGP before
+  applying this plugin.
 
 ### Task
 
@@ -91,10 +93,10 @@ To enable different styles you can simply:
 ktfmt {
     // Dropbox style - 4 space indentation
     dropboxStyle()
-    
+
     // Google style - 2 space indentation & automatically adds/removes trailing commas
     googleStyle()
-    
+
     // KotlinLang style - 4 space indentation - From kotlinlang.org/docs/coding-conventions.html
     kotlinLangStyle()
 }
@@ -121,7 +123,8 @@ ktfmt {
 
 You can leverage the `--include-only` to let ktfmt-gradle run only on a specific subset of files.
 
-To this you can register a simple task of type `KtfmtCheckTask` or `KtfmtFormatTask` in your `build.gradle.kts` as follows:
+To this you can register a simple task of type `KtfmtCheckTask` or `KtfmtFormatTask` in your `build.gradle.kts` as
+follows:
 
 ```kotlin
 import com.ncorti.ktfmt.gradle.tasks.*
@@ -132,10 +135,13 @@ tasks.register<KtfmtFormatTask>("ktfmtPrecommit") {
 }
 ```
 
-You can then invoke the task with `--include-only` and a comma separated list of relative path of files:
+## Generating with a pre-commit hook 🎣
+
+You can also generate a generate a git pre-commit hook which will run `ktfmtFormat` on your commits using the following
+command:
 
 ```
-./gradlew ktfmtPrecommit --include-only=src/main/java/File1.kt:src/main/java/File2.kt
+./gradlew ktfmtGenerateGitPreCommitHook
 ```
 
 The task will execute only on the file you passed and will skip all the others.

plugin-build/plugin/api/plugin.api

@@ -21,6 +21,12 @@ public abstract class com/ncorti/ktfmt/gradle/KtfmtPlugin : org/gradle/api/Plugi
 public final class com/ncorti/ktfmt/gradle/KtfmtPlugin$Companion {
 }
 
+public abstract class com/ncorti/ktfmt/gradle/tasks/CreateGitPreCommitHookTask : org/gradle/api/DefaultTask {
+	public fun <init> ()V
+	public final fun createHook ()V
+	public abstract fun getWorkerExecutor ()Lorg/gradle/workers/WorkerExecutor;
+}
+
 public abstract class com/ncorti/ktfmt/gradle/tasks/KtfmtBaseTask : org/gradle/api/tasks/SourceTask {
 	protected abstract fun execute (Lorg/gradle/workers/WorkQueue;)V
 	public abstract fun getIncludeOnly ()Lorg/gradle/api/provider/Property;

plugin-build/plugin/src/main/java/com/ncorti/ktfmt/gradle/KtfmtPlugin.kt

@@ -5,6 +5,7 @@ import com.ncorti.ktfmt.gradle.KtfmtPluginUtils.EXTENSION_NAME
 import com.ncorti.ktfmt.gradle.KtfmtPluginUtils.TASK_NAME_CHECK
 import com.ncorti.ktfmt.gradle.KtfmtPluginUtils.TASK_NAME_FORMAT
 import com.ncorti.ktfmt.gradle.KtfmtPluginUtils.createTasksForSourceSet
+import com.ncorti.ktfmt.gradle.KtfmtPluginUtils.registerGitPreCommitHookTask
 import com.ncorti.ktfmt.gradle.tasks.KtfmtBaseTask
 import com.ncorti.ktfmt.gradle.util.i
 import org.gradle.api.Plugin
@@ -78,6 +79,9 @@ abstract class KtfmtPlugin : Plugin<Project> {
 
     private fun applyKtfmt(project: Project) {
         val extension = project.extensions.getByType(KotlinProjectExtension::class.java)
+
+        registerGitPreCommitHookTask(project)
+
         extension.sourceSets.all {
             createTasksForSourceSet(
                 project,

plugin-build/plugin/src/main/java/com/ncorti/ktfmt/gradle/KtfmtPluginUtils.kt

@@ -1,5 +1,6 @@
 package com.ncorti.ktfmt.gradle
 
+import com.ncorti.ktfmt.gradle.tasks.CreateGitPreCommitHookTask
 import com.ncorti.ktfmt.gradle.tasks.KtfmtCheckTask
 import com.ncorti.ktfmt.gradle.tasks.KtfmtFormatTask
 import org.gradle.api.Project
@@ -109,13 +110,31 @@ internal object KtfmtPluginUtils {
             }
         val taskName = "$TASK_NAME_FORMAT$srcSetName"
         val inputDirs = srcDir.toList()
+
+        // check if specific files are specified to be included. If not, use the default includes
+        val includes =
+            (project.findProperty("ktfmt.gradle.includeOnly") as String?)
+                ?.split(",")
+                ?.filter { file -> file.isNotEmpty() }
+                ?.takeIf { files -> files.isNotEmpty() } ?: KtfmtPlugin.defaultIncludes
+
         return project.tasks.register(taskName, KtfmtFormatTask::class.java) {
             it.description =
                 "Run Ktfmt formatter validation for sourceSet '$name' on project '${project.name}'"
+
             it.setSource(inputDirs)
-            it.setIncludes(KtfmtPlugin.defaultIncludes)
+            it.setIncludes(includes)
             it.setExcludes(KtfmtPlugin.defaultExcludes)
             it.bean = ktfmtExtension.toBean()
         }
     }
+
+    internal fun registerGitPreCommitHookTask(project: Project) {
+        project.tasks.register(
+            "ktfmtGenerateGitPreCommitHook",
+            CreateGitPreCommitHookTask::class.java
+        ) {
+            it.description = "Creates a git hook that runs ktfmt before commit"
+        }
+    }
 }

plugin-build/plugin/src/main/java/com/ncorti/ktfmt/gradle/tasks/CreateGitPreCommitHookTask.kt

@@ -0,0 +1,20 @@
+package com.ncorti.ktfmt.gradle.tasks
+
+import com.ncorti.ktfmt.gradle.tasks.worker.PreCommitHookFormatAction
+import javax.inject.Inject
+import org.gradle.api.DefaultTask
+import org.gradle.api.tasks.TaskAction
+import org.gradle.workers.WorkerExecutor
+
+/** ktfmt-gradle Git hook task. Creates a git hook that runs ktfmt on git commit */
+abstract class CreateGitPreCommitHookTask : DefaultTask() {
+    @Inject abstract fun getWorkerExecutor(): WorkerExecutor
+
+    @TaskAction
+    fun createHook() {
+        val workQueue = getWorkerExecutor().noIsolation()
+        workQueue.submit(PreCommitHookFormatAction::class.java) { parameters ->
+            parameters.projectDir.set(project.projectDir)
+        }
+    }
+}

plugin-build/plugin/src/main/java/com/ncorti/ktfmt/gradle/tasks/worker/PreCommitHookFormatAction.kt

@@ -0,0 +1,63 @@
+package com.ncorti.ktfmt.gradle.tasks.worker
+
+import com.ncorti.ktfmt.gradle.util.e
+import com.ncorti.ktfmt.gradle.util.i
+import com.ncorti.ktfmt.gradle.util.w
+import java.io.File
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.logging.Logger
+import org.gradle.api.logging.Logging
+import org.gradle.workers.WorkAction
+import org.gradle.workers.WorkParameters
+import org.jetbrains.kotlin.incremental.createDirectory
+
+internal abstract class PreCommitHookFormatAction :
+    WorkAction<PreCommitHookFormatAction.PreCommitHookParameters> {
+
+    interface PreCommitHookParameters : WorkParameters {
+        val projectDir: DirectoryProperty
+    }
+
+    protected val logger: Logger = Logging.getLogger(PreCommitHookFormatAction::class.java)
+
+    override fun execute() {
+        val rootDirectory = parameters.projectDir.get().asFile
+        val gitDirectory = File(rootDirectory, ".git")
+        val hooksDirectory = File(gitDirectory, "hooks")
+
+        if (!gitDirectory.exists()) {
+            logger.e("Git directory not found, will not create the hook")
+            return
+        }
+
+        if (!hooksDirectory.exists()) {
+            logger.i("Hooks directory does not exist, will create one")
+            hooksDirectory.createDirectory()
+        }
+
+        val hookFile = File(hooksDirectory, "pre-commit")
+
+        if (hookFile.exists()) {
+            logger.w("Pre commit hook file already exists, aborting hook generation")
+        } else {
+            hookFile.createNewFile()
+
+            hookFile.writeText(
+                """
+                #!/bin/bash
+                staged_files_count=${'$'}(git diff --name-only --cached --numstat -- '*.kt' | wc -l)
+
+                # format only if there are kotlin files in git's index
+                if [[ ${'$'}staged_files_count -gt 0 ]]; then
+                    ${rootDirectory.path}/gradlew -Pktfmt.gradle.includeOnly=${'$'}(git diff --name-only --cached -- '*.kt' | paste -sd ",") ktfmtFormat;
+                    git add -A $(git diff --name-only --cached -- '*.kt')
+                fi
+                exit 0;
+            """
+                    .trimIndent()
+            )
+
+            logger.i("Ktfmt pre commit hook was created")
+        }
+    }
+}

plugin-build/plugin/src/test/java/com/ncorti/ktfmt/gradle/tasks/GitPreCommitHookIntegrationTest.kt

@@ -0,0 +1,115 @@
+package com.ncorti.ktfmt.gradle.tasks
+
+import com.google.common.truth.Truth.assertThat
+import java.io.File
+import org.gradle.testkit.runner.GradleRunner
+import org.gradle.testkit.runner.TaskOutcome
+import org.jetbrains.kotlin.gradle.internal.ensureParentDirsCreated
+import org.jetbrains.kotlin.incremental.createDirectory
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+
+class GitPreCommitHookIntegrationTest {
+    @TempDir lateinit var tempDir: File
+
+    @BeforeEach
+    fun setUp() {
+        File(tempDir, "src/main/java").mkdirs()
+        File("src/test/resources/jvmProject").copyRecursively(tempDir)
+    }
+
+    @Test
+    fun `it does not create the pre commit hook if git directory does not exist`() {
+        val result =
+            GradleRunner.create()
+                .withProjectDir(tempDir)
+                .withPluginClasspath()
+                .withArguments("ktfmtGenerateGitPreCommitHook")
+                .build()
+
+        assertThat(result.task(":ktfmtGenerateGitPreCommitHook")?.outcome)
+            .isEqualTo(TaskOutcome.SUCCESS)
+        assertThat(result.output)
+            .contains("[ktfmt] Git directory not found, will not create the hook")
+        assertThat(File("${tempDir.path}/.git/hooks/pre-commit").exists()).isFalse()
+    }
+
+    @Test
+    fun `it does create the pre commit hook if git directory exists`() {
+        val gitDirectory = File("${tempDir.path}/.git")
+        gitDirectory.createDirectory()
+
+        val result =
+            GradleRunner.create()
+                .withProjectDir(tempDir)
+                .withPluginClasspath()
+                .withArguments("ktfmtGenerateGitPreCommitHook")
+                .build()
+
+        assertThat(result.task(":ktfmtGenerateGitPreCommitHook")?.outcome)
+            .isEqualTo(TaskOutcome.SUCCESS)
+        assertThat(File("${tempDir.path}/.git/hooks/pre-commit").exists()).isTrue()
+
+        val hookContent = File("${tempDir.path}/.git/hooks/pre-commit").readText().split("\n")
+
+        assertThat(hookContent[1])
+            .isEqualTo(
+                "staged_files_count=$(git diff --name-only --cached --numstat -- '*.kt' | wc -l)"
+            )
+        assertThat(hookContent[4]).isEqualTo("if [[ ${'$'}staged_files_count -gt 0 ]]; then")
+        assertThat(hookContent[5])
+            .contains(
+                """
+                gradlew -Pktfmt.gradle.includeOnly=${'$'}(git diff --name-only --cached -- '*.kt' | paste -sd ",") ktfmtFormat;
+                """
+                    .trimIndent()
+            )
+        assertThat(hookContent[6]).contains("git add -A $(git diff --name-only --cached -- '*.kt')")
+    }
+
+    @Test
+    fun `it does not create the pre commit hook if git directory exists but hook also already exists`() {
+        val gitDirectory = File("${tempDir.path}/.git")
+
+        gitDirectory.createDirectory()
+
+        val hookFile = File("${tempDir.path}/.git/hooks/pre-commit")
+
+        hookFile.ensureParentDirsCreated()
+        hookFile.createNewFile()
+
+        hookFile.writeText(
+            """
+            #!/bin/bash
+            echo exists;
+        """
+                .trimIndent()
+        )
+
+        val result =
+            GradleRunner.create()
+                .withProjectDir(tempDir)
+                .withPluginClasspath()
+                .withArguments("ktfmtGenerateGitPreCommitHook")
+                .build()
+
+        assertThat(result.task(":ktfmtGenerateGitPreCommitHook")?.outcome)
+            .isEqualTo(TaskOutcome.SUCCESS)
+        assertThat(File("${tempDir.path}/.git/hooks/pre-commit").exists()).isTrue()
+        assertThat(result.output)
+            .contains("[ktfmt] Pre commit hook file already exists, aborting hook generation")
+
+        assertThat(hookFile.readText())
+            .isEqualTo(
+                """
+            #!/bin/bash
+            echo exists;
+        """
+                    .trimIndent()
+            )
+
+        // clean up
+        gitDirectory.delete()
+    }
+}