poc wasifill

Signed-off-by: Jordan Rash <[email protected]>

Author: jordan-rash

cmd/core.wit cmd/simple/core.wit

@@ -52,6 +52,12 @@ func main() {
 					}
 					fmt.Println("\t", tC.Name.TokenLiteral(), tC.Value.TokenLiteral())
 
+				case "func":
+					tC, ok := c.(*ast.FuncShape)
+					if !ok {
+						// error
+					}
+					fmt.Println("\t", tC.TokenLiteral(), tC.Value.TokenLiteral())
 				case "use":
 					tC, ok := c.(*ast.UseShape)
 					if !ok {
@@ -94,7 +100,7 @@ func parseWit(done chan *ast.AST) {
 		panic(err)
 	}
 
-	fmt.Printf("Parsing the following file:\n\n```\n%s\n```\n\n", string(b))
+	fmt.Printf("Parsing the following file:\n\n```wit\n%s\n```\n\n", string(b))
 
 	p := parser.New(lexer.NewLexer(string(b)))
 	t := p.Parse()

cmd/main.go cmd/simple/main.go

@@ -0,0 +1,218 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"text/template"
+
+	"github.com/jordan-rash/go-wit/ast"
+	"github.com/jordan-rash/go-wit/lexer"
+	"github.com/jordan-rash/go-wit/parser"
+
+	_ "embed"
+)
+
+//go:embed "rpc.tmpl"
+var rpc string
+
+const witfile string = `package jordan-rash:[email protected]
+
+interface types {
+  type pong = string
+}
+
+interface pingpong {
+  use types.{pong}
+  ping: func() -> pong
+}
+
+world ping-pong {
+  export pingpong
+}
+`
+
+type wasifill struct {
+	PackageNamespace string
+	PackageContract  string
+	Version          string
+	Types            []wftype
+	Funcs            []wffunc
+	Exports          []wfexports
+}
+
+type wftype struct {
+	Interface string
+	Name      string
+	Type      string
+}
+
+type wffunc struct {
+	Interface string
+	Name      string
+	Input     string
+	Output    string
+}
+
+func (w wffunc) PubName() string {
+	return strings.Title(w.Name)
+}
+
+func (w wffunc) PubOutput() string {
+	return strings.Title(w.Output)
+}
+
+func (w wftype) PubName() string {
+	return strings.Title(w.Name)
+}
+
+func (w wfexports) PubName() string {
+	return strings.Title(w.Name)
+}
+
+func (w wasifill) PubName() string {
+	return strings.Title(w.PackageContract)
+}
+
+type wfexports struct {
+	Type string
+	Name string
+}
+
+func main() {
+	p := parser.New(lexer.NewLexer(witfile))
+	t := p.Parse()
+
+	if p.Errors() != nil {
+		fmt.Printf("parser errors: %s", p.Errors().Error())
+		return
+	}
+
+	wf := new(wasifill)
+
+	for _, s := range t.Shapes {
+		switch s.TokenLiteral() {
+		case "package":
+			tS, ok := s.(*ast.PackageShape)
+			if !ok {
+				fmt.Println("package error")
+				return
+			}
+
+			wf.PackageNamespace = strings.Split(tS.Value, ":")[0]
+			wf.PackageContract = strings.Split(tS.Value, ":")[1]
+			wf.Version = tS.Version
+		case "interface":
+			tS, ok := s.(*ast.InterfaceShape)
+			if !ok {
+				fmt.Println("interface error")
+				return
+			}
+			for _, c := range tS.Children {
+				switch c.TokenLiteral() {
+				case "type":
+					tC, ok := c.(*ast.TypeStatement)
+					if !ok {
+						fmt.Println("interface type error")
+						return
+					}
+
+					tT := wftype{
+						Interface: tS.Name.Value,
+						Name:      tC.Name.TokenLiteral(),
+						Type:      tC.Value.TokenLiteral(),
+					}
+
+					wf.Types = append(wf.Types, tT)
+				case "func":
+					tC, ok := c.(*ast.FuncShape)
+					if !ok {
+						fmt.Println("interface use error")
+						return
+					}
+
+					tF := wffunc{
+						Interface: tS.Name.Value,
+						Name:      tC.Name.TokenLiteral(),
+						Input:     "",
+						Output:    tC.Value.TokenLiteral(),
+					}
+
+					wf.Funcs = append(wf.Funcs, tF)
+				case "use":
+					_, ok := c.(*ast.UseShape)
+					if !ok {
+						fmt.Println("interface use error")
+						return
+					}
+					// fmt.Println("\t", tC.TokenLiteral(), tC.Value.TokenLiteral())
+				default:
+					fmt.Printf("interface child error: %T\n", c)
+					return
+				}
+			}
+
+		case "world":
+			tS, ok := s.(*ast.WorldShape)
+			if !ok {
+				fmt.Println("world error")
+				return
+			}
+			for _, c := range tS.Children {
+				switch c.TokenLiteral() {
+				case "export":
+					tC, ok := c.(*ast.ExportShape)
+					if !ok {
+						fmt.Println("interface use error")
+						return
+					}
+					tE := wfexports{
+						Type: "function",
+						Name: tC.Value.TokenLiteral(),
+					}
+					wf.Exports = append(wf.Exports, tE)
+				}
+			}
+
+		default:
+			fmt.Println("error: invalid root token")
+			return
+		}
+
+	}
+
+	err := generateFiles(wf)
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+}
+
+func generateFiles(wf *wasifill) error {
+	_, err := os.Stat("gen")
+	if os.IsNotExist(err) {
+		if err := os.Mkdir("gen", os.ModePerm); err != nil {
+			return err
+		}
+	} else if err != nil {
+		return err
+	}
+
+	tmpl, err := template.New("rpc.tmpl").Parse(rpc)
+	if err != nil {
+		panic(err)
+	}
+
+	f, err := os.Create("./gen/gen.go")
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	err = tmpl.Execute(f, wf)
+	if err != nil {
+		panic(err)
+	}
+
+	return nil
+}

