resolve white space preservation when generating CMakeLists.txt

Author: vsch

VERSION.md

@@ -5,7 +5,7 @@
 ### Version History
 - [CLionArduinoPlugin Version Notes](#clionarduinoplugin-version-notes)
   - [TO DO](#to-do)
-  - [1.5.24 Next](#1524-next)
+  - [1.5.26 Next](#1526-next)
   - [1.5.11](#1511)
   - [1.5.9](#159)
   - [1.5.7](#157)
@@ -52,8 +52,13 @@
   * Add: inspection to check that `CMakeLists.txt` is out of sync, especially if missing the
     toolchain file.
 
-### 1.5.24 Next
+### 1.5.26 Next
 
+* Fix: resolve white space preservation in regenerated `CMakeLists.txt` file. Only changing text
+  for values which were changed.
+* Fix: `CMakeLists.txt` file with mixed project macro name when `PROJECT_NAME` or
+  `CMAKE_PROJECT_NAME` is used to set `_SRCS` and `_HDRS`, while project was set with another
+  macro name, for example `project(${ANOTHER_NAME})`
 * Fix: disable diff buttons if the toolchain file is not `ArduinoToolchain.cmake` so that other
   toolchain files will not be erroneously compared to bundled version.
 * Fix: add second diff button for toolchain diff viewing `Platform/Arduino.cmake`

src/com/vladsch/clionarduinoplugin/generators/ArduinoProjectGenerator.kt

@@ -369,7 +369,6 @@ abstract class ArduinoProjectGenerator(isLibrary: Boolean) : CMakeProjectGenerat
         //                JTextField field = ((TextFieldWithBrowseButton) jcomp).getTextField();
         //                String text = field.getText();
         //                field.setText(text);
-        //                int tmp = 0;
         //            }
         //            showChildTree((JComponent) comp, lvl + "." + i);
         //        }

src/com/vladsch/clionarduinoplugin/generators/cmake/ArduinoCMakeListsTxtBuilder.kt

@@ -77,7 +77,6 @@ class ArduinoCMakeListsTxtBuilder : CMakeListsTxtBuilder {
         // if command is not found or has less args then an empty value will be used
         //
 
-
         // @formatter:off
         val GENERATE_ARDUINO_FIRMWARE = CMakeCommandType("GENERATE_ARDUINO_FIRMWARE", "generate_arduino_firmware", arrayOf(), 1, 1, true, false, true, arrayOf("\${PROJECT_NAME}"), 0)
         val GENERATE_ARDUINO_LIBRARY = CMakeCommandType("GENERATE_ARDUINO_LIBRARY", "generate_arduino_library", arrayOf(), 1, 1, true, false, true, arrayOf("\${PROJECT_NAME}"), 0)
@@ -260,7 +259,6 @@ class ArduinoCMakeListsTxtBuilder : CMakeListsTxtBuilder {
 
             val baudRateText = appSettings.baudRateText
             builder.setOrAddCommand(SET_UPLOAD_SPEED, baudRateText.ifEmpty("9600")).setSuppressible(baudRateText.isEmpty())
-            //            builder.removeCommand(SET_UPLOAD_SPEED)
 
             builder.setOrAddCommand(SET_AFLAGS, "-v").setSuppressible(!appSettings.isVerbose)
 
@@ -273,7 +271,7 @@ class ArduinoCMakeListsTxtBuilder : CMakeListsTxtBuilder {
             }
 
             // Can add our own values to resolve variables
-            // TODO: figure out how to make comments unused false make sense with comments above
+            
             return builder.getCMakeContents(
                 null,
                 !appSettings.isCommentUnusedSettings,
@@ -315,8 +313,8 @@ class ArduinoCMakeListsTxtBuilder : CMakeListsTxtBuilder {
             val cMakeProjectName = builder.cMakeProjectName
 
             settings.projectName = cMakeProjectName ?: ""
-            settings.sources = cMakeVariableValues["\${PROJECT_NAME}_SRCS"].toTypedArray()
-            settings.headers = cMakeVariableValues["\${PROJECT_NAME}_HDRS"].toTypedArray()
+            settings.sources = cMakeVariableValues["${builder.cMakeProjectNameMacro}_SRCS"].toTypedArray()
+            settings.headers = cMakeVariableValues["${builder.cMakeProjectNameMacro}_HDRS"].toTypedArray()
             settings.sketch = cMakeVariableValues["${cMakeProjectName}_SKETCH"].firstOrNull() ?: ""
             settings.boardId = cMakeVariableValues["${cMakeProjectName}_BOARD"].firstOrNull() ?: ""
             settings.cpuId = cMakeVariableValues["ARDUINO_CPU"].firstOrNull() ?: ""

src/com/vladsch/clionarduinoplugin/generators/cmake/CMakeFormatter.java

@@ -4,7 +4,6 @@
 import com.vladsch.clionarduinoplugin.generators.cmake.ast.CMakeFile;
 import com.vladsch.clionarduinoplugin.generators.cmake.ast.LineEnding;
 import com.vladsch.flexmark.formatter.*;
-import com.vladsch.flexmark.formatter.FormatterOptions;
 import com.vladsch.flexmark.html.renderer.HtmlIdGenerator;
 import com.vladsch.flexmark.html.renderer.LinkType;
 import com.vladsch.flexmark.html.renderer.ResolvedLink;
@@ -41,6 +40,8 @@
 
 import static com.vladsch.flexmark.formatter.Formatter.NULL_ITERABLE;
 
+// TODO: add a node post processor to move nodes between if() ... else() ... endif() to be child nodes of if() and else() with block wrapper around them
+//       otherwise indentation will not work because all commands are at the root level.
 public class CMakeFormatter implements IRender {
 
     // syntax options

src/com/vladsch/clionarduinoplugin/generators/cmake/CMakeListsTxtBuilder.kt

@@ -1,12 +1,7 @@
 package com.vladsch.clionarduinoplugin.generators.cmake
 
 import com.intellij.openapi.diagnostic.Logger
-import com.vladsch.clionarduinoplugin.generators.cmake.ast.Argument
-import com.vladsch.clionarduinoplugin.generators.cmake.ast.BlankLine
-import com.vladsch.clionarduinoplugin.generators.cmake.ast.CMakeFile
-import com.vladsch.clionarduinoplugin.generators.cmake.ast.Command
-import com.vladsch.clionarduinoplugin.generators.cmake.ast.CommentedOutCommand
-import com.vladsch.clionarduinoplugin.generators.cmake.ast.LineComment
+import com.vladsch.clionarduinoplugin.generators.cmake.ast.*
 import com.vladsch.clionarduinoplugin.generators.cmake.commands.*
 import com.vladsch.clionarduinoplugin.resources.TemplateResolver
 import com.vladsch.clionarduinoplugin.resources.resolveRefs
@@ -210,10 +205,11 @@ abstract class CMakeListsTxtBuilder(
                         if (rawArgs.size > 1) cMakeVariableValues[rawArgs[0]] = rawArgs.slice(1 .. rawArgs.size - 1)
                         else cMakeVariableValues[rawArgs[0]] = null
                     } else if (rawArgs.isNotEmpty() && (rawArgs[0] == "\${PROJECT_NAME}_SRCS" || rawArgs[0] == "\${PROJECT_NAME}_HDRS"
-                            || rawArgs[0] == "\${CMAKE_PROJECT_NAME}_SRCS" || rawArgs[0] == "\${CMAKE_PROJECT_NAME}_HDRS")) {
+                            || rawArgs[0] == "\${CMAKE_PROJECT_NAME}_SRCS" || rawArgs[0] == "\${CMAKE_PROJECT_NAME}_HDRS")
+                    ) {
                         // this is most likely a mistake, since the project name is in cMakeProjectNameMacro
                         val replaceMacroName = cMakeProjectNameMacro + rawArgs[0].substring(rawArgs[0].length - 5)
-                        if (rawArgs.size > 1) cMakeVariableValues[replaceMacroName] = rawArgs.slice(1 .. rawArgs.size - 1) 
+                        if (rawArgs.size > 1) cMakeVariableValues[replaceMacroName] = rawArgs.slice(1 .. rawArgs.size - 1)
                         else cMakeVariableValues[replaceMacroName] = null
                     } else {
                         if (args.size > 1) cMakeVariableValues[useVarName ?: args[0]] = args.slice(1 .. args.size - 1)
@@ -264,15 +260,24 @@ abstract class CMakeListsTxtBuilder(
             // find the command or we can create a new one if we don't have it already or just make it into a text block
             var commandType: CMakeCommandType? = null
             val rawArgs = ArrayList<String>()
-            val rawArgLeadingSpaces = ArrayList<BasedSequence>()
+            val rawArgsLeadingSpaces = ArrayList<BasedSequence>()
 
             for (arg in node.getChildren()) {
                 if (arg is Argument) {
                     rawArgs.add(arg.text.toString())
-                    rawArgLeadingSpaces.add(arg.leadingSpaces)
+                    if (arg.previous is LineEnding) {
+                        rawArgsLeadingSpaces.add(arg.leadingSpaces.prefixWithEOL())
+                    } else {
+                        rawArgsLeadingSpaces.add(arg.leadingSpaces)
+                    }
                 }
             }
 
+            val lastChild = node.lastChild
+            val addBeforeClosing =
+                if (lastChild is LineEnding) node.baseSubSequence(lastChild.startOffset, node.closingMarker.startOffset)
+                else BasedSequence.NULL
+
             val commandName = node.command.toString()
             if (commandName == "set") {
                 // see if we have a matching set command
@@ -336,11 +341,10 @@ abstract class CMakeListsTxtBuilder(
             if (commandName == "made_up_command") {
                 val tmp = 0
             }
-            
+
             if (commandType != null) {
-                makeCommand = CMakeCommand(commandType, node.next is LineComment)
-                // KLUDGE: blank line nodes steal EOL from next node's leadingSpaces, so need to add it here to compensate 
-                makeCommand.leadingSpaces = if (node.previous is BlankLine) node.leadingSpaces.prefixWithEOL() else node.leadingSpaces
+                makeCommand = CMakeCommand(commandType, false, addBeforeClosing)
+                makeCommand.leadingSpaces = node.leadingSpaces
 
                 var i = 0
                 var j = 0
@@ -353,20 +357,19 @@ abstract class CMakeListsTxtBuilder(
                         val matcher = regEx.matcher(rawArgs[i++])
                         matcher.find()
                         for (g in 1 .. matcher.groupCount()) {
-                            makeCommand.setArg(j++, matcher.group(g), rawArgLeadingSpaces[g])
+                            makeCommand.setArg(j++, matcher.group(g), rawArgsLeadingSpaces[g])
                         }
                     } else i++
                 }
 
                 while (i < rawArgs.size) {
-                    makeCommand.setArg(j++, rawArgs[i], rawArgLeadingSpaces[i])
+                    makeCommand.setArg(j++, rawArgs[i], rawArgsLeadingSpaces[i])
                     i++
                 }
             } else {
                 // unknown command
-                makeCommand = CMakeUnknownCommand(commandName, rawArgs, rawArgLeadingSpaces, node.next is LineComment)
-                // KLUDGE: blank line nodes steal EOL from next node's leadingSpaces, so need to add it here to compensate 
-                makeCommand.leadingSpaces = if (node.previous is BlankLine) node.leadingSpaces.prefixWithEOL() else node.leadingSpaces
+                makeCommand = CMakeUnknownCommand(commandName, rawArgs, rawArgsLeadingSpaces, false, addBeforeClosing)
+                makeCommand.leadingSpaces = node.leadingSpaces
             }
 
             if (node is CommentedOutCommand) {
@@ -377,9 +380,7 @@ abstract class CMakeListsTxtBuilder(
         }
 
         // create a text element
-        // KLUDGE: blank line nodes steal EOL from next node's leadingSpaces, so need to add it here to compensate 
-        //    however, if the previous is a LineComment and it has EOL then adding an extra one would double blank lines
-        return CMakeText(node.chars.toString(), node is BlankLine && node.next !is BlankLine && node.next !is Command && !(node.previous is LineComment && node.previous?.chars?.endsWithEOL()?:false))
+        return CMakeText(node.chars.toString(), false)
     }
 
     fun elementOriginalText(element: CMakeElement): String {
@@ -437,7 +438,7 @@ abstract class CMakeListsTxtBuilder(
     }
 
     fun removeElement(index: Int) {
-        if (index + 1 < myElements.size) 
+        if (index + 1 < myElements.size)
             myElements[index + 1].isAddEOL = myElements[index].isAddEOL
         myElements.removeAt(index)
     }
@@ -802,7 +803,7 @@ abstract class CMakeListsTxtBuilder(
         val command = setCommand(commandType, args)
         if (command == null) {
             // create a new one and find where to insert it
-            val newCommand = CMakeCommand(commandType, args?.toList() ?: listOf(), null, true)
+            val newCommand = CMakeCommand(commandType, args?.toList() ?: listOf(), null, true, BasedSequence.NULL)
             addCommand(newCommand)
             return newCommand
         }
@@ -842,13 +843,19 @@ abstract class CMakeListsTxtBuilder(
                     if (commandType.isNoDupeArgs) {
                         // add another one after this one if the arg value is different
                         if (!command.allArgsEqual(argList)) {
-                            newCommand = CMakeCommand(command.commandType, argList, command.getArgsLeadingSpaces(argList), true)
+                            newCommand = CMakeCommand(
+                                command.commandType,
+                                argList,
+                                command.getArgsLeadingSpaces(argList),
+                                true,
+                                command.addBeforeClosing
+                            )
                             newCommand.commentOut(false)
                             addElementAfter(command, newCommand)
                         }
                     } else {
                         // add another one after this one
-                        newCommand = CMakeCommand(command.commandType, argList, null, true)
+                        newCommand = CMakeCommand(command.commandType, argList, null, true, BasedSequence.NULL)
                         addElementAfter(command, newCommand)
                     }
                 } else {
@@ -866,7 +873,7 @@ abstract class CMakeListsTxtBuilder(
                             replaceElement(command, newCommand)
                         } else {
                             // is a matched sub-type, need to replace completely
-                            newCommand = CMakeCommand(commandType, argList, null, false)
+                            newCommand = CMakeCommand(commandType, argList, null, false, command.addBeforeClosing)
                             newCommand.commentOut(false)
                             newCommand.setArgsWithDefaults(argList, command.getArgsLeadingSpaces(argList))
 
@@ -1082,7 +1089,7 @@ abstract class CMakeListsTxtBuilder(
         private val LOG = Logger.getInstance("com.vladsch.clionarduinoplugin.generators")
         private val DEFAULT_OPTIONS = MutableDataSet()
             .set(CMakeParser.AUTO_CONFIG, true)
-            .set(CMakeParser.AST_LINE_END_EOL, false)
+            .set(CMakeParser.AST_LINE_END_EOL, true)
             .set(CMakeParser.AST_COMMENTS, true)
             .set(CMakeParser.AST_BLANK_LINES, true)
             .set(CMakeParser.AST_ARGUMENT_SEPARATORS, true)

src/com/vladsch/clionarduinoplugin/generators/cmake/CMakeNodeFormatter.java

@@ -57,6 +57,9 @@ private void render(final Command node, final NodeFormatterContext context, fina
                 markdown.append("# ");
             }
         }
+        if (formatterOptions.preserveWhitespace) {
+            markdown.append(node.getLeadingSpaces());
+        }
         markdown.append(node.getCommand());
         if (formatterOptions.preserveWhitespace) {
             CMakeFormatterContext.appendWhiteSpaceBetween(markdown, node.getCommand(), node.getOpeningMarker(), formatterOptions.preserveWhitespace, formatterOptions.collapseWhitespace, true);

src/com/vladsch/clionarduinoplugin/generators/cmake/CMakeParser.java

@@ -190,8 +190,14 @@ protected boolean parseElement() {
                     if (res) {
                         // it is
                         CommentedOutCommand node = (CommentedOutCommand) document.getLastChildAny(CommentedOutCommand.class);
+                        
                         if (node != null) {
-                            node.setLeadingSpaces(input.subSequence(start, saved));
+                            BasedSequence leadingSpaces = BasedSequence.NULL;
+                            if (node.getPrevious() != null) {
+                                // commented out nodes get their leading spaces from the start of comment
+                                leadingSpaces = input.subSequence(node.getPrevious().getEndOffset(), start);
+                            }
+                            node.setLeadingSpaces(leadingSpaces);
                             node.setCommentMarker(input.subSequence(saved, saved + 1));
                             node.setCharsFromContent();
                         }
@@ -248,7 +254,12 @@ protected boolean parseCommandInvocation(Node parent, final boolean isCommentedO
 
                         if (parseLineEnding(parent, index)) {
                             // we are good
-                            commandNode.setLeadingSpaces(input.subSequence(start, command.getEndOffset()));
+                            BasedSequence leadingSpaces = BasedSequence.NULL;
+                            if (!isCommentedOut && commandNode.getPrevious() != null) {
+                                // commented out nodes get their leading spaces from the start of comment
+                                leadingSpaces = input.subSequence(commandNode.getPrevious().getEndOffset(), saved); 
+                            }
+                            commandNode.setLeadingSpaces(leadingSpaces);
                             commandNode.setCommand(command);
                             commandNode.setOpeningMarker(open);
                             commandNode.setArguments(input.subSequence(open.getEndOffset(), close.getStartOffset()));

src/com/vladsch/clionarduinoplugin/generators/cmake/ast/Argument.java

@@ -21,6 +21,21 @@ public Argument(final BasedSequence chars, final BasedSequence openingMarker, fi
         this.text = text;
         this.closingMarker = closingMarker;
     }
+    
+    public BasedSequence getLeadingSpaces() {
+        Node previous = getPrevious();
+        int startOffset = getStartOffset();
+
+        if (previous == null) {
+            if (getParent() instanceof Command) {
+                startOffset = ((Command) getParent()).getOpeningMarker().getEndOffset();
+            }
+        } else {
+            startOffset = previous.getEndOffset();
+        } 
+        
+        return baseSubSequence(startOffset, getStartOffset());
+    }
 
     @Override
     public BasedSequence[] getSegments() {

src/com/vladsch/clionarduinoplugin/generators/cmake/ast/Command.java

@@ -1,6 +1,7 @@
 package com.vladsch.clionarduinoplugin.generators.cmake.ast;
 
 import com.vladsch.flexmark.util.ast.Node;
+import com.vladsch.flexmark.util.misc.CharPredicate;
 import com.vladsch.flexmark.util.sequence.BasedSequence;
 
 public class Command extends Node {
@@ -34,8 +35,12 @@ public void getAstExtra(StringBuilder out) {
     public BasedSequence getLeadingSpaces() {
         return leadingSpaces;
     }
-
-    public void setLeadingSpaces(final BasedSequence leadingSpaces) {
+    
+    public void setLeadingSpaces(BasedSequence leadingSpaces) {
+        // need to trim spaces before EOL, these are previous node's trailing spaces
+        if (leadingSpaces.indexOf('\n') > 0) {
+            leadingSpaces = leadingSpaces.subSequence(leadingSpaces.countLeading(CharPredicate.SPACE_TAB));
+        }
         this.leadingSpaces = leadingSpaces.isEmpty() ? BasedSequence.NULL : leadingSpaces;
     }