From b21303cba52074be6ce01603b5b0280df4daf573 Mon Sep 17 00:00:00 2001 From: Sven Kiesewetter Date: Mon, 5 Dec 2022 13:59:59 +0100 Subject: [PATCH 1/5] feat: support to resolve library version conflicts (#81089) --- .../gradle/icm/tasks/CreateLibList.kt | 81 +++++++++++++++---- 1 file changed, 65 insertions(+), 16 deletions(-) diff --git a/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt b/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt index 9f51306..419e932 100644 --- a/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt +++ b/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt @@ -30,7 +30,10 @@ import org.gradle.api.tasks.Input import org.gradle.api.tasks.InputFiles import org.gradle.api.tasks.OutputFile import org.gradle.api.tasks.TaskAction +import org.gradle.util.internal.VersionNumber import java.io.FileInputStream +import java.lang.IllegalArgumentException +import java.lang.module.ModuleDescriptor.Version import java.util.* import javax.inject.Inject @@ -77,28 +80,25 @@ open class CreateLibList @Inject constructor( */ @TaskAction fun execute() { - val dependencies = mutableSetOf() + // map group+name to another map mapping group+name+version to cartridgeNames (space separated list) + // e.g. "aopalliance:aopalliance" -> { + // "1.0" -> "ac_order_export_xml_b2b ac_cxml_order_injection", + // "1.0.1" -> "ac_order_export_xml_b2b ac_cxml_order_injection" + // } val dependenciesVersions = mutableMapOf>() cartridgeDescriptors.get().forEach { val props = getCartridgeProperties(it) - dependencies.addAll(getLibraryIDs(props).apply { - this.forEach { - val groupAndName = it.substringBeforeLast(':') - val versionInProjects = dependenciesVersions.computeIfAbsent(groupAndName, { mutableMapOf() }) - versionInProjects.compute( - it - ) { _, p -> if (null == p) getCartridgeName(props) else p + " " + getCartridgeName(props) } + getLibraryIDs(props).forEach { libraryID -> + val groupAndName = libraryID.substringBeforeLast(':') + val version = libraryID.substringAfterLast(':') + val versionToCartridges = dependenciesVersions.computeIfAbsent(groupAndName) { mutableMapOf() } + versionToCartridges.compute(version) { _, cartNames -> + if (null == cartNames) getCartridgeName(props) else cartNames + " " + getCartridgeName(props) } - }) + } } - val conflicts = dependenciesVersions.filter { e -> 1 < e.value.size }.map { it.value }.toList() - if (conflicts.isNotEmpty()) { - throw GradleException( - "Unable to process libraries. Dependencies ${conflicts}" + - " are required by cartridge-projects in non-unique versions." - ) - } + val dependencies = dependenciesVersions.toSortedMap().map { (groupAndName, versionToCartridges) -> toDependencyId(groupAndName, resolveVersionConflict(groupAndName, versionToCartridges))}.toMutableList() exludeLibraryLists.get().forEach { val excludeList = DependencyListUtil.getIDList(environmentType.get(), it) @@ -119,6 +119,55 @@ open class CreateLibList @Inject constructor( } } + private fun resolveVersionConflict(groupAndName : String, versionToCartridges : Map) : String { + // not a conflict at all ? + if (versionToCartridges.size == 1){ + return versionToCartridges.keys.first() + } + + project.logger.debug("Trying to resolve a version conflict for dependency '{}' requiring the versions {}", groupAndName, versionToCartridges.keys) + + // parse to org.gradle.util.internal.VersionNumber + val versions = versionToCartridges.keys.map { versionStr -> + val versionNumber = VersionNumber.parse(versionStr) + if (versionNumber == VersionNumber.UNKNOWN) { + throw GradleException( + "The version string '$versionStr' can not be parsed into a ${VersionNumber::class.java} therefore the conflict resolution must be done manually: The dependency '$groupAndName' is required in ${versionToCartridges.size} versions by the following cartridges: $versionToCartridges") + } + versionNumber + }.sortedDescending() + + // check for major/minor/patch version jump + var prev : VersionNumber? = null + for (curr in versions) { + if (prev == null){ + prev = curr + continue // skip first iteration (nothing to compare) + } + if (prev.major != curr.major){ + throw GradleException( + "There's a major version conflict for dependency '$groupAndName': $prev <-> $curr. Please resolve this conflict analyzing the dependencies of the following cartridges: $versionToCartridges") + } + val chosen = maxOf(prev, curr) + if (prev.minor != curr.minor){ + project.logger.warn("There's a minor version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If this is not the correct version please resolve this conflict analyzing the dependencies of the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) + } + if (prev.micro != curr.micro){ + project.logger.info("There's a patch version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If this is not the correct version please resolve this conflict analyzing the dependencies of the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) + } + prev = curr + } + + // finally take the first (highest) version + val chosen = versions.first() + project.logger.debug("Resolved the version conflict for dependency '{}' choosing the versions {}", groupAndName, chosen) + return chosen.toString() + } + + private fun toDependencyId(groupAndName : String, version : String): String { + return "$groupAndName:$version" + } + private fun getCartridgeProperties(propsFile: RegularFile): Properties { val props = Properties() FileInputStream(propsFile.asFile).use { From 2c8ff237afc848dc38bd4dced683c0d8a913b000 Mon Sep 17 00:00:00 2001 From: Sven Kiesewetter Date: Mon, 5 Dec 2022 14:14:41 +0100 Subject: [PATCH 2/5] feat: support to resolve library version conflicts (#81089) * fixed line length --- .../gradle/icm/tasks/CreateLibList.kt | 62 ++++++++++++------- 1 file changed, 39 insertions(+), 23 deletions(-) diff --git a/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt b/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt index 419e932..bff8d80 100644 --- a/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt +++ b/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt @@ -32,19 +32,18 @@ import org.gradle.api.tasks.OutputFile import org.gradle.api.tasks.TaskAction import org.gradle.util.internal.VersionNumber import java.io.FileInputStream -import java.lang.IllegalArgumentException -import java.lang.module.ModuleDescriptor.Version -import java.util.* +import java.util.Properties import javax.inject.Inject /** * Collects all libraries (recursively through all (sub-)projects) and write IDs to a file */ open class CreateLibList @Inject constructor( - objectFactory: ObjectFactory ) : DefaultTask() { + objectFactory: ObjectFactory, +) : DefaultTask() { private val copiedLibrariesDirectoryProperty: Property = - project.objects.directoryProperty().convention(project.layout.buildDirectory.dir(BUILD_FOLDER)) + project.objects.directoryProperty().convention(project.layout.buildDirectory.dir(BUILD_FOLDER)) companion object { const val DEFAULT_NAME = "CreateLibraries" @@ -53,6 +52,7 @@ open class CreateLibList @Inject constructor( fun getName(type: String): String { return "${type.lowercase()}${DEFAULT_NAME}" } + fun getOutputPath(type: String): String { return "librarylist/${type.lowercase()}/file.list" } @@ -98,7 +98,9 @@ open class CreateLibList @Inject constructor( } } - val dependencies = dependenciesVersions.toSortedMap().map { (groupAndName, versionToCartridges) -> toDependencyId(groupAndName, resolveVersionConflict(groupAndName, versionToCartridges))}.toMutableList() + val dependencies = dependenciesVersions.toSortedMap().map { (groupAndName, versionToCartridges) -> + toDependencyId(groupAndName, resolveVersionConflict(groupAndName, versionToCartridges)) + }.toMutableList() exludeLibraryLists.get().forEach { val excludeList = DependencyListUtil.getIDList(environmentType.get(), it) @@ -108,7 +110,7 @@ open class CreateLibList @Inject constructor( val sortedDeps = dependencies.toList().sorted() val listFile = libraryListFile.asFile.get() - if(listFile.exists()) { + if (listFile.exists()) { listFile.delete() } @@ -119,52 +121,65 @@ open class CreateLibList @Inject constructor( } } - private fun resolveVersionConflict(groupAndName : String, versionToCartridges : Map) : String { + private fun resolveVersionConflict(groupAndName: String, versionToCartridges: Map): String { // not a conflict at all ? - if (versionToCartridges.size == 1){ + if (versionToCartridges.size == 1) { return versionToCartridges.keys.first() } - project.logger.debug("Trying to resolve a version conflict for dependency '{}' requiring the versions {}", groupAndName, versionToCartridges.keys) + project.logger.debug("Trying to resolve a version conflict for dependency '{}' requiring the versions {}", + groupAndName, versionToCartridges.keys) // parse to org.gradle.util.internal.VersionNumber val versions = versionToCartridges.keys.map { versionStr -> val versionNumber = VersionNumber.parse(versionStr) if (versionNumber == VersionNumber.UNKNOWN) { throw GradleException( - "The version string '$versionStr' can not be parsed into a ${VersionNumber::class.java} therefore the conflict resolution must be done manually: The dependency '$groupAndName' is required in ${versionToCartridges.size} versions by the following cartridges: $versionToCartridges") + "The version string '$versionStr' can not be parsed into a ${VersionNumber::class.java} " + + "therefore the conflict resolution must be done manually: The dependency '$groupAndName' is " + + "required in ${versionToCartridges.size} versions by the following cartridges: " + + "$versionToCartridges") } versionNumber }.sortedDescending() // check for major/minor/patch version jump - var prev : VersionNumber? = null + var prev: VersionNumber? = null for (curr in versions) { - if (prev == null){ + if (prev == null) { prev = curr continue // skip first iteration (nothing to compare) } - if (prev.major != curr.major){ + if (prev.major != curr.major) { throw GradleException( - "There's a major version conflict for dependency '$groupAndName': $prev <-> $curr. Please resolve this conflict analyzing the dependencies of the following cartridges: $versionToCartridges") + "There's a major version conflict for dependency '$groupAndName': $prev <-> $curr. Please " + + "resolve this conflict analyzing the dependencies of the following cartridges: " + + "$versionToCartridges") } val chosen = maxOf(prev, curr) - if (prev.minor != curr.minor){ - project.logger.warn("There's a minor version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If this is not the correct version please resolve this conflict analyzing the dependencies of the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) + if (prev.minor != curr.minor) { + project.logger.warn( + "There's a minor version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If " + + "this is not the correct version please resolve this conflict analyzing the dependencies of " + + "the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) } - if (prev.micro != curr.micro){ - project.logger.info("There's a patch version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If this is not the correct version please resolve this conflict analyzing the dependencies of the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) + if (prev.micro != curr.micro) { + project.logger.info( + "There's a patch version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If " + + "this is not the correct version please resolve this conflict analyzing the dependencies of " + + "the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) } prev = curr } // finally take the first (highest) version val chosen = versions.first() - project.logger.debug("Resolved the version conflict for dependency '{}' choosing the versions {}", groupAndName, chosen) + project.logger.debug("Resolved the version conflict for dependency '{}' choosing the versions {}", + groupAndName, chosen) return chosen.toString() } - private fun toDependencyId(groupAndName : String, version : String): String { + private fun toDependencyId(groupAndName: String, version: String): String { return "$groupAndName:$version" } @@ -175,11 +190,12 @@ open class CreateLibList @Inject constructor( } return props } - private fun getCartridgeName(props:Properties): String { + + private fun getCartridgeName(props: Properties): String { return props["cartridge.name"].toString() } - private fun getLibraryIDs(props:Properties): Set { + private fun getLibraryIDs(props: Properties): Set { val dependsOnLibs = props["cartridge.dependsOnLibs"].toString() return if (dependsOnLibs.isEmpty()) setOf() else dependsOnLibs.split(";").toSet() } From 9f6b59059001974cc987043cd3bd6c45a6d1cb2a Mon Sep 17 00:00:00 2001 From: Sven Kiesewetter Date: Tue, 6 Dec 2022 10:52:51 +0100 Subject: [PATCH 3/5] feat: support to resolve library version conflicts (#81089) * migrated to usage if semver4j (currently works but only supports real semantic version strings) --- build.gradle.kts | 1 + .../gradle/icm/tasks/CreateLibList.kt | 44 +++++++++++-------- 2 files changed, 26 insertions(+), 19 deletions(-) diff --git a/build.gradle.kts b/build.gradle.kts index 585c46a..a8e2060 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -320,6 +320,7 @@ dependencies { implementation(localGroovy()) compileOnly("org.apache.ant:ant:1.10.12") + implementation("com.vdurmont:semver4j:3.1.0") testImplementation("com.intershop.gradle.test:test-gradle-plugin:4.1.2") testImplementation(gradleTestKit()) diff --git a/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt b/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt index bff8d80..79da480 100644 --- a/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt +++ b/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt @@ -18,6 +18,8 @@ package com.intershop.gradle.icm.tasks import com.intershop.gradle.icm.utils.DependencyListUtil +import com.vdurmont.semver4j.Semver +import com.vdurmont.semver4j.SemverException import org.gradle.api.DefaultTask import org.gradle.api.GradleException import org.gradle.api.file.Directory @@ -30,7 +32,6 @@ import org.gradle.api.tasks.Input import org.gradle.api.tasks.InputFiles import org.gradle.api.tasks.OutputFile import org.gradle.api.tasks.TaskAction -import org.gradle.util.internal.VersionNumber import java.io.FileInputStream import java.util.Properties import javax.inject.Inject @@ -42,9 +43,6 @@ open class CreateLibList @Inject constructor( objectFactory: ObjectFactory, ) : DefaultTask() { - private val copiedLibrariesDirectoryProperty: Property = - project.objects.directoryProperty().convention(project.layout.buildDirectory.dir(BUILD_FOLDER)) - companion object { const val DEFAULT_NAME = "CreateLibraries" const val BUILD_FOLDER = "libraries" @@ -80,7 +78,7 @@ open class CreateLibList @Inject constructor( */ @TaskAction fun execute() { - // map group+name to another map mapping group+name+version to cartridgeNames (space separated list) + // map group+name to another map mapping -> version to cartridgeNames (space separated list) // e.g. "aopalliance:aopalliance" -> { // "1.0" -> "ac_order_export_xml_b2b ac_cxml_order_injection", // "1.0.1" -> "ac_order_export_xml_b2b ac_cxml_order_injection" @@ -98,6 +96,7 @@ open class CreateLibList @Inject constructor( } } + // convert dependenciesVersions into a list of dependencyIds resolving version conflicts if required val dependencies = dependenciesVersions.toSortedMap().map { (groupAndName, versionToCartridges) -> toDependencyId(groupAndName, resolveVersionConflict(groupAndName, versionToCartridges)) }.toMutableList() @@ -121,6 +120,13 @@ open class CreateLibList @Inject constructor( } } + /** + * Resolves a version conflict if required (more than 1 version referenced). The conflict is resolved by choosing + * the highest version except the version gap is a major update - then a GradleException is thrown. If the gap is + * a minor update a warning is logged, on a patch update an info message is logged. + * ATTENTION: this method requires the versions to be semantic version parseable by + * com.vdurmont.semver4j.Semver.Semver(java.lang.String) + */ private fun resolveVersionConflict(groupAndName: String, versionToCartridges: Map): String { // not a conflict at all ? if (versionToCartridges.size == 1) { @@ -132,19 +138,19 @@ open class CreateLibList @Inject constructor( // parse to org.gradle.util.internal.VersionNumber val versions = versionToCartridges.keys.map { versionStr -> - val versionNumber = VersionNumber.parse(versionStr) - if (versionNumber == VersionNumber.UNKNOWN) { + try { + Semver(versionStr) + } catch (e: SemverException) { throw GradleException( - "The version string '$versionStr' can not be parsed into a ${VersionNumber::class.java} " + - "therefore the conflict resolution must be done manually: The dependency '$groupAndName' is " + - "required in ${versionToCartridges.size} versions by the following cartridges: " + - "$versionToCartridges") + "The version string '$versionStr' can not be parsed therefore the conflict resolution must be " + + "done manually: The dependency '$groupAndName' is required in ${versionToCartridges.size} " + + "different versions by the following cartridges: " + + "$versionToCartridges", e) } - versionNumber }.sortedDescending() // check for major/minor/patch version jump - var prev: VersionNumber? = null + var prev: Semver? = null for (curr in versions) { if (prev == null) { prev = curr @@ -160,21 +166,21 @@ open class CreateLibList @Inject constructor( if (prev.minor != curr.minor) { project.logger.warn( "There's a minor version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If " + - "this is not the correct version please resolve this conflict analyzing the dependencies of " + - "the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) + "this is not the correct version please resolve this conflict by analyzing the dependencies " + + "of the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) } - if (prev.micro != curr.micro) { + if (prev.patch != curr.patch) { project.logger.info( "There's a patch version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If " + - "this is not the correct version please resolve this conflict analyzing the dependencies of " + - "the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) + "this is not the correct version please resolve this conflict by analyzing the dependencies " + + "of the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) } prev = curr } // finally take the first (highest) version val chosen = versions.first() - project.logger.debug("Resolved the version conflict for dependency '{}' choosing the versions {}", + project.logger.debug("Resolved the version conflict for dependency '{}' choosing version {}", groupAndName, chosen) return chosen.toString() } From 4f03e3273866d661e32a221c5a6ed4a78d238e80 Mon Sep 17 00:00:00 2001 From: Sven Kiesewetter Date: Wed, 7 Dec 2022 14:47:09 +0100 Subject: [PATCH 4/5] feat: support to resolve library version conflicts (#81089) * now using com.intershop.version:sementic-version:1.0.0 for version parsing/comparison --- build.gradle.kts | 2 +- .../gradle/icm/tasks/CreateLibList.kt | 20 +++++++++---------- 2 files changed, 10 insertions(+), 12 deletions(-) diff --git a/build.gradle.kts b/build.gradle.kts index a8e2060..b68ed27 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -320,7 +320,7 @@ dependencies { implementation(localGroovy()) compileOnly("org.apache.ant:ant:1.10.12") - implementation("com.vdurmont:semver4j:3.1.0") + implementation("com.intershop.version:semantic-version:1.0.0") testImplementation("com.intershop.gradle.test:test-gradle-plugin:4.1.2") testImplementation(gradleTestKit()) diff --git a/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt b/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt index 79da480..7b481f3 100644 --- a/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt +++ b/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt @@ -18,11 +18,9 @@ package com.intershop.gradle.icm.tasks import com.intershop.gradle.icm.utils.DependencyListUtil -import com.vdurmont.semver4j.Semver -import com.vdurmont.semver4j.SemverException +import com.intershop.version.semantic.SemanticVersion import org.gradle.api.DefaultTask import org.gradle.api.GradleException -import org.gradle.api.file.Directory import org.gradle.api.file.RegularFile import org.gradle.api.file.RegularFileProperty import org.gradle.api.model.ObjectFactory @@ -139,8 +137,8 @@ open class CreateLibList @Inject constructor( // parse to org.gradle.util.internal.VersionNumber val versions = versionToCartridges.keys.map { versionStr -> try { - Semver(versionStr) - } catch (e: SemverException) { + SemanticVersion.valueOf(versionStr) + } catch (e: Exception) { throw GradleException( "The version string '$versionStr' can not be parsed therefore the conflict resolution must be " + "done manually: The dependency '$groupAndName' is required in ${versionToCartridges.size} " + @@ -150,7 +148,7 @@ open class CreateLibList @Inject constructor( }.sortedDescending() // check for major/minor/patch version jump - var prev: Semver? = null + var prev: SemanticVersion? = null for (curr in versions) { if (prev == null) { prev = curr @@ -158,7 +156,7 @@ open class CreateLibList @Inject constructor( } if (prev.major != curr.major) { throw GradleException( - "There's a major version conflict for dependency '$groupAndName': $prev <-> $curr. Please " + + "There's a major version conflict for dependency '$groupAndName': ${prev.version} <-> ${curr.version}. Please " + "resolve this conflict analyzing the dependencies of the following cartridges: " + "$versionToCartridges") } @@ -167,22 +165,22 @@ open class CreateLibList @Inject constructor( project.logger.warn( "There's a minor version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If " + "this is not the correct version please resolve this conflict by analyzing the dependencies " + - "of the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) + "of the following cartridges: {}", groupAndName, prev.version, curr.version, chosen.version, versionToCartridges) } if (prev.patch != curr.patch) { project.logger.info( "There's a patch version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If " + "this is not the correct version please resolve this conflict by analyzing the dependencies " + - "of the following cartridges: {}", groupAndName, prev, curr, chosen, versionToCartridges) + "of the following cartridges: {}", groupAndName, prev.version, curr.version, chosen.version, versionToCartridges) } prev = curr } // finally take the first (highest) version - val chosen = versions.first() + val chosen = versions.first().version project.logger.debug("Resolved the version conflict for dependency '{}' choosing version {}", groupAndName, chosen) - return chosen.toString() + return chosen } private fun toDependencyId(groupAndName: String, version: String): String { From 9b7708b1f8bd87ddbaf80d5850d1e5bbd5e78d3a Mon Sep 17 00:00:00 2001 From: Sven Kiesewetter Date: Wed, 7 Dec 2022 14:58:39 +0100 Subject: [PATCH 5/5] feat: support to resolve library version conflicts (#81089) * fixed line length problems --- .../intershop/gradle/icm/tasks/CreateLibList.kt | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt b/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt index 7b481f3..082414c 100644 --- a/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt +++ b/src/main/kotlin/com/intershop/gradle/icm/tasks/CreateLibList.kt @@ -140,8 +140,8 @@ open class CreateLibList @Inject constructor( SemanticVersion.valueOf(versionStr) } catch (e: Exception) { throw GradleException( - "The version string '$versionStr' can not be parsed therefore the conflict resolution must be " + - "done manually: The dependency '$groupAndName' is required in ${versionToCartridges.size} " + + "The version string '$versionStr' can not be parsed therefore the conflict resolution must " + + "be done manually: The dependency '$groupAndName' is required in ${versionToCartridges.size} " + "different versions by the following cartridges: " + "$versionToCartridges", e) } @@ -156,22 +156,24 @@ open class CreateLibList @Inject constructor( } if (prev.major != curr.major) { throw GradleException( - "There's a major version conflict for dependency '$groupAndName': ${prev.version} <-> ${curr.version}. Please " + - "resolve this conflict analyzing the dependencies of the following cartridges: " + - "$versionToCartridges") + "There's a major version conflict for dependency '$groupAndName': ${prev.version} <-> " + + "${curr.version}. Please resolve this conflict analyzing the dependencies of the following " + + "cartridges: $versionToCartridges") } val chosen = maxOf(prev, curr) if (prev.minor != curr.minor) { project.logger.warn( "There's a minor version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If " + "this is not the correct version please resolve this conflict by analyzing the dependencies " + - "of the following cartridges: {}", groupAndName, prev.version, curr.version, chosen.version, versionToCartridges) + "of the following cartridges: {}", + groupAndName, prev.version, curr.version, chosen.version, versionToCartridges) } if (prev.patch != curr.patch) { project.logger.info( "There's a patch version conflict for dependency '{}': {} <-> {}. Version {} is chosen. If " + "this is not the correct version please resolve this conflict by analyzing the dependencies " + - "of the following cartridges: {}", groupAndName, prev.version, curr.version, chosen.version, versionToCartridges) + "of the following cartridges: {}", + groupAndName, prev.version, curr.version, chosen.version, versionToCartridges) } prev = curr } @@ -204,4 +206,3 @@ open class CreateLibList @Inject constructor( return if (dependsOnLibs.isEmpty()) setOf() else dependsOnLibs.split(";").toSet() } } -