- Add test and benchmarks for delete method

- Fix TestObjectEach
- Revert changes to bytes methods

Author: pytlesk4

.gitignore

@@ -6,3 +6,5 @@
 *.mprof
 
 vendor/github.com/buger/goterm/
+prof.cpu
+prof.mem

benchmark/benchmark_medium_payload_test.go

@@ -6,6 +6,8 @@ package benchmark
 
 import (
 	"encoding/json"
+	"testing"
+
 	"github.com/Jeffail/gabs"
 	"github.com/a8m/djson"
 	"github.com/antonholmquist/jason"
@@ -15,7 +17,6 @@ import (
 	"github.com/mreiferson/go-ujson"
 	"github.com/pquerna/ffjson/ffjson"
 	"github.com/ugorji/go/codec"
-	"testing"
 	// "fmt"
 	"bytes"
 	"errors"
@@ -37,6 +38,19 @@ func BenchmarkJsonParserMedium(b *testing.B) {
 	}
 }
 
+func BenchmarkJsonParserDelMedium(b *testing.B) {
+	fixture := make([]byte, 0, len(mediumFixture))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		fixture = append(fixture[:0], mediumFixture...)
+		fixture = jsonparser.Del(fixture, "person", "name", "fullName")
+		fixture = jsonparser.Del(fixture, "person", "github", "followers")
+		fixture = jsonparser.Del(fixture, "company")
+
+		nothing()
+	}
+}
+
 func BenchmarkJsonParserEachKeyManualMedium(b *testing.B) {
 	paths := [][]string{
 		[]string{"person", "name", "fullName"},

benchmark/benchmark_small_payload_test.go

@@ -6,6 +6,8 @@ package benchmark
 
 import (
 	"encoding/json"
+	"testing"
+
 	"github.com/Jeffail/gabs"
 	"github.com/a8m/djson"
 	"github.com/antonholmquist/jason"
@@ -15,7 +17,6 @@ import (
 	"github.com/mreiferson/go-ujson"
 	"github.com/pquerna/ffjson/ffjson"
 	"github.com/ugorji/go/codec"
-	"testing"
 	// "fmt"
 	"bytes"
 	"errors"
@@ -141,6 +142,20 @@ func BenchmarkJsonParserSetSmall(b *testing.B) {
 	}
 }
 
+func BenchmarkJsonParserDelSmall(b *testing.B) {
+	fixture := make([]byte, 0, len(smallFixture))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		fixture = append(fixture[:0], smallFixture...)
+		fixture = jsonparser.Del(fixture, "uuid")
+		fixture = jsonparser.Del(fixture, "tz")
+		fixture = jsonparser.Del(fixture, "ua")
+		fixture = jsonparser.Del(fixture, "stt")
+
+		nothing()
+	}
+}
+
 /*
    encoding/json
 */

bytes_safe.go

@@ -19,3 +19,7 @@ func parseFloat(b *[]byte) (float64, error) {
 func bytesToString(b *[]byte) string {
 	return string(*b)
 }
+
+func StringToBytes(s string) []byte {
+	return []byte(s)
+}

bytes_unsafe.go

@@ -3,6 +3,7 @@
 package jsonparser
 
 import (
+	"reflect"
 	"strconv"
 	"unsafe"
 )
@@ -16,16 +17,26 @@ import (
 //
 // TODO: Remove hack after Go 1.7 release
 //
-func equalStr(b []byte, s string) bool {
-	return *(*string)(unsafe.Pointer(&b)) == s
+func equalStr(b *[]byte, s string) bool {
+	return *(*string)(unsafe.Pointer(b)) == s
 }
 
-func parseFloat(b []byte) (float64, error) {
-	return strconv.ParseFloat(*(*string)(unsafe.Pointer(&b)), 64)
+func parseFloat(b *[]byte) (float64, error) {
+	return strconv.ParseFloat(*(*string)(unsafe.Pointer(b)), 64)
 }
 
 // A hack until issue golang/go#2632 is fixed.
 // See: https://github.com/golang/go/issues/2632
-func bytesToString(b []byte) string {
-	return *(*string)(unsafe.Pointer(&b))
+func bytesToString(b *[]byte) string {
+	return *(*string)(unsafe.Pointer(b))
+}
+
+func StringToBytes(s string) []byte {
+	sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
+	bh := reflect.SliceHeader{
+		Data: sh.Data,
+		Len:  sh.Len,
+		Cap:  sh.Len,
+	}
+	return *(*[]byte)(unsafe.Pointer(&bh))
 }

bytes_unsafe_test.go

@@ -27,7 +27,7 @@ func bytesEqualStrUnsafeSlower(abytes *[]byte, bstr string) bool {
 }
 
 func TestEqual(t *testing.T) {
-	if !equalStr([]byte{}, "") {
+	if !equalStr(&[]byte{}, "") {
 		t.Errorf(`equalStr("", ""): expected true, obtained false`)
 		return
 	}
@@ -37,11 +37,11 @@ func TestEqual(t *testing.T) {
 		s1, s2 := longstr[:i]+"1", longstr[:i]+"2"
 		b1 := []byte(s1)
 
-		if !equalStr(b1, s1) {
+		if !equalStr(&b1, s1) {
 			t.Errorf(`equalStr("a"*%d + "1", "a"*%d + "1"): expected true, obtained false`, i, i)
 			break
 		}
-		if equalStr(b1, s2) {
+		if equalStr(&b1, s2) {
 			t.Errorf(`equalStr("a"*%d + "1", "a"*%d + "2"): expected false, obtained true`, i, i)
 			break
 		}
@@ -50,7 +50,7 @@ func TestEqual(t *testing.T) {
 
 func BenchmarkEqualStr(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		equalStr(benchmarkBytes, benchmarkString)
+		equalStr(&benchmarkBytes, benchmarkString)
 	}
 }
 

parser.go

@@ -36,21 +36,75 @@ func tokenEnd(data []byte) int {
 	return len(data)
 }
 
-func findLastTokenEnd(data []byte, token byte) int {
+func findTokenStart(data []byte, token byte) int {
 	for i := len(data) - 1; i >= 0; i-- {
 		switch data[i] {
 		case token:
 			return i
+		case '[', '{':
+			return 0
 		}
 	}
 
 	return 0
 }
 
-func lastTokenEnd(data []byte) int {
+func findKeyStart(data []byte, key string) (int, error) {
+	i := 0
+	ln := len(data)
+	var stackbuf [unescapeStackBufSize]byte // stack-allocated array for allocation-free unescaping of small strings
+
+	if ku, err := Unescape(StringToBytes(key), stackbuf[:]); err == nil {
+		key = bytesToString(&ku)
+	}
+
+	for i < ln {
+		switch data[i] {
+		case '"':
+			i++
+			keyBegin := i
+
+			strEnd, keyEscaped := stringEnd(data[i:])
+			if strEnd == -1 {
+				break
+			}
+			i += strEnd
+			keyEnd := i - 1
+
+			valueOffset := nextToken(data[i:])
+			if valueOffset == -1 {
+				break
+			}
+
+			i += valueOffset
+
+			// if string is a key, and key level match
+			k := data[keyBegin:keyEnd]
+			// for unescape: if there are no escape sequences, this is cheap; if there are, it is a
+			// bit more expensive, but causes no allocations unless len(key) > unescapeStackBufSize
+			if keyEscaped {
+				if ku, err := Unescape(k, stackbuf[:]); err != nil {
+					break
+				} else {
+					k = ku
+				}
+			}
+
+			if data[i] == ':' && len(key) == len(k) && bytesToString(&k) == key {
+				return keyBegin - 1, nil
+			}
+
+		}
+		i++
+	}
+
+	return -1, KeyPathNotFoundError
+}
+
+func tokenStart(data []byte) int {
 	for i := len(data) - 1; i >= 0; i-- {
 		switch data[i] {
-		case ' ', '\n', '\r', '\t', ',', '}', ']':
+		case '\n', '\r', '\t', ',', '{', '[':
 			return i
 		}
 	}
@@ -195,7 +249,7 @@ func searchKeys(data []byte, keys ...string) int {
 					keyUnesc = ku
 				}
 
-				if equalStr(keyUnesc, keys[level-1]) {
+				if equalStr(&keyUnesc, keys[level-1]) {
 					keyLevel++
 					// If we found all keys in path
 					if keyLevel == lk {
@@ -341,9 +395,9 @@ func EachKey(data []byte, cb func(int, []byte, ValueType, error), paths ...[]str
 						return -1
 					}
 
-					pathsBuf[level-1] = bytesToString(keyUnesc)
+					pathsBuf[level-1] = bytesToString(&keyUnesc)
 					for pi, p := range paths {
-						if len(p) != level || pathFlags&bitwiseFlags[pi+1] != 0 || !equalStr(keyUnesc, p[level-1]) || !sameTree(p, pathsBuf[:level]) {
+						if len(p) != level || pathFlags&bitwiseFlags[pi+1] != 0 || !equalStr(&keyUnesc, p[level-1]) || !sameTree(p, pathsBuf[:level]) {
 							continue
 						}
 
@@ -544,46 +598,52 @@ func Del(data []byte, keys ...string) []byte {
 		array = true
 	}
 
-	_, _, startOffset, endOffset, err := internalGet(data, keys...)
-	if err == nil {
-		if !array {
-			lastTok := lastTokenEnd(data[:startOffset])
-			keyOffset, _ := stringEnd(data[:lastTok])
-			lastTokEnd := tokenEnd(data[endOffset:])
-
-			if keyOffset == -1 {
-				keyOffset = 0
-			} else {
-				keyOffset--
-			}
-			if lastTok != 0 {
-				startOffset = lastTok + keyOffset
-			}
-
-			if lastTokEnd >= len(data[endOffset:])-1 {
-				lastTokEnd = 0
-				startOffset = lastTok
-			} else {
-				lastTokEnd++
+	var startOffset, keyOffset int
+	endOffset := len(data)
+	var err error
+	if !array {
+		if len(keys) > 1 {
+			_, _, startOffset, endOffset, err = internalGet(data, keys[:lk-1]...)
+			if err == KeyPathNotFoundError {
+				// problem parsing the data
+				return data
 			}
-			endOffset = endOffset + lastTokEnd
-		} else {
-			tokEnd := tokenEnd(data[endOffset:])
-			tokStart := findLastTokenEnd(data[:startOffset], ","[0])
+		}
 
-			if data[endOffset+tokEnd] == ","[0] {
-				endOffset += tokEnd + 1
-			} else if data[endOffset+tokEnd] == "]"[0] && data[tokStart] == ","[0] {
-				startOffset = tokStart
-			}
+		keyOffset, err = findKeyStart(data[startOffset:endOffset], keys[lk-1])
+		if err == KeyPathNotFoundError {
+			// problem parsing the data
+			return data
+		}
+		keyOffset += startOffset
+		_, _, _, subEndOffset, _ := internalGet(data[startOffset:endOffset], keys[lk-1])
+		endOffset = startOffset + subEndOffset
+		tokEnd := tokenEnd(data[endOffset:])
+		tokStart := findTokenStart(data[:keyOffset], ","[0])
+
+		if data[endOffset+tokEnd] == ","[0] {
+			endOffset += tokEnd + 1
+		} else if data[endOffset+tokEnd] == "}"[0] && data[tokStart] == ","[0] {
+			keyOffset = tokStart
 		}
+	} else {
+		_, _, keyOffset, endOffset, err = internalGet(data, keys...)
+		if err == KeyPathNotFoundError {
+			// problem parsing the data
+			return data
+		}
+
+		tokEnd := tokenEnd(data[endOffset:])
+		tokStart := findTokenStart(data[:keyOffset], ","[0])
 
-		copy(data[startOffset:], data[endOffset:])
-		for k, n := len(data)-endOffset+startOffset, len(data); k < n; k++ {
-			data[k] = 0 // or the zero value of T
+		if data[endOffset+tokEnd] == ","[0] {
+			endOffset += tokEnd + 1
+		} else if data[endOffset+tokEnd] == "]"[0] && data[tokStart] == ","[0] {
+			keyOffset = tokStart
 		}
-		data = data[:len(data)-endOffset+startOffset]
 	}
+
+	data = append(data[:keyOffset], data[endOffset:]...)
 	return data
 }
 
@@ -972,7 +1032,7 @@ func GetUnsafeString(data []byte, keys ...string) (val string, err error) {
 		return "", e
 	}
 
-	return bytesToString(v), nil
+	return bytesToString(&v), nil
 }
 
 // GetString returns the value retrieved by `Get`, cast to a string if possible, trying to properly handle escape and utf8 symbols
@@ -1070,7 +1130,7 @@ func ParseString(b []byte) (string, error) {
 
 // ParseNumber parses a Number ValueType into a Go float64
 func ParseFloat(b []byte) (float64, error) {
-	if v, err := parseFloat(b); err != nil {
+	if v, err := parseFloat(&b); err != nil {
 		return 0, MalformedValueError
 	} else {
 		return v, nil