Merge branch 'master' of https://github.com/dengzii/AucFrameGenerator

# Conflicts:
#	src/com/dengzii/plugin/template/ui/ConfigDialog.form
#	src/com/dengzii/plugin/template/ui/ConfigDialog.java

Author: dengzii

resources/META-INF/plugin.xml

@@ -17,20 +17,23 @@
   ]]>
     </change-notes>
 
-    <idea-version since-build="182.711"/>
+    <idea-version since-build="183.2153.8"/>
 
     <depends>com.intellij.modules.java</depends>
     <depends>org.jetbrains.kotlin</depends>
 
     <extensions defaultExtensionNs="com.intellij">
         <fileTemplateGroup implementation="com.dengzii.plugin.template.template.FileTemplateFactory" order="first"/>
         <internalFileTemplate name="AndroidManifest" id="com.dengzii.plugin.template.ft.manifest"/>
+        <applicationConfigurable groupId="tools" displayName="Template Module Generator"
+                                 id="preferences.ModuleTemplateConfig"
+                                 instance="com.dengzii.plugin.template.ui.ConfigurePanel"/>
     </extensions>
 
     <actions>
         <!-- Add your actions here -->
         <action id="com.dengzii.plugin.template.gen" class="com.dengzii.plugin.template.CreateModuleAction"
-                text="Template Module Generator"
+                text="Create Module From Template"
                 description="Create module from template">
             <add-to-group group-id="ProjectViewPopupMenu" anchor="first"/>
         </action>

resources/META-INF/pluginIcon.svg

@@ -0,0 +1,10 @@
+package ${PACKAGE_NAME};
+
+import ${BASE_APPLICATION};
+
+public class ${CLASS_NAME} extends BaseApplication{
+
+    public void onCreate(){
+
+    }
+}

resources/fileTemplates/Template App.java.ft

@@ -2,7 +2,7 @@ package ${PACKAGE_NAME};
 
 import ${BASE_APPLICATION};
 
