Make smalidea a separate gradle/idea project

.gitignore

@@ -9,3 +9,4 @@
 *.ipr
 *.iws
 .idea
+/smalidea/.gradle

build.gradle

@@ -110,8 +110,7 @@ subprojects {
                    jflex: 'de.jflex:jflex:1.4.3',
                    jflex_plugin: 'co.tomlee.gradle.plugins:gradle-jflex-plugin:0.0.2',
                    proguard_gradle: 'net.sf.proguard:proguard-gradle:5.2.1',
-                   dx: 'com.google.android.tools:dx:1.7',
+                   dx: 'com.google.android.tools:dx:1.7'
-                   gson: 'com.google.code.gson:gson:2.3.1'
          ]
     }
 

settings.gradle

@@ -1 +1 @@
-include 'util', 'dexlib2', 'baksmali', 'smali', 'dexlib2:accessorTestGenerator', 'smalidea'
+include 'util', 'dexlib2', 'baksmali', 'smali', 'dexlib2:accessorTestGenerator'

smalidea/build.gradle

@@ -29,26 +29,139 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-configurations {
+buildscript {
-    antlr3
+    repositories {
+        maven {
+            url "https://plugins.gradle.org/m2/"
+        }
+    }
+    dependencies {
+        classpath 'gradle.plugin.org.jetbrains:gradle-intellij-plugin:0.0.40'
+        classpath 'org.eclipse.jgit:org.eclipse.jgit:2.0.0.201206130900-r'
+    }
 }
 
-ext.antlrSource = 'src/main/antlr3'
+apply plugin: 'java'
-ext.antlrOutput = file("${buildDir}/generated-sources/antlr3")
+apply plugin: 'idea'
+apply plugin: 'antlr'
 
-sourceSets.main.java.srcDir antlrOutput
+version = '0.03'
+
+if (!('release' in gradle.startParameter.taskNames)) {
+    def versionSuffix
+    try {
+        def git = org.eclipse.jgit.api.Git.open(file('..'))
+        def head = git.getRepository().getRef('HEAD')
+        versionSuffix = head.getObjectId().abbreviate(8).name()
+
+        if (!git.status().call().clean) {
+            versionSuffix += '-dirty'
+        }
+    } catch (Exception ex) {
+        // In case we can't get the commit for some reason,
+        // just use -dev
+        versionSuffix = 'dev'
+    }
+
+    def baseVersion = version
+    version = baseVersion + '-' + versionSuffix
+} else {
+    if (System.env.JDK7_HOME == null && !JavaVersion.current().isJava7()) {
+        throw new InvalidUserDataException("bzzzzzzzt. Release builds must be performed with java 7. " +
+                "Either run gradle with java 7, or define the JDK7_HOME environment variable.")
+    }
+}
+
+if (System.env.JDK7_HOME != null) {
+    sourceCompatibility = 1.7
+    targetCompatibility = 1.7
+
+    tasks.withType(JavaCompile) {
+        doFirst {
+            options.fork = true
+            options.bootClasspath = "$System.env.JDK7_HOME/jre/lib/rt.jar"
+            options.bootClasspath += "$File.pathSeparator$System.env.JDK7_HOME/jre/lib/jsse.jar"
+        }
+    }
+}
+
+// We don't want to use the org.jetbrains.intellij plugin when generating the idea project files,
+// so that idea classes aren't included as project dependencies, since they will already exist
+// in the plugin sdk defined for the project
+if (!('idea' in gradle.startParameter.taskNames)) {
+    apply plugin: 'org.jetbrains.intellij'
+
+    intellij {
+        version 'IC-14.1.4'
+        pluginName 'smalidea'
+
+        sandboxDirectory "${buildDir}/sandbox"
+    }
+} else {
+    // If we're running the idea task, let's make sure nothing else is being run, since
+    // we have to use a special configuration for the idea task
+    if (gradle.startParameter.taskNames.size() > 1) {
+        throw new InvalidUserDataException("The idea task must be run by itself.")
+    }
+}
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}
 
 dependencies {
-    compile project(':smali')
+    compile 'org.smali:smali:2.1.2'
-    compile depends.antlr_runtime
+    compile files("${System.properties['java.home']}/../lib/tools.jar")
-    compile depends.gson
+    compile 'org.antlr:antlr-runtime:3.5.2'
+    compile 'com.google.code.gson:gson:2.3.1'
 
-    antlr3 depends.antlr
+    antlr 'org.antlr:antlr:3.5.2'
 }
 
 idea {
-    module {
+    project {
         jdkName = 'IDEA Plugin jdk'
+        languageLevel 1.7
+
+        vcs = 'Git'
+
+        ipr {
+            withXml {
+                def node = it.asNode()
+
+                node.find { it.@name == 'ProjectRootManager' }
+                    .@'project-jdk-type' = 'IDEA JDK'
+
+                node.find { it.@name == 'VcsDirectoryMappings' }
+                    .mapping.@directory = '$PROJECT_DIR$/..'
+
+                def componentNode = node.find { it.@name == 'ProjectRunConfigurationManager' }
+
+                if (componentNode == null) {
+                    componentNode = it.node.appendNode 'component', [name: 'ProjectRunConfigurationManager']
+                }
+
+                if (componentNode.find { it.@name == 'All tests' } == null) {
+                    componentNode.append(new XmlParser().parseText("""
+                        <configuration default="false" name="All tests" type="JUnit" factoryName="JUnit">
+                          <extension name="coverage" enabled="false" merge="false" runner="idea" />
+                          <module name="smalidea" />
+                          <option name="TEST_OBJECT" value="directory" />
+                          <option name="VM_PARAMETERS" value="-Didea.system.path=${buildDir}/sandbox/config -Didea.system.path=${buildDir}/sandbox/system-test -Didea.load.plugins.id=org.jf.smalidea" />
+                          <option name="WORKING_DIRECTORY" value="file://\$PROJECT_DIR\$" />
+                          <option name="PASS_PARENT_ENVS" value="true" />
+                          <option name="TEST_SEARCH_SCOPE">
+                            <value defaultName="moduleWithDependencies" />
+                          </option>
+                          <dir value="\$PROJECT_DIR\$/src/test/java" />
+                        </configuration>"""))
+                }
+            }
+        }
+    }
+
+    module {
         excludeDirs -= buildDir
         if (buildDir.exists()) {
             excludeDirs.addAll(buildDir.listFiles())
@@ -63,33 +176,43 @@ idea {
 
         iml {
             withXml {
-                it.node.@type = "PLUGIN_MODULE"
+                def node = it.node
+
+                node.@type = 'PLUGIN_MODULE'
+
+                def pluginUrl = 'file://$MODULE_DIR$/src/main/resources/META-INF/plugin.xml'
+
+                def pluginNode = node.find { it.@name == 'DevKit.ModuleBuildProperties' }
+                if (pluginNode == null) {
+                    node.appendNode 'component', [name: 'DevKit.ModuleBuildProperties',
+                                                  url: pluginUrl]
+                } else {
+                    pluginNode.@url = pluginUrl
+                }
             }
         }
     }
 }
 
-// We can't actually compile the plugin with gradle, so we just disable everything
+task extractTokens(type: org.gradle.api.tasks.Copy) {
-// except the tasks related to generating the IDEA module and ANTLR parser
+    def allArtifacts = configurations.default.resolvedConfiguration.resolvedArtifacts
-tasks.all {
+    def smaliArtifact = allArtifacts.find { it.moduleVersion.id.name.equals('smali') }
-    if (!(name in ['idea', 'ideaModule', 'generateParserAntlrSource', 'clean'])) {
+
-        enabled = false
+    from(zipTree(smaliArtifact.file)) {
+        include '**/*.tokens'
     }
+    into "${buildDir}/tokens"
 }
 
-task generateParserAntlrSource(type: JavaExec, dependsOn: ":smali:generateGrammarSource") {
+generateGrammarSource {
-    def smaliOutputDir = file(relativePath(project.parent.childProjects.get('smali')
+    def tokensDir = file("${buildDir}/tokens/org/jf/smali")
-            .generateGrammarSource.outputDirectory))
+    inputs.file new File(tokensDir, 'smaliParser.tokens')
-
+    setArguments(['-lib', tokensDir.path])
-    inputs.file new File(smaliOutputDir, "smaliParser.tokens")
+    outputDirectory(file("${buildDir}/generated-src/antlr/main/org/jf/smalidea"))
-    inputs.dir file(antlrSource)
+}
-    outputs.dir file(antlrOutput)
+generateGrammarSource.dependsOn(extractTokens)
-
+
-    file(antlrOutput).mkdirs()
+ideaModule.dependsOn(generateGrammarSource)
-
+
-    classpath = configurations.antlr3
+task release(dependsOn: ':buildPlugin') {
-    main = 'org.antlr.Tool'
-    args '-fo', relativePath("${antlrOutput}/org/jf/smalidea")
-    args '-lib', smaliOutputDir
-    args new File(antlrSource, "smalideaParser.g")
 }