[json] cleanup some lint

internal/json/json.go

@@ -289,7 +289,6 @@ func (j *JSON) writeCurrentNumber(w io.Writer) (int, error) {
 				return 0, err
 			}
 			if !more {
-				end = true
 				break
 			}
 		}

internal/json/scanner.go

@@ -72,7 +72,7 @@ func (s *state) scan(chunk []byte, idx, max int) (int, error) {
 					if s.seeking {
 						if s.closerBalance == 0 {
 							// TODO: probably not this way
-							if string(s.keybuf.Bytes()) == string(s.seek) {
+							if s.keybuf.String() == string(s.seek) {
 								s.seeking = false
 								s.seekFound = true
 								return idx, nil

internal/json/scanner_test.go

@@ -9,39 +9,58 @@ import (
 func TestStateScanSimpleObject(t *testing.T) {
 	s := NewScanState('{')
 	assert.False(t, s.key)
-	s.scan([]byte{'"'}, 0, 1)
+
+	_, err := s.scan([]byte{'"'}, 0, 1)
+	assert.NoError(t, err)
 	assert.True(t, s.inStr)
 	assert.True(t, s.key)
-	s.scan([]byte{'\\'}, 0, 1)
+
+	_, err = s.scan([]byte{'\\'}, 0, 1)
+	assert.NoError(t, err)
 	assert.True(t, s.inStr)
 	assert.True(t, s.key)
-	s.scan([]byte{'"'}, 0, 1)
+
+	_, err = s.scan([]byte{'"'}, 0, 1)
+	assert.NoError(t, err)
 	assert.True(t, s.inStr)
 	assert.True(t, s.key)
-	s.scan([]byte{'"'}, 0, 1)
+
+	_, err = s.scan([]byte{'"'}, 0, 1)
+	assert.NoError(t, err)
 	assert.False(t, s.inStr)
 	assert.False(t, s.key)
 	assert.True(t, s.open, "still open after key")
-	s.scan([]byte(` : `), 0, 3)
+
+	_, err = s.scan([]byte(` : `), 0, 3)
+	assert.NoError(t, err)
 	assert.False(t, s.inStr)
 	assert.False(t, s.key)
-	s.scan([]byte(`"y`), 0, 2)
+
+	_, err = s.scan([]byte(`"y`), 0, 2)
+	assert.NoError(t, err)
 	assert.True(t, s.inStr)
 	assert.False(t, s.key)
-	s.scan([]byte(`ellow"`), 0, 6)
+
+	_, err = s.scan([]byte(`ellow"`), 0, 6)
+	assert.NoError(t, err)
 	assert.False(t, s.inStr)
 	assert.True(t, s.open, "still open after value")
-	s.scan([]byte{'}'}, 0, 1)
+
+	_, err = s.scan([]byte{'}'}, 0, 1)
+	assert.NoError(t, err)
 	assert.False(t, s.open, "closed by the closer")
 }
 
 func TestScanSubObjectDoesNotClose(t *testing.T) {
 	s := NewScanState('{')
 	buf := []byte(`"x":{"subobject":21}`)
-	s.scan(buf, 0, len(buf))
+	_, err := s.scan(buf, 0, len(buf))
 	assert.True(t, s.open)
-	s.scan([]byte{'}'}, 0, 1)
+	assert.NoError(t, err)
+
+	_, err = s.scan([]byte{'}'}, 0, 1)
 	assert.False(t, s.open)
+	assert.NoError(t, err)
 }
 
 func TestScanCloseBeforeEnd(t *testing.T) {
@@ -55,19 +74,26 @@ func TestScanCloseBeforeEnd(t *testing.T) {
 
 func TestScanStringDoesNotCloseObject(t *testing.T) {
 	s := NewScanState('{')
+
 	buf := []byte(`"}"`)
-	s.scan(buf, 0, len(buf))
+	_, err := s.scan(buf, 0, len(buf))
+	assert.NoError(t, err)
 	assert.True(t, s.open)
-	s.scan([]byte{'}'}, 0, 1)
+
+	_, err = s.scan([]byte{'}'}, 0, 1)
+	assert.NoError(t, err)
 	assert.False(t, s.open)
 }
 
 func TestEscapedSubStringDoesNotClose(t *testing.T) {
 	s := NewScanState('"')
 	buf := []byte(`x\"`)
-	s.scan(buf, 0, len(buf))
+	_, err := s.scan(buf, 0, len(buf))
+	assert.NoError(t, err)
 	assert.True(t, s.open)
-	s.scan([]byte{'"'}, 0, 1)
+
+	_, err = s.scan([]byte{'"'}, 0, 1)
+	assert.NoError(t, err)
 	assert.False(t, s.open)
 }
 
@@ -82,10 +108,14 @@ func TestScanForSimple(t *testing.T) {
 	s := NewScanState('{')
 	s.seekFor("z")
 	buf := []byte(`"x":99,"y":102,`)
-	s.scan(buf, 0, len(buf))
+
+	_, err := s.scan(buf, 0, len(buf))
 	assert.False(t, s.seekFound, "not found yet")
+	assert.NoError(t, err)
+
 	buf = []byte(`"z":199`)
-	s.scan(buf, 0, len(buf))
+	_, err = s.scan(buf, 0, len(buf))
+	assert.NoError(t, err)
 	assert.True(t, s.seekFound, "found")
 
 }
@@ -95,10 +125,14 @@ func TestScanForSimpleWithNestedTrap(t *testing.T) {
 	s.seekFor("target")
 	assert.False(t, s.seekFound, "not found yet")
 	buf := []byte(`"x":99,"p":{"target":12},`)
-	s.scan(buf, 0, len(buf))
+
+	_, err := s.scan(buf, 0, len(buf))
+	assert.NoError(t, err)
 	assert.False(t, s.seekFound, "not found yet")
+
 	buf = []byte(`"target":199`)
-	pos, _ := s.scan(buf, 0, len(buf))
+	pos, err := s.scan(buf, 0, len(buf))
+	assert.NoError(t, err)
 	assert.True(t, s.seekFound, "found")
 	assert.Equal(t, `":199`, string(buf[pos:]), "stopped in the correct place")
 }
@@ -107,8 +141,10 @@ func TestFutileScan(t *testing.T) {
 	s := NewScanState('{')
 	s.seekFor("target")
 	assert.False(t, s.seekFound, "not found yet")
+
 	buf := []byte(`"x":99,"p":{"target":12},"z":[{"target":12}]}`)
-	s.scan(buf, 0, len(buf))
+	_, err := s.scan(buf, 0, len(buf))
 	assert.False(t, s.seekFound, "not found yet")
 	assert.False(t, s.open)
+	assert.NoError(t, err)
 }