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

14.12

/internal/syntax/syntax_basic_node.go

package syntax

import "github.com/AsaiYusuke/jsonpath/errors"

type syntaxBasicNode struct {
        text          string
        connectedText string
        valueGroup    bool
        next          syntaxNode
        accessorMode  bool
        errorRuntime  *errorBasicRuntime
}

func (i *syntaxBasicNode) setText(text string) {
        i.text = text
}

func (i *syntaxBasicNode) getText() string {
        return i.text
}

func (i *syntaxBasicNode) setValueGroup() {
        i.valueGroup = true
}

func (i *syntaxBasicNode) isValueGroup() bool {
        return i.valueGroup
}

func (i *syntaxBasicNode) setConnectedText(text string) {
        i.connectedText = text
}

func (i *syntaxBasicNode) getConnectedText() string {
        return i.connectedText
}

func (i *syntaxBasicNode) setNext(next syntaxNode) {
        if i.next != nil {
                i.next.setNext(next)
        } else {
                i.next = next
        }
}

func (i *syntaxBasicNode) getNext() syntaxNode {
        return i.next
}

func (i *syntaxBasicNode) retrieveAnyValueNext(
        root interface{}, nextSrc interface{}, container *bufferContainer) errorRuntime {

        if i.next != nil {
                return i.next.retrieve(root, nextSrc, container)
        }

        if i.accessorMode {
                container.result = append(container.result, Accessor{
                        Get: func() interface{} { return nextSrc },
                        Set: nil,
                })
        } else {
                container.result = append(container.result, nextSrc)
        }

        return nil
}

func (i *syntaxBasicNode) retrieveMapNext(
        root interface{}, currentMap map[string]interface{}, key string, container *bufferContainer) errorRuntime {

        nextNode, ok := currentMap[key]
        if !ok {
                return newErrorMemberNotExist(i.errorRuntime.node)
        }

        if i.next != nil {
                return i.next.retrieve(root, nextNode, container)
        }

        if i.accessorMode {
                container.result = append(container.result, Accessor{
                        Get: func() interface{} { return currentMap[key] },
                        Set: func(value interface{}) { currentMap[key] = value },
                })
        } else {
                container.result = append(container.result, nextNode)
        }

        return nil
}

func (i *syntaxBasicNode) retrieveListNext(
        root interface{}, currentList []interface{}, index int, container *bufferContainer) errorRuntime {

        if i.next != nil {
                return i.next.retrieve(root, currentList[index], container)
        }

        if i.accessorMode {
                container.result = append(container.result, Accessor{
                        Get: func() interface{} { return currentList[index] },
                        Set: func(value interface{}) { currentList[index] = value },
                })
        } else {
                container.result = append(container.result, currentList[index])
        }

        return nil
}

func (i *syntaxBasicNode) setAccessorMode(mode bool) {
        i.accessorMode = mode
}

func (i *syntaxBasicNode) addDeepestError(
        err errorRuntime, deepestTextLen int, deepestError errorRuntime) (int, errorRuntime) {

        textLength := len(err.getSyntaxNode().getConnectedText())

        if deepestTextLen == 0 || deepestTextLen > textLength {
                return textLength, err
        }

        if deepestTextLen == textLength {
                if adapter, ok := deepestError.(errorRuntimeAdapter); ok {
                        if _, isTypeUnmatched := adapter.err.(errors.ErrorTypeUnmatched); isTypeUnmatched {
                                return deepestTextLen, err
                        }
                }
        }

        return deepestTextLen, deepestError
}

