@@ -106,7 +106,7 @@ github.com/fsnotify/fsnotify                        45d7d09e39ef4ac08d493309fa03

 # awslogs deps

 github.com/aws/aws-sdk-go                           2590bc875c54c9fda225d8e4e56a9d28d90c6a47 # v1.28.11

-github.com/jmespath/go-jmespath                     c2b33e8439af944379acbdd9c3a5fe0bc44bd8a5 # see https://github.com/aws/aws-sdk-go/blob/2590bc875c54c9fda225d8e4e56a9d28d90c6a47/Gopkg.toml#L42

+github.com/jmespath/go-jmespath                     2d053f87d1d7f9f48196ae04cf3daea4273d207d # v0.3.0

 # logentries

 github.com/bsphere/le_go                            7a984a84b5492ae539b79b62fb4a10afc63c7bcf

@@ -4,4 +4,84 @@

-See http://jmespath.org for more info.

+go-jmespath is a GO implementation of JMESPath,

+which is a query language for JSON.  It will take a JSON

+document and transform it into another JSON document

+through a JMESPath expression.

+

+Using go-jmespath is really easy.  There's a single function

+you use, `jmespath.search`:

+

+

+```go

+> import "github.com/jmespath/go-jmespath"

+>

+> var jsondata = []byte(`{"foo": {"bar": {"baz": [0, 1, 2, 3, 4]}}}`) // your data

+> var data interface{}

+> err := json.Unmarshal(jsondata, &data)

+> result, err := jmespath.Search("foo.bar.baz[2]", data)

+result = 2

+```

+

+In the example we gave the ``search`` function input data of

+`{"foo": {"bar": {"baz": [0, 1, 2, 3, 4]}}}` as well as the JMESPath

+expression `foo.bar.baz[2]`, and the `search` function evaluated

+the expression against the input data to produce the result ``2``.

+

+The JMESPath language can do a lot more than select an element

+from a list.  Here are a few more examples:

+

+```go

+> var jsondata = []byte(`{"foo": {"bar": {"baz": [0, 1, 2, 3, 4]}}}`) // your data

+> var data interface{}

+> err := json.Unmarshal(jsondata, &data)

+> result, err := jmespath.search("foo.bar", data)

+result = { "baz": [ 0, 1, 2, 3, 4 ] }

+

+

+> var jsondata  = []byte(`{"foo": [{"first": "a", "last": "b"},

+                           {"first": "c", "last": "d"}]}`) // your data

+> var data interface{}

+> err := json.Unmarshal(jsondata, &data)

+> result, err := jmespath.search({"foo[*].first", data)

+result [ 'a', 'c' ]

+

+

+> var jsondata = []byte(`{"foo": [{"age": 20}, {"age": 25},

+                           {"age": 30}, {"age": 35},

+                           {"age": 40}]}`) // your data

+> var data interface{}

+> err := json.Unmarshal(jsondata, &data)

+> result, err := jmespath.search("foo[?age > `30`]")

+result = [ { age: 35 }, { age: 40 } ]

+```

+

+You can also pre-compile your query. This is usefull if 

+you are going to run multiple searches with it:

+

+```go

+	> var jsondata = []byte(`{"foo": "bar"}`)

+	> var data interface{}

+    > err := json.Unmarshal(jsondata, &data)

+	> precompiled, err := Compile("foo")

+	> if err != nil{

+    >   // ... handle the error

+    > }

+    > result, err := precompiled.Search(data)

+	result = "bar"

+```

+

+## More Resources

+

+The example above only show a small amount of what

+a JMESPath expression can do.  If you want to take a

+tour of the language, the *best* place to go is the

+[JMESPath Tutorial](http://jmespath.org/tutorial.html).

+

+One of the best things about JMESPath is that it is

+implemented in many different programming languages including

+python, ruby, php, lua, etc.  To see a complete list of libraries,

+check out the [JMESPath libraries page](http://jmespath.org/libraries.html).

+

+And finally, the full JMESPath specification can be found

+on the [JMESPath site](http://jmespath.org/specification.html).

@@ -2,7 +2,7 @@ package jmespath

 import "strconv"

-// JMESPath is the epresentation of a compiled JMES path query. A JMESPath is

+// JMESPath is the representation of a compiled JMES path query. A JMESPath is

 // safe for concurrent use by multiple goroutines.

 type JMESPath struct {

 	ast  ASTNode

new file mode 100644

@@ -0,0 +1,5 @@

+module github.com/jmespath/go-jmespath

+

+go 1.14

+

+require github.com/stretchr/testify v1.5.1

@@ -137,7 +137,7 @@ func (p *Parser) Parse(expression string) (ASTNode, error) {

 	}

 	if p.current() != tEOF {

 		return ASTNode{}, p.syntaxError(fmt.Sprintf(

-			"Unexpected token at the end of the expresssion: %s", p.current()))

+			"Unexpected token at the end of the expression: %s", p.current()))

 	}

 	return parsed, nil

 }