shithub: furgit

Info  •  Files  •  Log  •  Branches

Revert "pktline: Make Reader/Writer structs"

This reverts commit 7f0a20840fa3efc51c2a2fc80c1f82e030e91f44.

--- a/pktline/pktline.go

+++ b/pktline/pktline.go

@@ -27,21 +27,14 @@

 	StatusResponseEnd

 )

-// Reader reads pkt-line data from an io.Reader.

-type Reader struct {

-	r io.Reader

-}

-

-// NewReader returns a Reader that reads from r.

-func NewReader(r io.Reader) *Reader {

-	return &Reader{r: r}

-}

-

-// ReadLine reads a single pkt-line from the underlying reader into buf.

+// ReadLine reads a single pkt-line from r into buf.

 // It returns the payload slice, number of payload bytes, and a status.

-func (pr *Reader) ReadLine(buf []byte) ([]byte, int, Status, error) {

+func ReadLine(r io.Reader, buf []byte) ([]byte, int, Status, error) {

+	if r == nil {

+		return nil, 0, StatusEOF, ErrInvalidHeader

+	}

 	var header [4]byte

-	if _, err := io.ReadFull(pr.r, header[:]); err != nil {

+	if _, err := io.ReadFull(r, header[:]); err != nil {

 		if errors.Is(err, io.EOF) {

 			return nil, 0, StatusEOF, io.EOF

 		}

@@ -73,7 +66,7 @@

 	if n > len(buf) {

 		return nil, 0, StatusEOF, ErrBufferTooSmall

 	}

-	if _, err := io.ReadFull(pr.r, buf[:n]); err != nil {

+	if _, err := io.ReadFull(r, buf[:n]); err != nil {

 		if errors.Is(err, io.ErrUnexpectedEOF) {

 			return nil, 0, StatusEOF, io.ErrUnexpectedEOF

 		}

@@ -82,48 +75,46 @@

 	return buf[:n], n, StatusData, nil

 }

-// Writer writes pkt-line data to an io.Writer.

-type Writer struct {

-	w io.Writer

-}

-

-// NewWriter returns a Writer that writes to w.

-func NewWriter(w io.Writer) *Writer {

-	return &Writer{w: w}

-}

-

 // WriteLine writes a single pkt-line with data as its payload.

-func (pw *Writer) WriteLine(data []byte) error {

+func WriteLine(w io.Writer, data []byte) error {

+	if w == nil {

+		return ErrInvalidHeader

+	}

 	if len(data) > maxPacketDataLen {

 		return ErrPacketTooLarge

 	}

 	var header [4]byte

 	setHeader(header[:], len(data)+4)

-	if _, err := pw.w.Write(header[:]); err != nil {

+	if _, err := w.Write(header[:]); err != nil {

 		return err

 	}

 	if len(data) == 0 {

 		return nil

 	}

-	_, err := pw.w.Write(data)

+	_, err := w.Write(data)

 	return err

 }

 // Flush writes a flush-pkt ("0000").

-func (pw *Writer) Flush() error {

-	_, err := io.WriteString(pw.w, "0000")

-	return err

+func Flush(w io.Writer) error {

+	return writeLiteral(w, "0000")

 }

 // Delim writes a delim-pkt ("0001").

-func (pw *Writer) Delim() error {

-	_, err := io.WriteString(pw.w, "0001")

-	return err

+func Delim(w io.Writer) error {

+	return writeLiteral(w, "0001")

 }

 // ResponseEnd writes a response-end pkt ("0002").

-func (pw *Writer) ResponseEnd() error {

-	_, err := io.WriteString(pw.w, "0002")

+func ResponseEnd(w io.Writer) error {

+	return writeLiteral(w, "0002")

+}

+

+func writeLiteral(w io.Writer, s string) error {

+	if w == nil {

+		return ErrInvalidHeader

+	}

+	_, err := io.WriteString(w, s)

 	return err

 }

--- a/pktline/pktline_test.go

+++ b/pktline/pktline_test.go

@@ -10,14 +10,12 @@

 func TestWriteReadLineRoundtrip(t *testing.T) {

 	var buf bytes.Buffer

 	payload := []byte("hello\n")

-	pw := NewWriter(&buf)

-	if err := pw.WriteLine(payload); err != nil {

+	if err := WriteLine(&buf, payload); err != nil {

 		t.Fatalf("WriteLine: %v", err)

 	}

 	dst := make([]byte, 64)

-	pr := NewReader(&buf)

-	line, n, status, err := pr.ReadLine(dst)

+	line, n, status, err := ReadLine(&buf, dst)

 	if err != nil {

 		t.Fatalf("ReadLine: %v", err)

 	}

@@ -45,9 +43,8 @@

 	for _, tt := range tests {

 		t.Run(tt.name, func(t *testing.T) {

 			r := bytes.NewBufferString(tt.input)

-			pr := NewReader(r)

 			dst := make([]byte, 16)

-			line, n, status, err := pr.ReadLine(dst)

+			line, n, status, err := ReadLine(r, dst)

 			if err != nil {

 				t.Fatalf("ReadLine: %v", err)

 			}

@@ -63,9 +60,8 @@

 func TestReadLineInvalidHeader(t *testing.T) {

 	r := bytes.NewBufferString("zzzz")

-	pr := NewReader(r)

 	dst := make([]byte, 16)

-	_, _, _, err := pr.ReadLine(dst)

+	_, _, _, err := ReadLine(r, dst)

 	if !errors.Is(err, ErrInvalidHeader) {

 		t.Fatalf("expected ErrInvalidHeader, got %v", err)

 	}

@@ -74,13 +70,11 @@

 func TestReadLineBufferTooSmall(t *testing.T) {

 	var buf bytes.Buffer

 	payload := []byte("abcd")

-	pw := NewWriter(&buf)

-	if err := pw.WriteLine(payload); err != nil {

+	if err := WriteLine(&buf, payload); err != nil {

 		t.Fatalf("WriteLine: %v", err)

 	}

 	dst := make([]byte, 2)

-	pr := NewReader(&buf)

-	_, _, _, err := pr.ReadLine(dst)

+	_, _, _, err := ReadLine(&buf, dst)

 	if !errors.Is(err, ErrBufferTooSmall) {

 		t.Fatalf("expected ErrBufferTooSmall, got %v", err)

 	}

@@ -88,8 +82,7 @@

 func TestWriteLineTooLarge(t *testing.T) {

 	payload := make([]byte, maxPacketDataLen+1)

-	pw := NewWriter(io.Discard)

-	if err := pw.WriteLine(payload); !errors.Is(err, ErrPacketTooLarge) {

+	if err := WriteLine(io.Discard, payload); !errors.Is(err, ErrPacketTooLarge) {

 		t.Fatalf("expected ErrPacketTooLarge, got %v", err)

 	}

 }

-- 

⑨