support more optional value for single_arg_call

Author: CppCXY

CodeService/src/Config/LuaStyle.cpp

@@ -117,7 +117,19 @@ void LuaStyle::ParseFromMap(std::map<std::string, std::string, std::less<>> &con
 
     BOOL_OPTION(space_before_closure_open_parenthesis)
 
-    BOOL_OPTION(space_before_function_call_single_arg)
+    if (configMap.count("space_before_function_call_single_arg")) {
+        auto & value = configMap.at("space_before_function_call_single_arg");
+        if (value == "true" || value == "always") {
+            space_before_function_call_single_arg = FunctionSingleArgSpace::Always;
+        } else if (value == "only_string") {
+            space_before_function_call_single_arg = FunctionSingleArgSpace::OnlyString;
+        } else if (value == "only_table") {
+            space_before_function_call_single_arg = FunctionSingleArgSpace::OnlyTable;
+        } else if (value == "false" || value == "none") {
+            space_before_function_call_single_arg = FunctionSingleArgSpace::None;
+        }
+    }
+
 
     BOOL_OPTION(space_before_open_square_bracket)
 

CodeService/src/Format/Analyzer/SpaceAnalyzer.cpp

@@ -159,10 +159,37 @@ void SpaceAnalyzer::ComplexAnalyze(FormatState &f, const LuaSyntaxTree &t) {
                             SpaceLeft(leftBrace, t, 1);
                         }
                     } else {
-                        if (f.GetStyle().space_before_function_call_single_arg) {
-                            SpaceLeft(syntaxNode, t, 1);
-                        } else {
-                            SpaceLeft(syntaxNode, t, 0);
+                        switch (f.GetStyle().space_before_function_call_single_arg) {
+                            case FunctionSingleArgSpace::None: {
+                                SpaceLeft(syntaxNode, t, 0);
+                                break;
+                            }
+                            case FunctionSingleArgSpace::Always: {
+                                SpaceLeft(syntaxNode, t, 1);
+                                break;
+                            }
+                            case FunctionSingleArgSpace::OnlyString: {
+                                auto firstToken = syntaxNode.GetFirstToken(t);
+                                if (firstToken.GetTokenKind(t) == TK_STRING
+                                    || firstToken.GetTokenKind(t) == TK_LONG_STRING) {
+                                    SpaceLeft(syntaxNode, t, 1);
+                                } else {
+                                    SpaceLeft(syntaxNode, t, 0);
+                                }
+                                break;
+                            }
+                            case FunctionSingleArgSpace::OnlyTable: {
+                                auto firstChild = syntaxNode.GetFirstChild(t);
+                                if (firstChild.GetSyntaxKind(t) == LuaSyntaxNodeKind::TableExpression) {
+                                    SpaceLeft(syntaxNode, t, 1);
+                                } else {
+                                    SpaceLeft(syntaxNode, t, 0);
+                                }
+                                break;
+                            }
+                            default: {
+                                break;
+                            }
                         }
                     }
                     break;

Test/src/FormatStyle_unitest.cpp

@@ -447,21 +447,45 @@ end
 TEST(FormatByStyleOption, space_before_function_call_single_arg) {
     LuaStyle style;
 
-    style.space_before_function_call_single_arg = true;
+    style.space_before_function_call_single_arg = FunctionSingleArgSpace::Always;
     EXPECT_TRUE(TestHelper::TestFormatted(
             R"(
 local f = p { a = 123 }
+p "aaa"
 )",
             R"(
 local f = p { a = 123 }
+p "aaa"
 )", style));
-    style.space_before_function_call_single_arg = false;
+    style.space_before_function_call_single_arg = FunctionSingleArgSpace::OnlyString;
     EXPECT_TRUE(TestHelper::TestFormatted(
             R"(
 local f = p { a = 123 }
+p "aaa"
 )",
             R"(
 local f = p{ a = 123 }
+p "aaa"
+)", style));
+    style.space_before_function_call_single_arg = FunctionSingleArgSpace::OnlyTable;
+    EXPECT_TRUE(TestHelper::TestFormatted(
+            R"(
+local f = p { a = 123 }
+p "aaa"
+)",
+            R"(
+local f = p { a = 123 }
+p"aaa"
+)", style));
+    style.space_before_function_call_single_arg = FunctionSingleArgSpace::None;
+    EXPECT_TRUE(TestHelper::TestFormatted(
+            R"(
+local f = p { a = 123 }
+p "aaa"
+)",
+            R"(
+local f = p{ a = 123 }
+p"aaa"
 )", style));
 }
 

include/CodeService/Config/LuaStyle.h

@@ -61,7 +61,7 @@ class LuaStyle {
 
     bool space_before_closure_open_parenthesis = false;
 
-    bool space_before_function_call_single_arg = true;
+    FunctionSingleArgSpace space_before_function_call_single_arg = FunctionSingleArgSpace::Always;
 
     bool space_before_open_square_bracket = false;
 

include/CodeService/Config/LuaStyleEnum.h

@@ -57,3 +57,10 @@ struct LineSpace {
     LineSpaceType Type;
     std::size_t Space;
 };
+
+enum class FunctionSingleArgSpace {
+    None,
+    Always, // true
+    OnlyTable,
+    OnlyString
+};

lua.template.editorconfig

@@ -44,7 +44,9 @@ space_before_function_call_open_parenthesis = false
 
 space_before_closure_open_parenthesis = true
 
-space_before_function_call_single_arg = true
+# optional always/only_string/only_table/none
+# or true/false
+space_before_function_call_single_arg = always
 
 space_before_open_square_bracket = false