Merge pull request #5 from jaksonlin/develop

Develop
jaksonlin · Oct 6, 2023 · 3c3e0d6 · 3c3e0d6
2 parents e1f7e7c + 700e441
commit 3c3e0d6
Show file tree

Hide file tree

Showing 45 changed files with 2,509 additions and 796 deletions.
diff --git a/ast/ast.go b/ast/ast.go
@@ -27,25 +27,25 @@ const (
 	AST_STATE_FINISHED
 )
 
-type jzoneAST struct {
+type JsonextAST struct {
 	ast      JsonNode
 	astTrace *util.Stack[JsonNode]
 	state    astState
 }
 
-func newJzoneAST() *jzoneAST {
-	return &jzoneAST{
+func NewJsonextAST() *JsonextAST {
+	return &JsonextAST{
 		ast:      nil,
 		astTrace: util.NewStack[JsonNode](),
 		state:    AST_STATE_INIT,
 	}
 }
 
-func (i *jzoneAST) GetAST() JsonNode {
+func (i *JsonextAST) GetAST() JsonNode {
 	return i.ast
 }
 
-func (i *jzoneAST) createRootNode(t AST_NODETYPE, value interface{}) error {
+func (i *JsonextAST) CreateRootNode(t AST_NODETYPE, value interface{}) error {
 	n, err := nodeFactory(t, value)
 	if err != nil {
 		return err
@@ -61,32 +61,35 @@ func (i *jzoneAST) createRootNode(t AST_NODETYPE, value interface{}) error {
 	return nil
 }
 
-func (i *jzoneAST) CreateNewASTNode(t AST_NODETYPE, value interface{}) error {
+func (i *JsonextAST) CreateNewASTNode(t AST_NODETYPE, value interface{}) error {
 	if i.state == AST_STATE_FINISHED {
 		return ErrorASTComplete
 	}
 	if i.ast == nil {
-		return i.createRootNode(t, value)
+		return i.CreateRootNode(t, value)
 	}
 	latest, err := i.astTrace.Peek()
 	if err != nil {
 		return err
 	}
 
 	switch realNode := latest.(type) {
+	//stack have array at top, awaiting element
 	case *JsonArrayNode:
-		return i.createNewNodeForArrayObject(realNode, t, value)
+		return i.CreateNewNodeForArrayObject(realNode, t, value)
+		// stack have object at top, awaiting kv pair node
 	case *JsonObjectNode:
-		return i.createNewNodeForObject(realNode, t, value)
+		return i.CreateNewNodeForObject(realNode, t, value)
+		// stack have kvpari at top, awaiting value node
 	case *JsonKeyValuePairNode:
-		return i.createValueNodeForKVPairs(realNode, t, value)
+		return i.CreateValueNodeForKVPairs(realNode, t, value)
 	default:
 		return ErrorASTUnexpectedElement
 	}
 
 }
 
-func (i *jzoneAST) createNewNodeForArrayObject(owner *JsonArrayNode, t AST_NODETYPE, value interface{}) error {
+func (i *JsonextAST) CreateNewNodeForArrayObject(owner *JsonArrayNode, t AST_NODETYPE, value interface{}) error {
 	n, err := nodeFactory(t, value)
 	if err != nil {
 		return err
@@ -101,7 +104,7 @@ func (i *jzoneAST) createNewNodeForArrayObject(owner *JsonArrayNode, t AST_NODET
 	return nil
 }
 
-func (i *jzoneAST) createNewNodeForObject(owner *JsonObjectNode, t AST_NODETYPE, value interface{}) error {
+func (i *JsonextAST) CreateNewNodeForObject(owner *JsonObjectNode, t AST_NODETYPE, value interface{}) error {
 	keyNode, err := nodeFactory(t, value)
 	if err != nil {
 		return err
@@ -114,7 +117,7 @@ func (i *jzoneAST) createNewNodeForObject(owner *JsonObjectNode, t AST_NODETYPE,
 	return nil
 }
 
-func (i *jzoneAST) createValueNodeForKVPairs(owner *JsonKeyValuePairNode, t AST_NODETYPE, value interface{}) error {
+func (i *JsonextAST) CreateValueNodeForKVPairs(owner *JsonKeyValuePairNode, t AST_NODETYPE, value interface{}) error {
 
 	n, err := nodeFactory(t, value)
 	if err != nil {
@@ -126,15 +129,17 @@ func (i *jzoneAST) createValueNodeForKVPairs(owner *JsonKeyValuePairNode, t AST_
 	} else {
 		// primivite value, finalize the k-v pair and append to the object node
 		owner.Value = n
-		err = i.finlizeKVPair()
+		err = i.FinlizeKVPair()
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (i *jzoneAST) finlizeKVPair() error {
+// 2 reason to finalise, enclose of kv pair due to `,`, enclose of kv pair due to `}`
+// {"1":2,"3":4}
+func (i *JsonextAST) FinlizeKVPair() error {
 	kvElement, err := i.astTrace.Pop() // pop the kv, because it should be finalized to objet now.
 	if err == util.ErrorEndOfStack {
 		return ErrorASTStackEmpty
@@ -149,34 +154,36 @@ func (i *jzoneAST) finlizeKVPair() error {
 	if kvOwnerObj.GetNodeType() != AST_OBJECT {
 		return ErrorASTUnexpectedElement
 	}
-	kvOwnerObj.(*JsonObjectNode).Append(kvElement.(*JsonKeyValuePairNode))
+	el := kvOwnerObj.(*JsonObjectNode)
+	el.Append(kvElement.(*JsonKeyValuePairNode))
+
 	return nil
 }
 
-func (i *jzoneAST) EncloseLatestElements() error {
+func (i *JsonextAST) EncloseLatestElements(currentOffset int) error {
 
 	itemToFinalize, err := i.astTrace.Pop()
 	if err == util.ErrorEndOfStack {
 		i.state = AST_STATE_FINISHED
 		return nil
 	}
-	err = i.storeFinlizedItemToOwner(itemToFinalize)
+	err = i.StoreFinlizedItemToOwner(itemToFinalize, currentOffset)
 	if err != nil {
 		return err
 	}
 	return nil
 
 }
 
-func (i *jzoneAST) TopElementType() (AST_NODETYPE, error) {
+func (i *JsonextAST) TopElementType() (AST_NODETYPE, error) {
 	t, err := i.astTrace.Peek()
 	if err != nil {
 		return AST_NODE_UNDEFINED, err
 	}
 	return t.GetNodeType(), nil
 }
 
-func (i *jzoneAST) storeFinlizedItemToOwner(itemToFinalize JsonNode) error {
+func (i *JsonextAST) StoreFinlizedItemToOwner(itemToFinalize JsonNode, currentOffset int) error {
 	nodeType := itemToFinalize.GetNodeType()
 	switch nodeType {
 	case AST_OBJECT: // item can only be value of kv or element of array
@@ -189,13 +196,16 @@ func (i *jzoneAST) storeFinlizedItemToOwner(itemToFinalize JsonNode) error {
 		}
 		switch ownerElement.GetNodeType() {
 		case AST_ARRAY:
-			ownerElement.(*JsonArrayNode).Append(itemToFinalize) // array case, put it in array
+			el := ownerElement.(*JsonArrayNode)
+			el.Append(itemToFinalize) // array case, put it in array
 		case AST_KVPAIR: // kv case
-			ownerElement.(*JsonKeyValuePairNode).Value = itemToFinalize
-			err = i.finlizeKVPair()
+			el := ownerElement.(*JsonKeyValuePairNode)
+			el.Value = itemToFinalize
+			err = i.FinlizeKVPair()
 			if err != nil {
 				return err
 			}
+
 		default:
 			return ErrorASTUnexpectedOwnerElement
 		}
@@ -205,10 +215,10 @@ func (i *jzoneAST) storeFinlizedItemToOwner(itemToFinalize JsonNode) error {
 	return nil
 }
 
-func (i *jzoneAST) HasOpenElement() bool {
+func (i *JsonextAST) HasOpenElement() bool {
 	return i.astTrace.Length() > 0
 }
 
-func (i *jzoneAST) HasComplete() bool {
+func (i *JsonextAST) HasComplete() bool {
 	return i.state == AST_STATE_FINISHED
 }
diff --git a/ast/ast_node.go b/ast/ast_node.go
@@ -8,18 +8,22 @@ import (
 
 type AST_NODETYPE byte
 
+func (a AST_NODETYPE) Byte() byte {
+	return byte(a)
+}
+
 const (
-	AST_NODE_TYPE_BOUNDARY = 200
-	AST_ARRAY              = 201
-	AST_OBJECT             = 202
-	AST_KVPAIR             = 203
-	AST_VARIABLE           = 204
-	AST_STRING_VARIABLE    = 205
-	AST_STRING             = 206
-	AST_NUMBER             = 207
-	AST_BOOLEAN            = 208
-	AST_NULL               = 209
-	AST_NODE_UNDEFINED     = 210
+	AST_NODE_TYPE_BOUNDARY AST_NODETYPE = 200
+	AST_ARRAY              AST_NODETYPE = 201
+	AST_OBJECT             AST_NODETYPE = 202
+	AST_KVPAIR             AST_NODETYPE = 203
+	AST_VARIABLE           AST_NODETYPE = 204
+	AST_STRING_VARIABLE    AST_NODETYPE = 205
+	AST_STRING             AST_NODETYPE = 206
+	AST_NUMBER             AST_NODETYPE = 207
+	AST_BOOLEAN            AST_NODETYPE = 208
+	AST_NULL               AST_NODETYPE = 209
+	AST_NODE_UNDEFINED     AST_NODETYPE = 210
 )
 
 func nodeFactory(t AST_NODETYPE, value interface{}) (JsonNode, error) {

diff --git a/ast/entry.go b/ast/entry.go
diff --git a/ast/err.go b/ast/err.go
@@ -5,25 +5,12 @@ import (
 )
 
 var (
-	ErrorASTComplete                          = errors.New("cannot create new ast node when the ast has finished")
-	ErrorASTStackInvalidElement               = errors.New("ast trace stack will only contain: kv, array, object, no primitive values")
-	ErrorASTUnexpectedElement                 = errors.New("unexecpted stack element type")
-	ErrorASTUnexpectedOwnerElement            = errors.New("unexecpted stack owner element type")
-	ErrorASTStackEmpty                        = errors.New("unexecpted stack empty")
-	ErrorASTEncloseElementType                = errors.New("enclose element type must be array or object")
-	ErrorASTIncorrectNodeType                 = errors.New("incorrect node type")
-	ErrorIncorrectSyntaxSymbolForConstructAST = errors.New("incorrect character for construct ast")
-	ErrorASTKeyValuePairNotStringAsKey        = errors.New("object key should be string")
-)
-
-var (
-	ErrorSyntaxEmptyStack                  = errors.New("empty syntax stack")
-	ErrorSyntaxEncloseIncorrectSymbol      = errors.New("invalid operation, not ]|} to enclose")
-	ErrorSyntaxEncloseSymbolNotMatch       = errors.New("enclose symbol not match")
-	ErrorSyntaxEncloseSymbolIncorrect      = errors.New("enclose symbol incorrect")
-	ErrorSyntaxCommaBehindLastItem         = errors.New("find `,]` or `,}` in the syntax checker")
-	ErrorSyntaxElementNotSeparatedByComma  = errors.New("syntax element not separated by comma")
-	ErrorSyntaxUnexpectedSymbolInArray     = errors.New("unexpected symbol in array")
-	ErrorSyntaxExtendedSyntaxVariableAsKey = errors.New("extended syntax variable as key")
-	ErrorSyntaxObjectSymbolNotMatch        = errors.New("object symbol not match")
+	ErrorASTComplete                   = errors.New("cannot create new ast node when the ast has finished")
+	ErrorASTStackInvalidElement        = errors.New("ast trace stack will only contain: kv, array, object, no primitive values")
+	ErrorASTUnexpectedElement          = errors.New("unexecpted stack element type")
+	ErrorASTUnexpectedOwnerElement     = errors.New("unexecpted stack owner element type")
+	ErrorASTStackEmpty                 = errors.New("unexecpted stack empty")
+	ErrorASTEncloseElementType         = errors.New("enclose element type must be array or object")
+	ErrorASTIncorrectNodeType          = errors.New("incorrect node type")
+	ErrorASTKeyValuePairNotStringAsKey = errors.New("object key should be string")
 )
diff --git a/ast/util.go b/ast/util.go