Add support for resolving latest or stable version of plugins

package-list.yaml

@@ -11,8 +11,9 @@ configurations:
   # Specify configurations where the packages/plugins depend on a specific kotlin and/or gradle version.
   - kotlin-version: "1.8.20"
     gradle-version: "7.6.2"
+
     plugins:
-      com.expediagroup.graphql: ["7.0.0-alpha.5", "6.5.2"]
+      com.expediagroup.graphql: ["stable"]
 
   - kotlin-version: "1.8.0"
     gradle-version: "8.2.1"
@@ -29,7 +30,7 @@ configurations:
   # Most packages should be placed here.
   - kotlin-version: "1.8.20"
     plugins:
-      org.panteleyev.jpackageplugin: "1.5.2"
+      org.panteleyev.jpackageplugin: "latest"
     packages:
       org.jetbrains.kotlinx:kotlinx-datetime: "0.4.0"
       com.expediagroup:

sync/src/config.py

@@ -18,7 +18,20 @@ class Package:
         return f'{self.group_id}:{self.artifact_id}:{self.version}'
 
     def __hash__(self):
-        return hash(str(self))
+        return hash((self.group_id, self.artifact_id, self.version))
+
+
+@dataclass
+class Plugin:
+    id: str
+    version: str
+
+    @property
+    def package(self):
+        return Package(self.id, self.id + '.gradle.plugin', self.version)
+
+    def __hash__(self):
+        return hash((self.id, self.version))
 
 
 @dataclass
@@ -26,7 +39,7 @@ class Configuration:
     name: str
     kotlin_version: str
     gradle_version: Optional[str]
-    plugins: dict[str, str]
+    plugins: list[Plugin]
     packages: list[Package]
 
 
@@ -46,7 +59,8 @@ def handle_packages(section) -> list[Package]:
                 try:
                     group_id, artifact_id = entry.split(':')
                 except ValueError:
-                    logger.exception(f'Illegal package identifier "{entry}". Should be on the format "groupId:artifactId"')
+                    logger.exception(
+                        f'Illegal package identifier "{entry}". Should be on the format "groupId:artifactId"')
                     continue
 
                 value = section[entry]
@@ -116,17 +130,17 @@ def parse_config(path: Path) -> Optional[Config]:
                 name=f'{kotlin_version}-packages',
                 kotlin_version=kotlin_version,
                 gradle_version=gradle_version,
-                plugins={},
+                plugins=[],
                 packages=packages
             ))
 
-            for plugin, plugin_versions in plugins.items():
+            for plugin_id, plugin_versions in plugins.items():
                 for plugin_version in plugin_versions:
                     configurations.append(Configuration(
-                        name=f'version-plugins-{plugin}',
+                        name=f'version-plugins-{plugin_id}',
                         kotlin_version=kotlin_version,
                         gradle_version=gradle_version,
-                        plugins={plugin: plugin_version},
+                        plugins=[Plugin(plugin_id, plugin_version)],
                         packages=[]
                     ))
 

sync/src/gradle.py

@@ -1,6 +1,6 @@
 from typing import Iterable
 
-from config import Package
+from config import Package, Plugin
 
 
 def create_gradle_settings(repo: str) -> str:
@@ -18,12 +18,12 @@ pluginManagement {
 """
 
 
-def create_gradle_build(kotlin_version: str, plugins: dict[str, str], packages: Iterable[Package], repo: str) -> str:
+def create_gradle_build(kotlin_version: str, plugins: Iterable[Plugin], packages: Iterable[Package], repo: str) -> str:
     return """// Generated, do not edit
 plugins {
     """ + f'kotlin("jvm") version "{kotlin_version}"' + """
     
-    """ + '\n    '.join(f'id("{name}") version "{version}"' for name, version in plugins.items()) + """
+    """ + '\n    '.join(f'id("{p.id}") version "{p.version}"' for p in plugins) + """
 }
 """ + ("""
 repositories {

sync/src/main.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from maven import get_effective_packages
 from config import parse_config, Configuration
 from gradle import create_gradle_build, create_gradle_settings
+from maven.plugins import get_effective_plugins
 
 logger = logging.getLogger(__name__)
 
@@ -17,13 +18,19 @@ async def resolve_kotlin(ident: str, configuration: Configuration, output_dir: P
         for resolved in await get_effective_packages(package, mirrors)
     ])
 
+    resolved_plugins = set([
+        resolved
+        for plugin in configuration.plugins
+        for resolved in await get_effective_plugins(plugin, mirrors)
+    ])
+
     gradle_path = configuration.gradle_version or "default"
     path = output_dir / f"{gradle_path}/{ident}-kotlin-{configuration.kotlin_version}"
     path.mkdir(parents=True)
     logger.debug(f'Creating {path}')
 
     logger.debug('Generating build.gradle.kts')
-    gradle_build = create_gradle_build(configuration.kotlin_version, configuration.plugins, resolved_packages, gradle_repo)
+    gradle_build = create_gradle_build(configuration.kotlin_version, resolved_plugins, resolved_packages, gradle_repo)
     (path / 'build.gradle.kts').write_text(gradle_build)
 
     logger.debug('Generating settings.gradle.kts')

sync/src/maven/plugins.py

@@ -0,0 +1,12 @@
+import dataclasses
+from typing import Iterable
+
+from config import Plugin
+from maven.version import resolve_version
+
+
+async def get_effective_plugins(plugin: Plugin, mirrors: Iterable[str]) -> list[Plugin]:
+    return [
+        dataclasses.replace(plugin, version=version)
+        for version in await resolve_version(plugin.package, mirrors)
+    ]