339 lines
7.8 KiB
Go
339 lines
7.8 KiB
Go
package builder
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"sort"
|
|
"strings"
|
|
|
|
"github.com/marte-community/marte-dev-tools/internal/index"
|
|
"github.com/marte-community/marte-dev-tools/internal/parser"
|
|
)
|
|
|
|
type Builder struct {
|
|
Files []string
|
|
Overrides map[string]string
|
|
variables map[string]parser.Value
|
|
}
|
|
|
|
func NewBuilder(files []string, overrides map[string]string) *Builder {
|
|
return &Builder{Files: files, Overrides: overrides, variables: make(map[string]parser.Value)}
|
|
}
|
|
|
|
func (b *Builder) Build(f *os.File) error {
|
|
// Build the Project Tree
|
|
tree := index.NewProjectTree()
|
|
|
|
var expectedProject string
|
|
var projectSet bool
|
|
|
|
for _, file := range b.Files {
|
|
content, err := os.ReadFile(file)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
p := parser.NewParser(string(content))
|
|
config, err := p.Parse()
|
|
if err != nil {
|
|
return fmt.Errorf("error parsing %s: %v", file, err)
|
|
}
|
|
|
|
// Check Namespace/Project Consistency
|
|
proj := ""
|
|
if config.Package != nil {
|
|
parts := strings.Split(config.Package.URI, ".")
|
|
if len(parts) > 0 {
|
|
proj = strings.TrimSpace(parts[0])
|
|
}
|
|
}
|
|
|
|
if !projectSet {
|
|
expectedProject = proj
|
|
projectSet = true
|
|
} else if proj != expectedProject {
|
|
return fmt.Errorf("multiple namespaces defined in sources: found '%s' and '%s'", expectedProject, proj)
|
|
}
|
|
|
|
tree.AddFile(file, config)
|
|
}
|
|
|
|
b.collectVariables(tree)
|
|
|
|
if expectedProject == "" {
|
|
for _, iso := range tree.IsolatedFiles {
|
|
tree.Root.Fragments = append(tree.Root.Fragments, iso.Fragments...)
|
|
for name, child := range iso.Children {
|
|
if existing, ok := tree.Root.Children[name]; ok {
|
|
b.mergeNodes(existing, child)
|
|
} else {
|
|
tree.Root.Children[name] = child
|
|
child.Parent = tree.Root
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Determine root node to print
|
|
rootNode := tree.Root
|
|
if expectedProject != "" {
|
|
if child, ok := tree.Root.Children[expectedProject]; ok {
|
|
rootNode = child
|
|
}
|
|
}
|
|
|
|
// Write entire root content (definitions and children) to the single output file
|
|
b.writeNodeBody(f, rootNode, 0)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (b *Builder) writeNodeContent(f *os.File, node *index.ProjectNode, indent int) {
|
|
indentStr := strings.Repeat(" ", indent)
|
|
|
|
// If this node has a RealName (e.g. +App), we print it as an object definition
|
|
if node.RealName != "" {
|
|
fmt.Fprintf(f, "%s%s = {\n", indentStr, node.RealName)
|
|
indent++
|
|
}
|
|
|
|
b.writeNodeBody(f, node, indent)
|
|
|
|
if node.RealName != "" {
|
|
indent--
|
|
indentStr = strings.Repeat(" ", indent)
|
|
fmt.Fprintf(f, "%s}\n", indentStr)
|
|
}
|
|
}
|
|
|
|
func (b *Builder) writeNodeBody(f *os.File, node *index.ProjectNode, indent int) {
|
|
// 1. Sort Fragments: Class first
|
|
sort.SliceStable(node.Fragments, func(i, j int) bool {
|
|
return hasClass(node.Fragments[i]) && !hasClass(node.Fragments[j])
|
|
})
|
|
|
|
writtenChildren := make(map[string]bool)
|
|
|
|
// 2. Write definitions from fragments
|
|
for _, frag := range node.Fragments {
|
|
for _, def := range frag.Definitions {
|
|
switch d := def.(type) {
|
|
case *parser.Field:
|
|
b.writeDefinition(f, d, indent)
|
|
case *parser.VariableDefinition:
|
|
continue
|
|
case *parser.ObjectNode:
|
|
norm := index.NormalizeName(d.Name)
|
|
if child, ok := node.Children[norm]; ok {
|
|
if !writtenChildren[norm] {
|
|
b.writeNodeContent(f, child, indent)
|
|
writtenChildren[norm] = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. Write Children (recursively)
|
|
sortedChildren := make([]string, 0, len(node.Children))
|
|
for k := range node.Children {
|
|
if !writtenChildren[k] {
|
|
sortedChildren = append(sortedChildren, k)
|
|
}
|
|
}
|
|
sort.Strings(sortedChildren) // Alphabetical for determinism
|
|
|
|
for _, k := range sortedChildren {
|
|
child := node.Children[k]
|
|
b.writeNodeContent(f, child, indent)
|
|
}
|
|
}
|
|
|
|
func (b *Builder) writeDefinition(f *os.File, def parser.Definition, indent int) {
|
|
indentStr := strings.Repeat(" ", indent)
|
|
switch d := def.(type) {
|
|
case *parser.Field:
|
|
fmt.Fprintf(f, "%s%s = %s\n", indentStr, d.Name, b.formatValue(d.Value))
|
|
}
|
|
}
|
|
|
|
func (b *Builder) formatValue(val parser.Value) string {
|
|
val = b.evaluate(val)
|
|
switch v := val.(type) {
|
|
case *parser.StringValue:
|
|
if v.Quoted {
|
|
return fmt.Sprintf("\"%s\"", v.Value)
|
|
}
|
|
return v.Value
|
|
case *parser.IntValue:
|
|
return v.Raw
|
|
case *parser.FloatValue:
|
|
return v.Raw
|
|
case *parser.BoolValue:
|
|
return fmt.Sprintf("%v", v.Value)
|
|
case *parser.VariableReferenceValue:
|
|
return v.Name
|
|
case *parser.ReferenceValue:
|
|
return v.Value
|
|
case *parser.ArrayValue:
|
|
elements := []string{}
|
|
for _, e := range v.Elements {
|
|
elements = append(elements, b.formatValue(e))
|
|
}
|
|
return fmt.Sprintf("{ %s }", strings.Join(elements, " "))
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func (b *Builder) mergeNodes(dest, src *index.ProjectNode) {
|
|
dest.Fragments = append(dest.Fragments, src.Fragments...)
|
|
for name, child := range src.Children {
|
|
if existing, ok := dest.Children[name]; ok {
|
|
b.mergeNodes(existing, child)
|
|
} else {
|
|
dest.Children[name] = child
|
|
child.Parent = dest
|
|
}
|
|
}
|
|
}
|
|
|
|
func hasClass(frag *index.Fragment) bool {
|
|
for _, def := range frag.Definitions {
|
|
if f, ok := def.(*parser.Field); ok && f.Name == "Class" {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (b *Builder) collectVariables(tree *index.ProjectTree) {
|
|
processNode := func(n *index.ProjectNode) {
|
|
for _, frag := range n.Fragments {
|
|
for _, def := range frag.Definitions {
|
|
if vdef, ok := def.(*parser.VariableDefinition); ok {
|
|
if valStr, ok := b.Overrides[vdef.Name]; ok {
|
|
p := parser.NewParser("Temp = " + valStr)
|
|
cfg, _ := p.Parse()
|
|
if len(cfg.Definitions) > 0 {
|
|
if f, ok := cfg.Definitions[0].(*parser.Field); ok {
|
|
b.variables[vdef.Name] = f.Value
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
if vdef.DefaultValue != nil {
|
|
b.variables[vdef.Name] = vdef.DefaultValue
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tree.Walk(processNode)
|
|
}
|
|
|
|
func (b *Builder) evaluate(val parser.Value) parser.Value {
|
|
switch v := val.(type) {
|
|
case *parser.VariableReferenceValue:
|
|
name := strings.TrimPrefix(v.Name, "$")
|
|
if res, ok := b.variables[name]; ok {
|
|
return b.evaluate(res)
|
|
}
|
|
return v
|
|
case *parser.BinaryExpression:
|
|
left := b.evaluate(v.Left)
|
|
right := b.evaluate(v.Right)
|
|
return b.compute(left, v.Operator, right)
|
|
}
|
|
return val
|
|
}
|
|
|
|
func (b *Builder) compute(left parser.Value, op parser.Token, right parser.Value) parser.Value {
|
|
if op.Type == parser.TokenConcat {
|
|
s1 := b.valToString(left)
|
|
s2 := b.valToString(right)
|
|
return &parser.StringValue{Value: s1 + s2, Quoted: true}
|
|
}
|
|
|
|
lF, lIsF := b.valToFloat(left)
|
|
rF, rIsF := b.valToFloat(right)
|
|
|
|
if lIsF || rIsF {
|
|
res := 0.0
|
|
switch op.Type {
|
|
case parser.TokenPlus:
|
|
res = lF + rF
|
|
case parser.TokenMinus:
|
|
res = lF - rF
|
|
case parser.TokenStar:
|
|
res = lF * rF
|
|
case parser.TokenSlash:
|
|
res = lF / rF
|
|
}
|
|
return &parser.FloatValue{Value: res, Raw: fmt.Sprintf("%g", res)}
|
|
}
|
|
|
|
lI, lIsI := b.valToInt(left)
|
|
rI, rIsI := b.valToInt(right)
|
|
|
|
if lIsI && rIsI {
|
|
res := int64(0)
|
|
switch op.Type {
|
|
case parser.TokenPlus:
|
|
res = lI + rI
|
|
case parser.TokenMinus:
|
|
res = lI - rI
|
|
case parser.TokenStar:
|
|
res = lI * rI
|
|
case parser.TokenSlash:
|
|
if rI != 0 {
|
|
res = lI / rI
|
|
}
|
|
case parser.TokenPercent:
|
|
if rI != 0 {
|
|
res = lI % rI
|
|
}
|
|
case parser.TokenAmpersand:
|
|
res = lI & rI
|
|
case parser.TokenPipe:
|
|
res = lI | rI
|
|
case parser.TokenCaret:
|
|
res = lI ^ rI
|
|
}
|
|
return &parser.IntValue{Value: res, Raw: fmt.Sprintf("%d", res)}
|
|
}
|
|
|
|
return left
|
|
}
|
|
|
|
func (b *Builder) valToString(v parser.Value) string {
|
|
switch val := v.(type) {
|
|
case *parser.StringValue:
|
|
return val.Value
|
|
case *parser.IntValue:
|
|
return val.Raw
|
|
case *parser.FloatValue:
|
|
return val.Raw
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func (b *Builder) valToFloat(v parser.Value) (float64, bool) {
|
|
switch val := v.(type) {
|
|
case *parser.FloatValue:
|
|
return val.Value, true
|
|
case *parser.IntValue:
|
|
return float64(val.Value), true
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
func (b *Builder) valToInt(v parser.Value) (int64, bool) {
|
|
switch val := v.(type) {
|
|
case *parser.IntValue:
|
|
return val.Value, true
|
|
}
|
|
return 0, false
|
|
}
|