initial formatter schema

src/language-server/universal-data-definition-language-formatter.ts

@@ -1,9 +1,8 @@
-import { AbstractFormatter, AstNode, Formatting, Module, PartialLangiumServices } from 'langium';
+import { AbstractFormatter, AstNode, Formatting, Module, PartialLangiumServices, } from 'langium';
 import * as ast from './generated/ast';
 import { UniversalDataDefinitionLanguageServices } from './universal-data-definition-language-module';
 
 export class UniversalDataDefinitionLanguageFormatter extends AbstractFormatter {
-
     protected formatContainer(node: AstNode): void {
         const formatter = this.getNodeFormatter(node);
         const open = formatter.keyword('{');
@@ -22,12 +21,22 @@ export class UniversalDataDefinitionLanguageFormatter extends AbstractFormatter
         close.surround(Formatting.noSpace()).prepend(Formatting.newLine({allowMore: true})).append(Formatting.newLine({allowMore: true}));
     }
 
-    protected format(node: AstNode): void {
+    protected formatNode(node: AstNode): void {
+        const formatter = this.getNodeFormatter(node);
+        formatter.property('name').prepend(Formatting.newLine()).surround(Formatting.oneSpace({allowMore: true}))
+    }
+
+    protected format(node: AstNode): void {        
         // This method is called for every AstNode in a document
         if (ast.isDataModel(node)) {
             this.formatDataModel(node);
-
         }
+        else if(ast.isConceptualAssociation(node)){            
+            this.formatConceptualAssociation(node)
+        }
+        else if(ast.isConceptualEntity(node)){
+            this.formatConceptualEntity(node)
+        }                
     }
 
 
@@ -50,10 +59,10 @@ export class UniversalDataDefinitionLanguageFormatter extends AbstractFormatter
 
     protected formatConceptualDataModel(cdm: ast.ConceptualDataModel): void {
         this.formatContainer(cdm);
-        cdm.cdm.forEach(dm => {
+        cdm.cdm.forEach(dm => {            
             this.formatConceptualDataModel(dm);
         })
-        cdm.element.forEach( elem => {
+        cdm.element.forEach( elem => {            
             this.formatConceptualElement(elem);
         })
     }
@@ -64,7 +73,7 @@ export class UniversalDataDefinitionLanguageFormatter extends AbstractFormatter
             this.formatLogicalDataModel(dm)
         })
         ldm.element.forEach( elem => {
-            this.formatElement(elem)
+            this.formatLogicalElement(elem)
         })
     }
 
@@ -74,17 +83,52 @@ export class UniversalDataDefinitionLanguageFormatter extends AbstractFormatter
             this.formatPlatfornDataModel(dm)
         })
         pdm.element.forEach(elem => {
-            this.formatElement(elem)
+            this.formatPlatformElement(elem)
         })
     }
 
