16482855623

Committed 23 Jul 2025 10:08PM UTC coverage: 58.447% (-0.2%) from 58.68%

Build # 16482855623

Build Type

Pull #855

github

Committed by

web-flow

Commit Message

Merge dca4c2302 into 5e8e214d1

Pull Request Pull Request #855: wip: Remove 'shape lifetime

Run Details

400 of 572 new or added lines in 70 files covered. (69.93%)

3 existing lines in 3 files now uncovered.

11939 of 20427 relevant lines covered (58.45%)

120.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

33.73

/facet-csv/src/serialize.rs

use facet_core::Facet;
use facet_reflect::Peek;
use facet_serialize::{Serializer, serialize_iterative};
use std::io::{self, Write};

/// Serializes a value to CSV
pub fn to_string<'facet, T: Facet<'facet>>(value: &'facet T) -> String {
    let peek = Peek::new(value);
    let mut output = Vec::new();
    let mut serializer = CsvSerializer::new(&mut output);
    serialize_iterative(peek, &mut serializer).unwrap();
    String::from_utf8(output).unwrap()
}

/// Serializes a Peek instance to CSV
pub fn peek_to_string<'facet>(peek: Peek<'_, 'facet>) -> String {
    let mut output = Vec::new();
    let mut serializer = CsvSerializer::new(&mut output);
    serialize_iterative(peek, &mut serializer).unwrap();
    String::from_utf8(output).unwrap()
}

/// Serializes a value to a writer in CSV format
pub fn to_writer<'a, T: Facet<'a>, W: Write>(value: &'a T, writer: &mut W) -> io::Result<()> {
    let peek = Peek::new(value);
    let mut serializer = CsvSerializer::new(writer);
    serialize_iterative(peek, &mut serializer)
}

/// Serializes a Peek instance to a writer in CSV format
pub fn peek_to_writer<'facet, W: Write>(peek: Peek<'_, 'facet>, writer: &mut W) -> io::Result<()> {
    let mut serializer = CsvSerializer::new(writer);
    serialize_iterative(peek, &mut serializer)
}

/// A struct to handle the CSV serializer logic
pub struct CsvSerializer<W> {
    /// Owned writer
    writer: W,

    /// The current position in a row
    pos: usize,

    /// Initialized by `start_object`
    n_fields: usize,

    /// Delimeter used to separate values
    delim: &'static [u8],

    /// Newline encoding
    newline: &'static [u8],
}
impl<W> CsvSerializer<W>
where
    W: Write,
{
    /// Initializes a new CSV Serializer
    pub fn new(writer: W) -> Self {
        Self {
            writer,
            pos: 0,
            n_fields: 0,
            delim: b",",
            newline: b"\n",
        }
    }

    fn set_n_fields(&mut self, n_fields: usize) {
        self.n_fields = n_fields;
    }

    /// Conditionally prefix the value with the required delimeter
    fn start_value(&mut self) -> Result<(), io::Error> {
        if self.pos == 0 {
            // no prefix
            Ok(())
        } else {
            self.writer.write_all(self.delim)
        }
    }

    /// Conditionally suffix the value with the required newline
    fn end_value(&mut self) -> Result<(), io::Error> {
        if self.pos == self.n_fields - 1 {
            // Reset the position to zero
            self.pos = 0;
            self.writer.write_all(self.newline)
        } else {
            // Increment the position
            self.pos += 1;
            // no suffix
            Ok(())
        }
    }
}

