Restructure gradle code

sync/src/gradle.py

@@ -1,105 +0,0 @@
-import logging
-from pathlib import Path
-from typing import Iterable
-
-from config import Configuration, Plugin, Package
-
-logger = logging.getLogger(__name__)
-
-
-def create_gradle(configuration: Configuration, repo: str, output_dir: Path):
-    gradle_path = output_dir / (configuration.gradle_version or "default")
-    name = f'kotlin-{configuration.kotlin_version}'
-    kotlin = configuration.kotlin_version
-
-    if configuration.packages:
-        create_gradle_project(f'{name}-packages', gradle_path, kotlin, [], configuration.packages, repo)
-
-    for i, plugin in enumerate(configuration.plugins):
-        create_gradle_project(f'{name}-plugins-{i}', gradle_path, kotlin, [plugin], [], repo)
-
-
-def create_gradle_project(name: str, gradle_path, kotlin: str, plugins: Iterable[Plugin], packages: Iterable[Package], repo: str):
-    path = gradle_path / name
-    logger.debug(f'Creating {path}')
-    path.mkdir(parents=True)
-
-    logger.debug('Generating build.gradle.kts')
-    gradle_build = create_gradle_build(kotlin, set(plugins), set(packages), repo)
-    (path / 'build.gradle.kts').write_text(gradle_build)
-
-    logger.debug('Generating settings.gradle.kts')
-    gradle_settings = create_gradle_settings(repo)
-    (path / 'settings.gradle.kts').write_text(gradle_settings)
-
-
-def create_gradle_settings(repo: str) -> str:
-    return """// Generated, do not edit
-rootProject.name = "gradle sync job"
-
-pluginManagement {
-    repositories {
-        maven {
-            url=uri("http://""" + repo + """/releases")
-            isAllowInsecureProtocol=true
-        }
-    }
-}
-"""
-
-
-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(p.gradle_spec for p in plugins) + """
-}
-""" + ("""
-repositories {
-    maven {
-        url=uri("http://""" + repo + """/releases")
-        isAllowInsecureProtocol=true
-    }
-}
-
-val deps = listOf<String>(
-    """ + ',\n    '.join(f'"{dep}"' for dep in sorted([str(p) for p in packages])) + """
-).flatMap {
-    listOf(it, it + ":sources", it + ":javadoc")
-}.map {
-    configurations.create(it.replace(':', '_')) {
-        isCanBeResolved = true
-        isCanBeConsumed = false
-    } to it
-}
-
-dependencies {
-    deps.forEach { (conf, dep) ->
-        conf(dep)
-    }
-}
-
-tasks.register("downloadDependencies") {
-    val logger = getLogger()
-
-    doLast {
-        deps.forEach { (conf, dep) ->
-            logger.warn("$conf")
-            try {
-                conf.files
-            } catch (e: Exception) {
-                if (dep.endsWith(":sources")) {
-                    logger.info("Package '$dep' has no sources")
-                } else if (dep.endsWith(":javadoc")) {
-                    logger.info("Package '$dep' has no javadoc")
-                } else {
-                    logger.info("Error while fetching '$dep': $e")
-                }
-            }
-        }
-    }
-}
-""" if packages else """
-tasks.register("downloadDependencies") {}
-""")

sync/src/gradle/__init__.py

@@ -0,0 +1 @@
+from .generate import generate_gradle

sync/src/gradle/build.py