1	package syntax
2
3	import "github.com/AsaiYusuke/jsonpath/errors"
4
5	type syntaxBasicNode struct {
6	text string
7	connectedText string
8	valueGroup bool
9	next syntaxNode
10	accessorMode bool
11	errorRuntime *errorBasicRuntime
12	}
13
14	func (i *syntaxBasicNode) setText(text string) {	×
15	i.text = text	×
16	}	×
17
18	func (i *syntaxBasicNode) getText() string {	1✔
19	return i.text	1✔
20	}	1✔
21
22	func (i *syntaxBasicNode) setValueGroup() {	×
23	i.valueGroup = true	×
24	}	×
25
26	func (i *syntaxBasicNode) isValueGroup() bool {	1✔
27	return i.valueGroup	1✔
28	}	1✔
29
30	func (i *syntaxBasicNode) setConnectedText(text string) {	1✔
31	i.connectedText = text	1✔
32	}	1✔
33
34	func (i *syntaxBasicNode) getConnectedText() string {	×
35	return i.connectedText	×
36	}	×
37
38	func (i *syntaxBasicNode) setNext(next syntaxNode) {	×
39	if i.next != nil {	×
40	i.next.setNext(next)	×
41	} else {	×
42	i.next = next	×
43	}	×
44	}
45
46	func (i *syntaxBasicNode) getNext() syntaxNode {	3✔
47	return i.next	3✔
48	}	3✔
49
50	func (i *syntaxBasicNode) retrieveAnyValueNext(
51	root interface{}, nextSrc interface{}, container *bufferContainer) errorRuntime {	×
52		×
53	if i.next != nil {	×
54	return i.next.retrieve(root, nextSrc, container)	×
55	}	×
56
57	if i.accessorMode {	×
58	container.result = append(container.result, Accessor{	×
59	Get: func() interface{} { return nextSrc },	×
60	Set: nil,
61	})
62	} else {	×
63	container.result = append(container.result, nextSrc)	×
64	}	×
65
66	return nil	×
67	}
68
69	func (i *syntaxBasicNode) retrieveMapNext(
70	root interface{}, currentMap map[string]interface{}, key string, container *bufferContainer) errorRuntime {	×
71		×
72	nextNode, ok := currentMap[key]	×
73	if !ok {	×
NEW 74	return newErrorMemberNotExist(i.errorRuntime.node)	×
75	}	×
76
77	if i.next != nil {	×
78	return i.next.retrieve(root, nextNode, container)	×
79	}	×
80
81	if i.accessorMode {	×
82	container.result = append(container.result, Accessor{	×
83	Get: func() interface{} { return currentMap[key] },	×
84	Set: func(value interface{}) { currentMap[key] = value },	×
85	})
86	} else {	×
87	container.result = append(container.result, nextNode)	×
88	}	×
89
90	return nil	×
91	}
92
93	func (i *syntaxBasicNode) retrieveListNext(
94	root interface{}, currentList []interface{}, index int, container *bufferContainer) errorRuntime {	×
95		×
96	if i.next != nil {	×
97	return i.next.retrieve(root, currentList[index], container)	×
98	}	×
99
100	if i.accessorMode {	×
101	container.result = append(container.result, Accessor{	×
102	Get: func() interface{} { return currentList[index] },	×
103	Set: func(value interface{}) { currentList[index] = value },	×
104	})
105	} else {	×
106	container.result = append(container.result, currentList[index])	×
107	}	×
108
109	return nil	×
110	}
111
112	func (i *syntaxBasicNode) setAccessorMode(mode bool) {	×
113	i.accessorMode = mode	×
114	}	×
115
116	func (i *syntaxBasicNode) addDeepestError(
117	err errorRuntime, deepestTextLen int, deepestError errorRuntime) (int, errorRuntime) {	×
118		×
119	textLength := len(err.getSyntaxNode().getConnectedText())	×
120		×
121	if deepestTextLen == 0 \|\| deepestTextLen > textLength {	×
122	return textLength, err	×
123	}	×
124
125	if deepestTextLen == textLength {	×
NEW 126	if adapter, ok := deepestError.(errorRuntimeAdapter); ok {	×
NEW 127	if _, isTypeUnmatched := adapter.err.(errors.ErrorTypeUnmatched); isTypeUnmatched {	×
NEW 128	return deepestTextLen, err	×
NEW 129	}	×
130	}
131	}
132
133	return deepestTextLen, deepestError	×
134	}

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