cmd/pingpong.wit cmd/simple/pingpong.wit

@@ -0,0 +1,74 @@
+package {{ .PackageContract }}
+
+import (
+	actor "github.com/wasmCloud/actor-tinygo"
+	msgpack "github.com/wasmcloud/tinygo-msgpack"
+)
+
+{{ range .Types }}
+type {{ .PubName }} {{ .Type }}
+{{ end }}
+
+{{- range $e := .Exports }}
+  {{- if (eq $e.Type "function") }}
+    {{- range $f := $.Funcs -}}
+      {{- if (eq $f.Interface $e.Name) }}
+type {{ $e.Name }} interface { 
+  {{ $f.PubName }}(ctx *actor.Context{{ $f.Input }}) {{ $f.PubOutput }}
+}
+      {{- end -}}
+    {{- end -}}
+  {{- end -}}
+{{- end }}
+
+{{ range .Types }}
+func (o *{{ .PubName }}) MEncode(encoder msgpack.Writer) error {
+	encoder.WriteString(string(*o))
+	return encoder.CheckError()
+}
+
+func MDecode{{ .PubName }}(d *msgpack.Decoder) ({{ .PubName }}, error) {
+	val, err := d.ReadString()
+	if err != nil {
+		return "", err
+	}
+
+	return {{ .PubName }}(val), nil
+}
+{{ end }}
+
+{{ range $e := .Exports }}
+type {{$.PubName}}Sender struct { transport actor.Transport }
+type {{$.PubName}}Receiver struct {}
+
+func NewProvider{{$.PubName}}() *{{$.PubName}}Sender {
+	transport := actor.ToProvider("{{$.PackageNamespace}}:{{$.PackageContract}}", "default")
+	return &{{$.PubName}}Sender{transport: transport}
+}
+
+func {{$.PubName}}Handler(a {{ .Name }}) actor.Handler {
+	return actor.NewHandler("{{$.PubName}}", &{{$.PubName}}Receiver{}, a)
+}
+
+func (r *{{$.PubName}}Receiver) Dispatch(ctx *actor.Context, svc interface{}, message *actor.Message) (*actor.Message, error) {
+	switch message.Method {
+  {{- range $f := $.Funcs }}
+  {{- if eq $e.Name .Interface }}
+    case "{{.PubName}}":
+      {
+        var sizer msgpack.Sizer
+        size_enc := &sizer
+        size_enc.WriteString(string(message.Arg))
+        buf := make([]byte, sizer.Len())
+        encoder := msgpack.NewEncoder(buf)
+        enc := &encoder
+        enc.WriteString(string(message.Arg))
+        return &actor.Message{Method: "{{$.PubName}}.{{.PubName}}", Arg: buf}, nil
+      }
+    {{- end }}
+    {{- end }}
+    default:
+      return nil, actor.NewRpcError("MethodNotHandled", "{{$.PubName}}."+message.Method)
+    }
+}
+{{ end }}

cmd/wasifill/main.go

@@ -24,6 +24,7 @@ type Parser struct {
 	errors error
 }
 
+// TODO: change input to string and create lexer
 func New(l *lexer.Lexer) *Parser {
 	p := &Parser{lexer: l}
 

cmd/wasifill/rpc.tmpl

@@ -106,6 +106,14 @@ var (
 		{"package wasi:derp", "wasi:derp", ""},
 		{"package wasi:[email protected]", "wasi:derp", "0.1.0"},
 	}
+	funcTests = []struct {
+		Input              string
+		name               string
+		expectedReturnType string
+	}{
+		{"derp: func() -> string", "derp", token.KEYWORD_STRING},
+		{"derp: func() -> foo", "derp", token.IDENTIFIER},
+	}
 )
 
 func TestParsePingPong(t *testing.T) {
@@ -183,6 +191,21 @@ func TestNestedInterfaceShapes(t *testing.T) {
 		assert.NotNil(t, tree)
 		assert.Len(t, tree.Shapes, 1)
 	}
+
+	for _, tt := range funcTests {
+		sb := strings.Builder{}
+		err = tmpl.Execute(&sb, tt)
+		assert.NoError(t, err)
+
+		p := New(lexer.NewLexer(sb.String()))
+
+		tree := p.Parse()
+		assert.NotNil(t, tree)
+		assert.NoError(t, p.Errors())
+
+		assert.NotNil(t, tree)
+		assert.Len(t, tree.Shapes, 1)
+	}
 }
 
 func TestNestedWorldShapes(t *testing.T) {
@@ -342,3 +365,24 @@ func TestExportShape(t *testing.T) {
 		}
 	}
 }
+
+func TestFuncShape(t *testing.T) {
+	for i, tt := range funcTests {
+		p := Parser{lexer: lexer.NewLexer(tt.Input)}
+		p.nextToken()
+
+		for p.peekToken.Type != token.END_OF_FILE {
+			tempType := p.parseFuncLine()
+			assert.NoError(t, p.Errors())
+
+			assert.Equal(t, tt.name, tempType.Name.Value, i)
+			switch tT := tempType.Value.(type) {
+			case *ast.Identifier:
+				assert.Equal(t, tt.expectedReturnType, string(tT.Token.Type), i)
+			case *ast.Child:
+				assert.Equal(t, tt.expectedReturnType, string(tT.Token.Type), i)
+			}
+
+		}
+	}
+}