spec

Create a comparison expression that compares a literal value to a path expression.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	cmp := spec.Comparison(
		spec.Literal(42),
		spec.EqualTo,
		spec.SingularQuery(false, spec.Name("age")),
	)
	fmt.Printf("%v\n", cmp)
}

Output:

42 == @["age"]

Create an existence expression as a filter expression.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	filter := spec.Filter(spec.And(
		spec.Existence(
			spec.Query(false, spec.Child(spec.Name("x"))),
		),
	))
	fmt.Printf("%v\n", filter)
}

Output:

?@["x"]

Create a filter selector that selects nodes with a descendant that contains an object field named "x".

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	f := spec.Filter(spec.And(
		spec.Existence(
			spec.Query(false, spec.Descendant(spec.Name("x"))),
		),
	))
	fmt.Printf("%v\n", f)
}

Output:

?@..["x"]

Use the standard match() function in a function expression.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/registry"
	"github.com/theory/jsonpath/spec"
)

func main() {
	reg := registry.New()
	fe := spec.Function(
		reg.Get("match"),
		spec.Query(false, spec.Child(spec.Name("rating"))),
		spec.Literal("good$"),
	)
	fmt.Printf("%v\n", fe)
}

Output:

match(@["rating"], "good$")

Create a few index selectors.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	for _, indexSelector := range []any{
		spec.Index(0),  // first item
		spec.Index(3),  // fourth item
		spec.Index(-1), // last item
	} {
		fmt.Printf("%v\n", indexSelector)
	}
}

Output:

0
3
-1

Pass a LiteralArg to a function.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/registry"
	"github.com/theory/jsonpath/spec"
)

func main() {
	reg := registry.New()
	fe := spec.Function(
		reg.Get("length"),
		spec.Literal("some string"),
	)
	fmt.Printf("%v\n", fe)
}

Output:

length("some string")

package main

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/theory/jsonpath"
	"github.com/theory/jsonpath/spec"
)

func main() {
	// Query all "author" object properties.
	p := jsonpath.New(spec.Query(
		true,
		spec.Descendant(spec.Name("author")),
	))

	// Select LocatedNodes from unmarshaled JSON input.
	store := bookstore()
	nodes := p.SelectLocated(store)

	// Show the LocatedNodes.
	items, err := json.MarshalIndent(nodes, "", "  ")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s\n", items)

}

// bookstore returns an unmarshaled JSON object.
func bookstore() any {
	src := []byte(`{
	  "store": {
	    "book": [
	    {
	      "category": "reference",
	      "author": "Nigel Rees",
	      "title": "Sayings of the Century",
	      "price": 8.95
	    },
	    {
	      "category": "fiction",
	      "author": "Evelyn Waugh",
	      "title": "Sword of Honour",
	      "price": 12.99
	    },
	    {
	      "category": "fiction",
	      "author": "Herman Melville",
	      "title": "Moby Dick",
	      "isbn": "0-553-21311-3",
	      "price": 8.99
	    },
	    {
	      "category": "fiction",
	      "author": "J. R. R. Tolkien",
	      "title": "The Lord of the Rings",
	      "isbn": "0-395-19395-8",
	      "price": 22.99
	    }
	    ],
	    "bicycle": {
	    "color": "red",
	    "price": 399
	    }
	  }
	}`)

	var value any
	if err := json.Unmarshal(src, &value); err != nil {
		log.Fatal(err)
	}
	return value
}

Output:

[
  {
    "node": "Nigel Rees",
    "path": "$['store']['book'][0]['author']"
  },
  {
    "node": "Evelyn Waugh",
    "path": "$['store']['book'][1]['author']"
  },
  {
    "node": "Herman Melville",
    "path": "$['store']['book'][2]['author']"
  },
  {
    "node": "J. R. R. Tolkien",
    "path": "$['store']['book'][3]['author']"
  }
]

Assemble a LogicalAnd consisting of multiple expressions.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	and := spec.And(
		spec.Value(42),
		spec.Existence(
			spec.Query(false, spec.Child(spec.Name("answer"))),
		),
	)
	fmt.Printf("%v\n", and)
}

Output:

42 && @["answer"]

Assemble a LogicalOr consisting of multiple expressions.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	and := spec.Or(
		spec.And(spec.Existence(
			spec.Query(false, spec.Child(spec.Name("answer"))),
		)),
		spec.And(spec.Value(42)),
	)
	fmt.Printf("%v\n", and)
}

Output:

@["answer"] || 42

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	fmt.Printf("%v\n", spec.Logical(true))
	fmt.Printf("%v\n", spec.Logical(false))
}

Output:

true
false

Create a few name selectors.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	for _, nameSelector := range []any{
		spec.Name("hello"),                 // ascii
		spec.Name(`Charlie "Bird" Parker`), // quoted
		spec.Name("އައްސަލާމް ޢަލައިކުމް"), // Unicode
		spec.Name("📡🪛🪤"),                   // emoji
	} {
		fmt.Printf("%v\n", nameSelector)
	}
}

Output:

"hello"
"Charlie \"Bird\" Parker"
"އައްސަލާމް ޢަލައިކުމް"
"📡🪛🪤"

Use a spec.NodesType to create a list of nodes, a.k.a. a JSON array.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	fmt.Printf("%v\n", spec.Nodes("hi", 42, true))
}

Output:

[hi 42 true]

Create a nonexistence expression as a filter expression.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	filter := spec.Filter(spec.And(
		spec.Nonexistence(
			spec.Query(false, spec.Child(spec.Name("x"))),
		),
	))
	fmt.Printf("%v\n", filter)
}

Output:

?!@["x"]

Compare a normalized JSONPath and its JSON Pointer equivalent.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	norm := spec.Normalized(
		spec.Name("x"),
		spec.Index(1),
		spec.Name("y"),
	)
	fmt.Printf("%v\n", norm)
	fmt.Printf("%v\n", norm.Pointer())
}

Output:

$['x'][1]['y']
/x/1/y

Use the standard count() function in a function expression.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/registry"
	"github.com/theory/jsonpath/spec"
)

func main() {
	reg := registry.New()
	nf := spec.NotFunction(spec.Function(
		reg.Get("length"),
		spec.Query(false, spec.Child(spec.Index(0))),
	))
	fmt.Printf("%v\n", nf)
}

Output:

!length(@[0])

Use a spec.NotParenExpr to negate the result of a LogicalOr expression.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	not := spec.NotParen(
		spec.And(
			spec.Existence(
				spec.Query(false, spec.Child(spec.Name("answer"))),
			),
		),
		spec.And(
			spec.Existence(
				spec.Query(false, spec.Child(spec.Name("question"))),
			),
		),
	)
	fmt.Printf("%v\n", not)
}

Output:

!(@["answer"] || @["question"])

Use a spec.ParenExpr to group the result of a LogicalOr expression.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	paren := spec.Paren(
		spec.And(
			spec.Existence(
				spec.Query(false, spec.Child(spec.Name("answer"))),
			),
		),
		spec.And(
			spec.Existence(
				spec.Query(false, spec.Child(spec.Name("question"))),
			),
		),
	)
	fmt.Printf("%v\n", paren)
}

Output:

(@["answer"] || @["question"])

Construct a couple of different path queries.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	// Create a query and its segments.
	q := spec.Query(
		true,
		spec.Child(spec.Name("store")),
		spec.Child(spec.Name("book")),
		spec.Child(spec.Wildcard()),
		spec.Child(spec.Name("author")),
	)
	fmt.Printf("%v\n", q)

	// Create a query with multi-selector segments.
	q = spec.Query(
		true,
		spec.Child(spec.Name("profile")),
		spec.Descendant(spec.Name("email"), spec.Name("phone")),
	)
	fmt.Printf("%v\n", q)

}

Output:

$["store"]["book"][*]["author"]
$["profile"]..["email","phone"]

Print the spec.FuncType for each spec.PathValue implementation.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	fmt.Printf("Implementation    FuncType\n")
	fmt.Printf("----------------- --------\n")
	for _, jv := range []spec.PathValue{
		spec.Value(nil),
		spec.Nodes(1, 2),
		spec.Logical(true),
	} {
		fmt.Printf("%-17T %v\n", jv, jv.FuncType())
	}
}

Output:

Implementation    FuncType
----------------- --------
*spec.ValueType   Value
spec.NodesType    Nodes
spec.LogicalType  Logical

Create a child segment that selects the name "hi", th index 2, or slice 1-3.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	child := spec.Child(
		spec.Name("hi"),
		spec.Index(2),
		spec.Slice(1, 3, 1),
	)
	fmt.Printf("%v\n", child)
}

Output:

["hi",2,1:3]

Create a descendant segment that selects the name "email" or array index zero from a node or any of its descendant nodes.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	child := spec.Descendant(
		spec.Name("email"),
		spec.Index(0),
	)
	fmt.Printf("%v\n", child)
}

Output:

..["email",0]

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	singular := spec.SingularQuery(
		true,
		spec.Name("profile"),
		spec.Name("contacts"),
		spec.Index(0),
		spec.Name("email"),
	)
	fmt.Printf("%v\n", singular)
}

Output:

$["profile"]["contacts"][0]["email"]

Create a few slice selectors.

package main

import (
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	// Select all values in a slice.
	for _, sliceSelector := range []any{
		spec.Slice(),         // full slice
		spec.Slice(1, 4),     // items 1-3
		spec.Slice(nil, 8),   // items 0-7
		spec.Slice(4, -1, 3), // items 4-last step by 3
		spec.Slice(5, 1, -2), // items 5-2, step by -2

	} {
		fmt.Printf("%v\n", sliceSelector)
	}
}

Output:

:
1:4
:8
4:-1:3
5:1:-2

Create A spec.ValueType for each supported JSON type.

package main

import (
	"encoding/json"
	"fmt"

	"github.com/theory/jsonpath/spec"
)

func main() {
	for _, val := range []any{
		"hello",
		42,
		98.6,
		json.Number("1024"),
		true,
		nil,
		map[string]any{"x": true},
		[]any{1, 2, false},
	} {
		fmt.Printf("%v\n", spec.Value(val))
	}
}

Output:

hello
42
98.6
1024
true
<nil>
map[x:true]
[1 2 false]