Rename WriteSettings to just Settings

Author: LaurenzV

src/chunk.rs

@@ -2,15 +2,15 @@ use super::*;
 
 /// Settings that should be applied while writing a PDF file.
 #[derive(Debug, Clone, Copy)]
-pub struct WriteSettings {
+pub struct Settings {
     /// Whether to enable pretty-writing. In this case, `pdf-writer` will serialize PDFs in such
     /// a way that they are easier to read by humans by applying more padding and indentation, at
     /// the cost of larger file sizes. If disabled, `pdf-writer` will serialize objects as compactly
     /// as possible, leading to better file sizes but making it harder to inspect the file manually.
     pub pretty: bool,
 }
 
-impl Default for WriteSettings {
+impl Default for Settings {
     fn default() -> Self {
         Self { pretty: true }
     }
@@ -30,7 +30,7 @@ impl Default for WriteSettings {
 pub struct Chunk {
     pub(crate) buf: Buf,
     pub(crate) offsets: Vec<(Ref, usize)>,
-    pub(crate) write_settings: WriteSettings,
+    pub(crate) settings: Settings,
 }
 
 impl Chunk {
@@ -45,14 +45,14 @@ impl Chunk {
         Self {
             buf: Buf::with_capacity(capacity),
             offsets: vec![],
-            write_settings: Default::default(),
+            settings: Default::default(),
         }
     }
 
     /// Create a new chunk with the given write settings.
-    pub fn with_settings(write_settings: WriteSettings) -> Self {
+    pub fn with_settings(settings: Settings) -> Self {
         let mut chunk = Self::new();
-        chunk.write_settings = write_settings;
+        chunk.settings = settings;
 
         chunk
     }
@@ -182,7 +182,7 @@ impl Chunk {
     /// Start writing an indirectly referenceable object.
     pub fn indirect(&mut self, id: Ref) -> Obj<'_> {
         self.offsets.push((id, self.buf.len()));
-        Obj::indirect(&mut self.buf, id, self.write_settings)
+        Obj::indirect(&mut self.buf, id, self.settings)
     }
 
     /// Start writing an indirectly referenceable stream.

src/content.rs

@@ -1,11 +1,11 @@
 use super::*;
-use crate::chunk::WriteSettings;
+use crate::chunk::Settings;
 use crate::object::{is_delimiter_character, TextStrLike};
 
 /// A builder for a content stream.
 pub struct Content {
     buf: Buf,
-    write_settings: WriteSettings,
+    settings: Settings,
     q_depth: usize,
 }
 
@@ -19,9 +19,9 @@ impl Content {
     }
 
     /// Create a new content stream with the given write settings.
-    pub fn with_settings(write_settings: WriteSettings) -> Self {
+    pub fn with_settings(settings: Settings) -> Self {
         let mut content = Self::new();
-        content.write_settings = write_settings;
+        content.settings = settings;
 
         content
     }
@@ -31,14 +31,14 @@ impl Content {
         Self {
             buf: Buf::with_capacity(capacity),
             q_depth: 0,
-            write_settings: Default::default(),
+            settings: Default::default(),
         }
     }
 
     /// Start writing an arbitrary operation.
     #[inline]
     pub fn op<'a>(&'a mut self, operator: &'a str) -> Operation<'a> {
-        Operation::start(&mut self.buf, operator, self.write_settings)
+        Operation::start(&mut self.buf, operator, self.settings)
     }
 
     /// Return the buffer of the content stream.
@@ -65,17 +65,13 @@ pub struct Operation<'a> {
     buf: &'a mut Buf,
     op: &'a str,
     first: bool,
-    write_settings: WriteSettings,
+    settings: Settings,
 }
 
 impl<'a> Operation<'a> {
     #[inline]
-    pub(crate) fn start(
-        buf: &'a mut Buf,
-        op: &'a str,
-        write_settings: WriteSettings,
-    ) -> Self {
-        Self { buf, op, first: true, write_settings }
+    pub(crate) fn start(buf: &'a mut Buf, op: &'a str, settings: Settings) -> Self {
+        Self { buf, op, first: true, settings }
     }
 
     /// Write a primitive operand.
@@ -108,7 +104,7 @@ impl<'a> Operation<'a> {
         // Similarly to how chunks are handled, we always add padding when pretty-writing
         // is enabled, and only lazily add padding depending on whether it's really necessary
         // if not.
-        let needs_padding = if self.write_settings.pretty {
+        let needs_padding = if self.settings.pretty {
             if !self.buf.is_empty() {
                 self.buf.push(pad_byte);
             }
@@ -119,7 +115,7 @@ impl<'a> Operation<'a> {
         };
 
         self.first = false;
-        Obj::direct(self.buf, 0, self.write_settings, needs_padding)
+        Obj::direct(self.buf, 0, self.settings, needs_padding)
     }
 }
 
@@ -130,7 +126,7 @@ impl Drop for Operation<'_> {
 
         // For example, in case we previously wrote a BT operator and then a [] operand in the
         // next operation, we don't need to pad them.
-        if (self.write_settings.pretty
+        if (self.settings.pretty
             || self.buf.last().is_some_and(|b| !is_delimiter_character(*b)))
             && !self.buf.is_empty()
         {
@@ -1751,7 +1747,7 @@ mod tests {
 
     #[test]
     fn test_content_array_no_pretty() {
-        let mut content = Content::with_settings(WriteSettings { pretty: false });
+        let mut content = Content::with_settings(Settings { pretty: false });
 
         content.set_font(Name(b"F1"), 12.0);
         content.set_font(Name(b"F2"), 15.0);
@@ -1775,7 +1771,7 @@ mod tests {
 
     #[test]
     fn test_content_dict_no_pretty() {
-        let mut content = Content::with_settings(WriteSettings { pretty: false });
+        let mut content = Content::with_settings(Settings { pretty: false });
 
         let mut mc = content.begin_marked_content_with_properties(Name(b"Test"));
         let mut properties = mc.properties();

src/lib.rs

@@ -203,7 +203,7 @@ use std::fmt::{self, Debug, Formatter};
 use std::io::Write;
 use std::ops::{Deref, DerefMut};
 
-use crate::chunk::WriteSettings;
+use crate::chunk::Settings;
 
 use self::writers::*;
 
@@ -230,9 +230,9 @@ impl Pdf {
     }
 
     /// Create a new PDF with the given write settings.
-    pub fn with_settings(write_settings: WriteSettings) -> Self {
+    pub fn with_settings(settings: Settings) -> Self {
         let mut pdf = Self::new();
-        pdf.write_settings = write_settings;
+        pdf.settings = settings;
 
         pdf
     }
@@ -308,7 +308,7 @@ impl Pdf {
     ///
     /// Panics if any indirect reference id was used twice.
     pub fn finish(self) -> Vec<u8> {
-        let Chunk { mut buf, mut offsets, write_settings } = self.chunk;
+        let Chunk { mut buf, mut offsets, settings } = self.chunk;
 
         offsets.sort();
 
@@ -356,7 +356,7 @@ impl Pdf {
         // Write the trailer dictionary.
         buf.extend(b"trailer\n");
 
-        let mut trailer = Obj::direct(&mut buf, 0, write_settings, false).dict();
+        let mut trailer = Obj::direct(&mut buf, 0, settings, false).dict();
         trailer.pair(Name(b"Size"), xref_len);
 
         if let Some(catalog_id) = self.catalog_id {
@@ -422,11 +422,11 @@ mod tests {
     }
 
     /// Return the slice of bytes written during the execution of `f`.
-    pub fn slice<F>(f: F, write_settings: WriteSettings) -> Vec<u8>
+    pub fn slice<F>(f: F, settings: Settings) -> Vec<u8>
     where
         F: FnOnce(&mut Pdf),
     {
-        let mut w = Pdf::with_settings(write_settings);
+        let mut w = Pdf::with_settings(settings);
         let start = w.len();
         f(&mut w);
         let end = w.len();
@@ -435,12 +435,12 @@ mod tests {
     }
 
     /// Return the slice of bytes written for an object.
-    pub fn slice_obj<F>(f: F, write_settings: WriteSettings) -> Vec<u8>
+    pub fn slice_obj<F>(f: F, settings: Settings) -> Vec<u8>
     where
         F: FnOnce(Obj<'_>),
     {
-        let buf = slice(|w| f(w.indirect(Ref::new(1))), write_settings);
-        if write_settings.pretty {
+        let buf = slice(|w| f(w.indirect(Ref::new(1))), settings);
+        if settings.pretty {
             buf[8..buf.len() - 9].to_vec()
         } else {
             buf[8..buf.len() - 8].to_vec()

src/macros.rs

@@ -19,15 +19,15 @@ macro_rules! test {
 #[cfg(test)]
 macro_rules! test_obj {
     (|$obj:ident| $write:expr, $($tts:tt)*) => {{
-        test!(crate::tests::slice_obj(|$obj| { $write; }, crate::WriteSettings::default()), $($tts)*)
+        test!(crate::tests::slice_obj(|$obj| { $write; }, crate::Settings::default()), $($tts)*)
     }}
 }
 
 /// Test how an object is written, without pretty-printing.
 #[cfg(test)]
 macro_rules! test_obj_no_pretty {
     (|$obj:ident| $write:expr, $($tts:tt)*) => {{
-        test!(crate::tests::slice_obj(|$obj| { $write; }, crate::WriteSettings { pretty: false }), $($tts)*)
+        test!(crate::tests::slice_obj(|$obj| { $write; }, crate::Settings { pretty: false }), $($tts)*)
     }}
 }
 

src/object.rs

@@ -4,7 +4,7 @@ use std::mem::ManuallyDrop;
 use std::num::NonZeroI32;
 
 use super::*;
-use crate::chunk::WriteSettings;
+use crate::chunk::Settings;
 
 /// A primitive PDF object.
 pub trait Primitive {
@@ -608,7 +608,7 @@ pub struct Obj<'a> {
     buf: &'a mut Buf,
     indirect: bool,
     indent: u8,
-    write_settings: WriteSettings,
+    settings: Settings,
     needs_padding: bool,
 }
 
@@ -618,32 +618,28 @@ impl<'a> Obj<'a> {
     pub(crate) fn direct(
         buf: &'a mut Buf,
         indent: u8,
-        write_settings: WriteSettings,
+        settings: Settings,
         needs_padding: bool,
     ) -> Self {
         Self {
             buf,
             indirect: false,
             indent,
-            write_settings,
+            settings,
             needs_padding,
         }
     }
 
     /// Start a new indirect object.
     #[inline]
-    pub(crate) fn indirect(
-        buf: &'a mut Buf,
-        id: Ref,
-        write_settings: WriteSettings,
-    ) -> Self {
+    pub(crate) fn indirect(buf: &'a mut Buf, id: Ref, settings: Settings) -> Self {
         buf.push_int(id.get());
         buf.extend(b" 0 obj\n");
         Self {
             buf,
             indirect: true,
             indent: 0,
-            write_settings,
+            settings,
             needs_padding: false,
         }
     }
@@ -671,7 +667,7 @@ impl<'a> Obj<'a> {
         if self.indirect {
             self.buf.extend(b"\nendobj\n");
 
-            if self.write_settings.pretty {
+            if self.settings.pretty {
                 self.buf.extend(b"\n");
             }
         }
@@ -734,7 +730,7 @@ pub struct Array<'a> {
     buf: &'a mut Buf,
     indirect: bool,
     indent: u8,
-    settings: WriteSettings,
+    settings: Settings,
     len: i32,
 }
 
@@ -744,7 +740,7 @@ writer!(Array: |obj| {
         buf: obj.buf,
         indirect: obj.indirect,
         indent: obj.indent,
-        settings: obj.write_settings,
+        settings: obj.settings,
         len: 0,
     }
 });
@@ -896,7 +892,7 @@ pub struct Dict<'a> {
     buf: &'a mut Buf,
     indirect: bool,
     indent: u8,
-    settings: WriteSettings,
+    settings: Settings,
     len: i32,
 }
 
@@ -906,7 +902,7 @@ writer!(Dict: |obj| {
         buf: obj.buf,
         indirect: obj.indirect,
         indent: obj.indent.saturating_add(2),
-        settings: obj.write_settings,
+        settings: obj.settings,
         len: 0,
     }
 });

src/renumber.rs

@@ -20,7 +20,7 @@ pub fn renumber(source: &Chunk, target: &mut Chunk, mapping: &mut dyn FnMut(Ref)
         patch_object(slice, &mut target.buf, mapping);
         target.buf.extend(b"\nendobj\n");
 
-        if target.write_settings.pretty {
+        if target.settings.pretty {
             target.buf.extend(b"\n");
         }
     }