⚗ HTML character sheet generation (first test)

jdr/sheet.go

@@ -1,19 +1,31 @@
 package jdr
 
 import (
-    //"html/template"
+    "html/template"
     "encoding/xml"
 
     "errors"
     "os"
+    "log"
 )
 
 type Page struct {
     Items []SheetItem
 }
 
+func (self *Page) ToHTML() template.HTML {
+    ret := ""
+
+    for _, item := range(self.Items) {
+        ret += string(item.ToHTML())
+    }
+
+    return template.HTML(ret)
+}
+
 type SheetItem interface {
     Name() string
+    ToHTML() template.HTML
 }
 
 type Block struct {
@@ -25,6 +37,24 @@ func (self *Block) Name() string {
     return self.name
 }
 
+func (self *Block) ToHTML() template.HTML {
+    begin  := `<fieldset>`
+    legend := `<legend>` + template.HTMLEscapeString(self.Name()) + `</legend>`
+    end    := `</fieldset>`
+
+    ret := template.HTML(begin)
+    if self.Name() != "" {
+        ret += template.HTML(legend)
+    }
+
+    for _, item := range(self.Items) {
+        ret += item.ToHTML()
+    }
+    ret += template.HTML(end)
+
+    return ret
+}
+
 type Variable struct {
     Type VariableType
     name string
@@ -34,11 +64,35 @@ func (self *Variable) Name() string {
     return self.name
 }
 
+func (self *Variable) ToHTML() template.HTML {
+    label := ""
+    if self.name != "" {
+        label = `<label>` + template.HTMLEscapeString(self.name) + `</label>`
+    }
+
+    html, err := self.Type.ToHTML(self.Type.DefaultValue())
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    return template.HTML(label) + html
+}
+
 type CharacterSheet struct {
     types map[string]VariableType
     Pages []*Page
 }
 
+func (self *CharacterSheet) Render() template.HTML {
+    ret := template.HTML("")
+
+    for _, page := range(self.Pages) {
+        ret += page.ToHTML()
+    }
+
+    return ret
+}
+
 func (self *CharacterSheet) AddType(t VariableType) {
     if self.types == nil {
         self.types = make(map[string]VariableType)

jdr/type.go

@@ -1,6 +1,8 @@
 package jdr
 
 import(
+    "html/template"
+
     "log"
     "errors"
     "strings"
@@ -13,6 +15,7 @@ var regexp_d = regexp.MustCompile(`^[1-9][0-9]*d([468]|1[02]|20|100)$`)
 type VariableType interface {
     Name() string
     Validate(value string) bool
+    ToHTML(value string) (template.HTML, error)
     DefaultValue() string
 }
 
@@ -26,6 +29,10 @@ func (*VariableType_badType) Validate(s string) bool {
     return false
 }
 
+func (*VariableType_badType) ToHTML(value string) (template.HTML, error) {
+    return template.HTML(""), errors.New("unknown type")
+}
+
 func (*VariableType_badType) DefaultValue() string {
     return ""
 }
@@ -52,6 +59,21 @@ func (self *VariableType_bool) Validate(value string) bool {
     return err == nil
 }
 
+func (self *VariableType_bool) ToHTML(value string) (template.HTML, error) {
+    val, err := self.ToBool(value)
+    if err != nil {
+        return template.HTML(""), err
+    }
+
+    ret := `<input type="checkbox"`
+    if(val) {
+        ret += ` checked`
+    }
+    ret += `/>`
+
+    return template.HTML(ret), nil
+}
+
 func (self *VariableType_bool) DefaultValue() string {
     return "false"
 }
@@ -71,6 +93,16 @@ func (self *VariableType_int) Validate(value string) bool {
     return err == nil
 }
 
+func (self *VariableType_int) ToHTML(value string) (template.HTML, error) {
+    val, err := self.ToInt(value)
+    if err != nil {
+        return template.HTML(""), err
+    }
+
+    ret := `<input type="number" step="1" value="` + strconv.FormatInt(val, 10) + `"/>`
+    return template.HTML(ret), nil
+}
+
 func (self *VariableType_int) DefaultValue() string {
     return "0"
 }
@@ -90,6 +122,17 @@ func (self *VariableType_float) Validate(value string) bool {
     return err == nil
 }
 
+func (self *VariableType_float) ToHTML(value string) (template.HTML, error) {
+    val, err := self.ToFloat(value)
+    if err != nil {
+        return template.HTML(""), err
+    }
+
+    ret := `<input type="number" value="` + strconv.FormatFloat(val, 'g', -1, 64) + `"/>`
+
+    return template.HTML(ret), nil
+}
+
 func (self *VariableType_float) DefaultValue() string {
     return "0.0"
 }
@@ -104,6 +147,11 @@ func (*VariableType_string) Validate(s string) bool {
     return true
 }
 
+func (self *VariableType_string) ToHTML(value string) (template.HTML, error) {
+    ret := `<input type="text" value="` + template.HTMLEscapeString(value) + `"/>`
+    return template.HTML(ret), nil
+}
+
 func (self *VariableType_string) DefaultValue() string {
     return ""
 }
@@ -118,6 +166,13 @@ func (*VariableType_d) Validate(s string) bool {
     return regexp_d.MatchString(s)
 }
 
+func (self *VariableType_d) ToHTML(value string) (template.HTML, error) {
+    //FIXME: non-generic version
+    ret := `<input type="text" value="` + template.HTMLEscapeString(value) +`"/>`
+
+    return template.HTML(ret), nil
+}
+
 func (self *VariableType_d) DefaultValue() string {
     //FIXME: non-generic version
     return ""
@@ -170,6 +225,33 @@ func (self *CustomEnum) Validate(value string) bool {
     return err == nil
 }
 
+func (self *CustomEnum) ToHTML(value string) (template.HTML, error) {
+    selectItem := value != ""
+
+    value_id := 0
+    if selectItem {
+        var err error
+        value_id, err = self.ToId(value)
+        if err != nil {
+            return template.HTML(""), err
+        }
+    }
+
+    ret := `<select>`
+    for i, v := range(self.Values) {
+        ret += `<option`
+        if selectItem && i == value_id {
+            ret += ` selected`
+        }
+        ret += `>`
+        ret += template.HTMLEscapeString(v)
+        ret += `</option>`
+    }
+    ret += `</select>`
+
+    return template.HTML(ret), nil
+}
+
 func (self *CustomEnum) DefaultValue() string {
     return ""
 }
@@ -189,6 +271,11 @@ func (self *CustomStruct) Validate(s string) bool {
     return false
 }
 
+func (self *CustomStruct) ToHTML(value string) (template.HTML, error) {
+    //FIXME: implement
+    return template.HTML(""), nil
+}
+
 func (self *CustomStruct) DefaultValue() string {
     //FIXME: non-generic version
     return ""

main.go

@@ -36,9 +36,10 @@ func main() {
     log.Fatal(http.ListenAndServe(":8080", r))
     */
 
-    _, err := jdr.ReadCharacterSheet("jdr-desc/wasteland.xml")
+    sheet, err := jdr.ReadCharacterSheet("jdr-desc/wasteland.xml")
     if err != nil {
         log.Fatal("error: ", err)
     }
+    log.Println(sheet.Render())
     //log.Println(sheet.CustomTypes.Enums[0].Name)
 }