fix UnSupport exception #62 #68

Author: sealkingking

src/main/kotlin/wu/seal/jsontokotlin/KotlinCodeMaker.kt

@@ -1,7 +1,9 @@
 package wu.seal.jsontokotlin
 
+import com.google.gson.Gson
 import com.google.gson.JsonElement
 import com.google.gson.JsonObject
+import com.sun.org.apache.regexp.internal.RE
 import wu.seal.jsontokotlin.codeelements.KClassAnnotation
 import wu.seal.jsontokotlin.codeelements.KProperty
 import wu.seal.jsontokotlin.utils.*
@@ -16,16 +18,20 @@ class KotlinCodeMaker {
     private var className: String? = null
     private var inputElement: JsonElement? = null
 
+    private var originElement:JsonElement
+
     private val indent = getIndent()
 
     private val toBeAppend = HashSet<String>()
 
     constructor(className: String, inputText: String) {
+        originElement = Gson().fromJson<JsonElement>(inputText,JsonElement::class.java)
         this.inputElement = TargetJsonElement(inputText).getTargetJsonElementForGeneratingCode()
         this.className = className
     }
 
     constructor(className: String, jsonElement: JsonElement) {
+        originElement = jsonElement
         this.inputElement = TargetJsonElement(jsonElement).getTargetJsonElementForGeneratingCode()
         this.className = className
     }
@@ -35,16 +41,10 @@ class KotlinCodeMaker {
         stringBuilder.append("\n")
 
         val jsonElement = inputElement
-        if (jsonElement!!.isJsonObject) {
-            appendClassName(stringBuilder)
-            appendCodeMember(stringBuilder, jsonElement.asJsonObject)
-        } else {
-            /**
-             * in this condition the only result it that we just give the json a List<Any> type is enough, No need to
-             * do any convert to make class type
-             */
-            throw UnSupportJsonException("Unsupported Json String")
-        }
+        checkIsNotEmptyObjectJSONElement(jsonElement)
+
+        appendClassName(stringBuilder)
+        appendCodeMember(stringBuilder, jsonElement?.asJsonObject!!)
 
         stringBuilder.append(")")
         if (toBeAppend.isNotEmpty()) {
@@ -54,6 +54,35 @@ class KotlinCodeMaker {
         return stringBuilder.toString()
     }
 
+    //the fucking code
+    private fun checkIsNotEmptyObjectJSONElement(jsonElement: JsonElement?) {
+        if (jsonElement!!.isJsonObject) {
+            if (jsonElement.asJsonObject.entrySet().isEmpty() && originElement.isJsonArray) {
+                //when [[[{}]]]
+                if (originElement.asJsonArray.onlyHasOneElementRecursive()) {
+                    val unSupportJsonException = UnSupportJsonException("Unsupported Json String")
+                    val adviceType = getArrayType("Any", originElement.asJsonArray).replace(Regex("Int|Float|String|Boolean"), "Any")
+                    unSupportJsonException.advice = """No need converting, just use $adviceType is enough for your json string"""
+                    throw unSupportJsonException
+                } else {
+                    //when [1,"a"]
+                    val unSupportJsonException = UnSupportJsonException("Unsupported Json String")
+                    unSupportJsonException.advice = """No need converting, just use List<Any> is enough for your json string"""
+                    throw unSupportJsonException
+                }
+            }
+        } else {
+            /**
+             * in this condition the only result it that we just give the json a List<Any> type is enough, No need to
+             * do any convert to make class type
+             */
+            val unSupportJsonException = UnSupportJsonException("Unsupported Json String")
+            val adviceType = getArrayType("Any", originElement.asJsonArray).replace("AnyX", "Any")
+            unSupportJsonException.advice = """No need converting, just use $adviceType is enough for your json string"""
+            throw unSupportJsonException
+        }
+    }
+
     private fun appendSubClassCode(stringBuilder: StringBuilder) {
         if (ConfigManager.isInnerClassModel) {
             appendInnerClassModelSubClassCode(stringBuilder)

src/main/kotlin/wu/seal/jsontokotlin/MakeKotlinClassAction.kt

@@ -76,13 +76,16 @@ class MakeKotlinClassAction : AnAction("MakeKotlinClass") {
 
 
         } catch (e: UnSupportJsonException) {
-            Messages.showInfoMessage("No need converting, just use List<Any> is enough for your json string", "Tip")
+            val advice = e.advice
+            Messages.showInfoMessage(dealWithHtmlConvert(advice), "Tip")
         } catch (e: Throwable) {
             dealWithException(jsonString, e)
             throw e
         }
     }
 
+    private fun dealWithHtmlConvert(advice: String) = advice.replace("<", "&lt;").replace(">", "&gt;")
+
     private fun reuseClassName(
             couldGetAndReuseClassNameInCurrentEditFileForInserCode: Boolean,
             className: String,
@@ -127,6 +130,8 @@ class MakeKotlinClassAction : AnAction("MakeKotlinClass") {
             return false
         }
 
+        val generateClassesString = codeMaker.makeKotlinDataClassCode()
+
         executeCouldRollBackAction(project) {
             var offset: Int
 
@@ -141,7 +146,7 @@ class MakeKotlinClassAction : AnAction("MakeKotlinClass") {
             }
             document.insertString(
                     Math.max(offset, 0),
-                    ClassCodeFilter.removeDuplicateClassCode(codeMaker.makeKotlinDataClassCode())
+                    ClassCodeFilter.removeDuplicateClassCode(generateClassesString)
             )
         }
         return true

src/main/kotlin/wu/seal/jsontokotlin/TargetJsonElement.kt

@@ -1,6 +1,7 @@
 package wu.seal.jsontokotlin
 
 import com.google.gson.*
+import wu.seal.jsontokotlin.utils.onlyHasOneElementRecursive
 import java.util.*
 
 /**
@@ -29,6 +30,8 @@ class TargetJsonElement : ITargetJsonElement {
                 } else {
                     throw IllegalStateException("Unbelievable！ should not throw out this exception")
                 }
+            } else if(jsonElement.asJsonArray.onlyHasOneElementRecursive()){
+                return getArrayChildElement(this.jsonElement.asJsonArray)
             } else if (allElementAreSamePrimitiveType(jsonElement.asJsonArray)) {
                 return jsonElement.asJsonArray[0]
             } else {
@@ -43,6 +46,7 @@ class TargetJsonElement : ITargetJsonElement {
         }
     }
 
+
     private fun allElementAreObject(jsonArray: JsonArray): Boolean {
         var allElementAreObject = true
         jsonArray.forEach {
@@ -95,6 +99,8 @@ class TargetJsonElement : ITargetJsonElement {
         /**
          * get an element from the element array , And the result element should contains all the json field in every
          * element of the array
+         *
+         * the input argument jsonArray should only contains jsonObject or only contains one element Recursive like [[["element"]]]
          */
         fun getFullFieldElementFromArrayElement(jsonArray: JsonArray): JsonElement {
 
@@ -118,6 +124,8 @@ class TargetJsonElement : ITargetJsonElement {
 
             return gson.fromJson(gson.toJson(map), JsonElement::class.java)
         }
+
+
     }
 
 }

src/main/kotlin/wu/seal/jsontokotlin/UnsupportJsonException.kt

@@ -4,4 +4,7 @@ package wu.seal.jsontokotlin
 /**
  * Throw out when the json to be convert don't support by this plugin or no need to convert to any classes
  */
-class UnSupportJsonException(message: String = "") : Exception(message)
+class UnSupportJsonException(message: String = "") : Exception(message) {
+    var advice: String = ""
+
+}

src/main/kotlin/wu/seal/jsontokotlin/utils/Extensions.kt

@@ -1,5 +1,6 @@
 package wu.seal.jsontokotlin.utils
 
+import com.google.gson.JsonArray
 import java.awt.Component
 import java.awt.Container
 import java.util.regex.Matcher
@@ -47,4 +48,30 @@ fun String.numberOf(subString: String):Int {
         count++
     }
     return count
+}
+
+/**
+ * array only has one element
+ */
+private fun JsonArray.onlyHasOneElement(): Boolean {
+    return size() == 1
+}
+
+/**
+ * if Multidimensional Arrays only has one element
+ */
+fun JsonArray.onlyHasOneElementRecursive(): Boolean {
+
+    if (size() == 0) {
+        return false
+    }
+    if (onlyHasOneElement().not()) {
+        return false
+    }
+
+    if (get(0).isJsonPrimitive || get(0).isJsonObject || get(0).isJsonNull) {
+        return true
+    }
+
+    return get(0).asJsonArray.onlyHasOneElementRecursive()
 }

src/test/kotlin/wu/seal/jsontokotlin/TargetJsonElementTest.kt

@@ -41,6 +41,12 @@ class TargetJsonElementTest {
 
         val text7 = """[1,"2",true]"""
 
+        val text8 = """[[[1]]]"""
+
+        val text9 = """[[1,2],[]]"""
+
+
+
 
         val targetElementJson1 = getTargetElementJson(gson, text1)
         targetElementJson1.should.be.equal(gson.toJson(gson.fromJson(text1, JsonElement::class.java)))
@@ -52,16 +58,22 @@ class TargetJsonElementTest {
         targetElementJson3.should.be.equal(gson.toJson(Any()))
 
         val targetElementJson4 = getTargetElementJson(gson, text4)
-        targetElementJson4.should.be.equal(error)
+        targetElementJson4.should.be.equal("1")
 
         val targetElementJson5 = getTargetElementJson(gson, text5)
-        targetElementJson5.should.be.equal(error)
+        targetElementJson5.should.be.equal("1")
 
         val targetElementJson6 = getTargetElementJson(gson, text6)
-        targetElementJson6.should.be.equal(error)
+        targetElementJson6.should.be.equal("\"1\"")
 
         val targetElementJson7 = getTargetElementJson(gson, text7)
-        targetElementJson7.should.be.equal(error)
+        targetElementJson7.should.be.equal("{}")
+
+        val targetElementJson8 = getTargetElementJson(gson, text8)
+        targetElementJson8.should.be.equal("1")
+
+        val targetElementJson9 = getTargetElementJson(gson, text9)
+        targetElementJson9.should.be.equal("{}")
 
     }