16410926563

Committed 21 Jul 2025 07:14AM UTC coverage: 17.851% (-79.5%) from 97.363%

Build # 16410926563

Build Type

Pull #46

github

Committed by

AsaiYusuke

Commit Message

refactor: move syntax and tests to internal directory

Separate directory structure from public API by relocating syntax
and test files under internal/ directory structure.

Pull Request Pull Request #46: Move syntax to the internal directory and reorganize tests

Run Details

181 of 406 new or added lines in 17 files covered. (44.58%)

3 existing lines in 1 file now uncovered.

676 of 3787 relevant lines covered (17.85%)

17.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/internal/syntax/syntax_node_identifier_recursive_child.go

package syntax

import (
        "reflect"
)

type syntaxRecursiveChildIdentifier struct {
        *syntaxBasicNode

        nextMapRequired  bool
        nextListRequired bool
}

func (i *syntaxRecursiveChildIdentifier) retrieve(
        root, current interface{}, container *bufferContainer) errorRuntime {

        switch current.(type) {
        case map[string]interface{}, []interface{}:
        default:
                foundType := msgTypeNull
                if current != nil {
                        foundType = reflect.TypeOf(current).String()
                }
                return newErrorTypeUnmatched(i.errorRuntime.node, msgTypeObjectOrArray, foundType)
        }

        var deepestTextLen int
        var deepestError errorRuntime

        targetNodes := make([]interface{}, 1, 5)
        targetNodes[0] = current

        for len(targetNodes) > 0 {
                currentTargetNode := targetNodes[len(targetNodes)-1]
                targetNodes = targetNodes[:len(targetNodes)-1]
                switch typedNodes := currentTargetNode.(type) {
                case map[string]interface{}:
                        if i.nextMapRequired {
                                if err := i.next.retrieve(root, typedNodes, container); err != nil {
                                        if len(container.result) == 0 {
                                                deepestTextLen, deepestError = i.addDeepestError(err, deepestTextLen, deepestError)
                                        }
                                }
                        }

                        sortKeys := getSortedKeys(typedNodes)
                        for index := len(typedNodes) - 1; index >= 0; index-- {
                                node := typedNodes[(*sortKeys)[index]]
                                switch node.(type) {
                                case map[string]interface{}, []interface{}:
                                        targetNodes = append(targetNodes, node)
                                }
                        }

                        putSortSlice(sortKeys)

                case []interface{}:
                        if i.nextListRequired {
                                if err := i.next.retrieve(root, typedNodes, container); err != nil {
                                        if len(container.result) == 0 {
                                                deepestTextLen, deepestError = i.addDeepestError(err, deepestTextLen, deepestError)
                                        }
                                }
                        }

                        for index := len(typedNodes) - 1; index >= 0; index-- {
                                node := typedNodes[index]
                                switch node.(type) {
                                case map[string]interface{}, []interface{}:
                                        targetNodes = append(targetNodes, node)
                                }
                        }
                }
        }

        if len(container.result) > 0 {
                return nil
        }

        if deepestError == nil {
                return newErrorMemberNotExist(i.errorRuntime.node)
        }

        return deepestError
}

1	package syntax
2
3	import (
4	"reflect"
5	)
6
7	type syntaxRecursiveChildIdentifier struct {
8	*syntaxBasicNode
9
10	nextMapRequired bool
11	nextListRequired bool
12	}
13
14	func (i *syntaxRecursiveChildIdentifier) retrieve(
15	root, current interface{}, container *bufferContainer) errorRuntime {	×
16		×
17	switch current.(type) {	×
18	case map[string]interface{}, []interface{}:	×
19	default:	×
20	foundType := msgTypeNull	×
21	if current != nil {	×
22	foundType = reflect.TypeOf(current).String()	×
23	}	×
NEW 24	return newErrorTypeUnmatched(i.errorRuntime.node, msgTypeObjectOrArray, foundType)	×
25	}
26
27	var deepestTextLen int	×
28	var deepestError errorRuntime	×
29		×
30	targetNodes := make([]interface{}, 1, 5)	×
31	targetNodes[0] = current	×
32		×
33	for len(targetNodes) > 0 {	×
34	currentTargetNode := targetNodes[len(targetNodes)-1]	×
35	targetNodes = targetNodes[:len(targetNodes)-1]	×
36	switch typedNodes := currentTargetNode.(type) {	×
37	case map[string]interface{}:	×
38	if i.nextMapRequired {	×
39	if err := i.next.retrieve(root, typedNodes, container); err != nil {	×
40	if len(container.result) == 0 {	×
41	deepestTextLen, deepestError = i.addDeepestError(err, deepestTextLen, deepestError)	×
42	}	×
43	}
44	}
45
46	sortKeys := getSortedKeys(typedNodes)	×
47	for index := len(typedNodes) - 1; index >= 0; index-- {	×
48	node := typedNodes[(*sortKeys)[index]]	×
49	switch node.(type) {	×
50	case map[string]interface{}, []interface{}:	×
51	targetNodes = append(targetNodes, node)	×
52	}
53	}
54
55	putSortSlice(sortKeys)	×
56
57	case []interface{}:	×
58	if i.nextListRequired {	×
59	if err := i.next.retrieve(root, typedNodes, container); err != nil {	×
60	if len(container.result) == 0 {	×
61	deepestTextLen, deepestError = i.addDeepestError(err, deepestTextLen, deepestError)	×
62	}	×
63	}
64	}
65
66	for index := len(typedNodes) - 1; index >= 0; index-- {	×
67	node := typedNodes[index]	×
68	switch node.(type) {	×
69	case map[string]interface{}, []interface{}:	×
70	targetNodes = append(targetNodes, node)	×
71	}
72	}
73	}
74	}
75
76	if len(container.result) > 0 {	×
77	return nil	×
78	}	×
79
80	if deepestError == nil {	×
NEW 81	return newErrorMemberNotExist(i.errorRuntime.node)	×
82	}	×
83
84	return deepestError	×
85	}

AsaiYusuke / jsonpath / 16410926563

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous