maven-publish.gradle

import org.gradle.api.internal.artifacts.dependencies.AbstractDependency
import org.gradle.api.internal.artifacts.dependencies.SelfResolvingDependencyInternal

apply plugin: 'maven-publish'

publishing {
    repositories {
        mavenLocal()
    }
}

ext.getArtifactId = { SourceSet sourceSet ->
    sourceSet.name == 'main' ? project.name : "$project.name-$sourceSet.name"
}

ext.addPublication = { SourceSet sourceSet  ->

    def sourceSetName = sourceSet.name

    def sourcesJarTask = project.tasks.create(name: "${sourceSetName}SourcesJar", type: Jar) {
        from sourceSet.allSource
        classifier = 'sources'
    }

    def javaDocJarTask = project.tasks.create(name: "${sourceSetName}JavaDocJar", type: Jar) {
        from javadoc
        classifier = 'javadoc'
    }

    def jarTask = sourceSetName.equals('main') ? jar : project.tasks.create(name: "${sourceSetName}Jar", type: Jar, dependsOn: sourceSet.classesTaskName) {
        from sourceSet.output
        def artifactId = project.getArtifactId(sourceSet)
        archiveBaseName = artifactId
    }

    project.publishing.publications.create("${sourceSetName}Maven", MavenPublication) {
        groupId = project.group
        artifactId = project.getArtifactId(sourceSet)
        artifact sourcesJarTask
        artifact jarTask
        if (sourceSetName == 'main') {
            artifact javaDocJarTask
        }
        pom.withXml {
            def depsNode = asNode().appendNode('dependencies')
            def dependencies = configurations.getByName(sourceSet.implementationConfigurationName).allDependencies
            dependencies
                    .findAll { it.group != null && it.name != null }
                    .forEach {
                def depNode = depsNode.appendNode('dependency')
                depNode.appendNode('groupId', it.group)
                depNode.appendNode('artifactId', it.name)
                depNode.appendNode('version', it.version)

                if (it.hasProperty('excludeRules') && !it.excludeRules.isEmpty()) {
                    def exclusionsNode = depNode.appendNode('exclusions')
                    it.excludeRules.each { rule ->
                        def exclusionNode = exclusionsNode.appendNode('exclusion')
                        exclusionNode.appendNode('groupId', rule.group)
                        exclusionNode.appendNode('artifactId', rule.module)
                    }
                }
            }
        }
    }
}

class SourceSetDependency extends AbstractDependency implements FileCollectionDependency, SelfResolvingDependencyInternal {
    private final Project project
    private final SourceSet sourceSet

    SourceSetDependency(Project project, SourceSet sourceSet) {
        this.project = project
        this.sourceSet = sourceSet
    }

    SourceSetDependency(Project project, String sourceSetName) {
        this(project, project.sourceSets.getByName(sourceSetName))
    }

    @Override
    FileCollection getFiles() {
        return sourceSet.output
    }

    @Override
    Set<File> resolve() {
        return sourceSet.output.files
    }

    @Override
    Set<File> resolve(boolean transitive) {
        return sourceSet.output.files
    }

    @Override
    String getGroup() {
        return project.group
    }

    @Override
    String getName() {
        return project.getArtifactId(sourceSet)
    }

    @Override
    String getVersion() {
        return project.version
    }

    @Override
    boolean contentEquals(Dependency dependency) {
        if (!(dependency instanceof SourceSetDependency)) {
            return false
        }

        SourceSetDependency sourceSetDep = (SourceSetDependency)dependency
        return this.project == sourceSetDep.project && this.sourceSet == sourceSetDep.sourceSet
    }

    @Override
    Dependency copy() {
        return new SourceSetDependency(project, sourceSet)
    }

    @Override
    ComponentIdentifier getTargetComponentId() {
        return null
    }

    @Override
    TaskDependency getBuildDependencies() {
        return null
    }
}

def sourceSetDependency(SourceSet sourceSet) {
    return new SourceSetDependency(project, sourceSet)
}

def sourceSetDependency(String sourceSet) {
    return new SourceSetDependency(project, sourceSet)
}

project.ext.sourceSetDependency = this.&sourceSetDependency

project.ext.publishSourceSets = { sourceSets ->
    sourceSets.findAll { it.name != 'test' && it.name != 'generated' }.each {
        project.addPublication(it)
    }
}

project.afterEvaluate {
    if (project.hasProperty('sourceSets')) {
        project.publishSourceSets(project.sourceSets)
    }
}

task install(type: DefaultTask, dependsOn: publishToMavenLocal)