jsonpath.peg

package jsonpath

type pegJSONPathParser Peg {
    jsonPathParser
}

expression <-
    jsonpath END {
        p.root = p.deleteRootIdentifier(p.pop().(syntaxNode))
        p.setConnectedText(p.root)
    } /

    jsonpath? < .* > END {
        panic(p.syntaxErr(
            begin, msgErrorInvalidSyntaxUnrecognizedInput, buffer))
    }

END <- !.

jsonpath          <- space rootNode          continuedJsonpath
jsonpathParameter <- space parameterRootNode continuedJsonpath

continuedJsonpath <- childNode* function* space {
        p.setNodeChain()
        p.updateRootValueGroup()
    }

rootNode          <- rootIdentifier / bracketNode / dotChildIdentifier
parameterRootNode <- rootIdentifier / currentRootIdentifier

childNode <-
    '..' ( bracketNode / dotChildIdentifier ) {
        p.pushRecursiveChildIdentifier(p.pop().(syntaxNode))
    } /

    < '.' dotChildIdentifier > {
        p.setLastNodeText(text)
    } /

    bracketNode

function <-
    < '.' functionName '()' > {
        p.pushFunction(text, p.pop().(string))
    }

functionName <-
    < [-_a-zA-Z0-9]+ > {
        p.push(text)
    }

bracketNode <-
    < squareBracketStart ( bracketChildIdentifier / qualifier ) squareBracketEnd > {
        p.setLastNodeText(text)
    }

rootIdentifier <-
    '$' {
        p.pushRootIdentifier()
    }

currentRootIdentifier <-
    '@' {
        p.pushCurrentRootIdentifier()
    }

dotChildIdentifier <-
    wildcardIdentifier /

    < ( '\\' signsWithoutHyphenUnderscore / ![\0x00-\0x1F\0x7F] !signsWithoutHyphenUnderscore . )+ > !'()' {
        p.pushChildSingleIdentifier(p.unescape(text))
    }

