build.gradle

// Do it this way so people with older Gradle can hopefully still build.
buildscript {
    repositories {
        jcenter()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }

    dependencies {
        classpath 'com.github.jengelman.gradle.plugins:shadow:4.0.2'
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'com.github.johnrengelman.shadow'
apply plugin: 'maven'

group = 'cuchaz'
version = '0.14.1'

def generatedSourcesDir = "$buildDir/generated-src"

def ENV = System.getenv()
if (ENV.BUILD_NUMBER) {
    version = version + "." + "${System.getenv().BUILD_NUMBER}"
}

sourceCompatibility = 1.8
targetCompatibility = 1.8

// Custom source layout
sourceSets {
    main {
        java { srcDir 'src/main/java' }
        resources { srcDir 'conf' }
    }
    test {
        java { srcDir 'src/test/java' }
        resources { srcDir 'test' }
    }
}

task generateSources(type: Copy) {
    from sourceSets.main.java
    into generatedSourcesDir

    filter { String line ->
        ("$line".replaceAll('@VERSION@', version))
    }
}

compileJava.source = generatedSourcesDir
compileJava.dependsOn generateSources

repositories {
    mavenLocal()
    mavenCentral()

    maven {
        name "Cuchaz Custom Repository"
        url 'http://maven.cuchazinteractive.com'
    }

    maven {
        name "Modmuss Repository"
        url 'http://maven.modmuss50.me/'
    }

	ivy {
		name "darcula"
		artifactPattern "https://raw.githubusercontent.com/bulenkov/Darcula/master/build/[module].[ext]"
	}
}

configurations {
    proGuard // used to download ProGuard
    application // used for JSyntaxPane so it's not in the library POM

    compile.extendsFrom application
}

dependencies {
    compile 'com.google.guava:guava:28.0-jre'
    compile 'net.fabricmc:procyon-fabric-compilertools:0.5.35.+'
    compile 'com.google.code.gson:gson:2.8.5'
    compile 'org.ow2.asm:asm:7.1'
    compile 'org.ow2.asm:asm-commons:7.1'
    compile 'org.ow2.asm:asm-tree:7.1'
    compile 'org.ow2.asm:asm-util:7.1'

    compile 'net.sf.jopt-simple:jopt-simple:6.0-alpha-3'

    application name: "darcula", version: "1.0.0"
    application 'de.sciss:syntaxpane:1.2.+'
    application 'me.xdrop:fuzzywuzzy:1.2.0'

    testCompile 'junit:junit:4.+'
    testCompile 'org.hamcrest:hamcrest-all:1.+'

    proGuard 'net.sf.proguard:proguard-base:5.+'
}

// For each set of test inputs, create an output jar and obfuscate it.
file('src/test/java/cuchaz/enigma/inputs').listFiles().each { theFile ->
    if (theFile.directory) {
        task("${theFile.name}TestJar", type: Jar) {
            from(sourceSets.test.output) {
                include "cuchaz/enigma/inputs/$theFile.name/**/*.class"
                include 'cuchaz/enigma/inputs/Keep.class'
            }

            archiveName = theFile.name + '.jar'
            destinationDir = file('build/test-inputs')
        }

        task("${theFile.name}TestObf", type: JavaExec,
                dependsOn: "${theFile.name}TestJar") {
            main 'proguard.ProGuard'
            classpath configurations.proGuard

            args '@proguard-test.conf', '-injars', file('build/test-inputs/' +
                    "${theFile.name}.jar"), '-outjars', file('build/test-obf/' +
                    "${theFile.name}.jar")
        }

        test.dependsOn "${theFile.name}TestObf"
    }
}

// We also semi-deobfuscate translation.jar to then test it... yeah... oh well.
task('deobfTranslationInput', type: JavaExec, dependsOn: 'translationTestObf')
        {
            classpath sourceSets.main.runtimeClasspath
            main 'cuchaz.enigma.CommandMain'
            args 'deobfuscate', file('build/test-obf/translation.jar'),
                    file('build/test-deobf/translation.jar')
        }
test.dependsOn 'deobfTranslationInput'

test {
    // Since the Minecraft test is really long (like 10 minutes D:) we turn it
    // off by default.
    if (!System.getProperty('enableExtremelySlowMinecraftTest', '')
            .equalsIgnoreCase('true')) {
        exclude 'cuchaz/enigma/TestSourceIndex.class'
    }

    // Allow people to specify a custom path to their Minecraft directory.
    // (Example: `gradle build -Denigma.test.minecraftdir=./`)
    systemProperties = [
            'enigma.test.minecraftdir': System.getProperty('test.minecraftdir')
    ]
}

// Set the main class.
jar.manifest.attributes 'Main-Class': 'cuchaz.enigma.Main'

// Make the "fat" application jar. This is useful to just throw in a classpath
// for tests, though it includes some slightly useless stuff.
shadowJar {
    append 'license.LGPL3.txt'
    append 'license.APL2.txt'
    append 'readme.txt'

    exclude 'META-INF/maven/**'
}

// Create a library jar, containing only the deobfuscation code, for use at
// runtime. This will be deployed to Maven Local with a POM, and can be uploaded
// to a remote server manually (for now anyway).
task libJar (type: Jar) {
    classifier = 'lib'

    from(sourceSets.main.output) {
        exclude 'cuchaz/enigma/gui/**'
        exclude 'cuchaz/enigma/convert/**'

        // Main classes + inner classes (keep CommandMain)
        exclude 'cuchaz/enigma/Main.class'
        exclude 'cuchaz/enigma/Main.class'
    }
}

task sourcesJar(type: Jar, dependsOn: generateSources) {
    classifier = 'sources'
    from generatedSourcesDir
    from sourceSets.main.resources
}

artifacts {
   archives shadowJar
   archives libJar
   archives sourcesJar
}

// And finally, make the build generate / install the jars.
build.dependsOn install

apply from: 'https://github.com/FabricMC/fabric-docs/raw/master/gradle/maven.gradle'

uploadArchives.repositories.mavenDeployer.pom.withXml {
	asNode().dependencies.'*'.findAll() { it.artifactId.text() == 'darcula' }
	.each() { it.parent().remove(it) }
}