Allow writing to io::Writer (#562)

* Allow writing to io::Writer

* Add a CHANGELOG entry

Author: juntyr

CHANGELOG.md

@@ -6,6 +6,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### API Changes
+
+- Add `ron::Options::to_io_writer` and `ron::Options::to_io_writer_pretty` to allow writing into an `io::Writer` ([#561](https://github.com/ron-rs/ron/pull/561))
+
 ## [0.9.0] - 2025-03-18
 
 ### API Changes

examples/encode_file.rs

@@ -0,0 +1,60 @@
+#![allow(dead_code)]
+
+use std::{collections::HashMap, fs::File};
+
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+struct Config {
+    boolean: bool,
+    float: f32,
+    map: HashMap<u8, char>,
+    nested: Nested,
+    tuple: (u32, u32),
+    vec: Vec<Nested>,
+}
+
+#[derive(Debug, Serialize)]
+struct Nested {
+    a: String,
+    b: char,
+}
+
+fn main() {
+    let config = Config {
+        boolean: true,
+        float: 8.2,
+        map: [(1, '1'), (2, '4'), (3, '9'), (4, '1'), (5, '2'), (6, '3')]
+            .into_iter()
+            .collect(),
+        nested: Nested {
+            a: String::from("Decode me!"),
+            b: 'z',
+        },
+        tuple: (3, 7),
+        vec: vec![
+            Nested {
+                a: String::from("Nested 1"),
+                b: 'x',
+            },
+            Nested {
+                a: String::from("Nested 2"),
+                b: 'y',
+            },
+            Nested {
+                a: String::from("Nested 3"),
+                b: 'z',
+            },
+        ],
+    };
+
+    let f = File::options()
+        .create(true)
+        .write(true)
+        .open("example-out.ron")
+        .expect("Failed opening file");
+
+    ron::Options::default()
+        .to_io_writer_pretty(f, &config, ron::ser::PrettyConfig::new())
+        .expect("Failed to write to file");
+}

src/options.rs

@@ -211,6 +211,45 @@ impl Options {
         value.serialize(&mut s)
     }
 
+    /// Serializes `value` into `writer`.
+    ///
+    /// This function does not generate any newlines or nice formatting;
+    /// if you want that, you can use
+    /// [`to_io_writer_pretty`][Self::to_io_writer_pretty] instead.
+    pub fn to_io_writer<W, T>(&self, writer: W, value: &T) -> Result<()>
+    where
+        W: io::Write,
+        T: ?Sized + ser::Serialize,
+    {
+        let mut adapter = Adapter {
+            writer,
+            error: Ok(()),
+        };
+        let result = self.to_writer(&mut adapter, value);
+        adapter.error?;
+        result
+    }
+
+    /// Serializes `value` into `writer` in a pretty way.
+    pub fn to_io_writer_pretty<W, T>(
+        &self,
+        writer: W,
+        value: &T,
+        config: PrettyConfig,
+    ) -> Result<()>
+    where
+        W: io::Write,
+        T: ?Sized + ser::Serialize,
+    {
+        let mut adapter = Adapter {
+            writer,
+            error: Ok(()),
+        };
+        let result = self.to_writer_pretty(&mut adapter, value, config);
+        adapter.error?;
+        result
+    }
+
     /// Serializes `value` and returns it as string.
     ///
     /// This function does not generate any newlines or nice formatting;
@@ -237,3 +276,21 @@ impl Options {
         Ok(output)
     }
 }
+
+// Adapter from io::Write to fmt::Write that keeps the error
+struct Adapter<W: io::Write> {
+    writer: W,
+    error: io::Result<()>,
+}
+
+impl<T: io::Write> fmt::Write for Adapter<T> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        match self.writer.write_all(s.as_bytes()) {
+            Ok(()) => Ok(()),
+            Err(e) => {
+                self.error = Err(e);
+                Err(fmt::Error)
+            }
+        }
+    }
+}