Merge pull request #308 from BalticAmadeus/241-improve-no-undo-format…

…ting Improved no-undo formating after extent keyword
BalticAmadeus · Feb 19, 2025 · ecd2041 · ecd2041
2 parents e56ecdb + 7e94dcd
commit ecd2041
Show file tree

Hide file tree

Showing 4 changed files with 81 additions and 35 deletions.
diff --git a/resources/functionalTests/defineVariable/9-extent/input.p b/resources/functionalTests/defineVariable/9-extent/input.p
@@ -0,0 +1,6 @@
+/* formatterSettingsOverride */
+/*  { "AblFormatter.variableDefinitionFormatting": true} */
+define VARIABLE cerror2 AS INTEGER Extent 100   no-undo.
+define VARIABLE cerror3 AS CHARACTER    extent 1000     NO-UNDO     init "UNDEFINED".
+define variable cerror5 as int    no-undo    extent 100.
+define variable cerror1 as decimal extent 10 no-undo.
diff --git a/resources/functionalTests/defineVariable/9-extent/target.p b/resources/functionalTests/defineVariable/9-extent/target.p
@@ -0,0 +1,6 @@
+/* formatterSettingsOverride */
+/*  { "AblFormatter.variableDefinitionFormatting": true} */
+define VARIABLE cerror2 AS INTEGER   Extent 100  no-undo.
+define VARIABLE cerror3 AS CHARACTER extent 1000 NO-UNDO init "UNDEFINED".
+define variable cerror5 as int                   no-undo extent 100.
+define variable cerror1 as decimal   extent 10   no-undo.
diff --git a/src/formatters/variableDefinition/VariableDefinitionFormatter.ts b/src/formatters/variableDefinition/VariableDefinitionFormatter.ts
@@ -16,10 +16,11 @@ export class VariableDefinitionFormatter
 {
     public static readonly formatterLabel = "variableDefinitionFormatting";
     private readonly settings: VariableDefinitionSettings;
-    private static visitedNodes: Set<number> = new Set();
-    private static alignType = 0;
-    private static alignNoUndo = 0;
-    private static alignVariableKeyword = 0;
+    private visitedNodes: Set<number> = new Set();
+    private alignType: number = 0;
+    private alignVariableTuning: number = 0;
+    private alignExtent: number = 0;
+    private alignVariableKeyword: number = 0;
     private hasAccessTuning = false;
 
     public constructor(configurationManager: IConfigurationManager) {
@@ -40,12 +41,12 @@ export class VariableDefinitionFormatter
         const oldText = FormatterHelper.getCurrentText(node, fullText);
         this.resetNodeVariables();
 
-        if (VariableDefinitionFormatter.visitedNodes.has(node.id)) {
+        if (this.visitedNodes.has(node.id)) {
             const newText = this.collectDefineString(node, fullText);
             return this.getCodeEdit(node, oldText, newText, fullText);
         }
 
-        this.resetStaticVariables();
+        this.resetVariables();
         let currentNode: SyntaxNode | null = node;
         for (
             currentNode;
@@ -59,7 +60,7 @@ export class VariableDefinitionFormatter
                 break;
             }
             this.collectDefineStructure(currentNode, fullText);
-            VariableDefinitionFormatter.visitedNodes.add(currentNode.id);
+            this.visitedNodes.add(currentNode.id);
         }
         const newText = this.collectDefineString(node, fullText);
         return this.getCodeEdit(node, oldText, newText, fullText);
@@ -94,23 +95,37 @@ export class VariableDefinitionFormatter
     ): void {
         switch (node.type) {
             case SyntaxNodeType.TypeTuning:
-                VariableDefinitionFormatter.alignNoUndo = Math.max(
-                    VariableDefinitionFormatter.alignNoUndo,
+                this.alignVariableTuning = Math.max(
+                    this.alignVariableTuning,
                     this.collectTypeTuningString(node, fullText).length
                 );
                 break;
             case SyntaxNodeType.Identifier:
-                VariableDefinitionFormatter.alignType = Math.max(
-                    VariableDefinitionFormatter.alignType,
+                this.alignType = Math.max(
+                    this.alignType,
                     FormatterHelper.getCurrentText(node, fullText).trim().length
                 );
                 break;
             case SyntaxNodeType.AccessTuning:
-                VariableDefinitionFormatter.alignVariableKeyword = Math.max(
-                    VariableDefinitionFormatter.alignVariableKeyword,
+                this.alignVariableKeyword = Math.max(
+                    this.alignVariableKeyword,
                     FormatterHelper.getCurrentText(node, fullText).trim().length
                 );
                 break;
+            case SyntaxNodeType.VariableTuning:
+                const hasExtentKeyword = node.children.find(
+                    (child) => child.type === SyntaxNodeType.ExtentKeyword
+                );
+                const IsPreviousTypeTunning =
+                    node.previousSibling?.type === SyntaxNodeType.TypeTuning;
+
+                if (hasExtentKeyword && IsPreviousTypeTunning) {
+                    this.alignExtent = Math.max(
+                        this.alignExtent,
+                        this.collectTypeTuningString(node, fullText).length
+                    );
+                }
+                break;
         }
     }
 
@@ -136,8 +151,7 @@ export class VariableDefinitionFormatter
                 newString =
                     typeTuningText +
                     " ".repeat(
-                        VariableDefinitionFormatter.alignNoUndo -
-                            typeTuningText.length
+                        this.alignVariableTuning - typeTuningText.length
                     );
                 break;
             case SyntaxNodeType.AccessTuning: {
@@ -148,10 +162,7 @@ export class VariableDefinitionFormatter
                 newString =
                     " " +
                     text +
-                    " ".repeat(
-                        VariableDefinitionFormatter.alignVariableKeyword -
-                            text.length
-                    );
+                    " ".repeat(this.alignVariableKeyword - text.length);
                 this.hasAccessTuning = true;
                 break;
             }
@@ -160,14 +171,9 @@ export class VariableDefinitionFormatter
                     node,
                     fullText
                 ).trim();
-                if (
-                    !this.hasAccessTuning &&
-                    VariableDefinitionFormatter.alignVariableKeyword !== 0
-                ) {
+                if (!this.hasAccessTuning && this.alignVariableKeyword !== 0) {
                     newString =
-                        " ".repeat(
-                            2 + VariableDefinitionFormatter.alignVariableKeyword
-                        ) + text;
+                        " ".repeat(2 + this.alignVariableKeyword) + text;
                     this.hasAccessTuning = true;
                 } else {
                     newString = " " + text;
@@ -180,15 +186,40 @@ export class VariableDefinitionFormatter
                     fullText
                 ).trim();
                 newString =
-                    " " +
-                    text +
-                    " ".repeat(
-                        VariableDefinitionFormatter.alignType - text.length
-                    );
+                    " " + text + " ".repeat(this.alignType - text.length);
                 break;
             case SyntaxNodeType.Error:
                 newString = FormatterHelper.getCurrentText(node, fullText);
                 break;
+            case SyntaxNodeType.VariableTuning:
+                let variableTuningText = "";
+                let spacesCount = 0;
+                const noUndoKeyword = node.children.find(
+                    (child) => child.type === SyntaxNodeType.NoUndoKeyword
+                );
+                const previousExtent = node.previousSibling?.children.find(
+                    (child) => child.type === SyntaxNodeType.ExtentKeyword
+                );
+
+                if (noUndoKeyword) {
+                    variableTuningText = this.collectTypeTuningString(
+                        node,
+                        fullText
+                    );
+                    if (previousExtent && node.previousSibling) {
+                        spacesCount =
+                            this.alignExtent -
+                            FormatterHelper.getCurrentText(
+                                node.previousSibling,
+                                fullText
+                            ).trim().length -
+                            1;
+                    } else {
+                        spacesCount = this.alignExtent;
+                    }
+                    newString = " ".repeat(spacesCount) + variableTuningText;
+                    break;
+                }
             default: {
                 const text = FormatterHelper.getCurrentText(
                     node,
@@ -235,9 +266,10 @@ export class VariableDefinitionFormatter
         this.hasAccessTuning = false;
     }
 
-    private resetStaticVariables() {
-        VariableDefinitionFormatter.alignType = 0;
-        VariableDefinitionFormatter.alignNoUndo = 0;
-        VariableDefinitionFormatter.alignVariableKeyword = 0;
+    private resetVariables() {
+        this.alignType = 0;
+        this.alignVariableTuning = 0;
+        this.alignExtent = 0;
+        this.alignVariableKeyword = 0;
     }
 }
diff --git a/src/model/SyntaxNodeType.ts b/src/model/SyntaxNodeType.ts
@@ -35,6 +35,7 @@ export enum SyntaxNodeType {
     AssignStatement = "assign_statement",
     Assignment = "assignment",
     VariableAssignment = "variable_assignment",
+    VariableTuning = "variable_tuning",
     Identifier = "identifier",
     SourceCode = "source_code",
     Argument = "argument",
@@ -125,6 +126,7 @@ export enum SyntaxNodeType {
     AssignKeyword = "ASSIGN",
     EachKeyword = "EACH",
     EndKeyword = "END",
+    ExtentKeyword = "EXTENT",
     IfKeyword = "IF",
     FindKeyword = "FIND",
     ForKeyword = "FOR",