Enable Customization of Package Name (#5)

Co-authored-by: Justin Kaufman <[email protected]>
Co-authored-by: Georg Dresler <[email protected]>

Author: 3 people

README.md

@@ -48,6 +48,19 @@ multiplatformSwiftPackage {
 }
 ```
 
+### Package Name
+By default, the name of the Swift package will be the base name of the first framework found in the project.
+However, you can declare a different name for the package.
+This might be useful if your frameworks have different base names, and you want your package to have a common name.
+
+```kotlin
+packageName("MyAwesomeKit")
+```
+
+Hint:
+If the cocoapods plugin is applied the name of the package will default to the value assigned to the `frameworkName` property.
+Otherwise, the value of the `baseName` property of the framework configuration will be used.
+
 ### Output Directory
 By default, the plugin will write all files into the _swiftpackage_ folder in the project directory.
 You can configure the output folder by providing a File object pointing to it.

build.gradle.kts

@@ -17,6 +17,7 @@ dependencies {
     testImplementation("io.kotest:kotest-assertions-core:4.3.0")
     testImplementation("io.kotest:kotest-property:4.3.0")
     testImplementation("io.mockk:mockk:1.10.0")
+    testImplementation(kotlin("gradle-plugin"))
 }
 
 java {

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/SwiftPackageExtension.kt

@@ -12,12 +12,23 @@ import java.io.File
 public open class SwiftPackageExtension(project: Project) {
 
     internal var buildConfiguration: BuildConfiguration = BuildConfiguration.Release
+    internal var packageName: Either<PluginConfigurationError, PackageName>? = null
     internal var outputDirectory: OutputDirectory = OutputDirectory(File(project.projectDir, "swiftpackage"))
     internal var swiftToolsVersion: SwiftToolVersion? = null
     internal var distributionMode: DistributionMode = DistributionMode.Local
     internal var targetPlatforms: Collection<Either<List<PluginConfigurationError>, TargetPlatform>> = emptyList()
     internal var appleTargets: Collection<AppleTarget> = emptyList()
 
+    /**
+     * Sets the name of the Swift package.
+     * Defaults to the base name of the first framework found in the project.
+     *
+     * @param name of the Swift package.
+     */
+    public fun packageName(name: String) {
+        packageName = PackageName.of(name)
+    }
+
     /**
      * Sets the directory where files like the Package.swift and XCFramework will be created.
      * Defaults to $projectDir/swiftpackage

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/domain/Either.kt

@@ -4,6 +4,10 @@ internal sealed class Either<out L, out R> {
     data class Left<out L, out R>(val value: L) : Either<L, R>()
     data class Right<out L, out R>(val value: R) : Either<L, R>()
 
+    val leftValueOrNull: L? get() = (this as? Left)?.value
+
+    val orNull: R? get() = (this as? Right)?.value
+
     fun <T> fold(l: (L) -> T, r: (R) -> T): T = when (this) {
         is Left -> l(value)
         is Right -> r(value)

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/domain/PackageName.kt

@@ -0,0 +1,19 @@
+package com.chromaticnoise.multiplatformswiftpackage.domain
+
+import com.chromaticnoise.multiplatformswiftpackage.domain.PluginConfiguration.PluginConfigurationError
+import com.chromaticnoise.multiplatformswiftpackage.domain.PluginConfiguration.PluginConfigurationError.InvalidPackageName
+
+internal class PackageName private constructor(val value: String) {
+
+    internal companion object {
+        fun of(name: String?): Either<PluginConfigurationError, PackageName> =
+            name?.ifNotBlank { Either.Right(PackageName(it)) }
+            ?: Either.Left(InvalidPackageName(name))
+    }
+
+    override fun equals(other: Any?): Boolean = value == (other as? PackageName)?.value
+
+    override fun hashCode(): Int = value.hashCode()
+
+    override fun toString(): String = "PackageName(value='$value')"
+}

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/domain/PluginConfiguration.kt

@@ -5,6 +5,7 @@ import com.chromaticnoise.multiplatformswiftpackage.domain.PluginConfiguration.P
 
 internal class PluginConfiguration private constructor(
     val buildConfiguration: BuildConfiguration,
+    val packageName: PackageName,
     val outputDirectory: OutputDirectory,
     val swiftToolsVersion: SwiftToolVersion,
     val distributionMode: DistributionMode,
@@ -14,6 +15,7 @@ internal class PluginConfiguration private constructor(
     internal companion object {
         fun of(extension: SwiftPackageExtension): Either<List<PluginConfigurationError>, PluginConfiguration> {
             val targetPlatforms = extension.targetPlatforms.platforms
+            val packageName = extension.getPackageName()
 
             val errors = mutableListOf<PluginConfigurationError>().apply {
                 if (extension.swiftToolsVersion == null) {
@@ -32,12 +34,15 @@ internal class PluginConfiguration private constructor(
                 if (extension.appleTargets.isEmpty() && targetPlatforms.isNotEmpty()) {
                     add(MissingAppleTargets)
                 }
+
+                packageName.leftValueOrNull?.let { error -> add(error) }
             }
 
             return if (errors.isEmpty()) {
                 Either.Right(
                     PluginConfiguration(
                         extension.buildConfiguration,
+                        packageName.orNull!!,
                         extension.outputDirectory,
                         extension.swiftToolsVersion!!,
                         extension.distributionMode,
@@ -49,12 +54,18 @@ internal class PluginConfiguration private constructor(
                 Either.Left(errors)
             }
         }
+
+        private fun SwiftPackageExtension.getPackageName(): Either<PluginConfigurationError, PackageName> = packageName
+            ?: appleTargets.getFrameworks(buildConfiguration).firstOrNull()?.let { framework ->
+                PackageName.of(framework.baseName)
+            } ?: Either.Left(InvalidPackageName(null))
     }
 
     internal sealed class PluginConfigurationError {
         object MissingSwiftToolsVersion : PluginConfigurationError()
         data class InvalidTargetName(val name: String) : PluginConfigurationError()
         object MissingTargetPlatforms : PluginConfigurationError()
         object MissingAppleTargets : PluginConfigurationError()
+        data class InvalidPackageName(val name: String?) : PluginConfigurationError()
     }
 }

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/domain/Project+PluginConfiguration.kt

@@ -33,5 +33,9 @@ private fun List<PluginConfigurationError>.toErrorMessage() = joinToString("\n\n
         * Target name is invalid: ${error.name}
           Only the following target names are valid: ${TargetName.values().joinToString { it.identifier }}
         """.trimIndent()
+        is PluginConfigurationError.InvalidPackageName -> """
+        * Package name is invalid: ${error.name}
+          Either declare the base name of your frameworks or use a non-empty package name.
+        """.trimIndent()
     }
 }

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/domain/SwiftPackageConfiguration.kt

@@ -6,6 +6,7 @@ import org.gradle.api.Project
 
 internal data class SwiftPackageConfiguration(
     private val project: Project,
+    private val packageName: PackageName,
     private val toolVersion: SwiftToolVersion,
     private val platforms: String,
     private val distributionMode: DistributionMode,
@@ -14,12 +15,12 @@ internal data class SwiftPackageConfiguration(
 
     private val distributionUrl = when (distributionMode) {
         DistributionMode.Local -> null
-        is DistributionMode.Remote -> distributionMode.url.appendPath(zipFileName(project))
+        is DistributionMode.Remote -> distributionMode.url.appendPath(zipFileName(project, packageName))
     }
 
     internal val templateProperties = mapOf(
         "toolsVersion" to toolVersion.name,
-        "name" to project.name,
+        "name" to packageName.value,
         "platforms" to platforms,
         "isLocal" to (distributionMode == DistributionMode.Local),
         "url" to distributionUrl?.value,

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/domain/extensions.kt

@@ -1,6 +1,7 @@
 package com.chromaticnoise.multiplatformswiftpackage.domain
 
 import org.gradle.api.Action
+import org.jetbrains.kotlin.gradle.plugin.mpp.Framework
 import org.jetbrains.kotlin.konan.target.Family
 import org.jetbrains.kotlin.konan.target.KonanTarget
 
@@ -34,3 +35,8 @@ internal val TargetName.konanTarget: KonanTarget get() = when (this) {
     TargetName.TvOSx64 -> KonanTarget.TVOS_X64
     TargetName.MacOSx64 -> KonanTarget.MACOS_X64
 }
+
+internal fun Collection<AppleTarget>.getFrameworks(buildConfiguration: BuildConfiguration): Collection<Framework> =
+    mapNotNull { target ->
+        target.framework(buildConfiguration)
+    }

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/task/CreateSwiftPackageTask.kt

@@ -22,10 +22,11 @@ internal fun Project.registerCreateSwiftPackageTask() {
 
             val packageConfiguration = SwiftPackageConfiguration(
                 project = project,
+                packageName = configuration.packageName,
                 toolVersion = configuration.swiftToolsVersion,
                 platforms = platforms(configuration),
                 distributionMode = configuration.distributionMode,
-                zipChecksum = zipFileChecksum(project, configuration.outputDirectory)
+                zipChecksum = zipFileChecksum(project, configuration.outputDirectory, configuration.packageName)
             )
 
             SimpleTemplateEngine()

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/task/CreateXCFrameworkTask.kt

@@ -1,6 +1,7 @@
 package com.chromaticnoise.multiplatformswiftpackage.task
 
 import com.chromaticnoise.multiplatformswiftpackage.domain.getConfigurationOrThrow
+import com.chromaticnoise.multiplatformswiftpackage.domain.getFrameworks
 import org.gradle.api.Project
 import org.gradle.api.tasks.Exec
 import java.io.File
@@ -10,12 +11,8 @@ internal fun Project.registerCreateXCFrameworkTask() = tasks.register("createXCF
     description = "Creates an XCFramework for all declared Apple targets"
 
     val configuration = getConfigurationOrThrow()
-    val buildConfiguration = configuration.buildConfiguration
-    val xcFrameworkDestination = File(configuration.outputDirectory.value, "${project.name}.xcframework")
-
-    val frameworks = configuration.appleTargets.mapNotNull { target ->
-        target.framework(buildConfiguration)
-    }
+    val xcFrameworkDestination = File(configuration.outputDirectory.value, "${configuration.packageName.value}.xcframework")
+    val frameworks = configuration.appleTargets.getFrameworks(configuration.buildConfiguration)
 
     dependsOn(frameworks.map { it.linkTaskName })
 
@@ -28,7 +25,7 @@ internal fun Project.registerCreateXCFrameworkTask() = tasks.register("createXCF
             add("-framework")
             add(framework.outputFile.path)
 
-            val dsymFile = File(framework.outputFile.parent, "${project.name}.framework.dSYM")
+            val dsymFile = File(framework.outputFile.parent, "${framework.baseName}.framework.dSYM")
             if (dsymFile.exists()) {
                 add("-debug-symbols")
                 add(dsymFile.path)

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/task/CreateZipFileTask.kt

@@ -13,7 +13,7 @@ internal fun Project.registerCreateZipFileTask() {
 
         val configuration = getConfigurationOrThrow()
         val outputDirectory = configuration.outputDirectory.value
-        archiveFileName.set(zipFileName(project))
+        archiveFileName.set(zipFileName(project, configuration.packageName))
         destinationDirectory.set(outputDirectory)
         from(outputDirectory) {
             include("**/*.xcframework/")

src/main/kotlin/com/chromaticnoise/multiplatformswiftpackage/task/zip-functions.kt

@@ -1,13 +1,14 @@
 package com.chromaticnoise.multiplatformswiftpackage.task
 
+import com.chromaticnoise.multiplatformswiftpackage.domain.PackageName
 import com.chromaticnoise.multiplatformswiftpackage.domain.OutputDirectory
 import org.gradle.api.Project
 import java.io.ByteArrayOutputStream
 import java.io.File
 
-internal fun zipFileChecksum(project: Project, outputDirectory: OutputDirectory): String {
+internal fun zipFileChecksum(project: Project, outputDirectory: OutputDirectory, packageName: PackageName): String {
     val outputPath = outputDirectory.value
-    return File(outputPath, zipFileName(project))
+    return File(outputPath, zipFileName(project, packageName))
         .takeIf { it.exists() }
         ?.let { zipFile ->
             ByteArrayOutputStream().use { os ->
@@ -22,4 +23,4 @@ internal fun zipFileChecksum(project: Project, outputDirectory: OutputDirectory)
         } ?: ""
 }
 
-internal fun zipFileName(project: Project) = "${project.name}-${project.version}.zip"
+internal fun zipFileName(project: Project, packageName: PackageName) = "${packageName.value}-${project.version}.zip"

src/test/kotlin/com/chromaticnoise/multiplatformswiftpackage/domain/PackageNameTest.kt

@@ -0,0 +1,34 @@
+package com.chromaticnoise.multiplatformswiftpackage.domain
+
+import com.chromaticnoise.multiplatformswiftpackage.domain.PluginConfiguration.PluginConfigurationError.InvalidPackageName
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.booleans.shouldBeFalse
+import io.kotest.matchers.booleans.shouldBeTrue
+import io.kotest.matchers.types.shouldBeInstanceOf
+import io.kotest.property.Arb
+import io.kotest.property.arbitrary.filter
+import io.kotest.property.arbitrary.string
+import io.kotest.property.forAll
+
+class PackageNameTest : StringSpec({
+
+    "empty name should not be valid" {
+        PackageName.of("").leftValueOrNull!!.shouldBeInstanceOf<InvalidPackageName>()
+    }
+
+    "blank names should not be valid" {
+        forAll(Arb.string().filter { it.isBlank() }) { name ->
+            PackageName.of(name).leftValueOrNull is InvalidPackageName
+        }
+    }
+
+    "two instances should be equal if their names are equal" {
+        (PackageName.of("equal name") == PackageName.of("equal name"))
+            .shouldBeTrue()
+    }
+
+    "two instances should not be equal if their names differ" {
+        (PackageName.of("some name") == PackageName.of("different name"))
+            .shouldBeFalse()
+    }
+})

src/test/kotlin/com/chromaticnoise/multiplatformswiftpackage/domain/PluginConfigurationTest.kt

@@ -4,9 +4,11 @@ import com.chromaticnoise.multiplatformswiftpackage.SwiftPackageExtension
 import com.chromaticnoise.multiplatformswiftpackage.domain.PluginConfiguration.PluginConfigurationError.*
 import io.kotest.core.spec.style.BehaviorSpec
 import io.kotest.core.test.TestCase
+import io.kotest.matchers.shouldBe
 import io.mockk.every
 import io.mockk.mockk
 import org.gradle.api.Project
+import org.jetbrains.kotlin.gradle.plugin.mpp.Framework
 import java.io.File
 
 class PluginConfigurationTest : BehaviorSpec() {
@@ -48,6 +50,38 @@ class PluginConfigurationTest : BehaviorSpec() {
                     (PluginConfiguration.of(extension) as Either.Left).value.contains(MissingAppleTargets)
                 }
             }
+
+            When("the package name produced errors") {
+                val expectedError = InvalidPackageName(null)
+                extension.packageName = Either.Left(expectedError)
+
+                Then("an error should be returned") {
+                    (PluginConfiguration.of(extension) as Either.Left).value.contains(expectedError)
+                }
+            }
+
+            When("the package name is null and no apple framework exists") {
+                extension.packageName = null
+                extension.appleTargets = emptyList()
+
+                Then("an error should be returned") {
+                    (PluginConfiguration.of(extension) as Either.Left).value.contains(InvalidPackageName(null))
+                }
+            }
+
+            When("the package name is null and apple frameworks exist") {
+                val expectedName = "expected name"
+                val framework = mockk<Framework> { every { baseName } returns expectedName }
+                extension.swiftToolsVersion = SwiftToolVersion.of("42")
+                extension.packageName = null
+                extension.appleTargets = listOf(
+                    mockk { every { framework(any()) } returns framework }
+                )
+
+                Then("the base name of the first framework should be used") {
+                    PluginConfiguration.of(extension).orNull!!.packageName.value shouldBe expectedName
+                }
+            }
         }
     }
 

src/test/kotlin/com/chromaticnoise/multiplatformswiftpackage/domain/SwiftPackageConfigurationTest.kt

@@ -5,7 +5,6 @@ import io.kotest.matchers.nulls.shouldBeNull
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.string.shouldEndWith
 import io.kotest.matchers.string.shouldStartWith
-import io.mockk.every
 import io.mockk.mockk
 
 class SwiftPackageConfigurationTest : StringSpec() {
@@ -17,10 +16,10 @@ class SwiftPackageConfigurationTest : StringSpec() {
                 .templateProperties["toolsVersion"].shouldBe("42")
         }
 
-        "name property should match the project name" {
+        "name property should match the configured package name" {
             configuration()
-                .copy(project = mockk(relaxed = true) { every { name } returns "project name" })
-                .templateProperties["name"].shouldBe("project name")
+                .copy(packageName = PackageName.of("expected name").orNull!!)
+                .templateProperties["name"].shouldBe("expected name")
         }
 
         "platforms property should match the given platforms" {
@@ -68,6 +67,7 @@ class SwiftPackageConfigurationTest : StringSpec() {
 
     private fun configuration() = SwiftPackageConfiguration(
         project = mockk(relaxed = true),
+        packageName = PackageName.of("package name").orNull!!,
         toolVersion = SwiftToolVersion.of("42")!!,
         platforms = "",
         distributionMode = DistributionMode.Local,