puma-plus-core 0.1.0

data/go/vendor/github.com/dunglas/httpsfv/item.go

@@ -0,0 +1,73 @@
+package httpsfv
+
+import (
+	"strings"
+)
+
+// Item is a bare value and associated parameters.
+// See https://httpwg.org/specs/rfc9651.html#item.
+type Item struct {
+	Value  interface{}
+	Params *Params
+}
+
+// NewItem returns a new Item.
+func NewItem(v interface{}) Item {
+	assertBareItem(v)
+
+	return Item{v, NewParams()}
+}
+
+func (i Item) member() {
+}
+
+// marshalSFV serializes as defined in
+// https://httpwg.org/specs/rfc9651.html#ser-item.
+func (i Item) marshalSFV(b *strings.Builder) error {
+	if i.Value == nil {
+		return ErrInvalidBareItem
+	}
+
+	if err := marshalBareItem(b, i.Value); err != nil {
+		return err
+	}
+
+	return i.Params.marshalSFV(b)
+}
+
+// UnmarshalItem parses an item as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-item.
+func UnmarshalItem(v []string) (Item, error) {
+	s := &scanner{
+		data: strings.Join(v, ","),
+	}
+
+	s.scanWhileSp()
+
+	sfv, err := parseItem(s)
+	if err != nil {
+		return Item{}, err
+	}
+
+	s.scanWhileSp()
+
+	if !s.eof() {
+		return Item{}, &UnmarshalError{off: s.off}
+	}
+
+	return sfv, nil
+}
+
+func parseItem(s *scanner) (Item, error) {
+	bi, err := parseBareItem(s)
+	if err != nil {
+		return Item{}, err
+	}
+
+	p, err := parseParams(s)
+	if err != nil {
+		return Item{}, err
+	}
+
+	return Item{bi, p}, nil
+}

data/go/vendor/github.com/dunglas/httpsfv/key.go

@@ -0,0 +1,81 @@
+package httpsfv
+
+import (
+	"errors"
+	"fmt"
+	"io"
+)
+
+// ErrInvalidKeyFormat is returned when the format of a parameter or dictionary key is invalid.
+var ErrInvalidKeyFormat = errors.New("invalid key format")
+
+// isKeyChar checks if c is a valid key characters.
+func isKeyChar(c byte) bool {
+	if isLowerCaseAlpha(c) || isDigit(c) {
+		return true
+	}
+
+	switch c {
+	case '_', '-', '.', '*':
+		return true
+	}
+
+	return false
+}
+
+// checkKey checks if the given value is a valid parameter key according to
+// https://httpwg.org/specs/rfc9651.html#param.
+func checkKey(k string) error {
+	if len(k) == 0 {
+		return fmt.Errorf("a key cannot be empty: %w", ErrInvalidKeyFormat)
+	}
+
+	if !isLowerCaseAlpha(k[0]) && k[0] != '*' {
+		return fmt.Errorf("a key must start with a lower case alpha character or *: %w", ErrInvalidKeyFormat)
+	}
+
+	for i := 1; i < len(k); i++ {
+		if !isKeyChar(k[i]) {
+			return fmt.Errorf("the character %c isn't allowed in a key: %w", k[i], ErrInvalidKeyFormat)
+		}
+	}
+
+	return nil
+}
+
+// marshalKey serializes as defined in
+// https://httpwg.org/specs/rfc9651.html#ser-key.
+func marshalKey(b io.StringWriter, k string) error {
+	if err := checkKey(k); err != nil {
+		return err
+	}
+
+	_, err := b.WriteString(k)
+
+	return err
+}
+
+// parseKey parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-key.
+func parseKey(s *scanner) (string, error) {
+	if s.eof() {
+		return "", &UnmarshalError{s.off, ErrInvalidKeyFormat}
+	}
+
+	c := s.data[s.off]
+	if !isLowerCaseAlpha(c) && c != '*' {
+		return "", &UnmarshalError{s.off, ErrInvalidKeyFormat}
+	}
+
+	start := s.off
+	s.off++
+
+	for !s.eof() {
+		if !isKeyChar(s.data[s.off]) {
+			break
+		}
+		s.off++
+	}
+
+	return s.data[start:s.off], nil
+}

