cleaning up

Author: arschles

README.md

@@ -32,12 +32,11 @@ val := jsonast.Parse(`{
     }
 }`)
 
-walked := val.
-    Walk().
+walked := jsonast.NewWalker(val).
     Field("street_num").
-    .Field("street_name")
-    .Field("city").
-    .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

array.go

@@ -32,32 +32,18 @@ type arrayImpl struct {
 	arr []Value
 }
 
-func isArray(i interface{}) bool {
-	_, ok := i.([]interface{})
-	return ok
-}
-
-func newArray(v *value) (Array, error) {
-	if !isArray(v.cur) {
-		return nil, errNotAnArray
-	}
-	ifaceArr := v.cur.([]interface{})
-	convertedArr := make([]Value, len(ifaceArr))
-	for i, iface := range ifaceArr {
-		val, err := valueFromIface(iface)
-		if err != nil {
-			return nil, err
-		}
-		convertedArr[i] = val
+func newArray(elts []Value) Array {
+	return arrayImpl{
+		Value: valueImpl{isArray: true},
+		arr:   elts,
 	}
-	return &arrayImpl{Value: v, arr: convertedArr}, nil
 }
 
-func (v *arrayImpl) Elts() []Value {
+func (v arrayImpl) Elts() []Value {
 	return v.arr
 }
 
-func (v *arrayImpl) Foreach(fn func(Value) error) error {
+func (v arrayImpl) Foreach(fn func(Value) error) error {
 	for _, val := range v.arr {
 		if err := fn(val); err != nil {
 			return err
@@ -66,7 +52,7 @@ func (v *arrayImpl) Foreach(fn func(Value) error) error {
 	return nil
 }
 
-func (v *arrayImpl) At(i int) (Value, error) {
+func (v arrayImpl) At(i int) (Value, error) {
 	if i >= len(v.arr) {
 		return nil, errIndexOutOfBounds{i: i}
 	}

bool.go

@@ -17,19 +17,11 @@ type boolImpl struct {
 	val bool
 }
 
-func isBool(i interface{}) bool {
-	_, ok := i.(bool)
-	return ok
-}
-
-func newBool(v *value) (Bool, error) {
-	if !isBool(v.cur) {
-		return nil, errNotABool
-	}
+func newBool(b bool) Bool {
 	return boolImpl{
-		Value: v,
-		val:   v.cur.(bool),
-	}, nil
+		Value: valueImpl{isBool: true},
+		val:   b,
+	}
 }
 
 func (b boolImpl) True() bool {

number.go

@@ -17,10 +17,18 @@ type number struct {
 	i float64
 }
 
+func newNumber(f float64) Number {
+	return &number{
+		Value: valueImpl{isNumber: true},
+		i:     f,
+	}
+}
+
 func (n *number) Float64() float64 {
 	return n.i
 }
 
+// TODO: remove?
 func convertNumber(i interface{}) (float64, error) {
 	switch t := i.(type) {
 	case int:
@@ -50,16 +58,3 @@ func convertNumber(i interface{}) (float64, error) {
 
 	}
 }
-
-func isNumber(i interface{}) bool {
-	_, err := convertNumber(i)
-	return err == nil
-}
-
-func newNumber(v *value) (Number, error) {
-	flt, err := convertNumber(v.cur)
-	if err != nil {
-		return nil, err
-	}
-	return &number{Value: v, i: flt}, nil
-}

object.go

@@ -2,6 +2,7 @@ package jsonast
 
 import (
 	"errors"
+	"fmt"
 )
 
 var (
@@ -12,21 +13,36 @@ var (
 type Object interface {
 	Value
 	Fields() []ObjectPair
-	ValueAt(name string) (Value, error)
+	ValueAt(key string) (Value, error)
 }
 
 // ObjectPair represents a single key-value pair in an object
 type ObjectPair struct {
-	Name  string
+	Key   string
 	Value Value
 }
 
-type object struct {
+type objectImpl struct {
 	Value
-	obj []ObjectPair
+	pairs []ObjectPair
 }
 
-func isObject(i interface{}) bool {
-	_, ok := i.(map[interface{}]interface{})
-	return ok
+func newObject(pairs []ObjectPair) Object {
+	return objectImpl{
+		Value: valueImpl{isObject: true},
+		pairs: pairs,
+	}
+}
+
+func (o objectImpl) Fields() []ObjectPair {
+	return o.pairs
+}
+
+func (o objectImpl) ValueAt(key string) (Value, error) {
+	for _, pair := range o.pairs {
+		if pair.Key == key {
+			return pair.Value, nil
+		}
+	}
+	return nil, fmt.Errorf("no such key %s", key)
 }

string.go

@@ -8,14 +8,9 @@ import (
 var errNotAString = errors.New("not a string")
 
 // String is a string JSON value
-type String struct {
+type String interface {
 	fmt.Stringer
 	Value
-	Str string
-}
-
-func NewString(s string) String {
-	String{Str: s}
 }
 
 type stringImpl struct {
@@ -27,14 +22,9 @@ func (s stringImpl) String() string {
 	return s.str
 }
 
-func isString(i interface{}) bool {
-	_, ok := i.(string)
-	return ok
-}
-
-func newString(v *value) (String, error) {
-	if !isString(v.cur) {
-		return nil, errNotAString
+func newString(str string) String {
+	return stringImpl{
+		Value: valueImpl{isString: true},
+		str:   str,
 	}
-	return &stringImpl{Value: v, str: v.cur.(string)}, nil
 }

value.go

@@ -1,14 +1,7 @@
 package jsonast
 
-import (
-	"encoding/json"
-)
-
 // Value is a generic node in a JSON AST. This implements fmt.Stringer
 type Value interface {
-	// Walk creates a walker, which is capable of walking the JSON
-	// tree with a few function calls
-	Walk() Walker
 	// IsString returns true if the data at this node is a string
 	IsString() bool
 	// IsNumber returns true if the data at this node is numeric
@@ -23,91 +16,18 @@ type Value interface {
 	IsNull() bool
 }
 
-type value struct {
-	b   []byte
-	cur interface{}
-}
-
-// ValueFromBytes decodes b into a Value, or returns an error if b is invalid
-// json
-func ValueFromBytes(b []byte) (Value, error) {
-	var iface interface{}
-	if err := json.Unmarshal(b, &iface); err != nil {
-		return nil, err
-	}
-	return &value{cur: iface, b: b}, nil
-}
-
-func valueFromIface(i interface{}) (Value, error) {
-	b, err := json.Marshal(i)
-	if err != nil {
-		return nil, err
-	}
-	return &value{b: b, cur: i}, nil
-}
-
-func (v *value) Bytes() []byte {
-	return v.b
-}
-
-// func (v *value) String() string {
-// 	return string(v.b)
-// }
-
-func (v *value) IsString() bool {
-	return isString(v.cur)
-}
-
-// func (v *value) StringVal() (String, error) {
-// 	return newString(v)
-// }
-
-func (v *value) IsNumber() bool {
-	return isNumber(v.cur)
-}
-
-// func (v *value) NumberVal() (Number, error) {
-// 	return newNumber(v)
-// }
-
-func (v *value) IsBool() bool {
-	return isBool(v)
-}
-
-// func (v *value) BoolVal() (Bool, error) {
-// 	if !v.IsBool() {
-// 		return nil, errNotABool
-// 	}
-// 	return newBool(v), nil
-// }
-
-func (v *value) IsObject() bool {
-	_, ok := v.cur.(map[interface{}]interface{})
-	return ok
-}
-
-// func (v *value) ObjectVal() (Object, error) {
-// 	if !v.IsObject() {
-// 		return nil, errNotAnObject
-// 	}
-// 	return newObject(v)
-// }
-
-func (v *value) IsArray() bool {
-	return isArray(v.cur)
-}
-
-// func (v *value) ArrayVal() (Array, error) {
-// 	if !v.IsArray() {
-// 		return nil, errNotAnArray
-// 	}
-// 	return newArray(v)
-// }
-
-func (v *value) IsNull() bool {
-	return v.cur == nil
+type valueImpl struct {
+	isString bool
+	isNumber bool
+	isBool   bool
+	isObject bool
+	isArray  bool
+	isNull   bool
 }
 
-// func (v *value) NullVal() (Null, error) {
-// 	return newNull(v)
-// }
+func (v valueImpl) IsString() bool { return v.isString }
+func (v valueImpl) IsNumber() bool { return v.isNumber }
+func (v valueImpl) IsBool() bool   { return v.isBool }
+func (v valueImpl) IsObject() bool { return v.isObject }
+func (v valueImpl) IsArray() bool  { return v.isArray }
+func (v valueImpl) IsNull() bool   { return v.isNull }

walker.go

@@ -7,13 +7,19 @@ 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 {
-	latestValue Value
-	Nulls       []Null
-	Strings     []String
-	Numbers     []Number
-	Objects     []Object
-	Arrays      []Array
-	err         error
+	initialValue Value
+	latestValue  Value
+	Nulls        []Null
+	Strings      []String
+	Numbers      []Number
+	Objects      []Object
+	Arrays       []Array
+	err          error
+}
+
+// NewWalker creates a new Walker from the given initVal
+func NewWalker(initVal Value) Walker {
+	return Walker{initialValue: initVal}
 }
 
 // Elt picks out the ith element of the current array