martino/marte_dev_tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

implemented ordering preservation

Browse Source
This commit is contained in:
Martino Ferrari
2026-01-23 10:23:02 +01:00
parent e2c87c90f3
commit 5c3f05a1a4
18 changed files with 262 additions and 279 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
internal/builder/builder.go
View File

@@ -71,86 +71,38 @@ func (b *Builder) writeNodeContent(f *os.File, node *index.ProjectNode, indent i
indentStr := strings.Repeat(" ", indent)
// If this node has a RealName (e.g. +App), we print it as an object definition
// UNLESS it is the top-level output file itself?
// If we are writing "App.marte", maybe we are writing the *body* of App?
// Spec: "unifying multi-file project into a single configuration output"
// Let's assume we print the Node itself.
if node.RealName != "" {
fmt.Fprintf(f, "%s%s = {\n", indentStr, node.RealName)
indent++
indentStr = strings.Repeat(" ", indent)
}
writtenChildren := make(map[string]bool)
// 2. Write definitions from fragments
for _, frag := range node.Fragments {
// Use formatter logic to print definitions
// We need a temporary Config to use Formatter?
// Or just reimplement basic printing? Formatter is better.
// But Formatter prints to io.Writer.
// We can reuse formatDefinition logic if we exposed it, or just copy basic logic.
// Since we need to respect indentation, using Formatter.Format might be tricky
// unless we wrap definitions in a dummy structure.
for _, def := range frag.Definitions {
// Basic formatting for now, referencing formatter style
b.writeDefinition(f, def, indent)
switch d := def.(type) {
case *parser.Field:
b.writeDefinition(f, d, indent)
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)
// Children are sub-nodes defined implicitly via #package A.B or explicitly +Sub
// Explicit +Sub are handled via Fragments logic (they are definitions in fragments).
// Implicit nodes (from #package A.B.C where B was never explicitly defined)
// show up in Children map but maybe not in Fragments?
// If a Child is NOT in fragments (implicit), we still need to write it.
// If it IS in fragments (explicit +Child), it was handled in loop above?
// Wait. My Indexer puts `+Sub` into `node.Children["Sub"]` AND adds a `Fragment` to `node` containing `+Sub` object?
// Let's check Indexer.
// Case ObjectNode:
// Adds Fragment to `child` (the Sub node).
// Does NOT add `ObjectNode` definition to `node`'s fragment list?
// "pt.addObjectFragment(child...)"
// It does NOT add to `fileFragment.Definitions`.
// So `node.Fragments` only contains Fields!
// Children are all in `node.Children`.
// So:
// 1. Write Fields (from Fragments).
// 2. Write Children (from Children map).
// But wait, Fragments might have order?
// "Relative ordering within a file is preserved."
// My Indexer splits Fields and Objects.
// Fields go to Fragments. Objects go to Children.
// This loses the relative order between Fields and Objects in the source file!
// Correct Indexer approach for preserving order:
// `Fragment` should contain a list of `Entry`.
// `Entry` can be `Field` OR `ChildNodeName`.
// But I just rewrote Indexer to split them.
// If strict order is required "within a file", my Indexer is slightly lossy regarding Field vs Object order.
// Spec: "Relative ordering within a file is preserved."
// To fix this without another full rewrite:
// Iterating `node.Children` alphabetically is arbitrary.
// We should ideally iterate them in the order they appear.
// For now, I will proceed with writing Children after Fields, which is a common convention,
// unless strict interleaving is required.
// Given "Class first" rule, reordering happens anyway.
// Sorting Children?
// Maybe keep a list of OrderedChildren in ProjectNode?
sortedChildren := make([]string, 0, len(node.Children))
for k := range node.Children {
sortedChildren = append(sortedChildren, k)
if !writtenChildren[k] {
sortedChildren = append(sortedChildren, k)
}
}
sort.Strings(sortedChildren) // Alphabetical for determinism

8
internal/formatter/formatter.go
View File

@@ -54,7 +54,7 @@ func fixComment(text string) string {
return "//# " + text[3:]
}
} else if strings.HasPrefix(text, "//") {
if len(text) > 2 && text[2] != ' ' && text[2] != '#' && text[2] != '!' {
if len(text) > 2 && text[2] != ' ' && text[2] != '#' && text[2] != '!' {
return "// " + text[2:]
}
}
@@ -101,7 +101,7 @@ func (f *Formatter) formatDefinition(def parser.Definition, indent int) int {
fmt.Fprintln(f.writer)
f.formatSubnode(d.Subnode, indent+1)
fmt.Fprintf(f.writer, "%s}", indentStr)
return d.Subnode.EndPosition.Line
}
@@ -175,7 +175,7 @@ func (f *Formatter) flushCommentsBefore(pos parser.Position, indent int, stick b
break
}
}
// If stick is true, we don't print extra newline.
// If stick is true, we don't print extra newline.
// The caller will print the definition immediately after this function returns.
// If stick is false (e.g. end of block comments), we act normally.
// But actually, the previous implementation didn't print extra newlines between comments and code
@@ -208,4 +208,4 @@ func (f *Formatter) popComment() string {
c := f.insertables[f.cursor]
f.cursor++
return c.Text
}
}

52
internal/index/index.go
View File

@@ -222,6 +222,7 @@ func (pt *ProjectTree) populateNode(node *ProjectNode, file string, config *pars
fileFragment.Definitions = append(fileFragment.Definitions, d)
pt.indexValue(file, d.Value)
case *parser.ObjectNode:
fileFragment.Definitions = append(fileFragment.Definitions, d)
norm := NormalizeName(d.Name)
if _, ok := node.Children[norm]; !ok {
node.Children[norm] = &ProjectNode{
@@ -276,6 +277,7 @@ func (pt *ProjectTree) addObjectFragment(node *ProjectNode, file string, obj *pa
pt.indexValue(file, d.Value)
pt.extractFieldMetadata(node, d)
case *parser.ObjectNode:
frag.Definitions = append(frag.Definitions, d)
norm := NormalizeName(d.Name)
if _, ok := node.Children[norm]; !ok {
node.Children[norm] = &ProjectNode{
@@ -390,25 +392,65 @@ func (pt *ProjectTree) ResolveReferences() {
for i := range pt.References {
ref := &pt.References[i]
if isoNode, ok := pt.IsolatedFiles[ref.File]; ok {
ref.Target = pt.findNode(isoNode, ref.Name)
ref.Target = pt.FindNode(isoNode, ref.Name, nil)
} else {
ref.Target = pt.findNode(pt.Root, ref.Name)
ref.Target = pt.FindNode(pt.Root, ref.Name, nil)
}
}
}
func (pt *ProjectTree) findNode(root *ProjectNode, name string) *ProjectNode {
func (pt *ProjectTree) FindNode(root *ProjectNode, name string, predicate func(*ProjectNode) bool) *ProjectNode {
if strings.Contains(name, ".") {
parts := strings.Split(name, ".")
rootName := parts[0]
var candidates []*ProjectNode
pt.findAllNodes(root, rootName, &candidates)
for _, cand := range candidates {
curr := cand
valid := true
for i := 1; i < len(parts); i++ {
nextName := parts[i]
normNext := NormalizeName(nextName)
if child, ok := curr.Children[normNext]; ok {
curr = child
} else {
valid = false
break
}
}
if valid {
if predicate == nil || predicate(curr) {
return curr
}
}
}
return nil
}
if root.RealName == name || root.Name == name {
return root
if predicate == nil || predicate(root) {
return root
}
}
for _, child := range root.Children {
if res := pt.findNode(child, name); res != nil {
if res := pt.FindNode(child, name, predicate); res != nil {
return res
}
}
return nil
}
func (pt *ProjectTree) findAllNodes(root *ProjectNode, name string, results *[]*ProjectNode) {
if root.RealName == name || root.Name == name {
*results = append(*results, root)
}
for _, child := range root.Children {
pt.findAllNodes(child, name, results)
}
}
type QueryResult struct {
Node *ProjectNode
Field *parser.Field

56
internal/lsp/server_test.go
View File

@@ -30,7 +30,7 @@ func TestInitProjectScan(t *testing.T) {
// +Source = { Class = C Link = Target }
// 012345678901234567890123456789012345
// Previous offset was 29.
// Now add 21?
// Now add 21?
// #package Test.Common\n
// +Source = ...
// So add 21 to Character? Or Line 1?
@@ -84,7 +84,7 @@ func TestInitProjectScan(t *testing.T) {
func TestHandleDefinition(t *testing.T) {
// Reset tree for test
tree = index.NewProjectTree()
content := `
+MyObject = {
Class = Type
@@ -136,7 +136,7 @@ func TestHandleDefinition(t *testing.T) {
func TestHandleReferences(t *testing.T) {
// Reset tree for test
tree = index.NewProjectTree()
content := `
+MyObject = {
Class = Type
@@ -173,38 +173,38 @@ func TestHandleReferences(t *testing.T) {
func TestLSPFormatting(t *testing.T) {
// Setup
content := `
content := `
#package Proj.Main
+Object={
Field=1
}
`
uri := "file:///test.marte"
// Open (populate documents map)
documents[uri] = content
// Format
params := DocumentFormattingParams{
TextDocument: TextDocumentIdentifier{URI: uri},
}
edits := handleFormatting(params)
if len(edits) != 1 {
t.Fatalf("Expected 1 edit, got %d", len(edits))
}
newText := edits[0].NewText
expected := `#package Proj.Main
uri := "file:///test.marte"
// Open (populate documents map)
documents[uri] = content
// Format
params := DocumentFormattingParams{
TextDocument: TextDocumentIdentifier{URI: uri},
}
edits := handleFormatting(params)
if len(edits) != 1 {
t.Fatalf("Expected 1 edit, got %d", len(edits))
}
newText := edits[0].NewText
expected := `#package Proj.Main
+Object = {
Field = 1
}
`
// Normalize newlines for comparison just in case
if strings.TrimSpace(strings.ReplaceAll(newText, "\r\n", "\n")) != strings.TrimSpace(strings.ReplaceAll(expected, "\r\n", "\n")) {
t.Errorf("Formatting mismatch.\nExpected:\n%s\nGot:\n%s", expected, newText)
}
}
// Normalize newlines for comparison just in case
if strings.TrimSpace(strings.ReplaceAll(newText, "\r\n", "\n")) != strings.TrimSpace(strings.ReplaceAll(expected, "\r\n", "\n")) {
t.Errorf("Formatting mismatch.\nExpected:\n%s\nGot:\n%s", expected, newText)
}
}

2
internal/parser/lexer.go
View File

@@ -257,4 +257,4 @@ func (l *Lexer) lexPackage() Token {
return l.lexUntilNewline(TokenPackage)
}
return l.emit(TokenError)
}
}

28
internal/parser/parser.go
View File

@@ -145,17 +145,17 @@ func (p *Parser) isSubnodeLookahead() bool {
// Look inside:
// peek(0) is '{'
// peek(1) is first token inside
t1 := p.peekN(1)
if t1.Type == TokenRBrace {
// {} -> Empty. Assume Array (Value) by default, unless forced?
// {} -> Empty. Assume Array (Value) by default, unless forced?
// If we return false, it parses as ArrayValue.
// If user writes "Sig = {}", is it an empty signal?
// Empty array is more common for value.
// Empty array is more common for value.
// If "Sig" is a node, it should probably have content or use +Sig.
return false
return false
}
if t1.Type == TokenIdentifier {
// Identifier inside.
// If followed by '=', it's a definition -> Subnode.
@@ -166,12 +166,12 @@ func (p *Parser) isSubnodeLookahead() bool {
// Identifier alone or followed by something else -> Reference/Value -> Array
return false
}
if t1.Type == TokenObjectIdentifier {
// +Node = ... -> Definition -> Subnode
return true
}
// Literals -> Array
return false
}
@@ -204,13 +204,13 @@ func (p *Parser) parseSubnode() (Subnode, error) {
func (p *Parser) parseValue() (Value, error) {
tok := p.next()
switch tok.Type {
case TokenString:
return &StringValue{
Position: tok.Position,
Value: strings.Trim(tok.Value, "\""),
Quoted: true,
}, nil
case TokenString:
return &StringValue{
Position: tok.Position,
Value: strings.Trim(tok.Value, "\""),
Quoted: true,
}, nil
case TokenNumber:
// Simplistic handling
if strings.Contains(tok.Value, ".") || strings.Contains(tok.Value, "e") {

4
internal/schema/schema.go
View File

@@ -114,7 +114,7 @@ func LoadFullSchema(projectRoot string) *Schema {
sysPaths := []string{
"/usr/share/mdt/marte_schema.json",
}
home, err := os.UserHomeDir()
if err == nil {
sysPaths = append(sysPaths, filepath.Join(home, ".local/share/mdt/marte_schema.json"))
@@ -135,4 +135,4 @@ func LoadFullSchema(projectRoot string) *Schema {
}
return s
}
}

31
internal/validator/validator.go
View File

@@ -343,7 +343,7 @@ func (v *Validator) validateGAMSignal(gamNode, signalNode *index.ProjectNode, di
var targetNode *index.ProjectNode
if signalsContainer, ok := dsNode.Children["Signals"]; ok {
targetNorm := index.NormalizeName(targetSignalName)
if child, ok := signalsContainer.Children[targetNorm]; ok {
targetNode = child
} else {
@@ -404,12 +404,12 @@ func (v *Validator) validateGAMSignal(gamNode, signalNode *index.ProjectNode, di
v.updateReferenceTarget(v.getNodeFile(signalNode), val.Position, targetNode)
}
}
// Property checks
v.checkSignalProperty(signalNode, targetNode, "Type")
v.checkSignalProperty(signalNode, targetNode, "NumberOfElements")
v.checkSignalProperty(signalNode, targetNode, "NumberOfDimensions")
// Check Type validity if present
if typeFields, ok := fields["Type"]; ok && len(typeFields) > 0 {
typeVal := v.getFieldValue(typeFields[0])
@@ -509,7 +509,7 @@ func (v *Validator) getFieldValue(f *parser.Field) string {
func (v *Validator) resolveReference(name string, file string, predicate func(*index.ProjectNode) bool) *index.ProjectNode {
if isoNode, ok := v.Tree.IsolatedFiles[file]; ok {
if found := v.findNodeRecursive(isoNode, name, predicate); found != nil {
if found := v.Tree.FindNode(isoNode, name, predicate); found != nil {
return found
}
return nil
@@ -517,24 +517,7 @@ func (v *Validator) resolveReference(name string, file string, predicate func(*i
if v.Tree.Root == nil {
return nil
}
return v.findNodeRecursive(v.Tree.Root, name, predicate)
}
func (v *Validator) findNodeRecursive(root *index.ProjectNode, name string, predicate func(*index.ProjectNode) bool) *index.ProjectNode {
// Simple recursive search matching name
if root.RealName == name || root.Name == index.NormalizeName(name) {
if predicate == nil || predicate(root) {
return root
}
}
// Recursive
for _, child := range root.Children {
if found := v.findNodeRecursive(child, name, predicate); found != nil {
return found
}
}
return nil
return v.Tree.FindNode(v.Tree.Root, name, predicate)
}
func (v *Validator) getNodeClass(node *index.ProjectNode) string {
@@ -554,7 +537,7 @@ func isValidType(t string) bool {
}
func (v *Validator) checkType(val parser.Value, expectedType string) bool {
// ... (same as before)
// ... (same as before)
switch expectedType {
case "int":
_, ok := val.(*parser.IntValue)
@@ -780,4 +763,4 @@ func (v *Validator) isGloballyAllowed(warningType string, contextFile string) bo
}
}
return false
}
}