Merge pull request #3 from mgnsk/dev

Rewrite with more test coverage

Author: mgnsk

README.md

@@ -0,0 +1,33 @@
+package ast_test
+
+import (
+	"testing"
+
+	"github.com/mgnsk/gong/internal/parser/lexer"
+	"github.com/mgnsk/gong/internal/parser/parser"
+)
+
+func parse(input string) (interface{}, error) {
+	lex := lexer.NewLexer([]byte(input))
+	p := parser.NewParser()
+	return p.Parse(lex)
+}
+
+func BenchmarkParser(b *testing.B) {
+	lex := lexer.NewLexer([]byte(
+		"[[[[[k*]/3].]$].8]))",
+	))
+	p := parser.NewParser()
+
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		lex.Reset()
+		p.Reset()
+		_, err := p.Parse(lex)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}

ast/ast_test.go

@@ -0,0 +1,35 @@
+package ast
+
+import (
+	"io"
+)
+
+// Bar is a bar.
+type Bar struct {
+	Name     string
+	DeclList NodeList
+}
+
+func (b Bar) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString(`bar "`)
+	n += ew.WriteString(b.Name)
+	n += ew.WriteString("\"\n")
+
+	for _, stmt := range b.DeclList {
+		n += ew.WriteString("\t")
+		n += ew.CopyFrom(stmt)
+		n += ew.WriteString("\n")
+	}
+
+	n += ew.WriteString("end")
+
+	return int64(n), ew.Flush()
+}
+
+// NewBar creates a new bar.
+func NewBar(name string, declList NodeList) Bar {
+	return Bar{Name: name, DeclList: declList}
+}

ast/bar.go

@@ -0,0 +1,76 @@
+package ast_test
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/mgnsk/gong/ast"
+	. "github.com/onsi/gomega"
+)
+
+func TestBar(t *testing.T) {
+	g := NewGomegaWithT(t)
+
+	input1 := `
+
+tempo 120
+timesig 1 4
+channel 1
+velocity 20
+program 1
+control 1 1
+assign c 60
+assign d 62
+bar "Bar 1"
+	start
+	c
+	stop
+end
+play "Bar 1"
+
+`
+
+	input2 := `
+tempo 120; timesig 1 4; channel 1; velocity 20;
+program 1; control 1 1
+assign c 60; assign d 62
+bar "Bar 1" start; c; stop; end
+play "Bar 1"
+`
+
+	res1, err := parse(input1)
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(res1).To(BeAssignableToTypeOf(ast.NodeList{}))
+
+	var buf1 bytes.Buffer
+	res1.(ast.NodeList).WriteTo(&buf1)
+
+	g.Expect(buf1.String()).To(Equal(strings.Trim(input1, " \n")))
+
+	res2, err := parse(input2)
+	g.Expect(err).NotTo(HaveOccurred())
+	g.Expect(res2).To(BeAssignableToTypeOf(ast.NodeList{}))
+	g.Expect(res2).To(Equal(res1))
+
+	var buf2 bytes.Buffer
+	res2.(ast.NodeList).WriteTo(&buf2)
+	g.Expect(buf2.String()).To(Equal(strings.Trim(input1, " \n")))
+}
+
+func TestCommandsForbiddenInBar(t *testing.T) {
+	for _, input := range []string{
+		"assign c 60",
+		`bar "Inner" start end`,
+		`play "test"`,
+	} {
+		t.Run(input, func(t *testing.T) {
+			g := NewGomegaWithT(t)
+
+			_, err := parse(fmt.Sprintf(`bar "Outer" %s; end`, input))
+			g.Expect(err).To(HaveOccurred())
+			g.Expect(err.Error()).To(ContainSubstring(`got:`))
+		})
+	}
+}

ast/bar_test.go

@@ -1,9 +1,10 @@
 package ast
 
 import (
+	"io"
 	"math"
 
-	"github.com/mgnsk/gong/internal/constants"
+	"github.com/mgnsk/gong/constants"
 	"github.com/mgnsk/gong/internal/parser/token"
 )
 
@@ -13,6 +14,22 @@ type CmdAssign struct {
 	Key  uint8
 }
 
