Fixed issue with inconsistent json write line split options

danielaparker · danielaparker · commit bfd1a335ec4c · 2025-11-28T12:16:27.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,7 +11,9 @@
 
     - Git Issue #659: Fixed jsonschema validation message 
 
-    - Fixed issue with JSON write option `array_array_split_lines::new_line`
+    - Fixed issue with JSON write option `array_array_split_lines` value `line_split_kind::new_line` not creating a new line
+
+    - Fixed issue with inconsistent JSON write option output
 
 - Changes
 
diff --git a/doc/ref/corelib/basic_json_options.md b/doc/ref/corelib/basic_json_options.md
@@ -122,9 +122,9 @@ Move constructor.
 [Decimal precision](#E3)  
 [Parse integer with lossless_bignum](#E4)  
 [Parse floating point with lossless_bignum](#E5)  
-[Object-array block formatting](#E6)  
-[Array-array block formatting](#E7)  
-[Prettify single line output](#E8)  
+[Root line splits](#E6)  
+[Object-array line splits](#E7)  
+[Array-array line splits](#E8)  
 [Indent with tabs](#E9)  
 [Allow trailing commas](#E10)  
 
@@ -306,7 +306,47 @@ Output:
 
 <div id="E6"/> 
 
-#### Object-array block formatting
+#### Root line splits
+
+```cpp
+#include <jsoncons/json.hpp>
+#include <iostream>
+
+using namespace jsoncons;
+
+int main()
+{
+    auto j = json::parse(R"(
+        [[1,2,3,4]]
+    )");
+
+    jsoncons::json_options options;
+    options.spaces_around_comma(jsoncons::spaces_option::space_after) // default when using pretty printing 
+        .line_splits(jsoncons::line_split_kind::same_line);           // default is multi_line 
+    
+    std::cout << "(1)\n" << pretty_print(j) << "\n\n";
+    std::cout << "(2)\n" << pretty_print(j, options) << "\n\n";
+}
+```
+Output:
+```
+(1)
+[
+    [
+        1,
+        2,
+        3,
+        4
+    ]
+]
+
+(2)
+[[1, 2, 3, 4]]
+```
+
+<div id="E7"/> 
+
+#### Object-array line splits
 
 ```cpp
 #include <jsoncons/json.hpp>
@@ -384,9 +424,9 @@ new_ine:
 }
 ```
 
-<div id="E7"/> 
+<div id="E8"/> 
 
-#### Array-array block formatting
+#### Array-array line splits
 
 ```cpp
 #include <jsoncons/json.hpp>
@@ -442,46 +482,6 @@ same_line:
 ]
 ```
 
-<div id="E8"/> 
-
-#### Prettify single line output
-
-```cpp
-#include <jsoncons/json.hpp>
-#include <iostream>
-
-using namespace jsoncons;
-
-int main()
-{
-    auto j = json::parse(R"(
-        [[1,2,3,4]]
-    )");
-
-    jsoncons::json_options options;
-    options.spaces_around_comma(jsoncons::spaces_option::space_after) // default when using pretty printing 
-        .line_splits(jsoncons::line_split_kind::same_line);           // default is multi_line 
-    
-    std::cout << "(1)\n" << pretty_print(j) << "\n\n";
-    std::cout << "(2)\n" << pretty_print(j, options) << "\n\n";
-}
-```
-Output:
-```
-(1)
-[
-    [
-        1,
-        2,
-        3,
-        4
-    ]
-]
-
-(2)
-[[1, 2, 3, 4]]
-```
-
 <div id="E9"/> 
 
 #### Indent with tabs
diff --git a/include/jsoncons/json_encoder.hpp b/include/jsoncons/json_encoder.hpp
@@ -227,7 +227,7 @@ namespace detail {
         class encoding_context
         {
             container_type type_;
-            line_split_kind line_splits_;
+            line_split_kind split_kind_;
             bool indent_before_;
             bool new_line_after_;
             std::size_t begin_pos_{0};
@@ -236,7 +236,7 @@ namespace detail {
         public:
             encoding_context(container_type type, line_split_kind split_lines, bool indent_once,
                              std::size_t begin_pos, std::size_t data_pos) noexcept
-               : type_(type), line_splits_(split_lines), indent_before_(indent_once), new_line_after_(false),
+               : type_(type), split_kind_(split_lines), indent_before_(indent_once), new_line_after_(false),
                  begin_pos_(begin_pos), data_pos_(data_pos)
             {
             }
@@ -292,19 +292,24 @@ namespace detail {
                 return type_ == container_type::array;
             }
 
+            line_split_kind split_kind() const
+            {
+                return split_kind_;
+            }
+
             bool is_same_line() const
             {
-                return line_splits_ == line_split_kind::same_line;
+                return split_kind_ == line_split_kind::same_line;
             }
 
             bool is_new_line() const
             {
-                return line_splits_ == line_split_kind::new_line;
+                return split_kind_ == line_split_kind::new_line;
             }
 
             bool is_multi_line() const
             {
-                return line_splits_ == line_split_kind::multi_line;
+                return split_kind_ == line_split_kind::multi_line;
             }
 
             bool is_indent_once() const
@@ -455,7 +460,9 @@ namespace detail {
             {
                 if (stack_.back().is_object())
                 {
-                    switch (options_.object_object_line_splits())
+                    line_split_kind split_kind = static_cast<uint8_t>(options_.object_object_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ? 
+                        options_.object_object_line_splits() : stack_.back().split_kind();
+                    switch (split_kind)
                     {
                         case line_split_kind::same_line:
                         case line_split_kind::new_line:
@@ -467,12 +474,14 @@ namespace detail {
                         default: // multi_line
                             break;
                     }
-                    stack_.emplace_back(container_type::object,options_.object_object_line_splits(), false,
+                    stack_.emplace_back(container_type::object,split_kind, false,
                                         column_, column_+open_object_brace_str_.length());
                 }
                 else // array
                 {
-                    switch (options_.array_object_line_splits())
+                    line_split_kind split_kind = static_cast<uint8_t>(options_.array_object_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ? 
+                        options_.array_object_line_splits() : stack_.back().split_kind();
+                    switch (split_kind)
                     {
                         case line_split_kind::same_line:
                             if (column_ >= options_.line_length_limit())
@@ -495,7 +504,7 @@ namespace detail {
                             new_line();
                             break;
                     }
-                    stack_.emplace_back(container_type::object,options_.array_object_line_splits(), false,
+                    stack_.emplace_back(container_type::object,split_kind, false,
                                         column_, column_+open_object_brace_str_.length());
                 }
             }
@@ -545,47 +554,52 @@ namespace detail {
             {
                 if (stack_.back().is_object())
                 {
-                    switch (options_.object_array_line_splits())
+                    line_split_kind split_kind = static_cast<uint8_t>(options_.object_array_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ? 
+                        options_.object_array_line_splits() : 
+                        stack_.back().split_kind();
+                    switch (split_kind)
                     {
                         case line_split_kind::same_line:
-                            stack_.emplace_back(container_type::array,options_.object_array_line_splits(),false,
+                            stack_.emplace_back(container_type::array,split_kind,false,
                                                 column_, column_ + open_array_bracket_str_.length());
                             break;
                         case line_split_kind::new_line:
                         {
-                            stack_.emplace_back(container_type::array,options_.object_array_line_splits(),true,
+                            stack_.emplace_back(container_type::array,split_kind,true,
                                                 column_, column_+open_array_bracket_str_.length());
                             break;
                         }
                         default: // multi_line
-                            stack_.emplace_back(container_type::array,options_.object_array_line_splits(),true,
+                            stack_.emplace_back(container_type::array,split_kind,true,
                                                 column_, column_+open_array_bracket_str_.length());
                             break;
                     }
                 }
                 else // array
                 {
-                    switch (options_.array_array_line_splits())
+                    line_split_kind split_kind = static_cast<uint8_t>(options_.array_array_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ? 
+                        options_.array_array_line_splits() : stack_.back().split_kind();
+                    switch (split_kind)
                     {
                         case line_split_kind::same_line:
                             if (stack_.back().is_multi_line())
                             {
                                 stack_.back().new_line_after(true);
                                 new_line();
                             }
-                            stack_.emplace_back(container_type::array,options_.array_array_line_splits(), false,
+                            stack_.emplace_back(container_type::array,split_kind, false,
                                                 column_, column_+open_array_bracket_str_.length());
                             break;
                         case line_split_kind::new_line:
                             stack_.back().new_line_after(true);
                             new_line();
-                            stack_.emplace_back(container_type::array,options_.array_array_line_splits(), true,
+                            stack_.emplace_back(container_type::array,split_kind, true,
                                                 column_, column_+open_array_bracket_str_.length());
                             break;
                         default: // multi_line
                             stack_.back().new_line_after(true);
                             new_line();
-                            stack_.emplace_back(container_type::array,options_.array_array_line_splits(), false,
+                            stack_.emplace_back(container_type::array,split_kind, false,
                                                 column_, column_+open_array_bracket_str_.length());
                             //new_line();
                             break;
@@ -1048,12 +1062,12 @@ namespace detail {
 
         void indent()
         {
-            indent_amount_ += static_cast<int>(options_.indent_size());
+            indent_amount_ += static_cast<uint8_t>(options_.indent_size());
         }
 
         void unindent()
         {
-            indent_amount_ -= static_cast<int>(options_.indent_size());
+            indent_amount_ -= static_cast<uint8_t>(options_.indent_size());
         }
 
         void new_line()
diff --git a/include/jsoncons/json_options.hpp b/include/jsoncons/json_options.hpp
@@ -23,7 +23,7 @@ enum class float_chars_format : uint8_t {general,fixed,scientific,hex};
 
 enum class indenting : uint8_t {no_indent = 0, indent = 1};
 
-enum class line_split_kind  : uint8_t {same_line=1, new_line, multi_line};
+enum class line_split_kind  : uint8_t {multi_line=0, new_line=1, same_line=2};
 
 enum class bignum_format_kind : uint8_t {raw, 
 #if !defined(JSONCONS_NO_DEPRECATED)
@@ -350,10 +350,10 @@ class basic_json_encode_options : public virtual basic_json_options_common<CharT
           byte_string_format_(byte_string_chars_format::none),
           bignum_format_(bignum_format_kind::raw),
           line_splits_(line_split_kind::multi_line),
-          object_object_line_splits_(line_split_kind{}),
-          object_array_line_splits_(line_split_kind{}),
-          array_array_line_splits_(line_split_kind{}),
-          array_object_line_splits_(line_split_kind{}),
+          object_object_line_splits_(line_split_kind::multi_line),
+          object_array_line_splits_(line_split_kind::multi_line),
+          array_array_line_splits_(line_split_kind::multi_line),
+          array_object_line_splits_(line_split_kind::multi_line),
           spaces_around_colon_(spaces_option::space_after),
           spaces_around_comma_(spaces_option::space_after),
           indent_char_(' ')
@@ -404,13 +404,13 @@ class basic_json_encode_options : public virtual basic_json_options_common<CharT
 
     line_split_kind line_splits() const  {return line_splits_;}
 
-    line_split_kind object_object_line_splits() const  {return object_object_line_splits_ == line_split_kind{} ? line_splits_ : object_object_line_splits_;}
+    line_split_kind object_object_line_splits() const  {return object_object_line_splits_;}
 
-    line_split_kind array_object_line_splits() const  {return array_object_line_splits_ == line_split_kind{} ? line_splits_ : array_object_line_splits_;}
+    line_split_kind array_object_line_splits() const  {return array_object_line_splits_;}
 
-    line_split_kind object_array_line_splits() const  {return object_array_line_splits_ == line_split_kind{} ? line_splits_ : object_array_line_splits_;}
+    line_split_kind object_array_line_splits() const  {return object_array_line_splits_;}
 
-    line_split_kind array_array_line_splits() const  {return array_array_line_splits_ == line_split_kind{} ? line_splits_ : array_array_line_splits_;}
+    line_split_kind array_array_line_splits() const  {return array_array_line_splits_;}
 
     uint8_t indent_size() const 
     {
diff --git a/test/corelib/src/json_line_split_tests.cpp b/test/corelib/src/json_line_split_tests.cpp
@@ -59,11 +59,7 @@ TEST_CASE("json_encoder line split tests")
 std::string expected = R"({
     "data": {
         "id": [1,2,3],
-        "item": [
-            [
-                1,2,3
-            ]
-        ],
+        "item": [[1,2,3]],
         "tags": []
     },
     "header": {
@@ -111,11 +107,7 @@ std::string expected = R"({
     std::string expected = R"({
     "data": {
         "id": [1,2,3],
-        "item": [
-            [
-                1,2,3
-            ]
-        ],
+        "item": [[1,2,3]],
         "tags": []
     },
     "header": {
@@ -138,13 +130,7 @@ std::string expected = R"({
     std::string expected = R"({
     "data": {
         "id": [1,2,3],
-        "item": [
-            [
-                1,
-                2,
-                3
-            ]
-        ],
+        "item": [[1,2,3]],
         "tags": []
     },
     "header": {
@@ -166,11 +152,7 @@ std::string expected = R"({
     std::string expected = R"({
     "data": {
         "id": [1,2,3],
-        "item": [
-            [
-                1,2,3
-            ]
-        ],
+        "item": [[1,2,3]],
         "tags": []
     },
     "header": {
diff --git a/test/corelib/src/json_options_tests.cpp b/test/corelib/src/json_options_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ namespace detail {`
`227`	`227`	`class encoding_context`
`228`	`228`	`{`
`229`	`229`	`container_type type_;`
`230`		`- line_split_kind line_splits_;`
	`230`	`+ line_split_kind split_kind_;`
`231`	`231`	`bool indent_before_;`
`232`	`232`	`bool new_line_after_;`
`233`	`233`	`std::size_t begin_pos_{0};`
`@@ -236,7 +236,7 @@ namespace detail {`
`236`	`236`	`public:`
`237`	`237`	`encoding_context(container_type type, line_split_kind split_lines, bool indent_once,`
`238`	`238`	`std::size_t begin_pos, std::size_t data_pos) noexcept`
`239`		`- : type_(type), line_splits_(split_lines), indent_before_(indent_once), new_line_after_(false),`
	`239`	`+ : type_(type), split_kind_(split_lines), indent_before_(indent_once), new_line_after_(false),`
`240`	`240`	`begin_pos_(begin_pos), data_pos_(data_pos)`
`241`	`241`	`{`
`242`	`242`	`}`
`@@ -292,19 +292,24 @@ namespace detail {`
`292`	`292`	`return type_ == container_type::array;`
`293`	`293`	`}`
`294`	`294`
	`295`	`+ line_split_kind split_kind() const`
	`296`	`+ {`
	`297`	`+ return split_kind_;`
	`298`	`+ }`
	`299`	`+`
`295`	`300`	`bool is_same_line() const`
`296`	`301`	`{`
`297`		`- return line_splits_ == line_split_kind::same_line;`
	`302`	`+ return split_kind_ == line_split_kind::same_line;`
`298`	`303`	`}`
`299`	`304`
`300`	`305`	`bool is_new_line() const`
`301`	`306`	`{`
`302`		`- return line_splits_ == line_split_kind::new_line;`
	`307`	`+ return split_kind_ == line_split_kind::new_line;`
`303`	`308`	`}`
`304`	`309`
`305`	`310`	`bool is_multi_line() const`
`306`	`311`	`{`
`307`		`- return line_splits_ == line_split_kind::multi_line;`
	`312`	`+ return split_kind_ == line_split_kind::multi_line;`
`308`	`313`	`}`
`309`	`314`
`310`	`315`	`bool is_indent_once() const`
`@@ -455,7 +460,9 @@ namespace detail {`
`455`	`460`	`{`
`456`	`461`	`if (stack_.back().is_object())`
`457`	`462`	`{`
`458`		`- switch (options_.object_object_line_splits())`
	`463`	`+ line_split_kind split_kind = static_cast<uint8_t>(options_.object_object_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ?`
	`464`	`+ options_.object_object_line_splits() : stack_.back().split_kind();`
	`465`	`+ switch (split_kind)`
`459`	`466`	`{`
`460`	`467`	`case line_split_kind::same_line:`
`461`	`468`	`case line_split_kind::new_line:`
`@@ -467,12 +474,14 @@ namespace detail {`
`467`	`474`	`default: // multi_line`
`468`	`475`	`break;`
`469`	`476`	`}`
`470`		`- stack_.emplace_back(container_type::object,options_.object_object_line_splits(), false,`
	`477`	`+ stack_.emplace_back(container_type::object,split_kind, false,`
`471`	`478`	`column_, column_+open_object_brace_str_.length());`
`472`	`479`	`}`
`473`	`480`	`else // array`
`474`	`481`	`{`
`475`		`- switch (options_.array_object_line_splits())`
	`482`	`+ line_split_kind split_kind = static_cast<uint8_t>(options_.array_object_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ?`
	`483`	`+ options_.array_object_line_splits() : stack_.back().split_kind();`
	`484`	`+ switch (split_kind)`
`476`	`485`	`{`
`477`	`486`	`case line_split_kind::same_line:`
`478`	`487`	`if (column_ >= options_.line_length_limit())`
`@@ -495,7 +504,7 @@ namespace detail {`
`495`	`504`	`new_line();`
`496`	`505`	`break;`
`497`	`506`	`}`
`498`		`- stack_.emplace_back(container_type::object,options_.array_object_line_splits(), false,`
	`507`	`+ stack_.emplace_back(container_type::object,split_kind, false,`
`499`	`508`	`column_, column_+open_object_brace_str_.length());`
`500`	`509`	`}`
`501`	`510`	`}`
`@@ -545,47 +554,52 @@ namespace detail {`
`545`	`554`	`{`
`546`	`555`	`if (stack_.back().is_object())`
`547`	`556`	`{`
`548`		`- switch (options_.object_array_line_splits())`
	`557`	`+ line_split_kind split_kind = static_cast<uint8_t>(options_.object_array_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ?`
	`558`	`+ options_.object_array_line_splits() :`
	`559`	`+ stack_.back().split_kind();`
	`560`	`+ switch (split_kind)`
`549`	`561`	`{`
`550`	`562`	`case line_split_kind::same_line:`
`551`		`- stack_.emplace_back(container_type::array,options_.object_array_line_splits(),false,`
	`563`	`+ stack_.emplace_back(container_type::array,split_kind,false,`
`552`	`564`	`column_, column_ + open_array_bracket_str_.length());`
`553`	`565`	`break;`
`554`	`566`	`case line_split_kind::new_line:`
`555`	`567`	`{`
`556`		`- stack_.emplace_back(container_type::array,options_.object_array_line_splits(),true,`
	`568`	`+ stack_.emplace_back(container_type::array,split_kind,true,`
`557`	`569`	`column_, column_+open_array_bracket_str_.length());`
`558`	`570`	`break;`
`559`	`571`	`}`
`560`	`572`	`default: // multi_line`
`561`		`- stack_.emplace_back(container_type::array,options_.object_array_line_splits(),true,`
	`573`	`+ stack_.emplace_back(container_type::array,split_kind,true,`
`562`	`574`	`column_, column_+open_array_bracket_str_.length());`
`563`	`575`	`break;`
`564`	`576`	`}`
`565`	`577`	`}`
`566`	`578`	`else // array`
`567`	`579`	`{`
`568`		`- switch (options_.array_array_line_splits())`
	`580`	`+ line_split_kind split_kind = static_cast<uint8_t>(options_.array_array_line_splits()) >= static_cast<uint8_t>(stack_.back().split_kind()) ?`
	`581`	`+ options_.array_array_line_splits() : stack_.back().split_kind();`
	`582`	`+ switch (split_kind)`
`569`	`583`	`{`
`570`	`584`	`case line_split_kind::same_line:`
`571`	`585`	`if (stack_.back().is_multi_line())`
`572`	`586`	`{`
`573`	`587`	`stack_.back().new_line_after(true);`
`574`	`588`	`new_line();`
`575`	`589`	`}`
`576`		`- stack_.emplace_back(container_type::array,options_.array_array_line_splits(), false,`
	`590`	`+ stack_.emplace_back(container_type::array,split_kind, false,`
`577`	`591`	`column_, column_+open_array_bracket_str_.length());`
`578`	`592`	`break;`
`579`	`593`	`case line_split_kind::new_line:`
`580`	`594`	`stack_.back().new_line_after(true);`
`581`	`595`	`new_line();`
`582`		`- stack_.emplace_back(container_type::array,options_.array_array_line_splits(), true,`
	`596`	`+ stack_.emplace_back(container_type::array,split_kind, true,`
`583`	`597`	`column_, column_+open_array_bracket_str_.length());`
`584`	`598`	`break;`
`585`	`599`	`default: // multi_line`
`586`	`600`	`stack_.back().new_line_after(true);`
`587`	`601`	`new_line();`
`588`		`- stack_.emplace_back(container_type::array,options_.array_array_line_splits(), false,`
	`602`	`+ stack_.emplace_back(container_type::array,split_kind, false,`
`589`	`603`	`column_, column_+open_array_bracket_str_.length());`
`590`	`604`	`//new_line();`
`591`	`605`	`break;`
`@@ -1048,12 +1062,12 @@ namespace detail {`
`1048`	`1062`
`1049`	`1063`	`void indent()`
`1050`	`1064`	`{`
`1051`		`- indent_amount_ += static_cast<int>(options_.indent_size());`
	`1065`	`+ indent_amount_ += static_cast<uint8_t>(options_.indent_size());`
`1052`	`1066`	`}`
`1053`	`1067`
`1054`	`1068`	`void unindent()`
`1055`	`1069`	`{`
`1056`		`- indent_amount_ -= static_cast<int>(options_.indent_size());`
	`1070`	`+ indent_amount_ -= static_cast<uint8_t>(options_.indent_size());`
`1057`	`1071`	`}`
`1058`	`1072`
`1059`	`1073`	`void new_line()`