more test

Author: efraespada

src/main/kotlin/components/Extensions.kt

@@ -3,6 +3,7 @@ package components
 import groovy.json.StringEscapeUtils
 import models.Configuration
 import models.Extension
+import models.ResourceFile
 import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.Project
 import java.io.File
@@ -36,6 +37,30 @@ fun File.validForConfiguration(configuration: Configuration): Boolean {
     return valid
 }
 
+fun File.resourceFile(configuration: Configuration): ResourceFile? {
+    var sourceFolder = ""
+    var validFile: File? = null
+    var valid = false
+    configuration.srcFolders.forEach { folder ->
+        if (this.absolutePath.contains("/$folder/".replace("//", "/"))
+            && !this.absolutePath.contains("/$resourceBackup/")
+        ) {
+            sourceFolder = folder
+            valid = true
+        }
+    }
+    if (valid) {
+        valid = false
+        configuration.stringFiles.forEach { file ->
+            if (this.absolutePath.contains("/$file".replace("//", "/"))) {
+                valid = true
+                validFile = this
+            }
+        }
+    }
+    return if (valid) ResourceFile(validFile!!, sourceFolder, configuration.name) else null
+}
+
 fun Project.absolutePath(): String = this.file(wrapperWindows).absolutePath.replace(
     wrapperWindows,
     emptyChar
@@ -50,3 +75,23 @@ fun Process.outputString() = this.inputStream.bufferedReader().use { it.readText
 fun defaultConfig(): Configuration {
     return Configuration("app", listOf("strings.xml"), listOf("src${File.separator}main"))
 }
+
+fun ResourceFile.backup(projectPath: String): File {
+    val cleanPath = "$projectPath${File.separator}$resourceBackup${File.separator}${this.module}" +
+            "${File.separator}${this.sourceFolder}${this.file.absolutePath.split(this.sourceFolder)[1]}"
+                .replace("${File.separator}${File.separator}", File.separator)
+
+    val backupFile = File(cleanPath)
+    this.file.copyTo(backupFile)
+    return backupFile
+}
+
+fun File.restore(projectPath: String): File {
+    val cleanPath = "$projectPath${File.separator}${this.absolutePath.split(resourceBackup)[1]}"
+                .replace("${File.separator}${File.separator}", File.separator)
+
+    val restore = File(cleanPath)
+    this.copyTo(restore, true)
+    return restore
+}
+

src/main/kotlin/models/Fingerprint.kt renamed to src/main/kotlin/components/Fingerprint.kt

@@ -1,8 +1,4 @@
-package models
-
-import components.PrintUtils
-import components.runCommand
-import components.signingReportTask
+package components
 
 private class Fingerprint {
 

src/main/kotlin/models/Os.kt renamed to src/main/kotlin/components/Os.kt

@@ -1,4 +1,4 @@
-package models
+package components
 
 enum class Os {
     WINDOWS,

src/main/kotlin/components/Tasks.kt

@@ -1,8 +1,5 @@
 package components
 
-import models.Os
-import models.getOs
-
 internal fun signingReportTask(): String = "${when (getOs()) {
     Os.WINDOWS -> wrapperWindows
     Os.OSX -> wrapperOsX

src/main/kotlin/components/XParser.kt

@@ -1,9 +1,63 @@
 package components
 
 import models.Configuration
+import models.ResourceFile
+import models.SAttribute
+import models.StringEntity
+import org.xml.sax.InputSource
 import java.io.File
+import javax.xml.parsers.DocumentBuilderFactory
 
-fun locateFiles(projectPath: String, configuration: Configuration): List<File> = File(projectPath).walkTopDown()
+fun locateFiles(projectPath: String, configuration: Configuration): List<ResourceFile> = File(projectPath).walkTopDown()
     .filterIndexed { _, file ->
         file.validForConfiguration(configuration)
-    }.toList()
+    }.map { it.resourceFile(configuration)!! }.toList()
+
+fun backupFiles(projectPath: String, configuration: Configuration): List<File> {
+    val resourceFiles = mutableListOf<File>()
+    val files = locateFiles(projectPath, configuration)
+    files.forEach { resource ->
+        resourceFiles.add(resource.backup(projectPath))
+    }
+    return resourceFiles
+}
+
+fun restoreFiles(projectPath: String): List<File> {
+    val resourceFiles = File("$projectPath${File.separator}$resourceBackup").walkTopDown().toList()
+    resourceFiles.filter { file ->
+        !file.isDirectory
+    }.map {
+        it.restore(projectPath)
+    }
+    return resourceFiles
+}
+
+fun parseXML(file: File, module: String, debug: Boolean): List<StringEntity> {
+    if (debug) {
+        val content = file.inputStream().readBytes().toString(Charsets.UTF_8)
+        PrintUtils.print(module, content, true)
+    }
+    val entities = mutableListOf<StringEntity>()
+    val builderFactory = DocumentBuilderFactory.newInstance()
+    val docBuilder = builderFactory.newDocumentBuilder()
+    val doc = docBuilder.parse(file.inputStream())
+    // reading player tags
+    val nList = doc.getElementsByTagName("string")
+    for (i in 0 until nList.length) {
+        val node = nList.item(i)
+        var name = ""
+        val attributes = mutableListOf<SAttribute>()
+        for (a in 0 until node.attributes.length) {
+            val attribute = node.attributes.item(a)
+            for (n in 0 until attribute.childNodes.length) {
+                val attr = attribute.childNodes.item(n)
+                // can set value
+                if (attribute.nodeName == "name") name = attr.nodeValue
+                attributes.add(SAttribute(attribute.nodeName, attr.nodeValue))
+            }
+        }
+        entities.add(StringEntity(name, attributes, node.firstChild.nodeValue))
+    }
+    return entities
+}
+

src/main/kotlin/models/ResourceFile.kt

@@ -0,0 +1,5 @@
+package models
+
+import java.io.File
+
+data class ResourceFile(val file: File, val sourceFolder: String, val module: String)

src/main/kotlin/models/StringEntity.kt

@@ -0,0 +1,4 @@
+package models
+
+data class StringEntity(val name: String, val attributes: List<SAttribute>, val value: String)
+data class SAttribute(val name: String, val value: String)

src/test/kotlin/SCTest.kt

@@ -1,16 +1,16 @@
 import components.*
-import models.extractFingerprint
 import org.junit.Test
 
 
 class SCTest {
 
     private val logger by logger()
 
+    private val projectName = "KotlinSample"
     private val prepareTask = """
-            rm -rf KotlinSample &&
-            git clone https://github.com/StringCare/KotlinSample.git &&
-            cd KotlinSample
+            rm -rf $projectName &&
+            git clone https://github.com/StringCare/$projectName.git &&
+            cd $projectName
         """.trimIndent()
 
     // gradlew task needs export ANDROID_SDK_ROOT=/Users/efrainespada/Library/Android/sdk
@@ -44,9 +44,45 @@ class SCTest {
     @Test
     fun `locate string files for default configuration`() {
         prepareTask.runCommand { _, _ ->
-            assert(locateFiles("KotlinSample", defaultConfig()).isNotEmpty())
+            assert(locateFiles(projectName, defaultConfig()).isNotEmpty())
         }
+    }
+
+    @Test
+    fun `backup string files`() {
+        prepareTask.runCommand { _, _ ->
+            assert(backupFiles(projectName, defaultConfig()).isNotEmpty())
+        }
+    }
+
+    @Test
+    fun `restore string files`() {
+        prepareTask.runCommand { _, _ ->
+            assert(backupFiles(projectName, defaultConfig()).isNotEmpty())
+            assert(restoreFiles(projectName).isNotEmpty())
+        }
+    }
 
+    @Test
+    fun `xml parsing`() {
+        prepareTask.runCommand { _, _ ->
+            val files = backupFiles(projectName, defaultConfig())
+            files.forEach {
+                assert(parseXML(it, "app", true).isNotEmpty())
+            }
+        }
+    }
+
+
+    @Test
+    fun `obfuscate string files`() {
+        prepareTask.runCommand { _, _ ->
+            val files = backupFiles(projectName, defaultConfig())
+            files.forEach {
+                val entities = parseXML(it, "app", true)
+
+            }
+        }
     }
 
 }