rename Read() methods into Marshal() (#221)

pkg/base/body.go

@@ -13,7 +13,7 @@ const (
 
 type body []byte
 
-func (b *body) read(header Header, rb *bufio.Reader) error {
+func (b *body) unmarshal(header Header, rb *bufio.Reader) error {
 	cls, ok := header["Content-Length"]
 	if !ok || len(cls) != 1 {
 		*b = nil

pkg/base/body_test.go

@@ -22,18 +22,18 @@ var casesBody = []struct {
 	},
 }
 
-func TestBodyRead(t *testing.T) {
+func TestBodyUnmarshal(t *testing.T) {
 	for _, ca := range casesBody {
 		t.Run(ca.name, func(t *testing.T) {
 			var p body
-			err := p.read(ca.h, bufio.NewReader(bytes.NewReader(ca.byts)))
+			err := p.unmarshal(ca.h, bufio.NewReader(bytes.NewReader(ca.byts)))
 			require.NoError(t, err)
 			require.Equal(t, ca.byts, []byte(p))
 		})
 	}
 }
 
-func TestBodyReadErrors(t *testing.T) {
+func TestBodyUnmarshalErrors(t *testing.T) {
 	for _, ca := range []struct {
 		name string
 		h    Header
@@ -67,7 +67,7 @@ func TestBodyReadErrors(t *testing.T) {
 	} {
 		t.Run(ca.name, func(t *testing.T) {
 			var p body
-			err := p.read(ca.h, bufio.NewReader(bytes.NewReader(ca.byts)))
+			err := p.unmarshal(ca.h, bufio.NewReader(bytes.NewReader(ca.byts)))
 			require.EqualError(t, err, ca.err)
 		})
 	}

pkg/base/header.go

@@ -34,18 +34,18 @@ type HeaderValue []string
 // Header is a RTSP reader, present in both Requests and Responses.
 type Header map[string]HeaderValue
 
-func (h *Header) read(rb *bufio.Reader) error {
+func (h *Header) unmarshal(br *bufio.Reader) error {
 	*h = make(Header)
 	count := 0
 
 	for {
-		byt, err := rb.ReadByte()
+		byt, err := br.ReadByte()
 		if err != nil {
 			return err
 		}
 
 		if byt == '\r' {
-			err := readByteEqual(rb, '\n')
+			err := readByteEqual(br, '\n')
 			if err != nil {
 				return err
 			}
@@ -58,7 +58,7 @@ func (h *Header) read(rb *bufio.Reader) error {
 		}
 
 		key := string([]byte{byt})
-		byts, err := readBytesLimited(rb, ':', headerMaxKeyLength-1)
+		byts, err := readBytesLimited(br, ':', headerMaxKeyLength-1)
 		if err != nil {
 			return fmt.Errorf("value is missing")
 		}
@@ -68,7 +68,7 @@ func (h *Header) read(rb *bufio.Reader) error {
 		// https://tools.ietf.org/html/rfc2616
 		// The field value MAY be preceded by any amount of spaces
 		for {
-			byt, err := rb.ReadByte()
+			byt, err := br.ReadByte()
 			if err != nil {
 				return err
 			}
@@ -77,15 +77,15 @@ func (h *Header) read(rb *bufio.Reader) error {
 				break
 			}
 		}
-		rb.UnreadByte()
+		br.UnreadByte()
 
-		byts, err = readBytesLimited(rb, '\r', headerMaxValueLength)
+		byts, err = readBytesLimited(br, '\r', headerMaxValueLength)
 		if err != nil {
 			return err
 		}
 		val := string(byts[:len(byts)-1])
 
-		err = readByteEqual(rb, '\n')
+		err = readByteEqual(br, '\n')
 		if err != nil {
 			return err
 		}

pkg/base/header_test.go

@@ -105,18 +105,18 @@ var cases = []struct {
 	},
 }
 
-func TestHeaderRead(t *testing.T) {
+func TestHeaderUnmarshal(t *testing.T) {
 	for _, ca := range cases {
 		t.Run(ca.name, func(t *testing.T) {
 			h := make(Header)
-			err := h.read(bufio.NewReader(bytes.NewBuffer(ca.dec)))
+			err := h.unmarshal(bufio.NewReader(bytes.NewBuffer(ca.dec)))
 			require.NoError(t, err)
 			require.Equal(t, ca.header, h)
 		})
 	}
 }
 
-func TestHeaderReadErrors(t *testing.T) {
+func TestHeaderUnmarshalErrors(t *testing.T) {
 	for _, ca := range []struct {
 		name string
 		dec  []byte
@@ -167,7 +167,7 @@ func TestHeaderReadErrors(t *testing.T) {
 	} {
 		t.Run(ca.name, func(t *testing.T) {
 			h := make(Header)
-			err := h.read(bufio.NewReader(bytes.NewBuffer(ca.dec)))
+			err := h.unmarshal(bufio.NewReader(bytes.NewBuffer(ca.dec)))
 			require.EqualError(t, err, ca.err)
 		})
 	}

pkg/base/interleaved_frame.go

@@ -21,8 +21,8 @@ type InterleavedFrame struct {
 	Payload []byte
 }
 
-// Read decodes an interleaved frame.
+// Unmarshal decodes an interleaved frame.
-func (f *InterleavedFrame) Read(br *bufio.Reader) error {
+func (f *InterleavedFrame) Unmarshal(br *bufio.Reader) error {
 	var header [4]byte
 	_, err := io.ReadFull(br, header[:])
 	if err != nil {

pkg/base/interleaved_frame_test.go

@@ -31,20 +31,20 @@ var casesInterleavedFrame = []struct {
 	},
 }
 
-func TestInterleavedFrameRead(t *testing.T) {
+func TestInterleavedFrameUnmarshal(t *testing.T) {
 	// keep f global to make sure that all its fields are overridden.
 	var f InterleavedFrame
 
 	for _, ca := range casesInterleavedFrame {
 		t.Run(ca.name, func(t *testing.T) {
-			err := f.Read(bufio.NewReader(bytes.NewBuffer(ca.enc)))
+			err := f.Unmarshal(bufio.NewReader(bytes.NewBuffer(ca.enc)))
 			require.NoError(t, err)
 			require.Equal(t, ca.dec, f)
 		})
 	}
 }
 
-func TestInterleavedFrameReadErrors(t *testing.T) {
+func TestInterleavedFrameUnmarshalErrors(t *testing.T) {
 	for _, ca := range []struct {
 		name string
 		byts []byte
@@ -68,7 +68,7 @@ func TestInterleavedFrameReadErrors(t *testing.T) {
 	} {
 		t.Run(ca.name, func(t *testing.T) {
 			var f InterleavedFrame
-			err := f.Read(bufio.NewReader(bytes.NewBuffer(ca.byts)))
+			err := f.Unmarshal(bufio.NewReader(bytes.NewBuffer(ca.byts)))
 			require.EqualError(t, err, ca.err)
 		})
 	}

pkg/base/request.go

@@ -48,9 +48,9 @@ type Request struct {
 	Body []byte
 }
 
-// Read reads a request.
+// Unmarshal reads a request.
-func (req *Request) Read(rb *bufio.Reader) error {
+func (req *Request) Unmarshal(br *bufio.Reader) error {
-	byts, err := readBytesLimited(rb, ' ', requestMaxMethodLength)
+	byts, err := readBytesLimited(br, ' ', requestMaxMethodLength)
 	if err != nil {
 		return err
 	}
@@ -60,7 +60,7 @@ func (req *Request) Read(rb *bufio.Reader) error {
 		return fmt.Errorf("empty method")
 	}
 
-	byts, err = readBytesLimited(rb, ' ', requestMaxURLLength)
+	byts, err = readBytesLimited(br, ' ', requestMaxURLLength)
 	if err != nil {
 		return err
 	}
@@ -72,7 +72,7 @@ func (req *Request) Read(rb *bufio.Reader) error {
 	}
 	req.URL = ur
 
-	byts, err = readBytesLimited(rb, '\r', requestMaxProtocolLength)
+	byts, err = readBytesLimited(br, '\r', requestMaxProtocolLength)
 	if err != nil {
 		return err
 	}
@@ -82,17 +82,17 @@ func (req *Request) Read(rb *bufio.Reader) error {
 		return fmt.Errorf("expected '%s', got %v", rtspProtocol10, proto)
 	}
 
-	err = readByteEqual(rb, '\n')
+	err = readByteEqual(br, '\n')
 	if err != nil {
 		return err
 	}
 
-	err = req.Header.read(rb)
+	err = req.Header.unmarshal(br)
 	if err != nil {
 		return err
 	}
 
-	err = (*body)(&req.Body).read(req.Header, rb)
+	err = (*body)(&req.Body).unmarshal(req.Header, br)
 	if err != nil {
 		return err
 	}

pkg/base/request_test.go

@@ -140,20 +140,20 @@ var casesRequest = []struct {
 	},
 }
 
-func TestRequestRead(t *testing.T) {
+func TestRequestUnmarshal(t *testing.T) {
 	// keep req global to make sure that all its fields are overridden.
 	var req Request
 
 	for _, ca := range casesRequest {
 		t.Run(ca.name, func(t *testing.T) {
-			err := req.Read(bufio.NewReader(bytes.NewBuffer(ca.byts)))
+			err := req.Unmarshal(bufio.NewReader(bytes.NewBuffer(ca.byts)))
 			require.NoError(t, err)
 			require.Equal(t, ca.req, req)
 		})
 	}
 }
 
-func TestRequestReadErrors(t *testing.T) {
+func TestRequestUnmarshalErrors(t *testing.T) {
 	for _, ca := range []struct {
 		name string
 		byts []byte
@@ -222,7 +222,7 @@ func TestRequestReadErrors(t *testing.T) {
 	} {
 		t.Run(ca.name, func(t *testing.T) {
 			var req Request
-			err := req.Read(bufio.NewReader(bytes.NewBuffer(ca.byts)))
+			err := req.Unmarshal(bufio.NewReader(bytes.NewBuffer(ca.byts)))
 			require.EqualError(t, err, ca.err)
 		})
 	}
@@ -246,7 +246,7 @@ func TestRequestString(t *testing.T) {
 		"testing")
 
 	var req Request
-	err := req.Read(bufio.NewReader(bytes.NewBuffer(byts)))
+	err := req.Unmarshal(bufio.NewReader(bytes.NewBuffer(byts)))
 	require.NoError(t, err)
 	require.Equal(t, string(byts), req.String())
 }

pkg/base/response.go

@@ -132,9 +132,9 @@ type Response struct {
 	Body []byte
 }
 
-// Read reads a response.
+// Unmarshal reads a response.
-func (res *Response) Read(rb *bufio.Reader) error {
+func (res *Response) Unmarshal(br *bufio.Reader) error {
-	byts, err := readBytesLimited(rb, ' ', 255)
+	byts, err := readBytesLimited(br, ' ', 255)
 	if err != nil {
 		return err
 	}
@@ -144,7 +144,7 @@ func (res *Response) Read(rb *bufio.Reader) error {
 		return fmt.Errorf("expected '%s', got %v", rtspProtocol10, proto)
 	}
 
-	byts, err = readBytesLimited(rb, ' ', 4)
+	byts, err = readBytesLimited(br, ' ', 4)
 	if err != nil {
 		return err
 	}
@@ -156,7 +156,7 @@ func (res *Response) Read(rb *bufio.Reader) error {
 	}
 	res.StatusCode = StatusCode(statusCode64)
 
-	byts, err = readBytesLimited(rb, '\r', 255)
+	byts, err = readBytesLimited(br, '\r', 255)
 	if err != nil {
 		return err
 	}
@@ -166,17 +166,17 @@ func (res *Response) Read(rb *bufio.Reader) error {
 		return fmt.Errorf("empty status message")
 	}
 
-	err = readByteEqual(rb, '\n')
+	err = readByteEqual(br, '\n')
 	if err != nil {
 		return err
 	}
 
-	err = res.Header.read(rb)
+	err = res.Header.unmarshal(br)
 	if err != nil {
 		return err
 	}
 
-	err = (*body)(&res.Body).read(res.Header, rb)
+	err = (*body)(&res.Body).unmarshal(res.Header, br)
 	if err != nil {
 		return err
 	}

pkg/base/response_test.go

@@ -92,20 +92,20 @@ var casesResponse = []struct {
 	},
 }
 
-func TestResponseRead(t *testing.T) {
+func TestResponseUnmarshal(t *testing.T) {
 	// keep res global to make sure that all its fields are overridden.
 	var res Response
 
 	for _, c := range casesResponse {
 		t.Run(c.name, func(t *testing.T) {
-			err := res.Read(bufio.NewReader(bytes.NewBuffer(c.byts)))
+			err := res.Unmarshal(bufio.NewReader(bytes.NewBuffer(c.byts)))
 			require.NoError(t, err)
 			require.Equal(t, c.res, res)
 		})
 	}
 }
 
-func TestResponseReadErrors(t *testing.T) {
+func TestResponseUnmarshalErrors(t *testing.T) {
 	for _, ca := range []struct {
 		name string
 		byts []byte
@@ -169,7 +169,7 @@ func TestResponseReadErrors(t *testing.T) {
 	} {
 		t.Run(ca.name, func(t *testing.T) {
 			var res Response
-			err := res.Read(bufio.NewReader(bytes.NewBuffer(ca.byts)))
+			err := res.Unmarshal(bufio.NewReader(bytes.NewBuffer(ca.byts)))
 			require.EqualError(t, err, ca.err)
 		})
 	}
@@ -220,7 +220,7 @@ func TestResponseString(t *testing.T) {
 		"testing")
 
 	var res Response
-	err := res.Read(bufio.NewReader(bytes.NewBuffer(byts)))
+	err := res.Unmarshal(bufio.NewReader(bytes.NewBuffer(byts)))
 	require.NoError(t, err)
 	require.Equal(t, string(byts), res.String())
 }

pkg/conn/conn.go

@@ -31,19 +31,19 @@ func NewConn(rw io.ReadWriter) *Conn {
 
 // ReadRequest reads a Request.
 func (c *Conn) ReadRequest() (*base.Request, error) {
-	err := c.req.Read(c.br)
+	err := c.req.Unmarshal(c.br)
 	return &c.req, err
 }
 
 // ReadResponse reads a Response.
 func (c *Conn) ReadResponse() (*base.Response, error) {
-	err := c.res.Read(c.br)
+	err := c.res.Unmarshal(c.br)
 	return &c.res, err
 }
 
 // ReadInterleavedFrame reads a InterleavedFrame.
 func (c *Conn) ReadInterleavedFrame() (*base.InterleavedFrame, error) {
-	err := c.fr.Read(c.br)
+	err := c.fr.Unmarshal(c.br)
 	return &c.fr, err
 }
 

pkg/media/medias_test.go

@@ -533,7 +533,7 @@ func TestMediasUnmarshal(t *testing.T) {
 	}
 }
 
-func TestMediasReadErrors(t *testing.T) {
+func TestMediasUnmarshalErrors(t *testing.T) {
 	for _, ca := range []struct {
 		name string
 		sdp  string