+func (c CmdAssign) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString("assign ")
+	n += ew.WriteRune(c.Note)
+	n += ew.WriteString(" ")
+	n += ew.WriteInt(int(c.Key))
+
+	return int64(n), ew.Flush()
+}
+
+// func (c CmdAssign) String() string {
+// 	return fmt.Sprintf("assign %c %d", c.Note, c.Key)
+// }
+
 // NewCmdAssign creates a note assignment command.
 func NewCmdAssign(note, key *token.Token) (CmdAssign, error) {
 	v, err := key.Int32Value()
@@ -31,6 +48,20 @@ func NewCmdAssign(note, key *token.Token) (CmdAssign, error) {
 // CmdTempo is a tempo command.
 type CmdTempo uint16
 
+func (c CmdTempo) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString("tempo ")
+	n += ew.WriteInt(int(c))
+
+	return int64(n), ew.Flush()
+}
+
+// func (c CmdTempo) String() string {
+// 	return fmt.Sprintf("tempo %d", c)
+// }
+
 // NewCmdTempo creates a tempo command.
 func NewCmdTempo(bpm *token.Token) (CmdTempo, error) {
 	v, err := bpm.Int32Value()
@@ -45,17 +76,33 @@ func NewCmdTempo(bpm *token.Token) (CmdTempo, error) {
 
 // CmdTimeSig is a time signature change command.
 type CmdTimeSig struct {
-	Beats uint8
-	Value uint8
+	Num   uint8
+	Denom uint8
+}
+
+func (c CmdTimeSig) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString("timesig ")
+	n += ew.WriteInt(int(c.Num))
+	n += ew.WriteString(" ")
+	n += ew.WriteInt(int(c.Denom))
+
+	return int64(n), ew.Flush()
 }
 
+// func (c CmdTimeSig) String() string {
+// 	return fmt.Sprintf("timesig %d %d", c.Num, c.Denom)
+// }
+
 // NewCmdTimeSig creates a time signature change command.
-func NewCmdTimeSig(beats, value *token.Token) (CmdTimeSig, error) {
-	b, err := beats.Int32Value()
+func NewCmdTimeSig(num, denom *token.Token) (CmdTimeSig, error) {
+	b, err := num.Int32Value()
 	if err != nil {
 		return CmdTimeSig{}, err
 	}
-	v, err := value.Int32Value()
+	v, err := denom.Int32Value()
 	if err != nil {
 		return CmdTimeSig{}, err
 	}
@@ -66,14 +113,28 @@ func NewCmdTimeSig(beats, value *token.Token) (CmdTimeSig, error) {
 		return CmdTimeSig{}, err
 	}
 	return CmdTimeSig{
-		Beats: uint8(b),
-		Value: uint8(v),
+		Num:   uint8(b),
+		Denom: uint8(v),
 	}, nil
 }
 
 // CmdChannel is a channel change command.
 type CmdChannel uint8
 
+func (c CmdChannel) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString("channel ")
+	n += ew.WriteInt(int(c))
+
+	return int64(n), ew.Flush()
+}
+
+// func (c CmdChannel) String() string {
+// 	return fmt.Sprintf("channel %d", c)
+// }
+
 // NewCmdChannel creates a channel change command.
 func NewCmdChannel(value *token.Token) (CmdChannel, error) {
 	v, err := value.Int32Value()
@@ -89,6 +150,20 @@ func NewCmdChannel(value *token.Token) (CmdChannel, error) {
 // CmdVelocity is a velocity change command.
 type CmdVelocity uint8
 
+func (c CmdVelocity) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString("velocity ")
+	n += ew.WriteInt(int(c))
+
+	return int64(n), ew.Flush()
+}
+
+// func (c CmdVelocity) String() string {
+// 	return fmt.Sprintf("velocity %d", c)
+// }
+
 // NewCmdVelocity creates a velocity change command.
 func NewCmdVelocity(value *token.Token) (CmdVelocity, error) {
 	v, err := value.Int32Value()
@@ -104,6 +179,20 @@ func NewCmdVelocity(value *token.Token) (CmdVelocity, error) {
 // CmdProgram is a program change command.
 type CmdProgram uint8
 
+func (c CmdProgram) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString("program ")
+	n += ew.WriteInt(int(c))
+
+	return int64(n), ew.Flush()
+}
+
+// func (c CmdProgram) String() string {
+// 	return fmt.Sprintf("program %d", c)
+// }
+
 // NewCmdProgram creates a program change command.
 func NewCmdProgram(value *token.Token) (CmdProgram, error) {
 	v, err := value.Int32Value()
@@ -122,6 +211,22 @@ type CmdControl struct {
 	Parameter uint8
 }
 
+func (c CmdControl) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString("control ")
+	n += ew.WriteInt(int(c.Control))
+	n += ew.WriteString(" ")
+	n += ew.WriteInt(int(c.Parameter))
+
+	return int64(n), ew.Flush()
+}
+
+// func (c CmdControl) String() string {
+// 	return fmt.Sprintf("control %d %d", c.Control, c.Parameter)
+// }
+
 // NewCmdControl creates a control change command.
 func NewCmdControl(control, value *token.Token) (CmdControl, error) {
 	c, err := control.Int32Value()
@@ -144,17 +249,52 @@ func NewCmdControl(control, value *token.Token) (CmdControl, error) {
 	}, nil
 }
 
-// CmdBar is a bar begin command.
-type CmdBar string
-
-// CmdEnd is a bar end command.
-type CmdEnd struct{}
-
 // CmdPlay is a bar play command.
 type CmdPlay string
 
+func (c CmdPlay) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString("play \"")
+	n += ew.WriteString(string(c))
+	n += ew.WriteString("\"")
+
+	return int64(n), ew.Flush()
+}
+
+// func (c CmdPlay) String() string {
+// 	return fmt.Sprintf(`play "%s"`, string(c))
+// }
+
 // CmdStart is a start commad.
 type CmdStart struct{}
 
+func (c CmdStart) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString("start")
+
+	return int64(n), ew.Flush()
+}
+
+// func (c CmdStart) String() string {
+// 	return "start"
+// }
+
 // CmdStop is a stop command.
 type CmdStop struct{}
+
+func (c CmdStop) WriteTo(w io.Writer) (int64, error) {
+	ew := newErrWriter(w)
+	var n int
+
+	n += ew.WriteString("stop")
+
+	return int64(n), ew.Flush()
+}
+
+// func (c CmdStop) String() string {
+// 	return "stop"
+// }