bump(github.com/go-openapi/spec): 7abd5745472fff5eb3685386d5fb8bf38683154d

vendor/github.com/mailru/easyjson/jwriter/writer.go

@@ -2,6 +2,7 @@
 package jwriter
 
 import (
+	"encoding/base64"
 	"io"
 	"strconv"
 	"unicode/utf8"
@@ -9,10 +10,22 @@ import (
 	"github.com/mailru/easyjson/buffer"
 )
 
+// Flags describe various encoding options. The behavior may be actually implemented in the encoder, but
+// Flags field in Writer is used to set and pass them around.
+type Flags int
+
+const (
+	NilMapAsEmpty   Flags = 1 << iota // Encode nil map as '{}' rather than 'null'.
+	NilSliceAsEmpty                   // Encode nil slice as '[]' rather than 'null'.
+)
+
 // Writer is a JSON writer.
 type Writer struct {
-	Error  error
-	Buffer buffer.Buffer
+	Flags Flags
+
+	Error        error
+	Buffer       buffer.Buffer
+	NoEscapeHTML bool
 }
 
 // Size returns the size of the data that was written out.
@@ -25,13 +38,24 @@ func (w *Writer) DumpTo(out io.Writer) (written int, err error) {
 	return w.Buffer.DumpTo(out)
 }
 
-// BuildBytes returns writer data as a single byte slice.
-func (w *Writer) BuildBytes() ([]byte, error) {
+// BuildBytes returns writer data as a single byte slice. You can optionally provide one byte slice
+// as argument that it will try to reuse.
+func (w *Writer) BuildBytes(reuse ...[]byte) ([]byte, error) {
 	if w.Error != nil {
 		return nil, w.Error
 	}
 
-	return w.Buffer.BuildBytes(), nil
+	return w.Buffer.BuildBytes(reuse...), nil
+}
+
+// ReadCloser returns an io.ReadCloser that can be used to read the data.
+// ReadCloser also resets the buffer.
+func (w *Writer) ReadCloser() (io.ReadCloser, error) {
+	if w.Error != nil {
+		return nil, w.Error
+	}
+
+	return w.Buffer.ReadCloser(), nil
 }
 
 // RawByte appends raw binary data to the buffer.
@@ -44,7 +68,7 @@ func (w *Writer) RawString(s string) {
 	w.Buffer.AppendString(s)
 }
 
-// RawByte appends raw binary data to the buffer or sets the error if it is given. Useful for
+// Raw appends raw binary data to the buffer or sets the error if it is given. Useful for
 // calling with results of MarshalJSON-like functions.
 func (w *Writer) Raw(data []byte, err error) {
 	switch {
@@ -59,6 +83,34 @@ func (w *Writer) Raw(data []byte, err error) {
 	}
 }
 
+// RawText encloses raw binary data in quotes and appends in to the buffer.
+// Useful for calling with results of MarshalText-like functions.
+func (w *Writer) RawText(data []byte, err error) {
+	switch {
+	case w.Error != nil:
+		return
+	case err != nil:
+		w.Error = err
+	case len(data) > 0:
+		w.String(string(data))
+	default:
+		w.RawString("null")
+	}
+}
+
+// Base64Bytes appends data to the buffer after base64 encoding it
+func (w *Writer) Base64Bytes(data []byte) {
+	if data == nil {
+		w.Buffer.AppendString("null")
+		return
+	}
+	w.Buffer.AppendByte('"')
+	dst := make([]byte, base64.StdEncoding.EncodedLen(len(data)))
+	base64.StdEncoding.Encode(dst, data)
+	w.Buffer.AppendBytes(dst)
+	w.Buffer.AppendByte('"')
+}
+
 func (w *Writer) Uint8(n uint8) {
 	w.Buffer.EnsureSpace(3)
 	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10)
@@ -200,6 +252,16 @@ func (w *Writer) Bool(v bool) {
 
 const chars = "0123456789abcdef"
 
+func isNotEscapedSingleChar(c byte, escapeHTML bool) bool {
+	// Note: might make sense to use a table if there are more chars to escape. With 4 chars
+	// it benchmarks the same.
+	if escapeHTML {
+		return c != '<' && c != '>' && c != '&' && c != '\\' && c != '"' && c >= 0x20 && c < utf8.RuneSelf
+	} else {
+		return c != '\\' && c != '"' && c >= 0x20 && c < utf8.RuneSelf
+	}
+}
+
 func (w *Writer) String(s string) {
 	w.Buffer.AppendByte('"')
 
@@ -209,39 +271,32 @@ func (w *Writer) String(s string) {
 	p := 0 // last non-escape symbol
 
 	for i := 0; i < len(s); {
-		// single-with character
-		if c := s[i]; c < utf8.RuneSelf {
-			var escape byte
+		c := s[i]
+
+		if isNotEscapedSingleChar(c, !w.NoEscapeHTML) {
+			// single-width character, no escaping is required
+			i++
+			continue
+		} else if c < utf8.RuneSelf {
+			// single-with character, need to escape
+			w.Buffer.AppendString(s[p:i])
 			switch c {
 			case '\t':
-				escape = 't'
+				w.Buffer.AppendString(`\t`)
 			case '\r':
-				escape = 'r'
+				w.Buffer.AppendString(`\r`)
 			case '\n':
-				escape = 'n'
+				w.Buffer.AppendString(`\n`)
 			case '\\':
-				escape = '\\'
+				w.Buffer.AppendString(`\\`)
 			case '"':
-				escape = '"'
-			case '<', '>':
-				// do nothing
+				w.Buffer.AppendString(`\"`)
 			default:
-				if c >= 0x20 {
-					// no escaping is required
-					i++
-					continue
-				}
-			}
-			if escape != 0 {
-				w.Buffer.AppendString(s[p:i])
-				w.Buffer.AppendByte('\\')
-				w.Buffer.AppendByte(escape)
-			} else {
-				w.Buffer.AppendString(s[p:i])
 				w.Buffer.AppendString(`\u00`)
 				w.Buffer.AppendByte(chars[c>>4])
 				w.Buffer.AppendByte(chars[c&0xf])
 			}
+
 			i++
 			p = i
 			continue