commons.gradle

/**
 *
 * Copyright 2011-2020 Martin Goellnitz
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 */
import org.gradle.api.artifacts.ExcludeRule
import org.gradle.api.artifacts.ModuleDependency
import org.gradle.api.artifacts.PublishArtifact
import org.gradle.api.internal.artifacts.configurations.DefaultConfiguration
import org.gradle.api.internal.java.JavaLibrary
import org.gradle.api.attributes.AttributeContainer
import org.gradle.api.attributes.Usage
import org.gradle.api.internal.component.UsageContext
import org.gradle.api.internal.component.SoftwareComponentInternal
import org.gradle.api.tasks.compile.AbstractCompile
import groovy.util.Node

version = '2.0-SNAPSHOT'

def release = project.hasProperty('release')

if (release) {
  apply plugin: 'pmd'
}
apply plugin: 'eclipse'
apply plugin: 'maven-publish'
apply plugin: 'tangram.tools'
apply plugin: 'com.jfrog.artifactory'

repositories {
  jcenter()
}

sourceCompatibility = 1.8
targetCompatibility = 1.8

if (project.hasProperty('jdk')) {
  def bootstrapClasspathStr = "${jdk}/jre/lib/rt.jar"
  println "Defining boot class path $bootstrapClasspathStr"
  project.tasks.withType(AbstractCompile, { AbstractCompile ac ->
      ac.options.bootstrapClasspath = files(bootstrapClasspathStr)
    })
}

// Project specific default output directory
eclipse.classpath.conventionMapping.defaultOutputDir = { new File("$buildDir/classes/main") }

if (release) {
  pmd {
    ruleSets = []
    ruleSetFiles = files("$project.rootProject.projectDir/pmd.xml")
    sourceSets = [sourceSets.main]
    toolVersion = '5.8.1'
  }
}

compileJava.options.encoding = 'UTF-8'
compileTestJava.options.encoding = 'UTF-8'

compileJava.doLast {
  // do this here to avoid compiling without source changes since this here is a source change
  incrementBuildCounter(project)
}

task sourcesJar(type: Jar, dependsOn: classes) {
  classifier = 'sources'
  from sourceSets.main.allSource
}

task javadocJar(type: Jar, dependsOn: javadoc) {
  classifier = 'javadoc'
  from "${buildDir}/docs/javadoc"
}

if (project.hasProperty("bintrayUser")&&project.hasProperty("bintrayKey")) {
  artifactory {
    contextUrl = 'https://oss.jfrog.org/artifactory'
    publish {
      repository {
        repoKey = version.endsWith('SNAPSHOT') ? 'oss-snapshot-local' : 'oss-release-local'
        username = "$bintrayUser"
        password = "$bintrayKey"
      }
      defaults {
        publications ('mavenJava')
      }
    }
  }
}

class WrappedRuntimeUsage implements UsageContext {

  private UsageContext delegate

  private DefaultConfiguration configuration

  WrappedRuntimeUsage(UsageContext usage, DefaultConfiguration conf) {
    delegate = usage
    configuration = conf
  }

  public String getName() {
    return delegate.name
  }


  public Usage getUsage() {
    return delegate.usage
  }


  public Set<PublishArtifact> getArtifacts() {
    return delegate.artifacts
  }


  public Set getGlobalExcludes() {
    return delegate.globalExcludes
  }


  public Set getDependencyConstraints() {
    return delegate.dependencyConstraints
  }


  public Set getCapabilities() {
    return delegate.apabilities
  }


  public AttributeContainer getAttributes() {
    return delegate.attributes
  }


  public Set<ModuleDependency> getDependencies() {
    Set<ModuleDependency> result = new HashSet<>()
    delegate.dependencies.each {
      if (!result.contains(it)) {
        result.add(it)
      } else {
        // println "Ignoring another $it.group:$it.name:$it.version"
      }
    }
    configuration.dependencies.each {
      if (!result.contains(it)) {
        // println "* Adding $it.group:$it.name:$it.version"
        result.add(it)
      } else {
        // println "* Ignoring another $it.group:$it.name:$it.version"
      }
    }
    return result
  }

}

class WrappedLibrary implements SoftwareComponentInternal {

  private JavaLibrary delegate;

  private DefaultConfiguration configuration

  WrappedLibrary(JavaLibrary lib, DefaultConfiguration conf) {
    delegate = lib;
    configuration = conf
  }

  public String getName() {
    return delegate.name
  }

  public Set<UsageContext> getUsages() {
    Set<UsageContext> result = new HashSet<>()
    delegate.usages.each {
      result.add(new WrappedRuntimeUsage(it, configuration))
    }
    return result
  }

}

publishing {
  publications {
    mavenJava(MavenPublication) {
      // println "Wrap: $project.name"
      from new WrappedLibrary(components.java, configurations.providedCompile)
      if (release) {
        artifact sourcesJar
        artifact javadocJar
      }
      configurations[JavaPlugin.RUNTIME_CONFIGURATION_NAME].allDependencies.findAll {
        it instanceof ModuleDependency && !it.excludeRules.isEmpty()
      }.each { ModuleDependency dep ->
        pom.withXml {
          def xmlDep = asNode().dependencies.dependency.find {
            it.groupId[0].text() == dep.group && it.artifactId[0].text() == dep.name
          }
          if (xmlDep) {
            def xmlExclusions = xmlDep.exclusions[0]
            if (!xmlExclusions) {
              xmlExclusions = xmlDep.appendNode('exclusions')
            }
            dep.excludeRules.each { ExcludeRule rule ->
              def xmlExclusion = xmlExclusions.appendNode('exclusion')
              xmlExclusion.appendNode('groupId', rule.group)
              xmlExclusion.appendNode('artifactId', rule.module)
            }
          }
        }
      }
      pom.withXml {
        def rootNode = asNode()
        rootNode.dependencies.'*'.findAll() {
          it.scope.text() == 'runtime'  && project.configurations.providedCompile.allDependencies.find { dep ->
            dep.name == it.artifactId.text()
          }
        }.each() {
          it.scope*.value = 'provided'
        }
        rootNode.children().get(3).plus {
          new Node(rootNode, 'name', "Tangram "+project.name.substring(8))
          new Node(rootNode, 'description', 'Object oriented templating and dynamic web development framework')
          new Node(rootNode, 'url', 'https://github.com/mgoellnitz/tangram/')
          def license = new Node(rootNode, 'licenses').appendNode('license')
          license.appendNode('name', 'LGPL-3.0')
          license.appendNode('url', 'http://opensource.org/licenses/LGPL-3.0')
          license
          def issues = new Node(rootNode, 'issueManagement')
          issues.appendNode('system', 'mail')
          issues.appendNode('url', 'mailto:tangram@provocon.de')
          issues
          def scm = new Node(rootNode, 'scm')
          scm.appendNode('connection', 'scm:git:git@github.com:mgoellnitz/tangram.git')
          scm.appendNode('developerConnection', 'scm:git:git@github.com:mgoellnitz/tangram.git')
          scm.appendNode('url', 'https://github.com/mgoellnitz/tangram.git')
          scm
          def developer = rootNode.appendNode('developers').appendNode('developer')
          developer.appendNode('name', 'Martin Goellnitz')
          developer.appendNode('organization', 'Provocon')
          developer.appendNode('organizationUrl', 'http://www.provocon.de/')
          developer
        }
      }
    }
  }
}