129 lines
3.6 KiB
Go
129 lines
3.6 KiB
Go
// Copyright 2022 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package foreachref
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
)
|
|
|
|
// Parser parses 'git for-each-ref' output according to a given output Format.
|
|
type Parser struct {
|
|
// tokenizes 'git for-each-ref' output into "reference paragraphs".
|
|
scanner *bufio.Scanner
|
|
|
|
// format represents the '--format' string that describes the expected
|
|
// 'git for-each-ref' output structure.
|
|
format Format
|
|
|
|
// err holds the last encountered error during parsing.
|
|
err error
|
|
}
|
|
|
|
// NewParser creates a 'git for-each-ref' output parser that will parse all
|
|
// references in the provided Reader. The references in the output are assumed
|
|
// to follow the specified Format.
|
|
func NewParser(r io.Reader, format Format) *Parser {
|
|
scanner := bufio.NewScanner(r)
|
|
|
|
// in addition to the reference delimiter we specified in the --format,
|
|
// `git for-each-ref` will always add a newline after every reference.
|
|
refDelim := make([]byte, 0, len(format.refDelim)+1)
|
|
refDelim = append(refDelim, format.refDelim...)
|
|
refDelim = append(refDelim, '\n')
|
|
|
|
// Split input into delimiter-separated "reference blocks".
|
|
scanner.Split(
|
|
func(data []byte, atEOF bool) (advance int, token []byte, err error) {
|
|
// Scan until delimiter, marking end of reference.
|
|
delimIdx := bytes.Index(data, refDelim)
|
|
if delimIdx >= 0 {
|
|
token := data[:delimIdx]
|
|
advance := delimIdx + len(refDelim)
|
|
return advance, token, nil
|
|
}
|
|
// If we're at EOF, we have a final, non-terminated reference. Return it.
|
|
if atEOF {
|
|
return len(data), data, nil
|
|
}
|
|
// Not yet a full field. Request more data.
|
|
return 0, nil, nil
|
|
})
|
|
|
|
return &Parser{
|
|
scanner: scanner,
|
|
format: format,
|
|
err: nil,
|
|
}
|
|
}
|
|
|
|
// Next returns the next reference as a collection of key-value pairs. nil
|
|
// denotes EOF but is also returned on errors. The Err method should always be
|
|
// consulted after Next returning nil.
|
|
//
|
|
// It could, for example return something like:
|
|
//
|
|
// { "objecttype": "tag", "refname:short": "v1.16.4", "object": "f460b7543ed500e49c133c2cd85c8c55ee9dbe27" }
|
|
func (p *Parser) Next() map[string]string {
|
|
if !p.scanner.Scan() {
|
|
return nil
|
|
}
|
|
fields, err := p.parseRef(p.scanner.Text())
|
|
if err != nil {
|
|
p.err = err
|
|
return nil
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Err returns the latest encountered parsing error.
|
|
func (p *Parser) Err() error {
|
|
return p.err
|
|
}
|
|
|
|
// parseRef parses out all key-value pairs from a single reference block, such as
|
|
//
|
|
// "objecttype tag\0refname:short v1.16.4\0object f460b7543ed500e49c133c2cd85c8c55ee9dbe27"
|
|
func (p *Parser) parseRef(refBlock string) (map[string]string, error) {
|
|
if refBlock == "" {
|
|
// must be at EOF
|
|
return nil, nil
|
|
}
|
|
|
|
fieldValues := make(map[string]string)
|
|
|
|
fields := strings.Split(refBlock, p.format.fieldDelimStr)
|
|
if len(fields) != len(p.format.fieldNames) {
|
|
return nil, fmt.Errorf("unexpected number of reference fields: wanted %d, was %d",
|
|
len(fields), len(p.format.fieldNames))
|
|
}
|
|
for i, field := range fields {
|
|
field = strings.TrimSpace(field)
|
|
|
|
var fieldKey string
|
|
var fieldVal string
|
|
firstSpace := strings.Index(field, " ")
|
|
if firstSpace > 0 {
|
|
fieldKey = field[:firstSpace]
|
|
fieldVal = field[firstSpace+1:]
|
|
} else {
|
|
// could be the case if the requested field had no value
|
|
fieldKey = field
|
|
}
|
|
|
|
// enforce the format order of fields
|
|
if p.format.fieldNames[i] != fieldKey {
|
|
return nil, fmt.Errorf("unexpected field name at position %d: wanted: '%s', was: '%s'",
|
|
i, p.format.fieldNames[i], fieldKey)
|
|
}
|
|
|
|
fieldValues[fieldKey] = fieldVal
|
|
}
|
|
|
|
return fieldValues, nil
|
|
}
|