adding a preliminary walker interface

Author: arschles

README.md

@@ -18,21 +18,26 @@ type Address struct {
     StreetName string
     City string
     State string
+    GateCode int
 }
 
 val := jsonast.Parse(`{
     "street_num":1,
     "street_name": "Microsoft Way",
     "city": "Redmond",
-    "state": "WA"
+    "state": "WA",
+    "other_info": {
+        "needs_signature": false,
+        "gate_codes": ["abcd", "efgh"]
+    }
 }`)
 
 walked := val.
     Walk().
     Field("street_num").
-    And().Field("street_name")
-    And().Field("city").
-    And().Field("state").Validate(func(v Value) bool {
+    .Field("street_name")
+    .Field("city").
+    .Field("state").Validate(func(v Value) bool {
         str, ok := v.(jsonast.String)
         if !ok {
             return false
@@ -43,20 +48,28 @@ walked := val.
             str.String() == "WA" ||
             str.String() == "OR" ||
             str.String() == "CA"
-    })
+    }).
+    Path(
+        jsonast.NewStringPathElt("other_info"),
+        jsonast.NewStringPathElt("gate_codes"),
+        jsonast.NewIntPathElt(0),
+    )
 
 if transformer.Err() != nil {
     log.Fatal(transformer.Err())
 }
 
-// transformer now has 3 jsonast.String fields in its Strings property
-// and 1 jsonast.Number field in its Numbers property.
+// walked now has the following fields in the following properties:
 //
-// you can now validate on these fields
+// - .Strings has 3 jsonast.String values (street_name, city, state)
+// - .Numbers has 2 jsonast.Number values (street_num, other_info.gate_codes[0])
+//
+// you can now create an Address from these fields
 address := Address{
-    StreetNum: transformer.Numbers[0],
-    StreetName: transformer.Strings[0],
-    City: transformer.Strings[1],
-    State: transformer.Strings[2],
+    StreetNum: walked.Numbers[0],
+    StreetName: walked.Strings[0],
+    City: walked.Strings[1],
+    State: walked.Strings[2],
+    GateCode: walked.Numbers[1],
 }
 ```

path.go

@@ -0,0 +1,36 @@
+package jsonast
+
+import (
+	"fmt"
+)
+
+// PathElt is a container for a single element of a json path
+type PathElt interface {
+	fmt.Stringer
+}
+
+type stringPathElt struct {
+	str string
+}
+
+func (s stringPathElt) String() string {
+	return fmt.Sprintf("StringPathElt(%s)", s.str)
+}
+
+type intPathElt struct {
+	i int
+}
+
+func (i intPathElt) String() string {
+	return fmt.Sprintf("IntPathElt(%d)", i)
+}
+
+// NewStringPathElt creates a new PathElt from s
+func NewStringPathElt(s string) PathElt {
+	return stringPathElt{str: s}
+}
+
+// NewIntPathElt creates a new PathElt from i
+func NewIntPathElt(i int) PathElt {
+	return intPathElt{i: i}
+}

walker.go

@@ -7,9 +7,13 @@ import (
 // Walker is a utility for walking the JSON tree with a few function calls,
 // and transforming the JSON that was walked into a type
 type Walker struct {
-	path   string
-	values []Value
-	err    error
+	latestValue Value
+	Nulls       []Null
+	Strings     []String
+	Numbers     []Number
+	Objects     []Object
+	Arrays      []Array
+	err         error
 }
 
 // Elt picks out the ith element of the current array
@@ -25,30 +29,28 @@ func (w Walker) Elt(i int) Walker {
 	return w
 }
 
-// Field picks out the key s in the current dictionary
-func (w Walker) Field(s string) Walker {
+// Path picks out the value pointed to by all the given path elements
+// and puts it into the next value
+func (w Walker) Path(pathElt PathElt, pathElts ...PathElt) Walker {
 	if w.err != nil {
 		return w
 	}
 	// TODO
-	return w
+	return nil
 }
-func (w Walker) And() Walker {
+
+// Field picks out the key s in the current dictionary
+func (w Walker) Field(s string) Walker {
 	if w.err != nil {
 		return w
 	}
-	// TODO
-	return w
+	return w.Path(NewStringPathElt(s))
 }
 
+// Validate validates the latest fetched value in w
 func (w Walker) Validate(fn func(Value) bool) Walker {
 	if w.err != nil {
 		return w
 	}
 	fn(values)
 }
-
-func (w Walker) curValue() Value {
-	// TODO: handle the case when there are no values
-	return w.values[len(w.values)-1]
-}