hatmill/internal/codegen/codegen.go

package main

import (
	"bytes"
    "encoding/json"
    "flag"
	"fmt"
	"go/format"
	"io/ioutil"
	"log"
	"strings"
)

const headerFmt = `// GENERATED BY gitlab.codemonkeysoftware.net/b/hatmill/internal/codegen
// DO NOT EDIT!

package %s

import "gitlab.codemonkeysoftware.net/b/hatmill"
`

func identifier(s string) string {
	words := strings.Split(s, "-")
	for i, word := range words {
		words[i] = strings.Title(word)
	}
	return strings.Join(words, "")
}

func fileHeader(packageName string) string {
    return fmt.Sprintf(headerFmt, packageName)
}

type AttribType int

const (
    String AttribType = iota
    Bool
)

func (t *AttribType) UnmarshalJSON(data []byte) error {
    if string(data) == "null" {
        return nil
    }

    var typeName string
    err := json.Unmarshal(data, &typeName)
    if err != nil {
        return fmt.Errorf("type property must be a string")
    }
    switch typeName {
    case "bool":
        *t = Bool
    case "string":
        *t = String
    default:
        return fmt.Errorf("unrecognized attribute type %s", typeName)
    }
    return nil
}

type AttribDef struct {
    Name string `json:"name"`
    Type AttribType `json:"type"`
}

func (def AttribDef) Generate() string {
    const (
		boolType   = "bool"
		stringType = "string"

		stringTemplate = `// %[1]s creates a "%[2]s" attribute
        func %[1]s(value string) hatmill.Attrib {
            return hatmill.Attrib{
                Key: "%[2]s",
                Value: value,
            }
        }
        `
		boolTemplate = `// %[1]s creates a "%[2]s" attribute
        func %[1]s() hatmill.Attrib {
            return hatmill.Attrib{
                Key: "%[2]s",
            }
        }
        `
	)

    var template string
    switch def.Type {
    case Bool:
        template = boolTemplate
    case String:
        template = stringTemplate
    default:
        panic(fmt.Errorf("unknown attribute type: %v", def.Type))
    }

    return fmt.Sprintf(template, identifier(def.Name), def.Name)
}

type ElemDef struct {
    Name string `json:"name"`
    Void bool `json:"void"`
}

func (def ElemDef) Generate() string {
    const (
        parentTemplate = `// %[1]s creates a <%[2]s> element.
        func %[1]s(attribs ...hatmill.Attrib) func(children ...hatmill.Term) hatmill.ParentElement {
            return func(children ...hatmill.Term) hatmill.ParentElement {
                return hatmill.ParentElement{
                    VoidElement: hatmill.VoidElement{
                        TagName: "%[2]s",
                        Attribs: attribs,
                    },
                    Children: children,
                }
            }
        }
        `
        voidTemplate = `// %[1]s creates a <%[2]s> element.
        func %[1]s(attribs ...hatmill.Attrib) hatmill.VoidElement {
            return hatmill.VoidElement{
                TagName: "%[2]s",
                Attribs: attribs,
            }
        }
        `
    )

    template := parentTemplate
    if def.Void {
        template = voidTemplate
    }
    return fmt.Sprintf(template, identifier(def.Name), def.Name)
}

type Defs struct {
    Attributes []AttribDef `json:"attributes"`
    Elements []ElemDef `json:"elements"`
}

func writeFormatted(fileName, packageName string, writeDefs func(*bytes.Buffer)) error {
	src := new(bytes.Buffer)
	src.WriteString(fileHeader(packageName))
	writeDefs(src)
	formatted, err := format.Source(src.Bytes())
	if err != nil {
		return err
	}
	return ioutil.WriteFile(fileName, formatted, 0644)
}

func main() {
    inputPath := flag.String("input", "", "JSON input file")
	elemPath := flag.String("elemfile", "", "generated element .go file")
	elemPkg := flag.String("elempkg", "", "generated element package name")
	attribPath := flag.String("attribfile", "", "generated attribute .go file")
	attribPkg := flag.String("attribpkg", "", "generated attribute package name")
    flag.Parse()

    input, err := ioutil.ReadFile(*inputPath)
    if err != nil {
        log.Fatal(err)
    }

    var defs Defs
    err = json.Unmarshal(input, &defs)
    if err != nil {
        log.Fatal(err)
    }

	err = writeFormatted(*attribPath, *attribPkg, func(buf *bytes.Buffer) {
		for _, attribDef := range defs.Attributes {
	        buf.WriteString(attribDef.Generate())
	    }
	})
	if err != nil {
		log.Fatal(err)
	}

	err = writeFormatted(*elemPath, *elemPkg, func(buf *bytes.Buffer) {
		for _, elemDef := range defs.Elements {
	        buf.WriteString(elemDef.Generate())
	    }
	})
	if err != nil {
		log.Fatal(err)
	}
}