impl<W> Serializer for CsvSerializer<W>
where
    W: Write,
{
    type Error = io::Error;

    fn start_object(&mut self, len: Option<usize>) -> Result<(), Self::Error> {
        self.set_n_fields(len.expect("Must know the length of the object for CSV"));
        Ok(())
    }

    fn end_object(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }

    fn start_array(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {
        unimplemented!("Arrays are not implemented yet in CSV")
    }

    fn end_array(&mut self) -> Result<(), Self::Error> {
        unimplemented!("Arrays are not implemented yet in CSV")
    }

    fn start_map(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {
        unimplemented!("Maps are not implemented yet in CSV")
    }

    fn end_map(&mut self) -> Result<(), Self::Error> {
        unimplemented!("Maps are not implemented yet in CSV")
    }

    fn serialize_field_name(&mut self, _name: &str) -> Result<(), Self::Error> {
        // field names are not serialized in CSV
        Ok(())
    }

    fn serialize_unit_variant(
        &mut self,
        _variant_index: usize,
        _variant_name: &str,
    ) -> Result<(), Self::Error> {
        // unit variants should not serialize to anything
        Ok(())
    }

    fn serialize_u8(&mut self, value: u8) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_u16(&mut self, value: u16) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_u32(&mut self, value: u32) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_u64(&mut self, value: u64) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_u128(&mut self, value: u128) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_usize(&mut self, value: usize) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_i8(&mut self, value: i8) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_i16(&mut self, value: i16) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_i32(&mut self, value: i32) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_i64(&mut self, value: i64) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_i128(&mut self, value: i128) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_isize(&mut self, value: isize) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_f32(&mut self, value: f32) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_f64(&mut self, value: f64) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_bool(&mut self, value: bool) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{}", if value { "true" } else { "false" })?;
        self.end_value()
    }

    fn serialize_char(&mut self, value: char) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error> {
        self.start_value()?;
        write!(self.writer, "{value}")?;
        self.end_value()
    }

    fn serialize_bytes(&mut self, _value: &[u8]) -> Result<(), Self::Error> {
        panic!("CSV does not support byte arrays")
    }

    fn serialize_none(&mut self) -> Result<(), Self::Error> {
        self.start_value()?;
        // skip empty columns
        self.end_value()
    }

    fn serialize_unit(&mut self) -> Result<(), Self::Error> {
        self.start_value()?;
        // skip empty columns
        self.end_value()
    }
}

1	use facet_core::Facet;
2	use facet_reflect::Peek;
3	use facet_serialize::{Serializer, serialize_iterative};
4	use std::io::{self, Write};
5
6	/// Serializes a value to CSV
7	pub fn to_string<'facet, T: Facet<'facet>>(value: &'facet T) -> String {	1✔
8	let peek = Peek::new(value);	1✔
9	let mut output = Vec::new();	1✔
10	let mut serializer = CsvSerializer::new(&mut output);	1✔
11	serialize_iterative(peek, &mut serializer).unwrap();	1✔
12	String::from_utf8(output).unwrap()	1✔
13	}	1✔
14
15	/// Serializes a Peek instance to CSV
NEW 16	pub fn peek_to_string<'facet>(peek: Peek<'_, 'facet>) -> String {	×
17	let mut output = Vec::new();	×
18	let mut serializer = CsvSerializer::new(&mut output);	×
NEW 19	serialize_iterative(peek, &mut serializer).unwrap();	×
20	String::from_utf8(output).unwrap()	×
21	}	×
22
23	/// Serializes a value to a writer in CSV format
24	pub fn to_writer<'a, T: Facet<'a>, W: Write>(value: &'a T, writer: &mut W) -> io::Result<()> {	×
25	let peek = Peek::new(value);	×
26	let mut serializer = CsvSerializer::new(writer);	×
27	serialize_iterative(peek, &mut serializer)	×
28	}	×
29
30	/// Serializes a Peek instance to a writer in CSV format
NEW 31	pub fn peek_to_writer<'facet, W: Write>(peek: Peek<'_, 'facet>, writer: &mut W) -> io::Result<()> {	×
32	let mut serializer = CsvSerializer::new(writer);	×
NEW 33	serialize_iterative(peek, &mut serializer)	×
34	}	×
35
36	/// A struct to handle the CSV serializer logic
37	pub struct CsvSerializer<W> {
38	/// Owned writer
39	writer: W,
40
41	/// The current position in a row
42	pos: usize,
43
44	/// Initialized by `start_object`
45	n_fields: usize,
46
47	/// Delimeter used to separate values
48	delim: &'static [u8],
49
50	/// Newline encoding
51	newline: &'static [u8],
52	}
53	impl<W> CsvSerializer<W>
54	where
55	W: Write,
56	{
57	/// Initializes a new CSV Serializer
58	pub fn new(writer: W) -> Self {	1✔
59	Self {	1✔
60	writer,	1✔
61	pos: 0,	1✔
62	n_fields: 0,	1✔
63	delim: b",",	1✔
64	newline: b"\n",	1✔
65	}	1✔
66	}	1✔
67
68	fn set_n_fields(&mut self, n_fields: usize) {	1✔
69	self.n_fields = n_fields;	1✔
70	}	1✔
71
72	/// Conditionally prefix the value with the required delimeter
73	fn start_value(&mut self) -> Result<(), io::Error> {	3✔
74	if self.pos == 0 {	3✔
75	// no prefix
76	Ok(())	1✔
77	} else {
78	self.writer.write_all(self.delim)	2✔
79	}
80	}	3✔
81
82	/// Conditionally suffix the value with the required newline
83	fn end_value(&mut self) -> Result<(), io::Error> {	3✔
84	if self.pos == self.n_fields - 1 {	3✔
85	// Reset the position to zero
86	self.pos = 0;	1✔
87	self.writer.write_all(self.newline)	1✔
88	} else {
89	// Increment the position
90	self.pos += 1;	2✔
91	// no suffix
92	Ok(())	2✔
93	}
94	}	3✔
95	}
96
97	impl<W> Serializer for CsvSerializer<W>
98	where
99	W: Write,
100	{
101	type Error = io::Error;
102
103	fn start_object(&mut self, len: Option<usize>) -> Result<(), Self::Error> {	1✔
104	self.set_n_fields(len.expect("Must know the length of the object for CSV"));	1✔
105	Ok(())	1✔
106	}	1✔
107
108	fn end_object(&mut self) -> Result<(), Self::Error> {	1✔
109	Ok(())	1✔
110	}	1✔
111
112	fn start_array(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {	×
113	unimplemented!("Arrays are not implemented yet in CSV")	×
114	}
115
116	fn end_array(&mut self) -> Result<(), Self::Error> {	×
117	unimplemented!("Arrays are not implemented yet in CSV")	×
118	}
119
120	fn start_map(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {	×
121	unimplemented!("Maps are not implemented yet in CSV")	×
122	}
123
124	fn end_map(&mut self) -> Result<(), Self::Error> {	×
125	unimplemented!("Maps are not implemented yet in CSV")	×
126	}
127
128	fn serialize_field_name(&mut self, _name: &str) -> Result<(), Self::Error> {	3✔
129	// field names are not serialized in CSV
130	Ok(())	3✔
131	}	3✔
132
133	fn serialize_unit_variant(	×
134	&mut self,	×
135	_variant_index: usize,	×
136	_variant_name: &str,	×
137	) -> Result<(), Self::Error> {	×
138	// unit variants should not serialize to anything
139	Ok(())	×
140	}	×
141
142	fn serialize_u8(&mut self, value: u8) -> Result<(), Self::Error> {	×
143	self.start_value()?;	×
144	write!(self.writer, "{value}")?;	×
145	self.end_value()	×
146	}	×
147
148	fn serialize_u16(&mut self, value: u16) -> Result<(), Self::Error> {	×
149	self.start_value()?;	×
150	write!(self.writer, "{value}")?;	×
151	self.end_value()	×
152	}	×
153
154	fn serialize_u32(&mut self, value: u32) -> Result<(), Self::Error> {	×
155	self.start_value()?;	×
156	write!(self.writer, "{value}")?;	×
157	self.end_value()	×
158	}	×
159
160	fn serialize_u64(&mut self, value: u64) -> Result<(), Self::Error> {	×
161	self.start_value()?;	×
162	write!(self.writer, "{value}")?;	×
163	self.end_value()	×
164	}	×
165
166	fn serialize_u128(&mut self, value: u128) -> Result<(), Self::Error> {	×
167	self.start_value()?;	×
168	write!(self.writer, "{value}")?;	×
169	self.end_value()	×
170	}	×
171
172	fn serialize_usize(&mut self, value: usize) -> Result<(), Self::Error> {	1✔
173	self.start_value()?;	1✔
174	write!(self.writer, "{value}")?;	1✔
175	self.end_value()	1✔
176	}	1✔
177
178	fn serialize_i8(&mut self, value: i8) -> Result<(), Self::Error> {	×
179	self.start_value()?;	×
180	write!(self.writer, "{value}")?;	×
181	self.end_value()	×
182	}	×
183
184	fn serialize_i16(&mut self, value: i16) -> Result<(), Self::Error> {	×
185	self.start_value()?;	×
186	write!(self.writer, "{value}")?;	×
187	self.end_value()	×
188	}	×
189
190	fn serialize_i32(&mut self, value: i32) -> Result<(), Self::Error> {	×
191	self.start_value()?;	×
192	write!(self.writer, "{value}")?;	×
193	self.end_value()	×
194	}	×
195
196	fn serialize_i64(&mut self, value: i64) -> Result<(), Self::Error> {	×
197	self.start_value()?;	×
198	write!(self.writer, "{value}")?;	×
199	self.end_value()	×
200	}	×
201
202	fn serialize_i128(&mut self, value: i128) -> Result<(), Self::Error> {	×
203	self.start_value()?;	×
204	write!(self.writer, "{value}")?;	×
205	self.end_value()	×
206	}	×
207
208	fn serialize_isize(&mut self, value: isize) -> Result<(), Self::Error> {	×
209	self.start_value()?;	×
210	write!(self.writer, "{value}")?;	×
211	self.end_value()	×
212	}	×
213
214	fn serialize_f32(&mut self, value: f32) -> Result<(), Self::Error> {	×
215	self.start_value()?;	×
216	write!(self.writer, "{value}")?;	×
217	self.end_value()	×
218	}	×
219
220	fn serialize_f64(&mut self, value: f64) -> Result<(), Self::Error> {	×
221	self.start_value()?;	×
222	write!(self.writer, "{value}")?;	×
223	self.end_value()	×
224	}	×
225
226	fn serialize_bool(&mut self, value: bool) -> Result<(), Self::Error> {	1✔
227	self.start_value()?;	1✔
228	write!(self.writer, "{}", if value { "true" } else { "false" })?;	1✔
229	self.end_value()	1✔
230	}	1✔
231
232	fn serialize_char(&mut self, value: char) -> Result<(), Self::Error> {	×
233	self.start_value()?;	×
234	write!(self.writer, "{value}")?;	×
235	self.end_value()	×
236	}	×
237
238	fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error> {	1✔
239	self.start_value()?;	1✔
240	write!(self.writer, "{value}")?;	1✔
241	self.end_value()	1✔
242	}	1✔
243
244	fn serialize_bytes(&mut self, _value: &[u8]) -> Result<(), Self::Error> {	×
245	panic!("CSV does not support byte arrays")	×
246	}
247
248	fn serialize_none(&mut self) -> Result<(), Self::Error> {	×
249	self.start_value()?;	×
250	// skip empty columns
251	self.end_value()	×
252	}	×
253
254	fn serialize_unit(&mut self) -> Result<(), Self::Error> {	×
255	self.start_value()?;	×
256	// skip empty columns
257	self.end_value()	×
258	}	×
259	}

facet-rs / facet / 16482855623

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous