fix: json array literal stream output (#2032)

Signed-off-by: Peefy <xpf6677@163.com>

Author: Peefy

3rdparty/serde_yaml/tests/test_value.rs

@@ -142,7 +142,7 @@ fn test_tagged() {
         Variant(usize),
     }
 
-    let value = serde_yaml::to_value(&Enum::Variant(0)).unwrap();
+    let value = serde_yaml::to_value(Enum::Variant(0)).unwrap();
 
     let deserialized: serde_yaml::Value = serde_yaml::from_value(value.clone()).unwrap();
     assert_eq!(value, deserialized);

crates/cmd/src/lib.rs

@@ -44,6 +44,7 @@ pub fn app() -> Command {
             .about("run")
             .arg(arg!([input] ... "Specify the input files to run").num_args(0..))
             .arg(arg!(output: -o --output <output> "Specify the YAML output file path"))
+            .arg(arg!(format: -f --format <format> "Specify the output format (yaml or json)"))
             .arg(arg!(setting: -Y --setting <setting> ... "Specify the input setting file").num_args(1..))
             .arg(arg!(verbose: -v --verbose "Print test information verbosely").action(ArgAction::Count))
             .arg(arg!(disable_none: -n --disable_none "Disable dumping None values"))

crates/cmd/src/run.rs

@@ -15,6 +15,7 @@ pub fn run_command<W: Write>(matches: &ArgMatches, writer: &mut W) -> Result<()>
     // Config settings building
     let settings = must_build_settings(matches);
     let output = settings.output();
+    let format_opt = matches.get_one::<String>("format").map(|s| s.as_str());
     let sess = Arc::new(ParseSession::default());
     match exec_program(sess.clone(), &settings.try_into()?) {
         Ok(result) => {
@@ -29,12 +30,23 @@ pub fn run_command<W: Write>(matches: &ArgMatches, writer: &mut W) -> Result<()>
                 }
                 sess.0.emit_stashed_diagnostics_and_abort()?;
             }
-            if !result.yaml_result.is_empty() {
+            // Select output based on format option
+            let output_str = match format_opt {
+                Some("json") => &result.json_result,
+                Some("yaml") | None => &result.yaml_result,
+                Some(f) => {
+                    return Err(anyhow::anyhow!(
+                        "Invalid format '{}', expected 'yaml' or 'json'",
+                        f
+                    ));
+                }
+            };
+            if !output_str.is_empty() {
                 match output {
-                    Some(o) => std::fs::write(o, result.yaml_result)?,
+                    Some(o) => std::fs::write(o, output_str)?,
                     // [`println!`] is not a good way to output content to stdout,
                     // using [`writeln`] can be better to redirect the output.
-                    None => writeln!(writer, "{}", result.yaml_result)?,
+                    None => writeln!(writer, "{}", output_str)?,
                 }
             }
         }

crates/evaluator/src/lib.rs

@@ -228,14 +228,25 @@ impl<'ctx> Evaluator<'ctx> {
 
     pub fn plan_value(&self, value: &ValueRef) -> (String, String) {
         let mut ctx = self.runtime_ctx.borrow_mut();
-        let value = match ctx.buffer.custom_manifests_output.clone() {
-            Some(output) => ValueRef::from_yaml_stream(&mut ctx, &output).unwrap(),
-            None => value.clone(),
-        };
-        let (json_string, yaml_string) = value.plan(&ctx);
-        ctx.json_result = json_string.clone();
-        ctx.yaml_result = yaml_string.clone();
-        (json_string, yaml_string)
+        // If custom_manifests_output is set (e.g., from yaml_stream), use it directly for YAML
+        match ctx.buffer.custom_manifests_output.take() {
+            Some(output) => {
+                // Use the pre-formatted YAML stream directly
+                let yaml_string = output.clone();
+                // For JSON, parse the YAML stream and format as JSON stream
+                let value = ValueRef::from_yaml_stream(&mut ctx, &yaml_string).unwrap();
+                let (json_string, _) = value.plan(&ctx);
+                ctx.json_result = json_string.clone();
+                ctx.yaml_result = yaml_string.clone();
+                (json_string, yaml_string)
+            }
+            None => {
+                let (json_string, yaml_string) = value.plan(&ctx);
+                ctx.json_result = json_string.clone();
+                ctx.yaml_result = yaml_string.clone();
+                (json_string, yaml_string)
+            }
+        }
     }
 }
 

crates/evaluator/src/snapshots/kcl_evaluator__tests__expr_stmt_4.snap

@@ -2,8 +2,6 @@
 source: crates/evaluator/src/tests.rs
 expression: "format! (\"{}\", evaluator.run().unwrap().1)"
 ---
-1
----
-2
----
-3
+- 1
+- 2
+- 3

crates/runner/src/tests.rs

@@ -308,10 +308,10 @@ fn exec_with_result_at(path: &str) {
         #[cfg(target_os = "windows")]
         let newline = "\r\n";
 
-        let expected = std::fs::read_to_string(output_file)
-            .unwrap()
+        let expected_str = std::fs::read_to_string(output_file).unwrap();
+        let expected = expected_str
             .strip_suffix(newline)
-            .unwrap()
+            .unwrap_or(&expected_str)
             .to_string();
 
         #[cfg(target_os = "windows")]

crates/runtime/src/manifests/tests.rs

@@ -4,28 +4,28 @@ use crate::*;
 fn test_kcl_manifests_yaml_stream() {
     let cases = [
         (
-            "a: 1\n",
+            "a: 1",
             ValueRef::list(Some(&[&ValueRef::dict(Some(&[("a", &ValueRef::int(1))]))])),
             YamlEncodeOptions::default(),
         ),
         (
-            "a: 1\nb: 2\n",
+            "a: 1\nb: 2",
             ValueRef::list(Some(&[&ValueRef::dict(Some(&[
                 ("a", &ValueRef::int(1)),
                 ("b", &ValueRef::int(2)),
             ]))])),
             YamlEncodeOptions::default(),
         ),
         (
-            "a:\n- 1\n- 2\n- 3\nb: s\n",
+            "a:\n- 1\n- 2\n- 3\nb: s",
             ValueRef::list(Some(&[&ValueRef::dict(Some(&[
                 ("a", &ValueRef::list_int(&[1, 2, 3])),
                 ("b", &ValueRef::str("s")),
             ]))])),
             YamlEncodeOptions::default(),
         ),
         (
-            "a: 1\n",
+            "a: 1",
             ValueRef::list(Some(&[&ValueRef::dict(Some(&[
                 ("a", &ValueRef::int(1)),
                 ("_b", &ValueRef::none()),
@@ -36,15 +36,15 @@ fn test_kcl_manifests_yaml_stream() {
             },
         ),
         (
-            "a: 1\nb: null\n",
+            "a: 1\nb: null",
             ValueRef::list(Some(&[&ValueRef::dict(Some(&[
                 ("a", &ValueRef::int(1)),
                 ("b", &ValueRef::none()),
             ]))])),
             YamlEncodeOptions::default(),
         ),
         (
-            "a: 1\n",
+            "a: 1",
             ValueRef::list(Some(&[&ValueRef::dict(Some(&[
                 ("a", &ValueRef::int(1)),
                 ("_b", &ValueRef::int(2)),

crates/runtime/src/manifests/yaml.rs

@@ -13,7 +13,10 @@ pub(crate) fn encode_yaml_stream_to_manifests(
             .as_list_ref()
             .values
             .iter()
-            .map(|v| v.to_yaml_string_with_options(&opts))
+            .map(|v| {
+                let s = v.to_yaml_string_with_options(&opts);
+                s.strip_suffix('\n').unwrap_or(&s).to_string()
+            })
             .collect::<Vec<String>>()
             .join(&format!("\n{}\n", opts.sep)),
     );
@@ -32,28 +35,28 @@ mod test_manifests_yaml {
     fn test_encode_yaml_stream_to_manifests() {
         let cases = [
             (
-                "a: 1\n",
+                "a: 1",
                 ValueRef::list(Some(&[&ValueRef::dict(Some(&[("a", &ValueRef::int(1))]))])),
                 YamlEncodeOptions::default(),
             ),
             (
-                "a: 1\nb: 2\n",
+                "a: 1\nb: 2",
                 ValueRef::list(Some(&[&ValueRef::dict(Some(&[
                     ("a", &ValueRef::int(1)),
                     ("b", &ValueRef::int(2)),
                 ]))])),
                 YamlEncodeOptions::default(),
             ),
             (
-                "a:\n- 1\n- 2\n- 3\nb: s\n",
+                "a:\n- 1\n- 2\n- 3\nb: s",
                 ValueRef::list(Some(&[&ValueRef::dict(Some(&[
                     ("a", &ValueRef::list_int(&[1, 2, 3])),
                     ("b", &ValueRef::str("s")),
                 ]))])),
                 YamlEncodeOptions::default(),
             ),
             (
-                "a: 1\n",
+                "a: 1",
                 ValueRef::list(Some(&[&ValueRef::dict(Some(&[
                     ("a", &ValueRef::int(1)),
                     ("_b", &ValueRef::none()),
@@ -64,15 +67,15 @@ mod test_manifests_yaml {
                 },
             ),
             (
-                "a: 1\nb: null\n",
+                "a: 1\nb: null",
                 ValueRef::list(Some(&[&ValueRef::dict(Some(&[
                     ("a", &ValueRef::int(1)),
                     ("b", &ValueRef::none()),
                 ]))])),
                 YamlEncodeOptions::default(),
             ),
             (
-                "a: 1\n",
+                "a: 1",
                 ValueRef::list(Some(&[&ValueRef::dict(Some(&[
                     ("a", &ValueRef::int(1)),
                     ("_b", &ValueRef::int(2)),

crates/runtime/src/value/api.rs

@@ -444,14 +444,21 @@ pub unsafe extern "C-unwind" fn kcl_value_plan_to_json(
 ) -> *mut kcl_value_ref_t {
     let p = unsafe { ptr_as_ref(p) };
     let ctx: &mut Context = unsafe { mut_ptr_as_ref(ctx) };
-    let value = match ctx.buffer.custom_manifests_output.clone() {
-        Some(output) => ValueRef::from_yaml_stream(ctx, &output).unwrap(),
-        None => p.clone(),
-    };
-    let (json_string, yaml_string) = value.plan(ctx);
-    ctx.json_result = json_string.clone();
-    ctx.yaml_result = yaml_string.clone();
-    new_mut_ptr(ctx, ValueRef::str(&json_string))
+    // If custom_manifests_output is set (e.g., from yaml_stream), use it directly for YAML
+    // For JSON, parse the YAML stream and format as JSON stream
+    if let Some(output) = ctx.buffer.custom_manifests_output.take() {
+        ctx.yaml_result = output.clone();
+        let yaml_result = ctx.yaml_result.clone();
+        let value = ValueRef::from_yaml_stream(ctx, &yaml_result).unwrap();
+        let (json_string, _) = value.plan(ctx);
+        ctx.json_result = json_string.clone();
+        new_mut_ptr(ctx, ValueRef::str(&ctx.json_result))
+    } else {
+        let (json_string, yaml_string) = p.plan(ctx);
+        ctx.json_result = json_string.clone();
+        ctx.yaml_result = yaml_string.clone();
+        new_mut_ptr(ctx, ValueRef::str(&ctx.json_result))
+    }
 }
 
 #[unsafe(no_mangle)]
@@ -461,14 +468,21 @@ pub unsafe extern "C-unwind" fn kcl_value_plan_to_yaml(
 ) -> *mut kcl_value_ref_t {
     let p = unsafe { ptr_as_ref(p) };
     let ctx = unsafe { mut_ptr_as_ref(ctx) };
-    let value = match ctx.buffer.custom_manifests_output.clone() {
-        Some(output) => ValueRef::from_yaml_stream(ctx, &output).unwrap(),
-        None => p.clone(),
-    };
-    let (json_string, yaml_string) = value.plan(ctx);
-    ctx.json_result = json_string.clone();
-    ctx.yaml_result = yaml_string.clone();
-    new_mut_ptr(ctx, ValueRef::str(&yaml_string))
+    // If custom_manifests_output is set (e.g., from yaml_stream), use it directly
+    if let Some(output) = ctx.buffer.custom_manifests_output.take() {
+        ctx.yaml_result = output.clone();
+        // For JSON, we still need to parse and format the YAML stream
+        let yaml_str = ctx.yaml_result.clone();
+        let value = ValueRef::from_yaml_stream(ctx, &yaml_str).unwrap();
+        let (json_string, _) = value.plan(ctx);
+        ctx.json_result = json_string;
+        new_mut_ptr(ctx, ValueRef::str(&ctx.yaml_result))
+    } else {
+        let (json_string, yaml_string) = p.plan(ctx);
+        ctx.json_result = json_string.clone();
+        ctx.yaml_result = yaml_string.clone();
+        new_mut_ptr(ctx, ValueRef::str(&yaml_string))
+    }
 }
 
 #[unsafe(no_mangle)]