-public class ${APPLICATION_NAME} extends BaseApplication{
+public class ${CLASS_NAME} extends BaseApplication{
 
     public void onCreate(){
 

resources/fileTemplates/Template Application.java.ft

@@ -2,9 +2,9 @@ package ${PACKAGE_NAME}
 
 import ${BASE_APPLICATION}
 
-public class App extends BaseApplication{
+class ${CLASS_NAME}:BaseApplication(){
 
-    public void onCreate(){
+    fun onCreate(){
 
     }
 }

resources/fileTemplates/Template Application.kt.ft

@@ -0,0 +1,3 @@
+dependencies{
+
+}

resources/fileTemplates/Template build.gradle.ft

@@ -1,7 +1,10 @@
 package com.dengzii.plugin.template
 
-import com.dengzii.plugin.template.model.ModuleConfig
+import com.dengzii.plugin.template.model.FileTreeNode
+import com.dengzii.plugin.template.model.Module
 import com.dengzii.plugin.template.template.AucTemplate
+import com.dengzii.plugin.template.utils.Logger
+import com.google.gson.Gson
 import com.intellij.ide.util.PropertiesComponent
 
 /**
@@ -18,22 +21,58 @@ object Config {
 
     private const val KEY_TEMPLATES = "KEY_TEMPLATES"
 
-    val DEFAULT_TEMPLATE = listOf(
-            ModuleConfig.create(AucTemplate.MODULE, "feature", "com.example.feature", "Java", "Auc Feature Module"),
-            ModuleConfig.create(AucTemplate.APP, "app", "com.example.feature", "Java", "Auc App Module"),
-            ModuleConfig.create(AucTemplate.PKG, "pkg", "com.example.feature", "Java", "Auc Pkg Module"),
-            ModuleConfig.create(AucTemplate.EXPORT, "export", "com.example.feature", "Java", "Auc Export Module")
+    private val GSON = Gson()
+    val DEFAULT_MODULE_TEMPLATE = listOf(
+            Module.create(AucTemplate.MODULE, "feature", "com.example.feature", "Java", "Auc Feature Module"),
+            Module.create(AucTemplate.APP, "app", "com.example.feature", "Java", "Auc App Module"),
+            Module.create(AucTemplate.PKG, "pkg", "com.example.feature", "Java", "Auc Pkg Module"),
+            Module.create(AucTemplate.EXPORT, "export", "com.example.feature", "Java", "Auc Export Module")
     )
 
+
     fun clear() {
         PropertiesComponent.getInstance().unsetValue(KEY_TEMPLATES)
     }
 
-    fun loadTemplates(): List<ModuleConfig> {
-        return DEFAULT_TEMPLATE
+    fun loadModuleTemplates(): MutableList<Module> {
+        val result = mutableListOf<Module>()
+        val arr = PropertiesComponent.getInstance().getValues(KEY_TEMPLATES)
+
+        if (arr.isNullOrEmpty()) {
+            return result
+        }
+        Logger.d(Config::class.java.simpleName, "loadModuleTemplates")
+        arr.forEach {
+            try {
+                val module = GSON.fromJson(it, Module::class.java)
+                setParent(module.template)
+                println(module.template.getTreeGraph())
+                result.add(module)
+            } catch (e: Exception) {
+                clear()
+                e.printStackTrace()
+                return result
+            }
+        }
+        result.addAll(DEFAULT_MODULE_TEMPLATE)
+        return result
     }
 
-    fun saveTemplates() {
+    fun saveModuleTemplates(templates: List<Module>) {
+        val t = mutableListOf<String>()
+        templates.forEach {
+            t.add(GSON.toJson(it))
+            Logger.d(Config::class.java.simpleName, "saveModuleTemplates ${t[t.lastIndex]}")
+        }
+        PropertiesComponent.getInstance().setValues(KEY_TEMPLATES, t.toTypedArray())
+    }
 
+    private fun setParent(node: FileTreeNode) {
+        node.children.forEach {
+            it.parent = node
+            if (it.isDir) {
+                setParent(it)
+            }
+        }
     }
 }

src/com/dengzii/plugin/template/Config.kt

@@ -1,7 +1,7 @@
 package com.dengzii.plugin.template
 
 import com.dengzii.plugin.template.model.FileTreeNode
-import com.dengzii.plugin.template.model.ModuleConfig
+import com.dengzii.plugin.template.model.Module
 import com.dengzii.plugin.template.utils.Logger
 import com.dengzii.plugin.template.utils.PluginKit
 import com.intellij.openapi.command.UndoConfirmationPolicy
@@ -18,15 +18,15 @@ import com.intellij.util.ThrowableRunnable
  * desc   :
  * </pre>
  */
-class FileWriteCommand(private var kit: PluginKit, private var moduleConfig: ModuleConfig) : ThrowableRunnable<Exception> {
+class FileWriteCommand(private var kit: PluginKit, private var module: Module) : ThrowableRunnable<Exception> {
 
     companion object {
         private val TAG = FileWriteCommand::class.java.simpleName
-        fun startAction(kit: PluginKit, moduleConfig: ModuleConfig) {
+        fun startAction(kit: PluginKit, module: Module) {
             WriteCommandAction.writeCommandAction(kit.project)
                     .withGlobalUndo()
                     .withUndoConfirmationPolicy(UndoConfirmationPolicy.REQUEST_CONFIRMATION)
-                    .run(FileWriteCommand(kit, moduleConfig))
+                    .run(FileWriteCommand(kit, module))
         }
     }
 
@@ -37,26 +37,37 @@ class FileWriteCommand(private var kit: PluginKit, private var moduleConfig: Mod
             Logger.i(TAG, "Current target is not directory.")
             return
         }
-        val fileTreeNode = moduleConfig.template
+        val fileTreeNode = module.template
         Logger.d(TAG, fileTreeNode.placeHolderMap.toString())
         fileTreeNode.children.forEach {
             createFileTree(it, current)
         }
     }
 
-    private fun createFileTree(treeNode: FileTreeNode, current: VirtualFile?) {
-        if (current == null) {
-            Logger.e(TAG, "The parent of ${treeNode.getPath()} is null")
-            return
-        }
+    private fun createFileTree(treeNode: FileTreeNode, currentDirectory: VirtualFile) {
         Logger.i(TAG, "Create ${treeNode.getPath()}")
         if (treeNode.isDir) {
-            kit.createDir(treeNode.name, current)
+            val dir = kit.createDir(treeNode.name, currentDirectory)
+            if (dir == null) {
+                Logger.e(TAG, "create directory failure: ${treeNode.name}")
+                return
+            }
             treeNode.children.forEach {
-                createFileTree(it, current.findChild(treeNode.name))
+                createFileTree(it, dir)
             }
         } else {
-            kit.createFile(treeNode.name, current)
+            if (treeNode.hasTemplate()) {
+                val result = kit.createFileFromTemplate(
+                        treeNode.name,
+                        treeNode.getTemplateName()!!,
+                        treeNode.placeHolderMap.orEmpty(),
+                        currentDirectory)
+                if (result == null) {
+                    Logger.e(TAG, "create file from template failed, file: ${treeNode.name} template:${treeNode.getTemplateName()}")
+                }
+            } else {
+                kit.createFile(treeNode.name, currentDirectory)
+            }
         }
     }
 }

src/com/dengzii/plugin/template/FileWriteCommand.kt

@@ -4,6 +4,7 @@ import com.dengzii.plugin.template.template.Placeholder
 import com.dengzii.plugin.template.template.replacePlaceholder
 import com.dengzii.plugin.template.utils.Logger
 import java.io.File
+import java.util.*
 
 /**
  * <pre>
@@ -22,15 +23,24 @@ open class FileTreeNode private constructor() {
         }
 
     var isDir = true
-    val children by lazy { mutableListOf<FileTreeNode>() }
-    var placeHolderMap: MutableMap<Placeholder, String>? = null
+    var children = mutableListOf<FileTreeNode>()
+    var placeHolderMap: MutableMap<String, String>? = null
         get() = field ?: parent?.placeHolderMap
 
+    // template for node, higher priority than fileTemplates
+    var template: String? = null
+
+    // template of filename
+    var fileTemplates: MutableMap<String, String>? = null
+        get() = field ?: parent?.fileTemplates
+
     // the origin name with original placeholder
     private var realName: String = ""
-    private var parent: FileTreeNode? = null
+    @Transient
+    var parent: FileTreeNode? = null
 
     companion object {
+
         private val TAG = FileTreeNode::class.java.simpleName
 
         fun root(path: String): FileTreeNode {
@@ -60,11 +70,30 @@ open class FileTreeNode private constructor() {
         return this
     }
 
+    fun getRealName(): String {
+        return realName
+    }
+
+    fun fileTemplate(fileName: String, template: String) {
+        if (this.fileTemplates == null) {
+            this.fileTemplates = mutableMapOf()
+        }
+        fileTemplates!![fileName] = template
+    }
+
+    fun hasTemplate(): Boolean {
+        return template != null || fileTemplates?.containsKey(realName) == true
+    }
+
+    fun getTemplateName(): String? {
+        return template ?: fileTemplates?.get(realName)
+    }
+
     fun placeholder(placeholder: Placeholder, value: String) {
         if (this.placeHolderMap == null) {
             this.placeHolderMap = kotlin.collections.mutableMapOf()
         }
-        placeHolderMap!![placeholder] = value
+        placeHolderMap!![placeholder.getPlaceholder()] = value
     }
 
     /**
@@ -112,16 +141,27 @@ open class FileTreeNode private constructor() {
     fun include(other: FileTreeNode) {
         if (!isDir) return
         other.children.forEach {
-            it.parent = this
-            children.add(it)
+            val child = it.clone()
+            child.parent = this
+            children.add(child)
         }
     }
 
-    fun dir(name: String, block: FileTreeNode.() -> Unit = {}) {
+    fun dir(path: String, block: FileTreeNode.() -> Unit = {}) {
         if (!isDir) return
-        val dir = FileTreeNode(this, name, true)
-        children.add(dir)
-        dir(block)
+        val dirs = path.split("/").filter { it.isNotBlank() }.toMutableList()
+        createDirs(dirs, this)(block)
+    }
+
+    private fun createDirs(dirs: MutableList<String>, parent: FileTreeNode): FileTreeNode {
+        if (dirs.isEmpty()) {
+            return parent
+        }
+        val current = dirs[0]
+        dirs.removeAt(0)
+        val dirNode = FileTreeNode(parent, current, true)
+        parent.children.add(dirNode)
+        return createDirs(dirs, dirNode)
     }
 
     fun file(name: String) {
@@ -141,18 +181,50 @@ open class FileTreeNode private constructor() {
         return parent!!.getPath() + "/" + name
     }
 
-
     fun isRoot(): Boolean {
         return this == parent
     }
 
     fun getTreeGraph(): String {
-        val strBuilder = StringBuilder()
-        traversal({ i, dep ->
-            val head = if (i.isRoot()) "┌" else if (children.last() == i) "└" else "├"
-            strBuilder.append("│   ".repeat(dep) + "$head─" + i.name)
+        return getNodeGraph().toString()
+    }
+
+    fun clone(): FileTreeNode {
+        val cl = FileTreeNode(null, name, isDir)
+        cl.fileTemplates = fileTemplates?.toMutableMap()
+        cl.placeHolderMap = placeHolderMap?.toMutableMap()
+        children.forEach {
+            val child = it.clone()
+            child.parent = cl
+            cl.children.add(child)
+        }
+        return cl
+    }
+
+    private fun getNodeGraph(head: Stack<String> = Stack(), str: StringBuilder = StringBuilder()): StringBuilder {
+
+        head.forEach {
+            str.append(it)
+        }
+        str.append(when (this) {
+            parent?.children?.last() -> "└─"
+            parent?.children?.first() -> "├─"
+            else -> if (parent?.parent != null) "├─" else "┌─"
         })
-        return strBuilder.toString()
+        str.append(name).append("\n")
+
+        if (!children.isNullOrEmpty()) {
+            head.push(when {
+                parent == null -> ""
+                parent?.children?.last() != this -> "│\t"
+                else -> "\t"
+            })
+            children.forEach {
+                str.append(it.getNodeGraph(head))
+            }
+            head.pop()
+        }
+        return str
     }
 
     private fun createChild() {