data/go/vendor/github.com/dunglas/httpsfv/list.go

@@ -0,0 +1,99 @@
+package httpsfv
+
+import (
+	"errors"
+	"strings"
+)
+
+// ErrInvalidListFormat is returned when the format of a list is invalid.
+var ErrInvalidListFormat = errors.New("invalid list format")
+
+// List contains items an inner lists.
+//
+// See https://httpwg.org/specs/rfc9651.html#list
+type List []Member
+
+// marshalSFV serializes as defined in
+// https://httpwg.org/specs/rfc9651.html#ser-list.
+func (l List) marshalSFV(b *strings.Builder) error {
+	s := len(l)
+	for i := 0; i < s; i++ {
+		if err := l[i].marshalSFV(b); err != nil {
+			return err
+		}
+
+		if i != s-1 {
+			if _, err := b.WriteString(", "); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+// UnmarshalList parses a list as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-list.
+func UnmarshalList(v []string) (List, error) {
+	s := &scanner{
+		data: strings.Join(v, ","),
+	}
+
+	s.scanWhileSp()
+
+	sfv, err := parseList(s)
+	if err != nil {
+		return List{}, err
+	}
+
+	return sfv, nil
+}
+
+// parseList parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-list.
+func parseList(s *scanner) (List, error) {
+	var l List
+
+	for !s.eof() {
+		m, err := parseItemOrInnerList(s)
+		if err != nil {
+			return nil, err
+		}
+
+		l = append(l, m)
+
+		s.scanWhileOWS()
+
+		if s.eof() {
+			return l, nil
+		}
+
+		if s.data[s.off] != ',' {
+			return nil, &UnmarshalError{s.off, ErrInvalidListFormat}
+		}
+		s.off++
+
+		s.scanWhileOWS()
+
+		if s.eof() {
+			// there is a trailing comma
+			return nil, &UnmarshalError{s.off, ErrInvalidListFormat}
+		}
+	}
+
+	return l, nil
+}
+
+// parseItemOrInnerList parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-item-or-list.
+func parseItemOrInnerList(s *scanner) (Member, error) {
+	if s.eof() {
+		return nil, &UnmarshalError{s.off, ErrInvalidInnerListFormat}
+	}
+
+	if s.data[s.off] == '(' {
+		return parseInnerList(s)
+	}
+
+	return parseItem(s)
+}

data/go/vendor/github.com/dunglas/httpsfv/member.go

@@ -0,0 +1,9 @@
+package httpsfv
+
+// Member is a marker interface for members of dictionaries and lists.
+//
+// See https://httpwg.org/specs/rfc9651.html#list.
+type Member interface {
+	member()
+	marshaler
+}

data/go/vendor/github.com/dunglas/httpsfv/params.go

@@ -0,0 +1,143 @@
+package httpsfv
+
+import (
+	"errors"
+	"strings"
+)
+
+// Params are an ordered map of key-value pairs that are associated with an item or an inner list.
+//
+// See https://httpwg.org/specs/rfc9651.html#param.
+type Params struct {
+	names  []string
+	values map[string]interface{}
+}
+
+// ErrInvalidParameterFormat is returned when the format of a parameter is invalid.
+var ErrInvalidParameterFormat = errors.New("invalid parameter format")
+
+// ErrInvalidParameterValue is returned when a parameter key is invalid.
+var ErrInvalidParameterValue = errors.New("invalid parameter value")
+
+// ErrMissingParameters is returned when the Params structure is missing from the element.
+var ErrMissingParameters = errors.New("missing parameters")
+
+// NewParams creates a new ordered map.
+func NewParams() *Params {
+	p := Params{}
+	p.names = []string{}
+	p.values = map[string]interface{}{}
+
+	return &p
+}
+
+// Get retrieves a parameter.
+func (p *Params) Get(k string) (interface{}, bool) {
+	v, ok := p.values[k]
+
+	return v, ok
+}
+
+// Add appends a new parameter to the ordered list.
+// If the key already exists, overwrite its value.
+func (p *Params) Add(k string, v interface{}) {
+	assertBareItem(v)
+
+	if _, exists := p.values[k]; !exists {
+		p.names = append(p.names, k)
+	}
+
+	p.values[k] = v
+}
+
+// Del removes a parameter from the ordered list.
+func (p *Params) Del(key string) bool {
+	if _, ok := p.values[key]; !ok {
+		return false
+	}
+
+	for i, k := range p.names {
+		if k == key {
+			p.names = append(p.names[:i], p.names[i+1:]...)
+
+			break
+		}
+	}
+
+	delete(p.values, key)
+
+	return true
+}
+
+// Names retrieves the list of parameter names in the appropriate order.
+func (p *Params) Names() []string {
+	return p.names
+}
+
+// marshalSFV serializes as defined in
+// https://httpwg.org/specs/rfc9651.html#ser-params.
+func (p *Params) marshalSFV(b *strings.Builder) error {
+	if p == nil {
+		return ErrMissingParameters
+	}
+	for _, k := range p.names {
+		if err := b.WriteByte(';'); err != nil {
+			return err
+		}
+
+		if err := marshalKey(b, k); err != nil {
+			return err
+		}
+
+		v := p.values[k]
+		if v == true {
+			continue
+		}
+
+		if err := b.WriteByte('='); err != nil {
+			return err
+		}
+
+		if err := marshalBareItem(b, v); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// parseParams parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-param.
+func parseParams(s *scanner) (*Params, error) {
+	p := NewParams()
+
+	for !s.eof() {
+		if s.data[s.off] != ';' {
+			break
+		}
+		s.off++
+		s.scanWhileSp()
+
+		k, err := parseKey(s)
+		if err != nil {
+			return nil, err
+		}
+
+		var i interface{}
+
+		if !s.eof() && s.data[s.off] == '=' {
+			s.off++
+
+			i, err = parseBareItem(s)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			i = true
+		}
+
+		p.Add(k, i)
+	}
+
+	return p, nil
+}

data/go/vendor/github.com/dunglas/httpsfv/string.go

@@ -0,0 +1,88 @@
+package httpsfv
+
+import (
+	"errors"
+	"strings"
+	"unicode"
+)
+
+// ErrInvalidStringFormat is returned when a string format is invalid.
+var ErrInvalidStringFormat = errors.New("invalid string format")
+
+// marshalString serializes as defined in
+// https://httpwg.org/specs/rfc9651.html#ser-string.
+func marshalString(b *strings.Builder, s string) error {
+	if err := b.WriteByte('"'); err != nil {
+		return err
+	}
+
+	for i := 0; i < len(s); i++ {
+		if s[i] <= '\u001F' || s[i] >= unicode.MaxASCII {
+			return ErrInvalidStringFormat
+		}
+
+		switch s[i] {
+		case '"', '\\':
+			if err := b.WriteByte('\\'); err != nil {
+				return err
+			}
+		}
+
+		if err := b.WriteByte(s[i]); err != nil {
+			return err
+		}
+	}
+
+	if err := b.WriteByte('"'); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// parseString parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-string.
+func parseString(s *scanner) (string, error) {
+	if s.eof() || s.data[s.off] != '"' {
+		return "", &UnmarshalError{s.off, ErrInvalidStringFormat}
+	}
+	s.off++
+
+	var b strings.Builder
+
+	for !s.eof() {
+		c := s.data[s.off]
+		s.off++
+
+		switch c {
+		case '\\':
+			if s.eof() {
+				return "", &UnmarshalError{s.off, ErrInvalidStringFormat}
+			}
+
+			n := s.data[s.off]
+			if n != '"' && n != '\\' {
+				return "", &UnmarshalError{s.off, ErrInvalidStringFormat}
+			}
+			s.off++
+
+			if err := b.WriteByte(n); err != nil {
+				return "", err
+			}
+
+			continue
+		case '"':
+			return b.String(), nil
+		default:
+			if c <= '\u001F' || c >= unicode.MaxASCII {
+				return "", &UnmarshalError{s.off, ErrInvalidStringFormat}
+			}
+
+			if err := b.WriteByte(c); err != nil {
+				return "", err
+			}
+		}
+	}
+
+	return "", &UnmarshalError{s.off, ErrInvalidStringFormat}
+}

data/go/vendor/github.com/dunglas/httpsfv/token.go

@@ -0,0 +1,71 @@
+package httpsfv
+
+import (
+	"errors"
+	"fmt"
+	"io"
+)
+
+// isExtendedTchar checks if c is a valid token character as defined in the spec.
+func isExtendedTchar(c byte) bool {
+	if isAlpha(c) || isDigit(c) {
+		return true
+	}
+
+	switch c {
+	case '!', '#', '$', '%', '&', '\'', '*', '+', '-', '.', '^', '_', '`', '|', '~', ':', '/':
+		return true
+	}
+
+	return false
+}
+
+// ErrInvalidTokenFormat is returned when a token format is invalid.
+var ErrInvalidTokenFormat = errors.New("invalid token format")
+
+// Token represents a token as defined in
+// https://httpwg.org/specs/rfc9651.html#token.
+// A specific type is used to distinguish tokens from strings.
+type Token string
+
+// marshalSFV serializes as defined in
+// https://httpwg.org/specs/rfc9651.html#ser-token.
+func (t Token) marshalSFV(b io.StringWriter) error {
+	if len(t) == 0 {
+		return fmt.Errorf("a token cannot be empty: %w", ErrInvalidTokenFormat)
+	}
+
+	if !isAlpha(t[0]) && t[0] != '*' {
+		return fmt.Errorf("a token must start with an alpha character or *: %w", ErrInvalidTokenFormat)
+	}
+
+	for i := 1; i < len(t); i++ {
+		if !isExtendedTchar(t[i]) {
+			return fmt.Errorf("the character %c isn't allowed in a token: %w", t[i], ErrInvalidTokenFormat)
+		}
+	}
+
+	_, err := b.WriteString(string(t))
+
+	return err
+}
+
+// parseToken parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-token.
+func parseToken(s *scanner) (Token, error) {
+	if s.eof() || (!isAlpha(s.data[s.off]) && s.data[s.off] != '*') {
+		return "", &UnmarshalError{s.off, ErrInvalidTokenFormat}
+	}
+
+	start := s.off
+	s.off++
+
+	for !s.eof() {
+		if !isExtendedTchar(s.data[s.off]) {
+			break
+		}
+		s.off++
+	}
+
+	return Token(s.data[start:s.off]), nil
+}

data/go/vendor/github.com/dunglas/httpsfv/utils.go

@@ -0,0 +1,16 @@
+package httpsfv
+
+// isLowerCaseAlpha checks if c is a lower cased alpha character.
+func isLowerCaseAlpha(c byte) bool {
+	return 'a' <= c && c <= 'z'
+}
+
+// isAlpha checks if c is an alpha character.
+func isAlpha(c byte) bool {
+	return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')
+}
+
+// isDigit checks if c is a digit.
+func isDigit(c byte) bool {
+	return '0' <= c && c <= '9'
+}

data/go/vendor/github.com/quic-go/qpack/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2019 Marten Seemann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/go/vendor/github.com/quic-go/qpack/README.md

@@ -0,0 +1,21 @@
+# QPACK
+
+[![PkgGoDev](https://pkg.go.dev/badge/github.com/quic-go/qpack)](https://pkg.go.dev/github.com/quic-go/qpack)
+[![Code Coverage](https://img.shields.io/codecov/c/github/quic-go/qpack/master.svg?style=flat-square)](https://codecov.io/gh/quic-go/qpack)
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/quic-go.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:quic-go)
+
+This is a minimal QPACK ([RFC 9204](https://datatracker.ietf.org/doc/html/rfc9204)) implementation in Go. It reuses the Huffman encoder / decoder code from the [HPACK implementation in the Go standard library](https://github.com/golang/net/tree/master/http2/hpack).
+
+It is fully interoperable with other QPACK implementations (both encoders and decoders). However, it does not support the dynamic table and relies solely on the static table and string literals (including Huffman encoding), which limits compression efficiency. If you're interested in dynamic table support, please comment on [issue #33](https://github.com/quic-go/qpack/issues/33).
+
+## Running the Interop Tests
+
+Install the [QPACK interop files](https://github.com/qpackers/qifs/) by running
+```bash
+git submodule update --init --recursive
+```
+
+Then run the tests:
+```bash
+go test -v ./interop
+```