From 6f729650cc49fb5519cadf68569d0b2cf67eccbc Mon Sep 17 00:00:00 2001
From: n0m1s <git@homnomnom.fr>
Date: Tue, 23 Jul 2019 17:43:21 +0200
Subject: [PATCH] =?UTF-8?q?=E2=9C=A8=20variable-group=20parser?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 jdr/sheet.go | 98 +++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 94 insertions(+), 4 deletions(-)

diff --git a/jdr/sheet.go b/jdr/sheet.go
index aad44ef..835ed98 100644
--- a/jdr/sheet.go
+++ b/jdr/sheet.go
@@ -70,11 +70,22 @@ func (n *xmlNode) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
     return d.DecodeElement((*node)(n), &start)
 }
 
-func parseVariable(root xmlNode, sheet *CharacterSheet) (*Variable, error) {
+func parseVariable(root xmlNode, sheet *CharacterSheet, defaults *Variable) (*Variable, error) {
     ret := &Variable{}
 
     typeOk := false
     nameOk := false
+
+    if defaults != nil {
+        switch defaults.Type.(type) {
+        case *VariableType_badType:
+            typeOk = false
+        default:
+            typeOk = true
+            ret.Type = defaults.Type
+        }
+    }
+
     for i := 0; i < len(root.Attrs); i++ {
         attrName := root.Attrs[i].Name.Local
         attrVal  := root.Attrs[i].Value
@@ -128,12 +139,91 @@ func parseBlock(root xmlNode, sheet *CharacterSheet) (*Block, error) {
     return ret, nil
 }
 
-func parseItem(root xmlNode, sheet *CharacterSheet) (SheetItem, error) {
+func parseVariableGroup(root xmlNode, sheet *CharacterSheet, defaults *Variable) ([]*Variable, error) {
+    ret := []*Variable{}
+
+    typeOk := false
+    if defaults == nil {
+        defaults = &Variable{}
+    } else {
+        typeOk = true
+    }
+
+    for i := 0; i < len(root.Attrs); i++ {
+        attrName := root.Attrs[i].Name.Local
+        attrVal  := root.Attrs[i].Value
+
+        switch attrName {
+        case "default-type":
+            t, err := sheet.getType(attrVal)
+            if err != nil {
+                return nil, err
+            }
+            defaults.Type = t
+            typeOk = true
+        }
+    }
+
+    if !typeOk {
+        defaults.Type = &VariableType_badType{}
+    }
+
+    for i := 0; i < len(root.Nodes); i++ {
+        node := root.Nodes[i]
+
+        switch node.XMLName.Local {
+        case "variable":
+            item, err := parseVariable(node, sheet, defaults)
+            if err != nil {
+                return nil, err
+            }
+
+            ret = append(ret, item)
+        case "variable-group":
+            items, err := parseVariableGroup(node, sheet, defaults)
+            if err != nil {
+                return nil, err
+            }
+
+            for j := 0; j < len(items); j++ {
+                ret = append(ret, items[j])
+            }
+
+        default:
+            return nil, errors.New("Unknown variable-group item: \"" + node.XMLName.Local + "\"")
+        }
+    }
+
+    return ret, nil
+}
+
+func parseItem(root xmlNode, sheet *CharacterSheet) ([]SheetItem, error) {
     switch root.XMLName.Local {
     case "block":
-        return parseBlock(root, sheet)
+        block, err := parseBlock(root, sheet)
+        if err != nil {
+            return nil, err
+        }
+
+        return []SheetItem{block}, nil
     case "variable":
-        return parseVariable(root, sheet)
+        variable, err := parseVariable(root, sheet, nil)
+        if err != nil {
+            return nil, err
+        }
+
+        return []SheetItem{variable}, err
+    case "variable-group":
+        variables, err := parseVariableGroup(root, sheet, nil)
+        if err != nil {
+            return nil, err
+        }
+
+        items := make([]SheetItem, len(variables))
+        for i, v := range variables {
+            items[i] = SheetItem(v)
+        }
+        return items, nil
     default:
         return nil, errors.New("Unknown item: " + root.XMLName.Local)
     }