@@ -0,0 +1,63 @@
+import logging
+from typing import Iterable
+
+from config import Plugin, Package
+
+logger = logging.getLogger(__name__)
+
+
+def generate_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(p.gradle_spec for p in plugins) + """
+}
+""" + ("""
+repositories {
+    maven {
+        url=uri("http://""" + repo + """/releases")
+        isAllowInsecureProtocol=true
+    }
+}
+
+val deps = listOf<String>(
+    """ + ',\n    '.join(f'"{dep}"' for dep in sorted([str(p) for p in packages])) + """
+).flatMap {
+    listOf(it, it + ":sources", it + ":javadoc")
+}.map {
+    configurations.create(it.replace(':', '_')) {
+        isCanBeResolved = true
+        isCanBeConsumed = false
+    } to it
+}
+
+dependencies {
+    deps.forEach { (conf, dep) ->
+        conf(dep)
+    }
+}
+
+tasks.register("downloadDependencies") {
+    val logger = getLogger()
+
+    doLast {
+        deps.forEach { (conf, dep) ->
+            logger.warn("$conf")
+            try {
+                conf.files
+            } catch (e: Exception) {
+                if (dep.endsWith(":sources")) {
+                    logger.info("Package '$dep' has no sources")
+                } else if (dep.endsWith(":javadoc")) {
+                    logger.info("Package '$dep' has no javadoc")
+                } else {
+                    logger.info("Error while fetching '$dep': $e")
+                }
+            }
+        }
+    }
+}
+""" if packages else """
+tasks.register("downloadDependencies") {}
+""")

sync/src/gradle/generate.py

@@ -0,0 +1,35 @@
+import logging
+from pathlib import Path
+from typing import Iterable
+
+from config import Configuration, Plugin, Package
+from .build import generate_gradle_build
+from .settings import generate_gradle_settings
+
+logger = logging.getLogger(__name__)
+
+
+def generate_gradle(configuration: Configuration, repo: str, output_dir: Path):
+    gradle_path = output_dir / (configuration.gradle_version or "default")
+    name = f'kotlin-{configuration.kotlin_version}'
+    kotlin = configuration.kotlin_version
+
+    if configuration.packages:
+        generate_gradle_project(f'{name}-packages', gradle_path, kotlin, [], configuration.packages, repo)
+
+    for i, plugin in enumerate(configuration.plugins):
+        generate_gradle_project(f'{name}-plugins-{i}', gradle_path, kotlin, [plugin], [], repo)
+
+
+def generate_gradle_project(name: str, gradle_path, kotlin: str, plugins: Iterable[Plugin], packages: Iterable[Package], repo: str):
+    path = gradle_path / name
+    logger.debug(f'Creating {path}')
+    path.mkdir(parents=True)
+
+    logger.debug('Generating build.gradle.kts')
+    gradle_build = generate_gradle_build(kotlin, set(plugins), set(packages), repo)
+    (path / 'build.gradle.kts').write_text(gradle_build)
+
+    logger.debug('Generating settings.gradle.kts')
+    gradle_settings = generate_gradle_settings(repo)
+    (path / 'settings.gradle.kts').write_text(gradle_settings)

sync/src/gradle/settings.py

@@ -0,0 +1,18 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def generate_gradle_settings(repo: str) -> str:
+    return """// Generated, do not edit
+rootProject.name = "gradle sync job"
+
+pluginManagement {
+    repositories {
+        maven {
+            url=uri("http://""" + repo + """/releases")
+            isAllowInsecureProtocol=true
+        }
+    }
+}
+"""

sync/src/main.py

@@ -5,7 +5,7 @@ import logging
 from pathlib import Path
 
 from config import parse_config, Configuration, MavenMirrors, Package
-from gradle import create_gradle
+from gradle import generate_gradle
 from maven import get_effective_packages, get_effective_plugins, resolve_version
 
 logger = logging.getLogger(__name__)
@@ -55,7 +55,7 @@ async def main(package_list: Path, output_dir: Path, gradle_repo: str) -> None:
             logger.info(f'Resolving configuration kotlin={configuration.kotlin_version}, gradle={configuration.gradle_version}')
             try:
                 for c in await resolve_kotlin(configuration, config.mirrors):
-                    create_gradle(c, gradle_repo, output_dir)
+                    generate_gradle(c, gradle_repo, output_dir)
             except:
                 logger.exception(f'Error resolving kotlin version {configuration.kotlin_version}')