Add option to include tests in paket install, update unity paket refe…

…rences format

src/integrationTest/groovy/wooga/gradle/paket/unity/PaketUnityIntegrationSpec.groovy

@@ -110,15 +110,16 @@ class PaketUnityIntegrationSpec extends IntegrationSpec {
     def "run paketUnityInstall with dependencies"() {
         given: "a small project with a unity project dir"
         def unityProjectName = "Test.Project"
-        def dependencyName = "Wooga.TestDependency"
+        def packageName = "TestDependency"
+        def dependencyName = "Wooga.${packageName}"
 
         and: "apply paket get plugin to get paket install task"
         buildFile << """
             ${applyPlugin(PaketGetPlugin)}
         """.stripIndent()
 
         and: "setup paket configuration"
-        setupPaketProject(dependencyName, unityProjectName)
+        setupPaketProject(dependencyName, unityProjectName, packageName)
 
         when:
         def result = runTasksSuccessfully(PaketUnityPlugin.INSTALL_TASK_NAME)
@@ -129,8 +130,8 @@ class PaketUnityIntegrationSpec extends IntegrationSpec {
         result.wasExecuted(PaketUnityPlugin.INSTALL_TASK_NAME)
     }
 
-    @Unroll("Copy assembly definitions when includeAssemblyDefinitions is #includeAssemblyDefinitions and set in #configurationString")
-    def "copy assembly definition files"() {
+    @Unroll("#includeStr assembly definitions when includeAssemblies is #includeAssemblies in reference and #includeAssembliesInTask in #configurationString")
+    def "include assembly definition files"() {
 
         given: "apply paket get plugin to get paket install task"
         buildFile << """
@@ -139,12 +140,13 @@ class PaketUnityIntegrationSpec extends IntegrationSpec {
 
         buildFile << """
             ${configurationString} {                 
-                    includeAssemblyDefinitions = ${includeAssemblyDefinitions}                  
+                    includeAssemblyDefinitions = ${includeAssembliesInTask}                  
             }      
         """.stripIndent()
 
         and: "setup paket configuration"
-        setupPaketProject(dependencyName, unityProjectName)
+        def nugetReference = "${dependencyName} [includeAssemblies:${includeAssemblies}]"
+        setupPaketProject(dependencyName, unityProjectName, packageName, nugetReference)
 
         and: "setup assembly definition file in package"
         def asmdefFileName = "${dependencyName}.${PaketUnityInstall.assemblyDefinitionFileExtension}"
@@ -161,22 +163,78 @@ class PaketUnityIntegrationSpec extends IntegrationSpec {
         result.wasExecuted(PaketUnityPlugin.INSTALL_TASK_NAME)
         def outputAsmdefFilePath = "${packagesDir}/${asmdefFileName}"
         def outputAsmdefFile = new File(outputAsmdefFilePath)
-        includeAssemblyDefinitions == outputAsmdefFile.exists()
+        included == outputAsmdefFile.exists()
 
         where:
-        baseConfigurationString | includeAssemblyDefinitions
-        "paketUnity" | true
-        "paketUnity" | false
-        "project.tasks.getByName(#taskName%%)" | true
-        "project.tasks.getByName(#taskName%%)" | false
+        baseConfigurationString                | includeAssemblies | includeAssembliesInTask | included
+        "paketUnity"                           | true              | true                    | true
+        "paketUnity"                           | true              | false                   | true
+        "paketUnity"                           | false             | true                    | true
+        "paketUnity"                           | false             | false                   | false
+        "project.tasks.getByName(#taskName%%)" | true              | true                    | true
+        "project.tasks.getByName(#taskName%%)" | true              | false                   | true
+        "project.tasks.getByName(#taskName%%)" | false             | true                    | true
+        "project.tasks.getByName(#taskName%%)" | false             | false                   | false
+
+
+        unityProjectName = "Test.Project"
+        taskName = PaketUnityPlugin.INSTALL_TASK_NAME + unityProjectName
+        packageName = "TestDependency"
+        dependencyName = "Wooga.${packageName}"
+        configurationString = baseConfigurationString.replace("#taskName%%", "'${taskName}'")
+        includeStr = included ? "Include" : "Exclude"
+    }
+
+    @Unroll("#includeStr tests when includeTests is #includeTests in reference and #includeTestsInTask in #configurationString")
+    def "include test files"() {
+
+        given: "apply paket get plugin to get paket install task"
+        buildFile << """
+            ${applyPlugin(PaketGetPlugin)}
+        """.stripIndent()
+
+        buildFile << """
+            ${configurationString} {                 
+                    includeTests = ${includeTestsInTask}                  
+            }      
+        """.stripIndent()
+
+        and: "setup paket package, add tests"
+        def nugetReference = "${dependencyName} [includeTests:${includeTests}]"
+        setupPaketProject(dependencyName, unityProjectName, packageName, nugetReference)
+
+        when:
+        def result = runTasksSuccessfully(PaketUnityPlugin.INSTALL_TASK_NAME)
+        def outputDir = "${unityProjectName}/Assets/Paket.Unity3D/${dependencyName}"
+        def packagesDir = new File(projectDir, outputDir)
+        assert packagesDir.exists()
+
+        then:
+        result.wasExecuted(PaketUnityPlugin.INSTALL_TASK_NAME)
+        def testDirectoryPath = "${packagesDir}/${packageName}/${PaketUnityInstall.testsDirectoryName}"
+        def testDirectory = new File(testDirectoryPath)
+        included == testDirectory.exists()
+
+        where:
+        baseConfigurationString                | includeTests | includeTestsInTask | included
+        "paketUnity"                           | true         | true               | true
+        "paketUnity"                           | true         | false              | true
+        "paketUnity"                           | false        | true               | true
+        "paketUnity"                           | false        | false              | false
+        "project.tasks.getByName(#taskName%%)" | true         | true               | true
+        "project.tasks.getByName(#taskName%%)" | true         | false              | true
+        "project.tasks.getByName(#taskName%%)" | false        | true               | true
+        "project.tasks.getByName(#taskName%%)" | false        | false              | false
 
         unityProjectName = "Test.Project"
         taskName = PaketUnityPlugin.INSTALL_TASK_NAME + unityProjectName
-        dependencyName = "Wooga.TestDependency"
+        packageName = "TestDependency"
+        dependencyName = "Wooga.${packageName}"
         configurationString = baseConfigurationString.replace("#taskName%%", "'${taskName}'")
+        includeStr = included ? "Include" : "Exclude"
     }
 
-    private void setupPaketProject(dependencyName, unityProjectName) {
+    private void setupPaketProject(dependencyName, unityProjectName, String packageName, String nugetReference = null) {
 
         def dependencies = createFile("paket.dependencies")
         dependencies << """
@@ -187,12 +245,20 @@ class PaketUnityIntegrationSpec extends IntegrationSpec {
         def lockFile = createFile("paket.lock")
         lockFile << """${dependencyName}""".stripIndent()
 
+        // Custom file used by our system to decide which files from an unity package
+        // get copied to the project
         def references = createFile("${unityProjectName}/paket.unity3d.references")
         references << """
-        ${dependencyName}
+        ${nugetReference ?: dependencyName}
         """.stripIndent()
 
-        createFile("packages/${dependencyName}/content/${dependencyName}.cs")
+        def useConvention = true
+        if (useConvention) {
+            createFile("packages/${dependencyName}/content/${packageName}/Runtime/RuntimeScript.cs")
+            createFile("packages/${dependencyName}/content/${packageName}/Editor/EditorScript.cs")
+            createFile("packages/${dependencyName}/content/${packageName}/${PaketUnityInstall.testsDirectoryName}/Editor/TestScript.cs")
+            createFile("packages/${dependencyName}/content/${packageName}/${PaketUnityInstall.testsDirectoryName}/Runtime/EditorTestScript.cs")
+        }
     }
 
     static boolean hasNoSource(ExecutionResult result, String taskName) {

src/main/groovy/wooga/gradle/paket/base/utils/internal/PaketLock.groovy

@@ -17,6 +17,9 @@
 
 package wooga.gradle.paket.base.utils.internal
 
+/**
+ * The parsed contents of paket.lock file
+ */
 class PaketLock {
 
     enum SourceType {
@@ -35,7 +38,10 @@ class PaketLock {
 
     enum LineType {
 
-        TYPE(0), REMOTE(1), NAME(2), DEPENDENCY(3)
+        TYPE(0),
+        REMOTE(1),
+        NAME(2),
+        DEPENDENCY(3)
 
         private final int value
 
@@ -107,15 +113,25 @@ class PaketLock {
         return false
     }
 
+    /**
+     * @param id The identifier for the dependency
+     * @return All the direct and transitive dependencies used by this dependency
+     */
     List<String> getDependencies(SourceType source, String id) {
-        content[source.getValue()] && content[source.getValue()][id] ? content[source.getValue()][id] as List<String> : []
+        // If the lock file has a reference with the given id,
+        // retrieve all its dependencies
+        content[source.value] && content[source.value][id]
+                ? content[source.value][id] as List<String>
+                : []
     }
 
+    /**
+     * @return Given a list of package references, returns all their dependencies
+     */
     List<String> getAllDependencies(List<String> references) {
-        def ref = references.collect { reference ->
+        def result = references.collect { reference ->
             [reference, getAllDependencies(getDependencies(SourceType.NUGET, reference))]
         }
-
-        ref.flatten().unique()
+        result.flatten().unique()
     }
 }

src/main/groovy/wooga/gradle/paket/base/utils/internal/PaketUnityReferences.groovy

@@ -17,21 +17,106 @@
 
 package wooga.gradle.paket.base.utils.internal
 
+
+import java.util.logging.Logger
+
+/**
+ * A single reference for an Unity WDK package
+ */
+class PaketUnityReference {
+
+    private static final Logger logger = Logger.getLogger(PaketUnityReference.class.name)
+
+    String name
+    Boolean includeTests = false
+    Boolean includeAssemblies = false
+
+    PaketUnityReference(String name) {
+        this.name = name
+    }
+
+    static PaketUnityReference Parse(String text) {
+
+        String pattern = /\s?(?<name>[A-Za-z0-9\.]+)\s*?(\s+(\[(?<properties>.*?)\]))?$/
+
+        def matcher = text =~ pattern
+        if (matcher.count == 0) {
+            logger.warning("Could not parse a reference from ${text}")
+            return null
+        }
+
+        def (_, String name, __, ___, String properties) = matcher[0]
+        PaketUnityReference result = new PaketUnityReference(name)
+
+        if (properties) {
+            try {
+                def map = parseMap(properties)
+                if (map) {
+                    result.includeTests = Boolean.parseBoolean(map["includeTests"]) ?: false
+                    result.includeAssemblies = Boolean.parseBoolean(map["includeAssemblies"]) ?: false
+                }
+            }
+            catch (Exception e) {
+                logger.warning("Failed to parse map from ${text}:\n${e}")
+            }
+        }
+
+        result
+    }
+
+    /***
+     * @param input A String containing a groovy map in the format "key:value,key:value"
+     * @return A map containing the parsed string's key-value pairs
+     */
+    static Map<String, ?> parseMap(String input) {
+        (input =~ /\s*,?\s*([^:]+?)\s*:\s*([^,]*)\s*/)
+                .collect { [it[1], it[2].trim()] }
+                .collectEntries()
+    }
+}
+
+/**
+ * A parsed <i>paket.unity3d.references</i> file, which contains
+ * references to the dependencies used by a project.
+ * These are used by this plugin during a paketInstall invocation
+ */
 class PaketUnityReferences {
 
-    public List<String> nugets
+    private final Map<String, PaketUnityReference> referencesByName
+    private final List<PaketUnityReference> references
+
+    List<PaketUnityReference> getReferences() {
+        references
+    }
+
+    List<String> getReferenceNames() {
+        references.collect({it -> it.name})
+    }
 
     PaketUnityReferences(File referencesFile) {
         this(referencesFile.text)
     }
 
     PaketUnityReferences(String referencesContent) {
-        nugets = []
-        referencesContent.eachLine { line ->
+        references = []
+        referencesByName = [:]
 
-            if(!line.empty){
-                nugets << line.trim()
+        referencesContent.eachLine { line ->
+            if (!line.empty) {
+                PaketUnityReference ref = PaketUnityReference.Parse(line.trim())
+                if (ref != null) {
+                    references << ref
+                    referencesByName.put(ref.name, ref)
+                }
             }
         }
     }
+
+    Boolean containsReference(String name) {
+        referencesByName.containsKey(name)
+    }
+
+    PaketUnityReference getReference(String name) {
+        referencesByName.containsKey(name) ? referencesByName[name] : null
+    }
 }

src/main/groovy/wooga/gradle/paket/unity/PaketUnityPlugin.groovy

@@ -80,6 +80,7 @@ class PaketUnityPlugin implements Plugin<Project> {
                 t.description = "Installs dependencies for Unity3d project ${referenceFile.parentFile.name} "
                 t.conventionMapping.map("paketOutputDirectoryName", { extension.getPaketOutputDirectoryName() })
                 t.conventionMapping.map("includeAssemblyDefinitions", { extension.getIncludeAssemblyDefinitions() })
+                t.conventionMapping.map("includeTests", { extension.getIncludeTests() })
                 t.conventionMapping.map("assemblyDefinitionFileStrategy", { extension.getAssemblyDefinitionFileStrategy() })
                 t.frameworks = extension.getPaketDependencies().getFrameworks()
                 t.lockFile = extension.getPaketLockFile()

src/main/groovy/wooga/gradle/paket/unity/PaketUnityPluginExtension.groovy

@@ -66,4 +66,15 @@ interface PaketUnityPluginExtension extends PaketPluginExtension {
      * @return Whether assembly definition files should be included during installation
      */
     Boolean getIncludeAssemblyDefinitions()
+
+    /**
+     * Sets whether test assemblies should be included during installation
+     * @param value
+     */
+    void setIncludeTests(Boolean value)
+
+    /**
+     * @return Whether test assemblies should be included during installation
+     */
+    Boolean getIncludeTests()
 }

src/main/groovy/wooga/gradle/paket/unity/internal/DefaultPaketUnityPluginExtension.groovy

@@ -31,6 +31,7 @@ class DefaultPaketUnityPluginExtension extends DefaultPaketPluginExtension imple
     protected AssemblyDefinitionFileStrategy assemblyDefinitionFileStrategy
     protected String customPaketOutputDirectory
     protected Boolean includeAssemblyDefinitions = false
+    protected Boolean includeTests = false
 
     DefaultPaketUnityPluginExtension(Project project,final PaketDependencyHandler dependencyHandler) {
         super(project, dependencyHandler)
@@ -71,4 +72,14 @@ class DefaultPaketUnityPluginExtension extends DefaultPaketPluginExtension imple
     Boolean getIncludeAssemblyDefinitions() {
         includeAssemblyDefinitions
     }
+
+    @Override
+    void setIncludeTests(Boolean value) {
+        includeTests = value
+    }
+
+    @Override
+    Boolean getIncludeTests() {
+        includeTests
+    }
 }