// Package pktline is git's framing: four hex digits of length, 0000 flush, 0001 delimiter.

package pktline

import (

"bufio"

"errors"

"fmt"

"io"

"strconv"

"strings"

)

const (

flush = "0000"

delim = "0001"

)

// ErrFlush is returned by Read when it reads a flush packet.

var ErrFlush = errors.New("flush")

// ErrDelim is returned by Read when it reads a delimiter packet.

var ErrDelim = errors.New("delim")

type Reader struct{ r *bufio.Reader }

func NewReader(r io.Reader) *Reader { return &Reader{bufio.NewReader(r)} }

// Read returns the next packet's payload, with any trailing newline removed.

func (p *Reader) Read() (string, error) {

var head [4]byte

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

return "", err

}

n, err := strconv.ParseUint(string(head[:]), 16, 32)

if err != nil {

return "", fmt.Errorf("malformed pkt-line length %q", head)

}

switch n {

case 0:

return "", ErrFlush

case 1:

return "", ErrDelim

}

if n < 4 {

return "", fmt.Errorf("impossible pkt-line length %d", n)

}

body := make([]byte, n-4)

if _, err := io.ReadFull(p.r, body); err != nil {

return "", err

}

return strings.TrimSuffix(string(body), "\n"), nil

}

type Writer struct{ w io.Writer }

func NewWriter(w io.Writer) *Writer { return &Writer{w} }

// Write sends one packet with a newline, which git expects for these text protocols.

func (p *Writer) Write(s string) error {

if len(s)+5 > 0xffff {

return errors.New("pkt-line too long")

}

_, err := fmt.Fprintf(p.w, "%04x%s\n", len(s)+5, s)

return err

}

// Flush sends a flush packet, which ends a section.

func (p *Writer) Flush() error {

_, err := io.WriteString(p.w, flush)

return err

}

// Delim sends a delimiter packet.

func (p *Writer) Delim() error {

_, err := io.WriteString(p.w, delim)

return err

}