Automatically generating dependency symbols

[chachako]

I created a project myself to create the corresponding mapping symbols by defining or searching for remote dependencies. I think this feature will be great if it is combined with refreshVersions.

Currently, refreshVersions often needs to manually built more dependencies to follow updates, which will be very troublesome in some cases, for example:

1. If some groups have added new components (AndroidX).
2. If I need to import some other dependencies (maybe some of my local dependencies).

At this time, I need to import dependencies through by string notations, apparently destroying the elegance of dependency management.

So I have currently have the following solution:

Configuration：

dependencyMapper {
  libraries(rootClass = "Libs") {
    // Follow the internal mapping path conversion
    map("com.diffplug.spotless:spotless-plugin-gradle")
    // Full specify mapping path
    map(
      "com.tfowl.ktor:ktor-jsoup" to "Ktor.Jsoup",
      "com.github.ben-manes.caffeine:caffeine" to "Caffeine",
    )

    remote {
      defaultRepositories {
        mavenCentral()
      }
      groups(
        "org.apache.tika",
        "io.ktor",
      )
      startsWith(
        "commons-io",
        "org.jetbrains.kotlin",
        "org.jetbrains.kotlinx",
      )
      // Specifies to search in google maven for dependencies starting with 'androidx'
      startsWith(
        "androidx",
        "com.android"
      ).filter {
        // Skip deprecated dependencies
        it.startsWith("com.android.support").not()
      } from google()
    }

    // Convert the generated name node
    transformName {
      when (it) {
        "Io" -> "IO"
        "ios", "IOS" -> "iOS"
        else it
      }
    }

    transformPath {
      it.replace("org.jetbrains.kotlin", "kotlin")
        .replace("org.jetbrains.intellij", "intellij")
        .removePrefix("com.")
        .removePrefix("net.")
      ...
    }
  }
  plugins(rootClass = "Plugins") {
    map("io.gitlab.arturbosch.detekt" to "Detekt")
  }
  // Even the mapping projects to dependencies, like Projects.Sample.Android, but I am not sure if this should be more creating a new project instead of bringing into `refreshVersions` (because the name seems to limit only version of something)
}

Pseudo code generated with bytebuddy:

class Libs {
    object Caffeine : DependencyNotation("com.github.ben-manes.caffeine:caffeine")
    class Ktor {
        object Jsoup : DependencyNotation("com.tfowl.ktor:ktor-jsoup")
        class Client {
            object Core : DependencyNotation("io.ktor:ktor-client-core") {
               object Jvm....
            }
        }
    }
    class Apache {
        class Tika {
            object Core : DependencyNotation("org.apache.tika:tika-core")
        }
    }
  ...
}

class Plugins {
    object Detekt: org.gradle.plugin.use.PluginDependency(pluginId = "io.gitlab.arturbosch.detekt", version = "_")
}

Use:

buildscript { 
    dependencies.classpath("deps-mapping.jar")
}

plugins { 
    id(Plugins.Detekt) apply false
}

implementation(Libs.Apache.Tika.Core)

The draft code should be very easy to understand...🙂

Bringing it to refreshVersions should have a good effect for dependency management, this will no longer need to have any pre-written dependencies, users can define their any dependencies and maintain remote up-to-date!

[chachako]

The generated part is a bit like version-catalogs, in fact, I have recently discovered it, it was a bit similar to my idea 🤣