-    protected formatConceptualElement(elem: ast.ConceptualElement): void {
+    /**Formatting conceptuals */
+    protected formatConceptualElement(elem: ast.ConceptualElement): void {                
         const formatter = this.getNodeFormatter(elem);
-        formatter.property('name').prepend(Formatting.newLine()).surround(Formatting.oneSpace({allowMore: true}));
+        formatter.property('name').prepend(Formatting.newLine({allowMore: true})).surround(Formatting.oneSpace({allowMore: true}));
         this.formatObj(elem);
     }
 
-    protected formatElement(elem: ast.LogicalElement | ast.PlatformElement): void {
+    protected formatConceptualEntity(entity: ast.ConceptualEntity): void {
+        this.formatContainer(entity)
+        entity.composition.forEach(comp => {
+            this.formatConceptualComposition(comp)
+        })
+    }
+
+    protected formatConceptualAssociation(cassoc: ast.ConceptualAssociation): void {
+        this.formatContainer(cassoc)
+
+        cassoc.composition.forEach(comp => {
+            this.formatConceptualComposition(comp)
+        })
+    }
+
+    protected formatConceptualComposition(comp: ast.ConceptualComposition   ): void {
+        this.formatContainer(comp)
+    }
+
+    protected formatConceptualParticipant(participant: ast.ConceptualParticipant): void {
+        this.formatContainer(participant)
+
+        if(participant?.type){
+            this.formatConceptualEntity(participant.type.ref!)
+        }
+    }
+
+    /**Formatting logicals */
+    protected formatLogicalElement(elem: ast.LogicalElement): void {
+        const formatter = this.getNodeFormatter(elem);
+        formatter.property('name').prepend(Formatting.newLine()).surround(Formatting.oneSpace({allowMore: true}));
+        this.formatObj(elem);   
+    }
+
+    protected formatPlatformElement(elem: ast.PlatformElement): void {
         const formatter = this.getNodeFormatter(elem);
         formatter.property('name').prepend(Formatting.newLine()).surround(Formatting.oneSpace({allowMore: true}));
         this.formatObj(elem);   
@@ -97,5 +141,4 @@ export const UniversalDataDefinitionLanguageModule: Module<UniversalDataDefiniti
     lsp: {
         Formatter: () => new UniversalDataDefinitionLanguageFormatter()
     }
-};
-
+};

uddl_test/uddl_test_formatting/universal-data-definition-language-formatter.test.ts

@@ -2,24 +2,125 @@ import { createUniversalDataDefinitionLanguageServices } from "../../src/languag
 import { EmptyFileSystem } from "langium";
 import { expectFormatting } from "langium/test";
 
-const universalDataDefinitionLanguageService =createUniversalDataDefinitionLanguageServices({...EmptyFileSystem,}).UniversalDataDefinitionLanguage;
-const universalDataDefinitionLanguageFormatting = expectFormatting(universalDataDefinitionLanguageService
-);
+const universalDataDefinitionLanguageService = createUniversalDataDefinitionLanguageServices({...EmptyFileSystem,}).UniversalDataDefinitionLanguage;
+const universalDataDefinitionLanguageFormatting = expectFormatting(universalDataDefinitionLanguageService);
 
 describe("Universal Data Definition Language Formatter", () => {
-  it("should indent correctly", async () => {
+  it("should format cdm array", async () => {
     await universalDataDefinitionLanguageFormatting({
       before:
-        'dm PPT "Base data structures to support People, Places and Things"{cdm Conceptual "Need to start at Conceptual Level"{}}',
+        'dm PPT "Base data structures to support People, Places and Things"{cdm Conceptual "Need to start at Conceptual Level"{cdm anothercdm "A cdm with another data" {observable Information "Something a party can learn";}}}',
       after: `dm PPT "Base data structures to support People, Places and Things"
 {
 
     cdm Conceptual "Need to start at Conceptual Level"
     {
 
+        cdm anothercdm "A cdm with another data"
+        {
+
+            observable Information "Something a party can learn";
+        }
+
     }
 
-}`
+}`,
+    });
+  });
+
+  it("should format cdm with conceptual association", async () => {
+    await universalDataDefinitionLanguageFormatting({
+      before:
+        'dm PPT "Base data structures to support People, Places and Things"{cdm Conceptual "Need to start at Conceptual Level"{cassoc Training "Information delivered over time from one party to another " {};}}',
+      after: `dm PPT "Base data structures to support People, Places and Things"
+{
+
+    cdm Conceptual "Need to start at Conceptual Level"
+    {
+
+        cassoc Training "Information delivered over time from one party to another "
+        {
+
+        };
+
+    }
+
+}`,
     });
   });
+
+  it("should format cdm with conceptual entity", async () => {
+    await universalDataDefinitionLanguageFormatting({
+      before:
+        'dm PPT "Base data structures to support People, Places and Things"{cdm Conceptual "Need to start at Conceptual Level"{centity AddressableEntity "Any entity that is addressable in some way" {};}}',
+      after: `dm PPT "Base data structures to support People, Places and Things"
+{
+
+    cdm Conceptual "Need to start at Conceptual Level"
+    {
+
+        centity AddressableEntity "Any entity that is addressable in some way"
+        {
+
+        };
+
+    }
+
+}`,
+    });
+  });
+
+  it('should format cdm with conceptual basis',async () => {
+    await universalDataDefinitionLanguageFormatting({
+      before: 
+      'dm PPT "Base data structures to support People, Places and Things"{cdm Conceptual "Need to start at Conceptual Level"{basis uddlBasis "Formating conceptual basis entity"; }}',
+      after: `dm PPT "Base data structures to support People, Places and Things"
+{
+
+    cdm Conceptual "Need to start at Conceptual Level"
+    {
+
+        basis uddlBasis "Formating conceptual basis entity";
+    }
+
+}`,
+    })    
+  })
+
+  it('should format cdm with conceptual domain',async () => {
+    await universalDataDefinitionLanguageFormatting({
+      before: 
+      'dm PPT "Base data structures to support People, Places and Things"{cdm Conceptual "Need to start at Conceptual Level"{domain NaturalPerson "Base definition of a natural person"; }}',
+      after: `dm PPT "Base data structures to support People, Places and Things"
+{
+
+    cdm Conceptual "Need to start at Conceptual Level"
+    {
+
+        domain NaturalPerson "Base definition of a natural person";
+    }
+
+}`,
+    })    
+  })
+
+  it("should format ldm array",async () => {
+    await universalDataDefinitionLanguageFormatting({
+      before: 'dm Book "Base definition for book requirement" {ldm library "contains available books" {ldm BookShelf "Books related by category"{}}}',
+      after: `dm Book "Base definition for book requirement"
+{
+
+    ldm library "contains available books"
+    {
+
+        ldm BookShelf "Books related by category"
+        {
+
+        }
+
+    }
+
+}`
+    })    
+  })
 });