fix save string number

gui/gui.go

@@ -196,20 +196,10 @@ func (g *Gui) SaveJSON() {
 }
 
 func (g *Gui) makeJSON(node *tview.TreeNode) interface{} {
-	nodeType := node.GetReference().(Type)
+	ref := node.GetReference().(Reference)
 	children := node.GetChildren()
 
-	switch nodeType {
+	switch ref.JSONType {
-	case Root:
-		if len(children) == 1 {
-			return g.makeJSON(children[0])
-		} else {
-			var i []interface{}
-			for _, n := range children {
-				i = append(i, g.makeJSON(n))
-			}
-			return i
-		}
 	case Object:
 		i := make(map[string]interface{})
 		for _, n := range children {
@@ -224,7 +214,7 @@ func (g *Gui) makeJSON(node *tview.TreeNode) interface{} {
 		return i
 	case Key:
 		v := node.GetChildren()[0]
-		if v.GetReference().(Type) == Value {
+		if v.GetReference().(Reference).JSONType == Value {
 			return g.parseValue(v)
 		}
 		return map[string]interface{}{
@@ -237,12 +227,19 @@ func (g *Gui) makeJSON(node *tview.TreeNode) interface{} {
 
 func (g *Gui) parseValue(node *tview.TreeNode) interface{} {
 	v := node.GetText()
-	if i, err := strconv.Atoi(v); err == nil {
+	ref := node.GetReference().(Reference)
+
+	switch ref.ValueType {
+	case Int:
+		i, _ := strconv.Atoi(v)
 		return i
-	} else if f, err := strconv.ParseFloat(v, 64); err == nil {
+	case Float:
+		f, _ := strconv.ParseFloat(v, 64)
 		return f
-	} else if b, err := strconv.ParseBool(v); err == nil {
+	case Boolean:
+		b, _ := strconv.ParseBool(v)
 		return b
 	}
+
 	return v
 }

gui/tree.go

@@ -30,11 +30,11 @@ func (t *Tree) UpdateView(g *Gui, i interface{}) {
 		var root *tview.TreeNode
 		switch r.Kind() {
 		case reflect.Map:
-			root = tview.NewTreeNode("{object}").SetReference(Object)
+			root = tview.NewTreeNode("{object}").SetReference(Reference{JSONType: Object})
 		case reflect.Slice:
-			root = tview.NewTreeNode("{array}").SetReference(Array)
+			root = tview.NewTreeNode("{array}").SetReference(Reference{JSONType: Array})
 		default:
-			root = tview.NewTreeNode("{value}").SetReference(Key)
+			root = tview.NewTreeNode("{value}").SetReference(Reference{JSONType: Key})
 		}
 
 		root.SetChildren(t.AddNode(i))
@@ -57,11 +57,11 @@ func (t *Tree) AddNode(node interface{}) []*tview.TreeNode {
 			r := reflect.ValueOf(v)
 
 			if r.Kind() == reflect.Slice {
-				newNode.SetReference(Array)
+				newNode.SetReference(Reference{JSONType: Array})
 			} else if r.Kind() == reflect.Map {
-				newNode.SetReference(Object)
+				newNode.SetReference(Reference{JSONType: Object})
 			} else {
-				newNode.SetReference(Key)
+				newNode.SetReference(Reference{JSONType: Key})
 			}
 
 			log.Printf("key:%v value:%v value_kind:%v", k, v, newNode.GetReference())
@@ -74,7 +74,7 @@ func (t *Tree) AddNode(node interface{}) []*tview.TreeNode {
 				r := reflect.ValueOf(n)
 				if r.Kind() != reflect.Slice {
 					objectNode := tview.NewTreeNode("{object}").
-						SetChildren(t.AddNode(v)).SetReference(Object)
+						SetChildren(t.AddNode(v)).SetReference(Reference{JSONType: Object})
 
 					log.Printf("value:%v value_kind:%v", v, "object")
 					nodes = append(nodes, objectNode)
@@ -85,7 +85,21 @@ func (t *Tree) AddNode(node interface{}) []*tview.TreeNode {
 		}
 	default:
 		log.Printf("value:%v value_kind:%v", node, "value")
-		nodes = append(nodes, t.NewNodeWithLiteral(node).SetReference(Value))
+		ref := reflect.ValueOf(node)
+		var valueType ValueType
+		switch ref.Kind() {
+		case reflect.Int:
+			valueType = Int
+		case reflect.Float64:
+			valueType = Float
+		case reflect.Bool:
+			valueType = Boolean
+		default:
+			valueType = String
+		}
+
+		nodes = append(nodes, t.NewNodeWithLiteral(node).
+			SetReference(Reference{JSONType: Value, ValueType: valueType}))
 	}
 	return nodes
 }

gui/type.go

@@ -1,25 +1,47 @@
 package gui
 
-type Type int
+type JSONType int
 
 const (
-	Unknown Type = iota
+	Root JSONType = iota + 1
-	Root
 	Object
 	Array
 	Key
 	Value
 )
 
-var TypeMap = map[Type]string{
+var jsonTypeMap = map[JSONType]string{
-	Unknown: "unknown",
+	Object: "object",
-	Root:    "root",
+	Array:  "array",
-	Object:  "object",
+	Key:    "key",
-	Array:   "array",
+	Value:  "value",
-	Key:     "key",
-	Value:   "value",
 }
 
-func (t Type) String() string {
+func (t JSONType) String() string {
-	return TypeMap[t]
+	return jsonTypeMap[t]
+}
+
+type ValueType int
+
+const (
+	Int ValueType = iota + 1
+	String
+	Float
+	Boolean
+)
+
+var valueTypeMap = map[ValueType]string{
+	Int:     "int",
+	String:  "string",
+	Float:   "float",
+	Boolean: "boolean",
+}
+
+func (v ValueType) String() string {
+	return valueTypeMap[v]
+}
+
+type Reference struct {
+	JSONType  JSONType
+	ValueType ValueType
 }