Bump to version 0.1.0; add support for "default" toolchain.

The "default" toolchain runs `cargo build` without a `--toolchain`
parameter, and therefore needs some configuration to address the
inconsistency in cargo's output.

Author: ncalexan

Diff for: plugin/build.gradle

@@ -16,7 +16,7 @@ gradlePlugin {
 }
 
 group 'org.mozilla.rust-android-gradle'
-version '0.0.4'
+version '0.1.0'
 
 publishing {
     repositories {
@@ -28,7 +28,7 @@ publishing {
         maven(MavenPublication) {
             groupId 'org.mozilla.rust-android-gradle'
             artifactId 'rust-android'
-            version '0.0.4'
+            version '0.1.0'
 
             from components.java
         }

Diff for: plugin/src/main/kotlin/com/nishtahir/CargoBuildTask.kt

@@ -1,6 +1,7 @@
 package com.nishtahir;
 
 import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.tasks.TaskAction
 import java.io.File
@@ -13,43 +14,54 @@ open class CargoBuildTask : DefaultTask() {
         extensions[CargoExtension::class].apply {
             targets.forEach { target ->
                 val toolchain = toolchains.find { (arch) -> arch == target }
-                if (toolchain != null) {
-                    buildProjectForTarget(project, toolchain, this)
 
-                    val targetDirectory = targetDirectory ?: "${module}/target"
+                if (toolchain == null) {
+                    throw GradleException("No such target $target")
+                }
+
+                buildProjectForTarget(project, toolchain, this)
 
-                    copy { spec ->
+                val targetDirectory = targetDirectory ?: "${module}/target"
+
+                copy { spec ->
+                    if (toolchain.target != null) {
                         spec.from(File(project.projectDir, "${targetDirectory}/${toolchain.target}/${profile}"))
-                        spec.include(targetInclude)
                         spec.into(File(buildDir, "rustJniLibs/${toolchain.folder}"))
+                    } else {
+                        spec.from(File(project.projectDir, "${targetDirectory}/${profile}"))
+                        spec.into(File(buildDir, "rustResources/${defaultToolchainBuildPrefixDir}"))
                     }
-                } else {
-                    println("No such target $target")
+                    spec.include(targetIncludes.asIterable())
                 }
             }
         }
     }
 
     private fun buildProjectForTarget(project: Project, toolchain: Toolchain, cargoExtension: CargoExtension) {
         project.exec { spec ->
-            val cc = "${project.getToolchainDirectory()}/${toolchain.cc()}"
-            val ar = "${project.getToolchainDirectory()}/${toolchain.ar()}"
-            println("using CC: $cc")
-            println("using AR: $ar")
             with(spec) {
                 standardOutput = System.out
                 workingDir = File(project.project.projectDir, cargoExtension.module)
-                environment("CC", cc)
-                environment("AR", ar)
-                environment("RUSTFLAGS", "-C linker=$cc")
 
-                val theCommandLine = mutableListOf("cargo", "build", "--target=${toolchain.target}")
+                val theCommandLine = mutableListOf("cargo", "build");
+
                 if (cargoExtension.profile != "debug") {
-                     // Cargo is rigid: it accepts "--release" for release (and
-                     // nothing for dev).  This is a cheap way of allowing only
-                     // two values.
-                     theCommandLine.add("--${cargoExtension.profile}")
+                    // Cargo is rigid: it accepts "--release" for release (and
+                    // nothing for dev).  This is a cheap way of allowing only
+                    // two values.
+                    theCommandLine.add("--${cargoExtension.profile}")
                 }
+
+                if (toolchain.target != null) {
+                    theCommandLine.add("--target=${toolchain.target}")
+
+                    val cc = "${project.getToolchainDirectory()}/${toolchain.cc()}"
+                    val ar = "${project.getToolchainDirectory()}/${toolchain.ar()}"
+                    environment("CC", cc)
+                    environment("AR", ar)
+                    environment("RUSTFLAGS", "-C linker=$cc")
+                }
+
                 commandLine = theCommandLine
             }
         }.assertNormalExitValue()

Diff for: plugin/src/main/kotlin/com/nishtahir/CargoExtension.kt

@@ -21,7 +21,16 @@ open class CargoExtension {
     /**
      * Which Cargo built outputs to consider JNI libraries.
      *
-     * Defaults to `"*.so"`.
+     * Defaults to `["*.so", "*.dylib", "*.dll"]`.
      */
-    var targetInclude: String = "*.so"
+    var targetIncludes: Array<String> = arrayOf("*.so", "*.dylib", "*.dll")
+
+    /**
+     * Android toolchains know where to put their outputs; it's a well-known value like
+     * `armeabi-v7a` or `x86`.  The default toolchain outputs don't know where to put their output;
+     * use this to say where.
+     *
+     * Defaults to `""`.
+     */
+    var defaultToolchainBuildPrefixDir: String? = ""
 }

Diff for: plugin/src/main/kotlin/com/nishtahir/GenerateToolchainsTask.kt

@@ -28,6 +28,7 @@ open class GenerateToolchainsTask : DefaultTask() {
         val targets = project.extensions[CargoExtension::class].targets
 
         toolchains
+                .filter { it.target != null }
                 .filterNot { (arch) -> minApi < 21 && arch.endsWith("64") }
                 .filter { (arch) -> targets.contains(arch) }
                 .forEach { (arch) ->

Diff for: plugin/src/main/kotlin/com/nishtahir/RustAndroidPlugin.kt

@@ -10,6 +10,11 @@ import java.io.File
 const val RUST_TASK_GROUP = "rust"
 
 val toolchains = listOf(
+        Toolchain("default",
+                null,
+                "<cc>",
+                "<ar>",
+                "default"),
         Toolchain("arm",
                 "arm-linux-androideabi",
                 "bin/arm-linux-androideabi-clang",
@@ -38,7 +43,7 @@ val toolchains = listOf(
 )
 
 data class Toolchain(val platform: String,
-                     val target: String,
+                     val target: String?,
                      val cc: String,
                      val ar: String,
                      val folder: String) {
@@ -69,6 +74,7 @@ open class RustAndroidPlugin : Plugin<Project> {
     private inline fun <reified T : BaseExtension> configurePlugin(project: Project) = with(project) {
         extensions[T::class].apply {
             sourceSets.getByName("main").jniLibs.srcDir(File("$buildDir/rustJniLibs/"))
+            sourceSets.getByName("test").resources.srcDir(File("$buildDir/rustResources/"))
         }
 
         val generateToolchain = tasks.maybeCreate("generateToolchains",