Merge pull request #93 from nebula-plugins/enhance-facets-api

Add API to Facets that can be used in Kotlin DSL

Author: rpalcolea

src/main/groovy/nebula/plugin/responsible/NebulaFacetPlugin.groovy

@@ -187,6 +187,60 @@ class NebulaFacetPlugin implements Plugin<Project> {
         return instantiator.newInstance(NamedContainerProperOrder.class, type, instantiator, factory, decorator)
     }
 
+    /**
+     * Creates and configures a test facet programmatically using an Action.
+     * This is a type-safe alternative to using the container's create method,
+     * particularly useful for plugins written in Kotlin or Java.
+     *
+     * @param name the name of the test facet
+     * @param configureAction the action to configure the test facet
+     * @return the created and configured test facet
+     */
+    TestFacetDefinition createTestFacet(String name, Action<? super TestFacetDefinition> configureAction) {
+        TestFacetDefinition facet = new TestFacetDefinition(name)
+        configureAction.execute(facet)
+        extension.add(facet)
+        return facet
+    }
+
+    /**
+     * Creates a test facet with default configuration.
+     *
+     * @param name the name of the test facet
+     * @return the created test facet
+     */
+    TestFacetDefinition createTestFacet(String name) {
+        TestFacetDefinition facet = new TestFacetDefinition(name)
+        extension.add(facet)
+        return facet
+    }
+
+    /**
+     * Creates and configures a regular (non-test) facet programmatically using an Action.
+     *
+     * @param name the name of the facet
+     * @param configureAction the action to configure the facet
+     * @return the created and configured facet
+     */
+    FacetDefinition createFacet(String name, Action<? super FacetDefinition> configureAction) {
+        FacetDefinition facet = new FacetDefinition(name)
+        configureAction.execute(facet)
+        extension.add(facet)
+        return facet
+    }
+
+    /**
+     * Creates a regular facet with default configuration.
+     *
+     * @param name the name of the facet
+     * @return the created facet
+     */
+    FacetDefinition createFacet(String name) {
+        FacetDefinition facet = new FacetDefinition(name)
+        extension.add(facet)
+        return facet
+    }
+
     // TODO React to changes on a FacetDefinition, and re-create source set
 }
 

src/main/groovy/nebula/plugin/responsible/NebulaIntegTestPlugin.groovy

@@ -1,6 +1,7 @@
 package nebula.plugin.responsible
 
 import groovy.transform.CompileStatic
+import org.gradle.api.Action
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPlugin
@@ -22,11 +23,15 @@ class NebulaIntegTestPlugin implements Plugin<Project> {
         NebulaFacetPlugin facetPlugin = project.plugins.apply(NebulaFacetPlugin) as NebulaFacetPlugin
 
         project.plugins.withType(JavaPlugin) {
-            facetPlugin.extension.create(FACET_NAME) { TestFacetDefinition facet ->
-                facet.setTestTaskName(TASK_NAME)
-                facet.setParentSourceSet(PARENT_SOURCE_SET)
-                facet.setIncludeInCheckLifecycle(shouldIncludeInCheckLifecycle())
-            }
+            // Use the type-safe helper method - works with Java, Kotlin, and Groovy
+            facetPlugin.createTestFacet(FACET_NAME, new Action<TestFacetDefinition>() {
+                @Override
+                void execute(TestFacetDefinition facet) {
+                    facet.setTestTaskName(TASK_NAME)
+                    facet.setParentSourceSet(PARENT_SOURCE_SET)
+                    facet.setIncludeInCheckLifecycle(shouldIncludeInCheckLifecycle())
+                }
+            })
         }
     }
 

src/main/groovy/nebula/plugin/responsible/gradle/NamedContainerProperOrder.groovy

@@ -1,5 +1,6 @@
 package nebula.plugin.responsible.gradle
 
+import org.gradle.api.Action
 import org.gradle.api.NamedDomainObjectFactory
 import org.gradle.api.Namer
 import org.gradle.api.internal.CollectionCallbackActionDecorator
@@ -31,13 +32,31 @@ class NamedContainerProperOrder<T> extends FactoryNamedDomainObjectContainer<T>
     }
 
     @Override
-    public T create(String name, Closure configureClosure) {
-        assertCanAdd(name);
-        T object = doCreate(name);
+    T create(String name, Closure configureClosure) {
+        assertCanAdd(name)
+        T object = doCreate(name)
         // Configure the object BEFORE, adding and kicking off addEvents in doAdd
         ConfigureUtil.configure(configureClosure, object)
-        add(object);
-        return object;
+        add(object)
+        return object
+    }
+
+    /**
+     * Creates and configures a new object using an Action for Java/Kotlin interop.
+     * This allows plugins written in Kotlin or Java to create and configure facets
+     * programmatically without requiring Groovy closures.
+     *
+     * @param name the name of the object to create
+     * @param configureAction the action to configure the object
+     * @return the created and configured object
+     */
+    T create(String name, Action<? super T> configureAction) {
+        assertCanAdd(name)
+        T object = doCreate(name)
+        // Configure the object BEFORE adding, to maintain same semantics as closure version
+        configureAction.execute(object)
+        add(object)
+        return object
     }
 
 }

src/test/groovy/nebula/plugin/responsible/NebulaFacetPluginKotlinDslIntegrationSpec.groovy

@@ -0,0 +1,57 @@
+package nebula.plugin.responsible
+
+/**
+ * Integration test using REAL Kotlin DSL (build.gradle.kts) to verify
+ * the plugin works correctly with Kotlin build scripts and the programmatic API.
+ *
+ * This demonstrates that users can create facets programmatically from Kotlin DSL
+ * build scripts using idiomatic Kotlin lambda syntax.
+ */
+class NebulaFacetPluginKotlinDslIntegrationSpec extends BaseIntegrationTestKitSpec {
+
+    def 'create test facet from Kotlin DSL with lambda syntax'() {
+        given:
+        // Use actual build.gradle.kts (Kotlin DSL) with Java source
+        // This is a common real-world scenario: Kotlin build scripts with Java code
+        def buildFileKts = new File(projectDir, 'build.gradle.kts')
+        buildFileKts.text = '''
+            plugins {
+                java
+                id("com.netflix.nebula.facet")
+            }
+
+            import nebula.plugin.responsible.NebulaFacetPlugin
+
+            val facetPlugin = project.plugins.getPlugin(NebulaFacetPlugin::class.java)
+
+            // Idiomatic Kotlin lambda syntax - no Groovy closures required!
+            facetPlugin.createTestFacet("integTest") {
+                testTaskName = "integrationTest"
+                parentSourceSet = "test"
+                includeInCheckLifecycle = true
+            }
+
+            repositories {
+                mavenCentral()
+            }
+
+            dependencies {
+                testImplementation("junit:junit:4.13.2")
+            }
+        '''.stripIndent()
+
+        // Java test source (common scenario: Kotlin DSL + Java source)
+        writeTest('src/integTest/java/', 'com.example', false)
+
+        when:
+        def result = runTasks('integrationTest')
+
+        then:
+        result.task(':integrationTest')
+        fileExists('build/classes/java/integTest/com/example/HelloWorldTest.class')
+    }
+
+    boolean fileExists(String path) {
+        new File(projectDir, path).exists()
+    }
+}