build-sys: use local asciigoat.org/core [DO-NOT-MERGE]

Signed-off-by: Alejandro Mery <amery@jpi.io>

README.md

@@ -1,57 +0,0 @@
-# asciigoat's INI parser
-
-[![Go Reference][godoc-badge]][godoc]
-[![Go Report Card][goreport-badge]][goreport]
-
-`asciigoat.org/ini` is a simple Go library that very loosly parses
-[`INI`-style][wikipedia-dosini] documents allowing the implementation
-of stricter parsers of similar form.
-
-**asciigoat** is [MIT](https://opensource.org/license/mit/) licensed.
-
-[godoc]: https://pkg.go.dev/asciigoat.org/ini
-[godoc-badge]: https://pkg.go.dev/badge/asciigoat.org/ini.svg
-[goreport]: https://goreportcard.com/report/asciigoat.org/ini
-[goreport-badge]: https://goreportcard.com/badge/asciigoat.org/ini
-
-[godoc-lexer]: https://pkg.go.dev/asciigoat.org/core/lexer
-[godoc-parser-parser]: https://pkg.go.dev/asciigoat.org/ini/parser#Parser
-[godoc-basic-parser]: https://pkg.go.dev/asciigoat.org/ini/basic#Decode
-
-[wikipedia-dosini]: https://en.wikipedia.org/wiki/INI_file
-
-## Parser
-
-[`parser.Parser`][godoc-parser-parser] uses
-[`asciigoat`'s lexer][godoc-lexer] to process an `INI`-style document
-emiting tokens and errors via callbacks.
-
-## Basic Parser
-
-[`basic.Decode()`][godoc-basic-parser] provies a one-shot decoder
-that returns a structured document for you to post-process.
-
-To allow for correct handling of repetition of section and field names downstream,
-it uses arrays instead of maps, and makes almost no judgment
-about what section or field names are acceptable.
-
-## Other Implementations
-
-Other implementations exist, and they are mature and feature-rich, but they
-are highly opinionated about what's a valid file. Built around maps they don't
-allow repeating names and constraint what characters can be used.
-
-These are great when you can adapt, or already agree, to their conditions but
-that's not always the case when you are parsing configuration files from
-other applications and that's what [asciigoat.org/ini][godoc] attempts to solve.
-
-* [gcfg](https://pkg.go.dev/gopkg.in/gcfg.v1)
-* [unknwon's go-ini](https://github.com/go-ini/ini)
-* [wlevene's GoINI](https://github.com/wlevene/ini)
-
-## See also
-
-* [asciigoat.org/core](https://asciigoat.org/core)
-* [oss.jpi.io](https://oss.jpi.io)
-* [INI file][wikipedia-dosini] (_wikipedia_)
-* [TOML](https://www.kelche.co/blog/go/toml/)

basic/basic.go

@@ -1,24 +0,0 @@
-// Package basic provides a basic representation of dosini-style documents
-package basic
-
-// Document represents an INI-style document
-type Document struct {
-	Global []Field
-
-	Sections []Section
-}
-
-// Section represents an INI-style section with optional GIT-style IDs
-type Section struct {
-	Key     string
-	ID      string
-	EmptyID bool
-
-	Fields []Field
-}
-
-// Field represents a key = value entry in an INI-style document
-type Field struct {
-	Key   string
-	Value string
-}

basic/decoder.go

@@ -1,49 +0,0 @@
-package basic
-
-import (
-	"bytes"
-	"io"
-	"io/fs"
-	"strings"
-
-	"asciigoat.org/ini/parser"
-)
-
-type decoder struct {
-	p   *parser.Parser
-	out *Document
-
-	queue   []*token
-	current *Section
-}
-
-// Decode attempts to decode an INI-style from an [io.Reader] array into a [Document]
-func Decode(r io.Reader) (*Document, error) {
-	var out Document
-
-	if r == nil {
-		return nil, fs.ErrNotExist
-	}
-
-	// parser
-	p := parser.NewParser(r)
-	// decoder
-	dec := decoder{p: p, out: &out}
-	// glue
-	p.OnToken = dec.OnToken
-	p.OnError = dec.OnError
-
-	// Go!
-	err := p.Run()
-	return &out, err
-}
-
-// DecodeBytes attempts to decode an INI-style bytes array into a [Document]
-func DecodeBytes(b []byte) (*Document, error) {
-	return Decode(bytes.NewReader(b))
-}
-
-// DecodeString attempts to decode an INI-style string into a [Document]
-func DecodeString(s string) (*Document, error) {
-	return Decode(strings.NewReader(s))
-}

basic/error.go

@@ -1,33 +0,0 @@
-package basic
-
-import (
-	"errors"
-
-	"asciigoat.org/core/lexer"
-)
-
-var (
-	errInvalidToken = errors.New("invalid token")
-)
-
-func newErrInvalidToken(t *token) *lexer.Error {
-	err := &lexer.Error{
-		Line:    t.pos.Line,
-		Column:  t.pos.Column,
-		Content: t.value,
-		Err:     errInvalidToken,
-	}
-	return err
-}
-
-func (dec *decoder) OnError(pos lexer.Position, content string, err error) error {
-	err = &lexer.Error{
-		Line:    pos.Line,
-		Column:  pos.Column,
-		Content: content,
-		Err:     err,
-	}
-
-	dec.executeFinal()
-	return err
-}

basic/token.go

@@ -1,154 +0,0 @@
-package basic
-
-import (
-	"fmt"
-
-	"asciigoat.org/core/lexer"
-	"asciigoat.org/ini/parser"
-)
-
-type token struct {
-	pos   lexer.Position
-	typ   parser.TokenType
-	value string
-}
-
-func (t token) String() string {
-	return fmt.Sprintf("%s %s: %q", t.pos, t.typ, t.value)
-}
-
-func (dec *decoder) executeFinal() {
-	if len(dec.queue) > 0 {
-		// we have unfinished businesses
-		switch dec.queue[0].typ {
-		case parser.TokenSectionStart:
-			dec.execute(parser.TokenSectionEnd)
-		case parser.TokenFieldKey:
-			dec.execute(parser.TokenFieldValue)
-		}
-	}
-}
-
-func (dec *decoder) execute(typ parser.TokenType) {
-	switch typ {
-	case parser.TokenSectionEnd:
-		name1, ok1 := dec.getValue(1, parser.TokenSectionName)
-
-		if ok1 {
-			name2, ok2 := dec.getValue(2, parser.TokenSectionSubname)
-
-			dec.addSection(name1, name2, ok2)
-		}
-
-		dec.reset()
-	case parser.TokenFieldValue:
-		key, _ := dec.getValue(0, parser.TokenFieldKey)
-		value, _ := dec.getValue(1, parser.TokenFieldValue)
-
-		dec.addField(key, value)
-		dec.reset()
-	}
-}
-
-func (dec *decoder) addSection(key, id string, allowEmptyID bool) {
-	emptyID := allowEmptyID && id == ""
-
-	// index for dec.current
-	n := len(dec.out.Sections)
-
-	// new section
-	dec.out.Sections = append(dec.out.Sections, Section{
-		Key:     key,
-		ID:      id,
-		EmptyID: emptyID,
-	})
-
-	// pointer to the latest section
-	dec.current = &dec.out.Sections[n]
-}
-
-func (dec *decoder) addField(key, value string) {
-	field := Field{
-		Key:   key,
-		Value: value,
-	}
-
-	if p := dec.current; p != nil {
-		// in section
-		p.Fields = append(p.Fields, field)
-	} else {
-		// global
-		dec.out.Global = append(dec.out.Global, field)
-	}
-}
-
-func (dec *decoder) getValue(idx int, typ parser.TokenType) (string, bool) {
-	switch {
-	case idx < 0 || idx >= len(dec.queue):
-		// out of range
-		return "", false
-	case dec.queue[idx].typ != typ:
-		// wrong type
-		return "", false
-	default:
-		return dec.queue[idx].value, true
-	}
-}
-
-func (dec *decoder) reset() {
-	dec.queue = dec.queue[:0]
-}
-
-func (dec *decoder) depth(depth int) bool {
-	return len(dec.queue) == depth
-}
-
-func (dec *decoder) depthAfter(depth int, typ parser.TokenType) bool {
-	_, ok := dec.getValue(depth-1, typ)
-	if ok {
-		return len(dec.queue) == depth
-	}
-	return false
-}
-
-func (dec *decoder) typeOK(typ parser.TokenType) bool {
-	switch typ {
-	case parser.TokenSectionStart, parser.TokenFieldKey:
-		// first token only
-		return dec.depth(0)
-	case parser.TokenSectionName:
-		// right after TokenSectionStart
-		return dec.depthAfter(1, parser.TokenSectionStart)
-	case parser.TokenSectionSubname:
-		// right after TokenSectionName
-		return dec.depthAfter(2, parser.TokenSectionName)
-	case parser.TokenSectionEnd:
-		// only on a section with name
-		_, ok := dec.getValue(1, parser.TokenSectionName)
-		return ok
-	case parser.TokenFieldValue:
-		// right after a TokenFieldKey
-		return dec.depthAfter(1, parser.TokenFieldKey)
-	default:
-		// never
-		return false
-	}
-}
-
-func (dec *decoder) OnToken(pos lexer.Position, typ parser.TokenType, value string) error {
-	t := &token{pos, typ, value}
-
-	switch {
-	case typ == parser.TokenComment:
-		// ignore comments
-		return nil
-	case dec.typeOK(typ):
-		// acceptable token
-		dec.queue = append(dec.queue, t)
-		dec.execute(typ)
-		return nil
-	default:
-		// unacceptable
-		return newErrInvalidToken(t)
-	}
-}

basic/write.go

@@ -1,104 +0,0 @@
-package basic
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-
-	"asciigoat.org/ini/parser"
-)
-
-// WriteNewLine is the new line representation used by [doc.WriteTo]
-const WriteNewLine = "\n"
-
-// AsBuffer returns a INI representation of the document on
-// a memory buffer
-func (doc *Document) AsBuffer(nl string) *bytes.Buffer {
-	var buf bytes.Buffer
-
-	if len(doc.Global) > 0 {
-		_, _ = writeFieldsTo(&buf, doc.Global, nl)
-	}
-
-	for _, sec := range doc.Sections {
-		if buf.Len() > 0 {
-			_, _ = buf.WriteString(nl)
-		}
-
-		_ = writeSectionToBuffer(&buf, &sec, nl)
-	}
-
-	return &buf
-}
-
-func writeFieldsTo(w io.Writer, fields []Field, nl string) (int64, error) {
-	var written int
-	for _, field := range fields {
-		n, err := fmt.Fprintf(w, "%s = %q%s", field.Key, field.Value, nl)
-		switch {
-		case err != nil:
-			return int64(written), err
-		case n > 0:
-			written += n
-		}
-	}
-	return int64(written), nil
-}
-
-// String generates a string output for "%s"
-func (field Field) String() string {
-	var buf bytes.Buffer
-
-	_, _ = writeFieldsTo(&buf, []Field{field}, WriteNewLine)
-	return buf.String()
-}
-
-func writeSectionToBuffer(w *bytes.Buffer, sec *Section, nl string) int {
-	var written, n int
-
-	_, _ = w.WriteRune(parser.RuneSectionStart)
-	written++
-
-	n, _ = w.WriteString(sec.Key)
-	written += n
-
-	switch {
-	case sec.EmptyID:
-		n, _ = w.WriteString(" \"\"")
-		written += n
-	case sec.ID != "":
-		_, _ = w.WriteRune(' ')
-		n, _ = fmt.Fprintf(w, "%q", sec.ID)
-		written += n + 1
-	}
-
-	_, _ = w.WriteRune(parser.RuneSectionEnd)
-	written++
-
-	n, _ = w.WriteString(nl)
-	written += n
-
-	n64, _ := writeFieldsTo(w, sec.Fields, nl)
-	return written + int(n64)
-}
-
-// String generates a string output for "%s"
-func (sec *Section) String() string {
-	var buf bytes.Buffer
-
-	_ = writeSectionToBuffer(&buf, sec, WriteNewLine)
-	return buf.String()
-}
-
-// WriteTo writes a INI representation of the document
-// onto the provided writer.
-func (doc *Document) WriteTo(w io.Writer) (int64, error) {
-	buf := doc.AsBuffer(WriteNewLine)
-	return buf.WriteTo(w)
-}
-
-// String generates a string output for "%s"
-func (doc *Document) String() string {
-	buf := doc.AsBuffer(WriteNewLine)
-	return buf.String()
-}

go.mod

@@ -2,8 +2,10 @@ module asciigoat.org/ini
 
 go 1.19
 
+replace asciigoat.org/core => ../core
+
 require (
-	asciigoat.org/core v0.3.7
+	asciigoat.org/core v0.3.6
 	github.com/mgechev/revive v1.3.3
 	golang.org/x/tools v0.12.0
 )

go.sum

@@ -1,5 +1,3 @@
-asciigoat.org/core v0.3.7 h1:tMasdvZgsMJJMVsZVfXXB5lqq82pFiCsyEmOEmcmAfI=
-asciigoat.org/core v0.3.7/go.mod h1:tXj+JUutxRbcO40ZQRuUVaZ4rnYz1kAZ0nblisV8u74=
 github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
 github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/chavacava/garif v0.0.0-20230608123814-4bd63c2919ab h1:5JxePczlyGAtj6R1MUEFZ/UFud6FfsOejq7xLC2ZIb0=

parser/lexer.go

@@ -15,30 +15,21 @@ func (p *Parser) lexStart() (lexer.StateFn, error) {
 		r, _, err := p.src.ReadRune()
 		switch {
 		case err != nil:
-			return p.emitError("", err)
+			err = p.emitError("", err)
+			return nil, err
 		case IsNewLine(r):
-			// new line
-			p.lexMoreNewLine(r)
+			p.lexNewLine(r)
 			p.stepLine()
 		case IsSpace(r):
-			// whitespace
 			p.stepRune()
-		case IsCommentStart(r):
-			// switch to comment lexer
-			p.src.UnreadRune()
-			return p.lexComment, nil
-		case IsSectionStart(r):
-			// section
-			return p.lexSectionStart, nil
 		default:
-			// entry
 			p.src.UnreadRune()
-			return p.lexEntryStart, nil
+			return p.lexToken, nil
 		}
 	}
 }
 
-func (p *Parser) lexMoreNewLine(r1 rune) {
+func (p *Parser) lexNewLine(r1 rune) {
 	// r1 is warrantied to be either '\r' or '\n'
 	r2, _, err := p.src.ReadRune()
 	switch r1 {
@@ -67,78 +58,9 @@ func (p *Parser) lexMoreNewLine(r1 rune) {
 	}
 }
 
-func (p *Parser) lexComment() (lexer.StateFn, error) {
-	// until the end of the line
-	p.src.AcceptAll(IsNotNewLine)
-
-	err := p.emitString(TokenComment)
-	return p.lexStart, err
-}
-
-func (p *Parser) lexSectionStart() (lexer.StateFn, error) {
-	if err := p.emitString(TokenSectionStart); err != nil {
-		return nil, err
-	}
-
-	// remove whitespace between `[` and the name
-	if p.src.AcceptAll(IsSpaceNotNewLine) {
-		p.stepString()
-	}
-
-	if !p.src.AcceptAll(IsName) {
-		// no name
-		return p.emitError("section name missing", lexer.ErrUnacceptableRune)
-	}
-
-	if err := p.emitString(TokenSectionName); err != nil {
-		return nil, err
-	}
-
-	// remove whitespace between the name andthe closing `]`
-	if p.src.AcceptAll(IsSpaceNotNewLine) {
-		p.stepString()
-	}
-
-	r, _, err := p.src.ReadRune()
-	switch {
-	case err != nil:
-		return p.emitError("", err)
-	case IsSectionEnd(r):
-		err := p.emitString(TokenSectionEnd)
-		return p.lexStart, err
-	default:
-		return p.emitInvalidRune(r)
-	}
-}
-
-func (p *Parser) lexEntryStart() (lexer.StateFn, error) {
-	p.src.AcceptAll(IsName)
-	if err := p.emitString(TokenFieldKey); err != nil {
-		return nil, err
-	}
-
-	// ignore whitespace between key and the '=' sign
-	if p.src.AcceptAll(IsSpaceNotNewLine) {
-		p.stepString()
-	}
-
-	r, _, err := p.src.ReadRune()
-	switch {
-	case err != nil:
-		return p.emitError("", err)
-	case r != RuneFieldEqual:
-		return p.emitInvalidRune(r)
-	}
-
-	// ignore whitespace between the '=' and the value
-	if p.src.AcceptAll(IsSpaceNotNewLine) {
-		p.stepString()
-	}
-
-	p.src.AcceptAll(IsNotNewLine)
-	if err := p.emitString(TokenFieldValue); err != nil {
-		return nil, err
-	}
+func (p *Parser) lexToken() (lexer.StateFn, error) {
+	p.src.AcceptAll(IsNotSpace)
 
+	err := p.emitString(TokenUnknown)
 	return p.lexStart, err
 }

parser/lexer_runes.go

@@ -1,35 +1,9 @@
 package parser
 
 import (
-	"strings"
-
 	"asciigoat.org/core/lexer"
 )
 
-const (
-	RuneComment      = ';' // RuneComment is the standard dosini comment character
-	RuneCommentExtra = '#' // RuneCommentExtra is UNIX shell's comment character
-	RuneSectionStart = '[' // RuneSectionStart indicates the start of a section declaration
-	RuneSectionEnd   = ']' // RuneSectionEnd indiciates the end of a section declaration
-	RuneFieldEqual   = '=' // RuneFieldEqual separates field keys from their values
-)
-
-var (
-	// RunesComment is a string containing all runes acceptable to start comments
-	RunesComment = string([]rune{
-		RuneComment,
-		RuneCommentExtra,
-	})
-	// RunesSpecial is a string containing all the runes with special meaning
-	RunesSpecial = string([]rune{
-		RuneComment,
-		RuneCommentExtra,
-		RuneSectionStart,
-		RuneSectionEnd,
-		RuneFieldEqual,
-	})
-)
-
 var (
 	// IsNewLine tells if the rune indicates a line break or the start of one
 	IsNewLine = lexer.NewIsIn("\r\n")
@@ -39,29 +13,4 @@ var (
 	IsSpace = lexer.IsSpace
 	// IsNotSpace tells if the rune is not considered whitespace by Unicode
 	IsNotSpace = lexer.NewIsNot(IsSpace)
-	// IsCommentStart ...
-	IsCommentStart = lexer.NewIsIn(RunesComment)
 )
-
-// IsSpaceNotNewLine indicates a rune is whitespace but not a new line
-func IsSpaceNotNewLine(r rune) bool {
-	return IsSpace(r) && !IsNewLine(r)
-}
-
-// IsSectionStart indicates the rune starts the section declaration
-func IsSectionStart(r rune) bool { return r == RuneSectionStart }
-
-// IsSectionEnd indicates the rune ends the section declaration
-func IsSectionEnd(r rune) bool { return r == RuneSectionEnd }
-
-// IsName indicates a rune is acceptable for section or field names
-func IsName(r rune) bool {
-	switch {
-	case IsSpace(r):
-		return false
-	case strings.ContainsRune(RunesSpecial, r):
-		return false
-	default:
-		return true
-	}
-}

parser/parser.go

@@ -51,29 +51,27 @@ func (p *Parser) setDefaults() {
 }
 
 func (p *Parser) emitString(typ TokenType) error {
+	var err error
+
 	s := p.src.Emit()
-	err := p.OnToken(p.pos, typ, s)
+	err = p.OnToken(p.pos, typ, s)
 	p.pos.StepN(len(s))
 
 	return err
 }
 
-func (p *Parser) emitError(content string, err error) (lexer.StateFn, error) {
+func (p *Parser) emitError(content string, err error) error {
 	err2 := p.OnError(p.pos, content, err)
 	switch {
 	case err2 != nil:
 		// return wrapped error
-		return nil, err2
+		return err2
 	default:
 		// return original error
-		return nil, err
+		return err
 	}
 }
 
-func (p *Parser) emitInvalidRune(r rune) (lexer.StateFn, error) {
-	return p.emitError(string([]rune{r}), lexer.ErrUnacceptableRune)
-}
-
 // stepLine discards the data and moves the position
 // to the next line.
 func (p *Parser) stepLine() {