signsWithoutHyphenUnderscore <- [ -,./:-@[-^`{-~]

bracketChildIdentifier <-
    bracketNodeIdentifier (
        sep bracketNodeIdentifier {
            identifier2 := p.pop().(syntaxNode)
            identifier1 := p.pop().(syntaxNode)
            p.pushChildMultiIdentifier(identifier1, identifier2)
        }
    )* !sep

bracketNodeIdentifier <-
    (
        wildcardIdentifier /
        singleQuotedNodeIdentifier /
        doubleQuotedNodeIdentifier
    )

wildcardIdentifier <-
    '*' {
        p.pushChildWildcardIdentifier()
    }

singleQuotedNodeIdentifier <-
    '\'' < ( '\\' ( ['/\\bfnrt] / hexDigits ) / [^'\\] )* > '\'' {
        p.pushChildSingleIdentifier(p.unescapeSingleQuotedString(text))
    }

doubleQuotedNodeIdentifier <-
    '"' < ( '\\' ( ["/\\bfnrt] / hexDigits ) / [^"\\] )* > '"' {
        p.pushChildSingleIdentifier(p.unescapeDoubleQuotedString(text))
    }

hexDigits <- 'u' hexDigit hexDigit hexDigit hexDigit
hexDigit  <- [a-fA-F0-9]

qualifier <- union / script / filter

union <-
    index (
        sep index {
            childIndexUnion := p.pop().(*syntaxUnionQualifier)
            parentIndexUnion := p.pop().(*syntaxUnionQualifier)
            parentIndexUnion.merge(childIndexUnion)
            parentIndexUnion.setValueGroup()
            p.push(parentIndexUnion)
        }
    )* !sep

index <-
    (
        slice {
            step  := p.pop().(*syntaxIndexSubscript)
            end   := p.pop().(*syntaxIndexSubscript)
            start := p.pop().(*syntaxIndexSubscript)

            if step.isOmitted {
                step.number = 1
            }

            if step.number >= 0 {
                p.pushSlicePositiveStepSubscript(start, end, step)
            } else {
                p.pushSliceNegativeStepSubscript(start, end, step)
            }
        } /

        < indexNumber > {
            p.pushIndexSubscript(text)
        } /

        '*' {
            p.pushWildcardSubscript()
        }
    ) {
        p.pushUnionQualifier(p.pop().(syntaxSubscript))
    }

slice <-
    anyIndex sepSlice anyIndex (
        sepSlice anyIndex /
        space {
            p.pushIndexSubscript(`1`)
        }
    )

anyIndex <-
    < indexNumber? > {
        if len(text) > 0 {
            p.pushIndexSubscript(text)
        } else {
            p.pushOmittedIndexSubscript(`0`)
        }
    }

indexNumber <- [-+]? [0-9]+

sep      <- space ',' space
sepSlice <- space ':' space

script <-
    scriptStart < command > scriptEnd {
        p.pushScriptQualifier(text)
    }

command <- ( !scriptEnd . )+

filter <-
    filterStart query filterEnd {
        p.pushFilterQualifier(p.pop().(syntaxQuery))
    }

query <-
    andQuery (
        logicOr andQuery {
            rightQuery := p.pop().(syntaxQuery)
            leftQuery := p.pop().(syntaxQuery)
            p.pushLogicalOr(leftQuery, rightQuery)
        }
    )*

andQuery <-
    basicQuery (
        logicAnd basicQuery {
            rightQuery := p.pop().(syntaxQuery)
            leftQuery := p.pop().(syntaxQuery)
            p.pushLogicalAnd(leftQuery, rightQuery)
        }
    )*

basicQuery <-
    subQueryStart query subQueryEnd /

    < comparator > {
        query := p.pop()
        p.push(query)

        if logicalNot, ok := query.(*syntaxLogicalNot); ok {
            query = (*logicalNot).query
        }
        if checkQuery, ok := query.(*syntaxBasicCompareQuery); ok {
            _, leftIsCurrentRoot := checkQuery.leftParam.param.(*syntaxQueryParamCurrentRoot)
            _, rightIsCurrentRoot := checkQuery.rightParam.param.(*syntaxQueryParamCurrentRoot)
            if leftIsCurrentRoot && rightIsCurrentRoot {
                panic(p.syntaxErr(
                    begin, msgErrorInvalidSyntaxTwoCurrentNode, buffer))
            }
        }
    } /

    < logicNot? jsonpathFilter > {
        _ = p.pop()
        jsonpathFilter := p.pop().(syntaxQuery)

        if text[0:1] == `!` {
            p.pushLogicalNot(jsonpathFilter)
        } else {
            p.push(jsonpathFilter)
        }
    }

logicOr  <- space '||' space
logicAnd <- space '&&' space
logicNot <- '!' space

comparator <-
    qParam space (
        '==' space qParam {
            rightParam := p.pop().(*syntaxBasicCompareParameter)
            leftParam := p.pop().(*syntaxBasicCompareParameter)
            p.pushCompareEQ(leftParam, rightParam)
        } /

        '!=' space qParam {
            rightParam := p.pop().(*syntaxBasicCompareParameter)
            leftParam := p.pop().(*syntaxBasicCompareParameter)
            p.pushCompareNE(leftParam, rightParam)
        }
    ) /

    qNumericParam space (
        '<=' space qNumericParam {
            rightParam := p.pop().(*syntaxBasicCompareParameter)
            leftParam := p.pop().(*syntaxBasicCompareParameter)
            p.pushCompareLE(leftParam, rightParam)
        } /

        '<' space qNumericParam {
            rightParam := p.pop().(*syntaxBasicCompareParameter)
            leftParam := p.pop().(*syntaxBasicCompareParameter)
            p.pushCompareLT(leftParam, rightParam)
        } /

        '>=' space qNumericParam {
            rightParam := p.pop().(*syntaxBasicCompareParameter)
            leftParam := p.pop().(*syntaxBasicCompareParameter)
            p.pushCompareGE(leftParam, rightParam)
        } /

        '>' space qNumericParam {
            rightParam := p.pop().(*syntaxBasicCompareParameter)
            leftParam := p.pop().(*syntaxBasicCompareParameter)
            p.pushCompareGT(leftParam, rightParam)
        }
    ) /

    singleJsonpathFilter space '=~' space '/' < regex > '/' {
        leftParam := p.pop().(*syntaxBasicCompareParameter)
        p.pushCompareRegex(leftParam, text)
    }

qParam <-
    qLiteral {
        p.pushCompareParameterLiteral(p.pop())
    } /

    singleJsonpathFilter

qNumericParam <-
    lNumber {
        p.pushCompareParameterLiteral(p.pop())
    } /

    singleJsonpathFilter

qLiteral <- lNumber / lBool / lString / lNull

singleJsonpathFilter <-
    < jsonpathFilter > {
        isLiteral := p.pop().(bool)
        param := p.pop().(syntaxQueryJSONPathParameter)
        if param.isValueGroupParameter() {
            panic(p.syntaxErr(
                begin, msgErrorInvalidSyntaxFilterValueGroup, buffer))
        }
        p.pushBasicCompareParameter(param.(syntaxQuery), isLiteral)
    }

jsonpathFilter <-
    {
        p.saveParams()
    } jsonpathParameter {
        p.loadParams()

        node := p.pop().(syntaxNode)
        checkNode := node
        if aggregateFunction, ok := node.(*syntaxAggregateFunction); ok {
            checkNode = aggregateFunction.param
        }

        switch checkNode.(type) {
        case *syntaxRootIdentifier:
            p.pushCompareParameterRoot(p.deleteRootIdentifier(node))
            p.push(true)
        case *syntaxCurrentRootIdentifier:
            p.pushCompareParameterCurrentRoot(p.deleteRootIdentifier(node))
            p.push(false)
        }
    }

lNumber <- < [-+]? [0-9] [-+.0-9a-zA-Z]* > {
        p.push(p.toFloat(text))
    }

lBool <-
    ( 'true' / 'True' / 'TRUE' ) {
        p.push(true)
    } /

    ( 'false' / 'False' / 'FALSE' ) {
        p.push(false)
    }

lString <-
    '\'' < ( '\\' [\\'] / [^'] )* > '\'' {
        p.push(p.unescape(text))
    } /

    '"' < ( '\\' [\\"] / [^"] )* > '"' {
        p.push(p.unescape(text))
    }

lNull <- ( 'null' / 'Null' / 'NULL' ) {
        p.push(nil)
    }

regex <- ( '\\' [\\/] / [^/] )*

squareBracketStart <- '[' space
squareBracketEnd   <- space ']'

scriptStart <- '(' space
scriptEnd   <- space ')'

filterStart <- '?(' space
filterEnd   <- space ')'

subQueryStart <- '(' space
subQueryEnd   <- space ')'

space <- ' ' *