got rid of gradle in favor of ivy+ssjb

8 files changed, 251 insertions, 143 deletions

diff --git a/.hgignore b/.hgignore
index d552dedf..9ff982e6 100644
--- a/.hgignore
+++ b/.hgignore
@@ -1,17 +1,15 @@
 
 syntax: regexp
-^\.classpath$
+^\.
 syntax: regexp
-^\.project$
+^bin$
 syntax: regexp
-^\.gradle$
-syntax: regexp
-^\.settings$
-syntax: regexp
-^libs$
+^lib$
 syntax: regexp
 ^build$
 syntax: regexp
 ^data$
 syntax: regexp
-^input$
\ No newline at end of file
+^input$
+syntax: regexp
+^ivy$
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
deleted file mode 100644
index ce4b65b8..00000000
--- a/build.gradle
+++ /dev/null
@@ -1,135 +0,0 @@
-
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "eu.appsatori:gradle-fatjar-plugin:0.2-rc1"
-        classpath "net.sf.proguard:proguard-gradle:5.0"
-    }
-}
-
-apply plugin: "java"
-apply plugin: "eclipse"
-apply plugin: "maven"
-apply plugin: "fatjar"
-
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
-
-group = "com.cuchazinteractive"
-archivesBaseName = "enigma"
-version = "0.6b"
-
-sourceSets {
-        main {
-                java {
-                        srcDir "src"
-                }
-                resources {
-                        srcDir "conf"
-                }
-        }
-        test {
-                java {
-                        srcDir "test"
-                }
-        }
-}
-
-repositories {
-        mavenCentral()
-}
-
-dependencies {
-        compile fileTree( dir: "libs", include: "*.jar" )
-        compile "de.sciss:jsyntaxpane:1.0.0"
-        compile "com.google.guava:guava:17.0"
-        compile "org.javassist:javassist:3.18.1-GA"
-        
-        testCompile "junit:junit:4.11"
-        testCompile "org.hamcrest:hamcrest-all:1.3"
-}
-
-fatJar {
-        from( "." ) {
-                include( "*.txt" )
-        }
-        manifest {
-                attributes(
-                        "Title": archivesBaseName,
-                        "Manifest-Version": "1.0",
-                        "Version": version,
-                        "Main-Class" : "cuchaz.enigma.Main"
-                )
-        }
-}
-
-task jarLoneClass( type: Jar ) {
-        from( sourceSets.test.output ) {
-                include( "cuchaz/enigma/inputs/Keep.class" )
-                include( "cuchaz/enigma/inputs/loneClass/**" )
-        }
-        archiveName( "testLoneClass.jar" )
-}
-
-task jarInheritanceTree( type: Jar ) {
-        from( sourceSets.test.output ) {
-                include( "cuchaz/enigma/inputs/Keep.class" )
-                include( "cuchaz/enigma/inputs/inheritanceTree/**" )
-        }
-        archiveName( "testInheritanceTree.jar" )
-}
-
-task jarConstructors( type: Jar ) {
-        from( sourceSets.test.output ) {
-                include( "cuchaz/enigma/inputs/Keep.class" )
-                include( "cuchaz/enigma/inputs/constructors/**" )
-        }
-        archiveName( "testConstructors.jar" )
-}
-
-task jarInnerClasses( type: Jar ) {
-        from( sourceSets.test.output ) {
-                include( "cuchaz/enigma/inputs/Keep.class" )
-                include( "cuchaz/enigma/inputs/innerClasses/**" )
-        }
-        archiveName( "testInnerClasses.jar" )
-}
-
-tasks.withType( proguard.gradle.ProGuardTask ) {
-        libraryjars( "${System.getProperty('java.home')}/lib/rt.jar" )
-        overloadaggressively
-        repackageclasses
-        allowaccessmodification
-        dontoptimize
-        dontshrink
-        keep( "class cuchaz.enigma.inputs.Keep" )
-}
-
-task obfLoneClass( type: proguard.gradle.ProGuardTask, dependsOn: jarLoneClass ) {
-        def name = "LoneClass"
-        injars( "build/libs/test${name}.jar" )
-        outjars( "build/libs/test${name}.obf.jar" )
-}
-
-task obfInheritanceTree( type: proguard.gradle.ProGuardTask, dependsOn: jarInheritanceTree ) {
-        def name = "InheritanceTree"
-        injars( "build/libs/test${name}.jar" )
-        outjars( "build/libs/test${name}.obf.jar" )
-}
-
-task obfConstructors( type: proguard.gradle.ProGuardTask, dependsOn: jarConstructors ) {
-        def name = "Constructors"
-        injars( "build/libs/test${name}.jar" )
-        outjars( "build/libs/test${name}.obf.jar" )
-}
-
-task obfInnerClasses( type: proguard.gradle.ProGuardTask, dependsOn: jarInnerClasses ) {
-        def name = "InnerClasses"
-        injars( "build/libs/test${name}.jar" )
-        outjars( "build/libs/test${name}.obf.jar" )
-}
-
-task obfTestCases( dependsOn: tasks.withType( proguard.gradle.ProGuardTask ) )
diff --git a/build.py b/build.py
new file mode 100644
index 00000000..69182514
--- /dev/null
+++ b/build.py
@@ -0,0 +1,57 @@
+
+import os
+import ssjb
+
+# settings
+projectName = "enigma"
+version = "0.6b"
+author = "Cuchaz"
+
+dirBin = "bin"
+dirBuild = "build"
+dirTemp = os.path.join(dirBuild, "tmp")
+
+
+def getJarFullName(name) :
+    return "%s-%s-%s.jar" % (projectName, name, version)
+
+def buildGuiJar():
+    jarName = "gui"
+    os.makedirs(dirTemp)
+    ssjb.copyFiles(dirTemp, dirBin, ssjb.findFiles(dirBin))
+    ssjb.unpackJars(dirTemp, "ivy/bundles", recursive=True)
+    ssjb.unpackJars(dirTemp, "ivy/jars", recursive=True)
+    ssjb.unpackJars(dirTemp, "libs", recursive=True)
+    ssjb.delete(os.path.join(dirTemp, "LICENSE.txt"))
+    ssjb.copyFile(dirTemp, "license.APL2.txt")
+    ssjb.copyFile(dirTemp, "license.GPL3.txt")
+    ssjb.copyFile(dirTemp, "readme.gui.txt", renameTo="readme.txt")
+    manifest = ssjb.buildManifest("%s-%s" % (projectName, jarName), version, author, "cuchaz.enigma.Main")
+    ssjb.jar(os.path.join(dirBuild, getJarFullName(jarName)), dirTemp, manifest=manifest)
+    ssjb.delete(dirTemp)
+
+def buildTranslateJar():
+    jarName = "translate"
+    os.makedirs(dirTemp)
+    files = ssjb.findFiles(dirBin, "cuchaz/enigma/mapping/*")
+    files += ssjb.findFiles(dirBin, "cuchaz/enigma/bytecode/*")
+    ssjb.copyFiles(dirTemp, dirBin, files)
+    ssjb.copyFile(dirTemp, "license.GPL3.txt", renameTo="license.txt")
+    ssjb.copyFile(dirTemp, "readme.translate.txt", renameTo="readme.txt")
+    manifest = ssjb.buildManifest("%s-%s" % (projectName, jarName), version, author)
+    ssjb.jar(os.path.join(dirBuild, getJarFullName(jarName)), dirTemp, manifest=manifest)
+    ssjb.delete(dirTemp)
+
+def taskMain():
+    ssjb.delete(dirBuild)
+    os.makedirs(dirBuild)
+    buildGuiJar()
+    buildTranslateJar()
+
+
+ssjb.registerTask("main", taskMain)
+
+
+if __name__ == "__main__":
+    ssjb.run()
+
diff --git a/ivy.xml b/ivy.xml
new file mode 100644
index 00000000..aa9d1f84
--- /dev/null
+++ b/ivy.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<ivy-module version="2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ant.apache.org/ivy/schemas/ivy.xsd">
+        <info organisation="com.cuchazinteractive" module="Enigma" status="integration"/>
+        <dependencies>
+                <dependency org="com.google.guava" name="guava" rev="17.0" transitive="false"/>
+                <dependency org="de.sciss" name="jsyntaxpane" rev="1.0.0" transitive="false"/>
+                <dependency org="org.javassist" name="javassist" rev="3.18.1-GA" transitive="false"/>
+                
+                <!-- for testing -->
+                <dependency org="junit" name="junit" rev="4.11" transitive="false"/>
+                <dependency org="org.hamcrest" name="hamcrest-all" rev="1.3" transitive="false"/>
+        </dependencies>
+</ivy-module>
diff --git a/libs/procyon-decompiler-0.5.26-enigma.jar b/libs/procyon-decompiler-0.5.26-enigma.jar
new file mode 100644
index 00000000..4a3737ee
--- /dev/null
+++ b/libs/procyon-decompiler-0.5.26-enigma.jar
diff --git a/readme.txt b/readme.gui.txt
index 81f985a0..81f985a0 100644
--- a/readme.txt
+++ b/readme.gui.txt
diff --git a/readme.translate.txt b/readme.translate.txt
new file mode 100644
index 00000000..455d16ed
--- /dev/null
+++ b/readme.translate.txt
@@ -0,0 +1,12 @@
+
+Enigma v0.6 beta
+A tool for deobfuscation of Java bytecode
+
+Copyright Jeff Martin, 2014
+
+
+LICENSE
+
+Enigma is distributed under the GNU General Public license version 3
+
+A copy of the GNU General Public license verion 3 has been included in this distribution.
diff --git a/ssjb.py b/ssjb.py
new file mode 100644
index 00000000..d3e2bb52
--- /dev/null
+++ b/ssjb.py
@@ -0,0 +1,163 @@
+
+# stupidly simple jar builder
+# Jeff Martin
+# 2015-01-05
+
+import os
+import sys
+import shutil
+import subprocess
+import zipfile
+import tempfile
+import re
+import fnmatch
+
+
+# setup tasks
+tasks = {}
+
+def registerTask(name, func):
+    tasks[name] = func
+
+def run():
+
+    # get the task name
+    taskName = "main"
+    if len(sys.argv) > 1:
+        taskName = sys.argv[1]
+    
+    # find that task
+    try:
+        task = tasks[taskName]
+    except:
+        print "Couldn't find task: %s" % taskName
+        return
+
+    # run it!
+    task()
+
+
+# set up the default main task
+def mainTask():
+    print "The main task doesn't do anything by default"
+
+registerTask("main", mainTask)
+
+
+# library of useful functions
+
+def findFiles(dirSrc, pattern=None):
+    out = []
+    for root, dirs, files in os.walk(dirSrc):
+        for file in files:
+            path = os.path.join(root, file)[len(dirSrc) + 1:]
+            if pattern is None or fnmatch.fnmatch(path, pattern):
+                out.append(path)
+    return out
+
+def copyFile(dirDest, pathSrc, renameTo=None):
+    (dirParent, filename) = os.path.split(pathSrc)
+    if renameTo is None:
+        renameTo = filename
+    pathDest = os.path.join(dirDest, renameTo)
+    shutil.copy2(pathSrc, pathDest)
+
+def copyFiles(dirDest, dirSrc, paths):
+    for path in paths:
+        pathSrc = os.path.join(dirSrc, path)
+        pathDest = os.path.join(dirDest, path)
+        dirParent = os.path.dirname(pathDest)
+        if not os.path.isdir(dirParent):
+            os.makedirs(dirParent)
+        shutil.copy2(pathSrc, pathDest)
+
+def patternStringToRegex(patternString):
+
+    # escape special chars
+    patternString = re.escape(patternString)
+    
+    # process ** and * wildcards
+    replacements = {
+        re.escape("**"): ".*",
+        re.escape("*"): "[^" + os.sep + "]+"
+    }
+    def getReplacement(match):
+        print "matched", match
+        return "a"
+    patternString = re.compile("(\\\\\*)+").sub(lambda m: replacements[m.group(0)], patternString)
+
+    return re.compile("^" + patternString + "$")
+
+def matchesAnyPath(path, patternStrings):
+    for patternString in patternStrings:
+        pattern = patternStringToRegex(patternString)
+        # TEMP
+        print path, pattern.match(path) is not None
+        if pattern.match(path) is not None:
+            return True
+    return False
+
+def delete(path):
+    try:
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+        elif os.path.isfile(path):
+            os.remove(path)
+    except:
+        # don't care if it failed
+        pass
+
+def buildManifest(title, version, author, mainClass=None):
+    manifest = {
+        "Title": title,
+        "Version": version,
+        "Created-by": author
+    }
+    if mainClass is not None:
+        manifest["Main-Class"] = mainClass
+    return manifest
+
+def jar(pathOut, dirIn, dirRoot=None, manifest=None):
+
+    # build the base args
+    if dirRoot is None:
+        dirRoot = dirIn
+        dirIn = "."
+    invokeArgs = ["jar"]
+    filesArgs = ["-C", dirRoot, dirIn]
+
+    if manifest is not None:
+        # make a temp file for the manifest
+        tempFile, tempFilename = tempfile.mkstemp(text=True)
+        try:
+            # write the manifest
+            for (key, value) in manifest.iteritems():
+                os.write(tempFile, "%s: %s\n" % (key, value))
+            os.close(tempFile)
+
+            # build the jar with a manifest
+            subprocess.call(invokeArgs + ["cmf", tempFilename, pathOut] + filesArgs)
+
+        finally:
+            os.remove(tempFilename)
+    else:
+        # just build the jar without a manifest
+        subprocess.call(invokeArgs + ["cf", pathOut] + filesArgs)
+
+    print "Wrote jar: %s" % pathOut
+
+def unpackJar(dirOut, pathJar):
+    with zipfile.ZipFile(pathJar) as zf:
+        for member in zf.infolist():
+            zf.extract(member, dirOut)
+    print "Unpacked jar: %s" % pathJar
+
+def unpackJars(dirOut, dirJars, recursive=False):
+    for name in os.listdir(dirJars):
+        path = os.path.join(dirJars, name)
+        if os.path.isfile(path):
+            if name[-4:] == ".jar":
+                unpackJar(dirOut, path)
+        elif os.path.isdir(path) and recursive:
+            unpackJars(dirOut, path, recursive)
+